Merge pull request #10069 from home-assistant/release-0-56-2

0.56.2
Version bump to 0.56.2
2026-01-12 18:47:17 +01:00 · 2017-10-23 17:40:58 +02:00 · 2017-10-23 16:09:26 +02:00 · 2017-10-23 13:49:45 +02:00 · 2017-10-23 13:48:25 +02:00 · 2017-10-23 13:46:00 +02:00
632 changed files with 31412 additions and 6123 deletions
--- a/.coveragerc
+++ b/.coveragerc
@@ -8,6 +8,9 @@ omit =
    homeassistant/helpers/signal.py

    # omit pieces of code that rely on external devices being present
+    homeassistant/components/abode.py
+    homeassistant/components/*/abode.py
+
    homeassistant/components/alarmdecoder.py
    homeassistant/components/*/alarmdecoder.py

@@ -50,6 +53,9 @@ omit =
    homeassistant/components/digital_ocean.py
    homeassistant/components/*/digital_ocean.py

+	homeassistant/components/doorbird.py
+	homeassistant/components/*/doorbird.py
+
    homeassistant/components/dweet.py
    homeassistant/components/*/dweet.py

@@ -143,6 +149,9 @@ omit =
    homeassistant/components/rachio.py
    homeassistant/components/*/rachio.py

+    homeassistant/components/raincloud.py
+    homeassistant/components/*/raincloud.py
+
    homeassistant/components/raspihats.py
    homeassistant/components/*/raspihats.py

@@ -155,9 +164,15 @@ omit =
    homeassistant/components/rpi_pfio.py
    homeassistant/components/*/rpi_pfio.py

+    homeassistant/components/satel_integra.py
+    homeassistant/components/*/satel_integra.py
+
    homeassistant/components/scsgate.py
    homeassistant/components/*/scsgate.py

+    homeassistant/components/skybell.py
+    homeassistant/components/*/skybell.py
+
    homeassistant/components/tado.py
    homeassistant/components/*/tado.py

@@ -167,8 +182,17 @@ omit =
    homeassistant/components/tellstick.py
    homeassistant/components/*/tellstick.py

+    homeassistant/components/tesla.py
+    homeassistant/components/*/tesla.py
+
+    homeassistant/components/thethingsnetwork.py
+    homeassistant/components/*/thethingsnetwork.py
+
    homeassistant/components/*/thinkingcleaner.py

+    homeassistant/components/toon.py
+    homeassistant/components/*/toon.py
+
    homeassistant/components/tradfri.py
    homeassistant/components/*/tradfri.py

@@ -176,6 +200,9 @@ omit =
    homeassistant/components/notify/twilio_sms.py
    homeassistant/components/notify/twilio_call.py

+    homeassistant/components/usps.py
+    homeassistant/components/*/usps.py
+
    homeassistant/components/velbus.py
    homeassistant/components/*/velbus.py

@@ -196,15 +223,15 @@ omit =
    homeassistant/components/wemo.py
    homeassistant/components/*/wemo.py

-    homeassistant/components/wink.py
+    homeassistant/components/wink/*
    homeassistant/components/*/wink.py

-    homeassistant/components/xiaomi.py
-    homeassistant/components/binary_sensor/xiaomi.py
-    homeassistant/components/cover/xiaomi.py
-    homeassistant/components/light/xiaomi.py
-    homeassistant/components/sensor/xiaomi.py
-    homeassistant/components/switch/xiaomi.py
+    homeassistant/components/xiaomi_aqara.py
+    homeassistant/components/binary_sensor/xiaomi_aqara.py
+    homeassistant/components/cover/xiaomi_aqara.py
+    homeassistant/components/light/xiaomi_aqara.py
+    homeassistant/components/sensor/xiaomi_aqara.py
+    homeassistant/components/switch/xiaomi_aqara.py

    homeassistant/components/zabbix.py
    homeassistant/components/*/zabbix.py
@@ -238,6 +265,7 @@ omit =
    homeassistant/components/binary_sensor/rest.py
    homeassistant/components/binary_sensor/tapsaff.py
    homeassistant/components/browser.py
+    homeassistant/components/calendar/todoist.py
    homeassistant/components/camera/bloomsky.py
    homeassistant/components/camera/ffmpeg.py
    homeassistant/components/camera/foscam.py
@@ -245,6 +273,7 @@ omit =
    homeassistant/components/camera/rpi_camera.py
    homeassistant/components/camera/onvif.py
    homeassistant/components/camera/synology.py
+    homeassistant/components/camera/yi.py
    homeassistant/components/climate/eq3btsmart.py
    homeassistant/components/climate/flexit.py
    homeassistant/components/climate/heatmiser.py
@@ -274,6 +303,7 @@ omit =
    homeassistant/components/device_tracker/gpslogger.py
    homeassistant/components/device_tracker/huawei_router.py
    homeassistant/components/device_tracker/icloud.py
+    homeassistant/components/device_tracker/keenetic_ndms2.py
    homeassistant/components/device_tracker/linksys_ap.py
    homeassistant/components/device_tracker/linksys_smart.py
    homeassistant/components/device_tracker/luci.py
@@ -322,10 +352,12 @@ omit =
    homeassistant/components/light/tplink.py
    homeassistant/components/light/tradfri.py
    homeassistant/components/light/x10.py
+    homeassistant/components/light/xiaomi_miio.py
    homeassistant/components/light/yeelight.py
    homeassistant/components/light/yeelightsunflower.py
    homeassistant/components/light/zengge.py
    homeassistant/components/lirc.py
+    homeassistant/components/lock/nello.py
    homeassistant/components/lock/nuki.py
    homeassistant/components/lock/lockitron.py
    homeassistant/components/lock/sesame.py
@@ -373,29 +405,36 @@ omit =
    homeassistant/components/media_player/vlc.py
    homeassistant/components/media_player/volumio.py
    homeassistant/components/media_player/yamaha.py
+    homeassistant/components/media_player/yamaha_musiccast.py
+    homeassistant/components/mycroft.py
    homeassistant/components/notify/aws_lambda.py
    homeassistant/components/notify/aws_sns.py
    homeassistant/components/notify/aws_sqs.py
    homeassistant/components/notify/ciscospark.py
    homeassistant/components/notify/clicksend.py
+    homeassistant/components/notify/clicksend_tts.py
    homeassistant/components/notify/discord.py
    homeassistant/components/notify/facebook.py
    homeassistant/components/notify/free_mobile.py
    homeassistant/components/notify/gntp.py
    homeassistant/components/notify/group.py
+    homeassistant/components/notify/hipchat.py
    homeassistant/components/notify/instapush.py
    homeassistant/components/notify/kodi.py
    homeassistant/components/notify/lannouncer.py
    homeassistant/components/notify/llamalab_automate.py
    homeassistant/components/notify/matrix.py
    homeassistant/components/notify/message_bird.py
+    homeassistant/components/notify/mycroft.py
    homeassistant/components/notify/nfandroidtv.py
    homeassistant/components/notify/nma.py
+    homeassistant/components/notify/prowl.py
    homeassistant/components/notify/pushbullet.py
    homeassistant/components/notify/pushetta.py
    homeassistant/components/notify/pushover.py
    homeassistant/components/notify/pushsafer.py
    homeassistant/components/notify/rest.py
+    homeassistant/components/notify/rocketchat.py
    homeassistant/components/notify/sendgrid.py
    homeassistant/components/notify/simplepush.py
    homeassistant/components/notify/slack.py
@@ -411,6 +450,7 @@ omit =
    homeassistant/components/remote/itach.py
    homeassistant/components/scene/hunterdouglas_powerview.py
    homeassistant/components/scene/lifx_cloud.py
+    homeassistant/components/sensor/airvisual.py
    homeassistant/components/sensor/arest.py
    homeassistant/components/sensor/arwn.py
    homeassistant/components/sensor/bbox.py
@@ -436,6 +476,7 @@ omit =
    homeassistant/components/sensor/dovado.py
    homeassistant/components/sensor/dte_energy_bridge.py
    homeassistant/components/sensor/dublin_bus_transport.py
+    homeassistant/components/sensor/dwd_weather_warnings.py
    homeassistant/components/sensor/ebox.py
    homeassistant/components/sensor/eddystone_temperature.py
    homeassistant/components/sensor/eliqonline.py
@@ -471,6 +512,7 @@ omit =
    homeassistant/components/sensor/metoffice.py
    homeassistant/components/sensor/miflora.py
    homeassistant/components/sensor/modem_callerid.py
+    homeassistant/components/sensor/mopar.py
    homeassistant/components/sensor/mqtt_room.py
    homeassistant/components/sensor/mvglive.py
    homeassistant/components/sensor/netdata.py
@@ -495,6 +537,7 @@ omit =
    homeassistant/components/sensor/sabnzbd.py
    homeassistant/components/sensor/scrape.py
    homeassistant/components/sensor/sensehat.py
+    homeassistant/components/sensor/serial.py
    homeassistant/components/sensor/serial_pm.py
    homeassistant/components/sensor/shodan.py
    homeassistant/components/sensor/skybeacon.py
@@ -508,18 +551,22 @@ omit =
    homeassistant/components/sensor/swiss_public_transport.py
    homeassistant/components/sensor/synologydsm.py
    homeassistant/components/sensor/systemmonitor.py
+    homeassistant/components/sensor/tank_utility.py
    homeassistant/components/sensor/ted5000.py
    homeassistant/components/sensor/temper.py
+    homeassistant/components/sensor/tibber.py
    homeassistant/components/sensor/time_date.py
    homeassistant/components/sensor/torque.py
    homeassistant/components/sensor/transmission.py
+    homeassistant/components/sensor/travisci.py
    homeassistant/components/sensor/twitch.py
    homeassistant/components/sensor/uber.py
    homeassistant/components/sensor/upnp.py
    homeassistant/components/sensor/ups.py
-    homeassistant/components/sensor/usps.py
    homeassistant/components/sensor/vasttrafik.py
    homeassistant/components/sensor/waqi.py
+    homeassistant/components/sensor/worldtidesinfo.py
+    homeassistant/components/sensor/worxlandroid.py
    homeassistant/components/sensor/xbox_live.py
    homeassistant/components/sensor/yweather.py
    homeassistant/components/sensor/zamg.py
@@ -545,13 +592,14 @@ omit =
    homeassistant/components/switch/rest.py
    homeassistant/components/switch/rpi_rf.py
    homeassistant/components/switch/tplink.py
+    homeassistant/components/switch/telnet.py
    homeassistant/components/switch/transmission.py
    homeassistant/components/switch/wake_on_lan.py
+    homeassistant/components/switch/xiaomi_miio.py
    homeassistant/components/telegram_bot/*
    homeassistant/components/thingspeak.py
    homeassistant/components/tts/amazon_polly.py
    homeassistant/components/tts/picotts.py
-    homeassistant/components/upnp.py
    homeassistant/components/vacuum/roomba.py
    homeassistant/components/weather/bom.py
    homeassistant/components/weather/buienradar.py
@@ -561,6 +609,7 @@ omit =
    homeassistant/components/weather/zamg.py
    homeassistant/components/zeroconf.py
    homeassistant/components/zwave/util.py
+    homeassistant/components/vacuum/mqtt.py


 [report]
--- a/.gitignore
+++ b/.gitignore
@@ -94,3 +94,6 @@ docs/build

 # Windows Explorer
 desktop.ini
+/home-assistant.pyproj
+/home-assistant.sln
+/.vs/home-assistant/v14
--- a/25
+++ b/25
@@ -29,6 +29,9 @@ homeassistant/components/weblink.py @home-assistant/core
 homeassistant/components/websocket_api.py @home-assistant/core
 homeassistant/components/zone.py @home-assistant/core

+# To monitor non-pypi additions
+requirements_all.txt @andrey-git
+
 Dockerfile @home-assistant/docker
 virtualization/Docker/* @home-assistant/docker

@@ -36,6 +39,28 @@ homeassistant/components/zwave/* @home-assistant/z-wave
 homeassistant/components/*/zwave.py @home-assistant/z-wave

 # Indiviudal components
+homeassistant/components/alarm_control_panel/egardia.py @jeroenterheerdt
+homeassistant/components/camera/yi.py @bachya
+homeassistant/components/climate/eq3btsmart.py @rytilahti
+homeassistant/components/climate/sensibo.py @andrey-git
 homeassistant/components/cover/template.py @PhracturedBlue
 homeassistant/components/device_tracker/automatic.py @armills
+homeassistant/components/history_graph.py @andrey-git
+homeassistant/components/light/tplink.py @rytilahti
+homeassistant/components/light/yeelight.py @rytilahti
 homeassistant/components/media_player/kodi.py @armills
+homeassistant/components/media_player/monoprice.py @etsinko
+homeassistant/components/sensor/airvisual.py @bachya
+homeassistant/components/sensor/miflora.py @danielhiversen
+homeassistant/components/sensor/tibber.py @danielhiversen
+homeassistant/components/sensor/waqi.py @andrey-git
+homeassistant/components/switch/rainmachine.py @bachya
+homeassistant/components/switch/tplink.py @rytilahti
+
+homeassistant/components/*/axis.py @Kane610
+homeassistant/components/*/broadlink.py @danielhiversen
+homeassistant/components/*/rfxtrx.py @danielhiversen
+homeassistant/components/tesla.py @zabuldon
+homeassistant/components/*/tesla.py @zabuldon
+homeassistant/components/*/xiaomi_aqara.py @danielhiversen
+homeassistant/components/*/xiaomi_miio.py @rytilahti
--- a/6
+++ b/6
@@ -11,7 +11,6 @@ MAINTAINER Paulus Schoutsen <Paulus@PaulusSchoutsen.nl>
 #ENV INSTALL_FFMPEG no
 #ENV INSTALL_LIBCEC no
 #ENV INSTALL_PHANTOMJS no
-#ENV INSTALL_COAP_CLIENT no
 #ENV INSTALL_SSOCR no

 VOLUME /config
@@ -25,11 +24,10 @@ RUN virtualization/Docker/setup_docker_prereqs

 # Install hass component dependencies
 COPY requirements_all.txt requirements_all.txt
-
-# Uninstall enum34 because some depenndecies install it but breaks Python 3.4+.
+# Uninstall enum34 because some dependencies install it but breaks Python 3.4+.
 # See PR #8103 for more info.
 RUN pip3 install --no-cache-dir -r requirements_all.txt && \
-    pip3 install --no-cache-dir mysqlclient psycopg2 uvloop cchardet
+    pip3 install --no-cache-dir mysqlclient psycopg2 uvloop cchardet cython

 # Copy source
 COPY . .
--- a/README.rst
+++ b/README.rst
@@ -33,10 +33,6 @@ of a component, check the `Home Assistant help section <https://home-assistant.i
   :target: https://coveralls.io/r/home-assistant/home-assistant?branch=master
 .. |Chat Status| image:: https://img.shields.io/discord/330944238910963714.svg
   :target: https://discord.gg/c5DvZ4e
-.. |Join the chat at https://gitter.im/home-assistant/home-assistant| image:: https://img.shields.io/badge/gitter-general-blue.svg
-   :target: https://gitter.im/home-assistant/home-assistant?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge
-.. |Join the dev chat at https://gitter.im/home-assistant/home-assistant/devs| image:: https://img.shields.io/badge/gitter-development-yellowgreen.svg
-   :target: https://gitter.im/home-assistant/home-assistant/devs?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge
 .. |screenshot-states| image:: https://raw.github.com/home-assistant/home-assistant/master/docs/screenshots.png
   :target: https://home-assistant.io/demo/
 .. |screenshot-components| image:: https://raw.github.com/home-assistant/home-assistant/dev/docs/screenshot-components.png
--- a/docs/source/conf.py
+++ b/docs/source/conf.py
@@ -117,7 +117,11 @@ def linkcode_resolve(domain, info):
        linespec = "#L%d" % (lineno + 1)
    else:
        linespec = ""
-    fn = relpath(fn, start='../')
+    index = fn.find("/homeassistant/")
+    if index == -1:
+        index = 0
+
+    fn = fn[index:]

    return '{}/blob/{}/{}{}'.format(GITHUB_URL, code_branch, fn, linespec)

--- a/homeassistant/main.py
+++ b/homeassistant/main.py
@@ -126,6 +126,12 @@ def get_arguments() -> argparse.Namespace:
        type=int,
        default=None,
        help='Enables daily log rotation and keeps up to the specified days')
+    parser.add_argument(
+        '--log-file',
+        type=str,
+        default=None,
+        help='Log file to write to.  If not set, CONFIG/home-assistant.log '
+             'is used')
    parser.add_argument(
        '--runner',
        action='store_true',
@@ -256,13 +262,14 @@ def setup_and_run_hass(config_dir: str,
        }
        hass = bootstrap.from_config_dict(
            config, config_dir=config_dir, verbose=args.verbose,
-            skip_pip=args.skip_pip, log_rotate_days=args.log_rotate_days)
+            skip_pip=args.skip_pip, log_rotate_days=args.log_rotate_days,
+            log_file=args.log_file)
    else:
        config_file = ensure_config_file(config_dir)
        print('Config directory:', config_dir)
        hass = bootstrap.from_config_file(
            config_file, verbose=args.verbose, skip_pip=args.skip_pip,
-            log_rotate_days=args.log_rotate_days)
+            log_rotate_days=args.log_rotate_days, log_file=args.log_file)

    if hass is None:
        return None
--- a/homeassistant/bootstrap.py
+++ b/homeassistant/bootstrap.py
@@ -11,13 +11,11 @@ from typing import Any, Optional, Dict

 import voluptuous as vol

-import homeassistant.components as core_components
+from homeassistant import (
+    core, config as conf_util, loader, components as core_components)
 from homeassistant.components import persistent_notification
-import homeassistant.config as conf_util
-import homeassistant.core as core
 from homeassistant.const import EVENT_HOMEASSISTANT_CLOSE
 from homeassistant.setup import async_setup_component
-import homeassistant.loader as loader
 from homeassistant.util.logging import AsyncHandler
 from homeassistant.util.package import async_get_user_site, get_user_site
 from homeassistant.util.yaml import clear_secret_cache
@@ -27,6 +25,10 @@ from homeassistant.helpers.signal import async_register_signal_handling
 _LOGGER = logging.getLogger(__name__)

 ERROR_LOG_FILENAME = 'home-assistant.log'
+
+# hass.data key for logging information.
+DATA_LOGGING = 'logging'
+
 FIRST_INIT_COMPONENT = set((
    'recorder', 'mqtt', 'mqtt_eventstream', 'logger', 'introduction',
    'frontend', 'history'))
@@ -38,7 +40,8 @@ def from_config_dict(config: Dict[str, Any],
                     enable_log: bool=True,
                     verbose: bool=False,
                     skip_pip: bool=False,
-                     log_rotate_days: Any=None) \
+                     log_rotate_days: Any=None,
+                     log_file: Any=None) \
                     -> Optional[core.HomeAssistant]:
    """Try to configure Home Assistant from a configuration dictionary.

@@ -56,7 +59,7 @@ def from_config_dict(config: Dict[str, Any],
    hass = hass.loop.run_until_complete(
        async_from_config_dict(
            config, hass, config_dir, enable_log, verbose, skip_pip,
-            log_rotate_days)
+            log_rotate_days, log_file)
    )

    return hass
@@ -69,7 +72,8 @@ def async_from_config_dict(config: Dict[str, Any],
                           enable_log: bool=True,
                           verbose: bool=False,
                           skip_pip: bool=False,
-                           log_rotate_days: Any=None) \
+                           log_rotate_days: Any=None,
+                           log_file: Any=None) \
                           -> Optional[core.HomeAssistant]:
    """Try to configure Home Assistant from a configuration dictionary.

@@ -77,6 +81,18 @@ def async_from_config_dict(config: Dict[str, Any],
    This method is a coroutine.
    """
    start = time()
+
+    if enable_log:
+        async_enable_logging(hass, verbose, log_rotate_days, log_file)
+
+    if sys.version_info[:2] < (3, 5):
+        _LOGGER.warning(
+            'Python 3.4 support has been deprecated and will be removed in '
+            'the begining of 2018. Please upgrade Python or your operating '
+            'system. More info: https://home-assistant.io/blog/2017/10/06/'
+            'deprecating-python-3.4-support/'
+        )
+
    core_config = config.get(core.DOMAIN, {})

    try:
@@ -87,9 +103,6 @@ def async_from_config_dict(config: Dict[str, Any],

    yield from hass.async_add_job(conf_util.process_ha_config_upgrade, hass)

-    if enable_log:
-        async_enable_logging(hass, verbose, log_rotate_days)
-
    hass.config.skip_pip = skip_pip
    if skip_pip:
        _LOGGER.warning("Skipping pip installation of required modules. "
@@ -153,7 +166,8 @@ def from_config_file(config_path: str,
                     hass: Optional[core.HomeAssistant]=None,
                     verbose: bool=False,
                     skip_pip: bool=True,
-                     log_rotate_days: Any=None):
+                     log_rotate_days: Any=None,
+                     log_file: Any=None):
    """Read the configuration file and try to start all the functionality.

    Will add functionality to 'hass' parameter if given,
@@ -165,7 +179,7 @@ def from_config_file(config_path: str,
    # run task
    hass = hass.loop.run_until_complete(
        async_from_config_file(
-            config_path, hass, verbose, skip_pip, log_rotate_days)
+            config_path, hass, verbose, skip_pip, log_rotate_days, log_file)
    )

    return hass
@@ -176,7 +190,8 @@ def async_from_config_file(config_path: str,
                           hass: core.HomeAssistant,
                           verbose: bool=False,
                           skip_pip: bool=True,
-                           log_rotate_days: Any=None):
+                           log_rotate_days: Any=None,
+                           log_file: Any=None):
    """Read the configuration file and try to start all the functionality.

    Will add functionality to 'hass' parameter.
@@ -187,7 +202,7 @@ def async_from_config_file(config_path: str,
    hass.config.config_dir = config_dir
    yield from async_mount_local_lib_path(config_dir, hass.loop)

-    async_enable_logging(hass, verbose, log_rotate_days)
+    async_enable_logging(hass, verbose, log_rotate_days, log_file)

    try:
        config_dict = yield from hass.async_add_job(
@@ -205,7 +220,7 @@ def async_from_config_file(config_path: str,

@core.callback
 def async_enable_logging(hass: core.HomeAssistant, verbose: bool=False,
-                         log_rotate_days=None) -> None:
+                         log_rotate_days=None, log_file=None) -> None:
    """Set up the logging.

    This method must be run in the event loop.
@@ -239,13 +254,18 @@ def async_enable_logging(hass: core.HomeAssistant, verbose: bool=False,
        pass

    # Log errors to a file if we have write access to file or config dir
-    err_log_path = hass.config.path(ERROR_LOG_FILENAME)
+    if log_file is None:
+        err_log_path = hass.config.path(ERROR_LOG_FILENAME)
+    else:
+        err_log_path = os.path.abspath(log_file)
+
    err_path_exists = os.path.isfile(err_log_path)
+    err_dir = os.path.dirname(err_log_path)

    # Check if we can write to the error log if it exists or that
    # we can create files in the containing directory if not.
    if (err_path_exists and os.access(err_log_path, os.W_OK)) or \
-       (not err_path_exists and os.access(hass.config.config_dir, os.W_OK)):
+       (not err_path_exists and os.access(err_dir, os.W_OK)):

        if log_rotate_days:
            err_handler = logging.handlers.TimedRotatingFileHandler(
@@ -272,6 +292,8 @@ def async_enable_logging(hass: core.HomeAssistant, verbose: bool=False,
        logger.addHandler(async_handler)
        logger.setLevel(logging.INFO)

+        # Save the log file location for access by other components.
+        hass.data[DATA_LOGGING] = err_log_path
    else:
        _LOGGER.error(
            "Unable to setup error log %s (access denied)", err_log_path)
--- a/homeassistant/components/init.py
+++ b/homeassistant/components/init.py
@@ -10,6 +10,7 @@ Component design guidelines:
 import asyncio
 import itertools as it
 import logging
+import os

 import homeassistant.core as ha
 import homeassistant.config as conf_util
@@ -101,9 +102,20 @@ def reload_core_config(hass):
    hass.services.call(ha.DOMAIN, SERVICE_RELOAD_CORE_CONFIG)


+@asyncio.coroutine
+def async_reload_core_config(hass):
+    """Reload the core config."""
+    yield from hass.services.async_call(ha.DOMAIN, SERVICE_RELOAD_CORE_CONFIG)
+
+
@asyncio.coroutine
 def async_setup(hass, config):
    """Set up general services related to Home Assistant."""
+    descriptions = yield from hass.async_add_job(
+        conf_util.load_yaml_config_file, os.path.join(
+            os.path.dirname(__file__), 'services.yaml')
+    )
+
    @asyncio.coroutine
    def async_handle_turn_service(service):
        """Handle calls to homeassistant.turn_on/off."""
@@ -143,11 +155,14 @@ def async_setup(hass, config):
        yield from asyncio.wait(tasks, loop=hass.loop)

    hass.services.async_register(
-        ha.DOMAIN, SERVICE_TURN_OFF, async_handle_turn_service)
+        ha.DOMAIN, SERVICE_TURN_OFF, async_handle_turn_service,
+        descriptions[ha.DOMAIN][SERVICE_TURN_OFF])
    hass.services.async_register(
-        ha.DOMAIN, SERVICE_TURN_ON, async_handle_turn_service)
+        ha.DOMAIN, SERVICE_TURN_ON, async_handle_turn_service,
+        descriptions[ha.DOMAIN][SERVICE_TURN_ON])
    hass.services.async_register(
-        ha.DOMAIN, SERVICE_TOGGLE, async_handle_turn_service)
+        ha.DOMAIN, SERVICE_TOGGLE, async_handle_turn_service,
+        descriptions[ha.DOMAIN][SERVICE_TOGGLE])

    @asyncio.coroutine
    def async_handle_core_service(call):
@@ -172,11 +187,14 @@ def async_setup(hass, config):
            hass.async_add_job(hass.async_stop(RESTART_EXIT_CODE))

    hass.services.async_register(
-        ha.DOMAIN, SERVICE_HOMEASSISTANT_STOP, async_handle_core_service)
+        ha.DOMAIN, SERVICE_HOMEASSISTANT_STOP, async_handle_core_service,
+        descriptions[ha.DOMAIN][SERVICE_HOMEASSISTANT_STOP])
    hass.services.async_register(
-        ha.DOMAIN, SERVICE_HOMEASSISTANT_RESTART, async_handle_core_service)
+        ha.DOMAIN, SERVICE_HOMEASSISTANT_RESTART, async_handle_core_service,
+        descriptions[ha.DOMAIN][SERVICE_HOMEASSISTANT_RESTART])
    hass.services.async_register(
-        ha.DOMAIN, SERVICE_CHECK_CONFIG, async_handle_core_service)
+        ha.DOMAIN, SERVICE_CHECK_CONFIG, async_handle_core_service,
+        descriptions[ha.DOMAIN][SERVICE_CHECK_CONFIG])

    @asyncio.coroutine
    def async_handle_reload_config(call):
@@ -191,6 +209,7 @@ def async_setup(hass, config):
            hass, conf.get(ha.DOMAIN) or {})

    hass.services.async_register(
-        ha.DOMAIN, SERVICE_RELOAD_CORE_CONFIG, async_handle_reload_config)
+        ha.DOMAIN, SERVICE_RELOAD_CORE_CONFIG, async_handle_reload_config,
+        descriptions[ha.DOMAIN][SERVICE_RELOAD_CORE_CONFIG])

    return True
--- a/homeassistant/components/abode.py
+++ b/homeassistant/components/abode.py
@@ -0,0 +1,352 @@
+"""
+This component provides basic support for Abode Home Security system.
+
+For more details about this component, please refer to the documentation at
+https://home-assistant.io/components/abode/
+"""
+import asyncio
+import logging
+from functools import partial
+from os import path
+
+import voluptuous as vol
+
+from homeassistant.config import load_yaml_config_file
+from homeassistant.const import (
+    ATTR_ATTRIBUTION, ATTR_DATE, ATTR_TIME, ATTR_ENTITY_ID, CONF_USERNAME,
+    CONF_PASSWORD, CONF_EXCLUDE, CONF_NAME, CONF_LIGHTS,
+    EVENT_HOMEASSISTANT_STOP, EVENT_HOMEASSISTANT_START)
+from homeassistant.helpers import config_validation as cv
+from homeassistant.helpers import discovery
+from homeassistant.helpers.entity import Entity
+from requests.exceptions import HTTPError, ConnectTimeout
+
+REQUIREMENTS = ['abodepy==0.12.1']
+
+_LOGGER = logging.getLogger(__name__)
+
+CONF_ATTRIBUTION = "Data provided by goabode.com"
+CONF_POLLING = 'polling'
+
+DOMAIN = 'abode'
+
+NOTIFICATION_ID = 'abode_notification'
+NOTIFICATION_TITLE = 'Abode Security Setup'
+
+EVENT_ABODE_ALARM = 'abode_alarm'
+EVENT_ABODE_ALARM_END = 'abode_alarm_end'
+EVENT_ABODE_AUTOMATION = 'abode_automation'
+EVENT_ABODE_FAULT = 'abode_panel_fault'
+EVENT_ABODE_RESTORE = 'abode_panel_restore'
+
+SERVICE_SETTINGS = 'change_setting'
+SERVICE_CAPTURE_IMAGE = 'capture_image'
+SERVICE_TRIGGER = 'trigger_quick_action'
+
+ATTR_DEVICE_ID = 'device_id'
+ATTR_DEVICE_NAME = 'device_name'
+ATTR_DEVICE_TYPE = 'device_type'
+ATTR_EVENT_CODE = 'event_code'
+ATTR_EVENT_NAME = 'event_name'
+ATTR_EVENT_TYPE = 'event_type'
+ATTR_EVENT_UTC = 'event_utc'
+ATTR_SETTING = 'setting'
+ATTR_USER_NAME = 'user_name'
+ATTR_VALUE = 'value'
+
+ABODE_DEVICE_ID_LIST_SCHEMA = vol.Schema([str])
+
+CONFIG_SCHEMA = vol.Schema({
+    DOMAIN: vol.Schema({
+        vol.Required(CONF_USERNAME): cv.string,
+        vol.Required(CONF_PASSWORD): cv.string,
+        vol.Optional(CONF_NAME): cv.string,
+        vol.Optional(CONF_POLLING, default=False): cv.boolean,
+        vol.Optional(CONF_EXCLUDE, default=[]): ABODE_DEVICE_ID_LIST_SCHEMA,
+        vol.Optional(CONF_LIGHTS, default=[]): ABODE_DEVICE_ID_LIST_SCHEMA
+    }),
+}, extra=vol.ALLOW_EXTRA)
+
+CHANGE_SETTING_SCHEMA = vol.Schema({
+    vol.Required(ATTR_SETTING): cv.string,
+    vol.Required(ATTR_VALUE): cv.string
+})
+
+CAPTURE_IMAGE_SCHEMA = vol.Schema({
+    ATTR_ENTITY_ID: cv.entity_ids,
+})
+
+TRIGGER_SCHEMA = vol.Schema({
+    ATTR_ENTITY_ID: cv.entity_ids,
+})
+
+ABODE_PLATFORMS = [
+    'alarm_control_panel', 'binary_sensor', 'lock', 'switch', 'cover',
+    'camera', 'light'
+]
+
+
+class AbodeSystem(object):
+    """Abode System class."""
+
+    def __init__(self, username, password, name, polling, exclude, lights):
+        """Initialize the system."""
+        import abodepy
+        self.abode = abodepy.Abode(
+            username, password, auto_login=True, get_devices=True,
+            get_automations=True)
+        self.name = name
+        self.polling = polling
+        self.exclude = exclude
+        self.lights = lights
+        self.devices = []
+
+    def is_excluded(self, device):
+        """Check if a device is configured to be excluded."""
+        return device.device_id in self.exclude
+
+    def is_automation_excluded(self, automation):
+        """Check if an automation is configured to be excluded."""
+        return automation.automation_id in self.exclude
+
+    def is_light(self, device):
+        """Check if a switch device is configured as a light."""
+        import abodepy.helpers.constants as CONST
+
+        return (device.generic_type == CONST.TYPE_LIGHT or
+                (device.generic_type == CONST.TYPE_SWITCH and
+                 device.device_id in self.lights))
+
+
+def setup(hass, config):
+    """Set up Abode component."""
+    from abodepy.exceptions import AbodeException
+
+    conf = config[DOMAIN]
+    username = conf.get(CONF_USERNAME)
+    password = conf.get(CONF_PASSWORD)
+    name = conf.get(CONF_NAME)
+    polling = conf.get(CONF_POLLING)
+    exclude = conf.get(CONF_EXCLUDE)
+    lights = conf.get(CONF_LIGHTS)
+
+    try:
+        hass.data[DOMAIN] = AbodeSystem(
+            username, password, name, polling, exclude, lights)
+    except (AbodeException, ConnectTimeout, HTTPError) as ex:
+        _LOGGER.error("Unable to connect to Abode: %s", str(ex))
+
+        hass.components.persistent_notification.create(
+            'Error: {}<br />'
+            'You will need to restart hass after fixing.'
+            ''.format(ex),
+            title=NOTIFICATION_TITLE,
+            notification_id=NOTIFICATION_ID)
+        return False
+
+    setup_hass_services(hass)
+    setup_hass_events(hass)
+    setup_abode_events(hass)
+
+    for platform in ABODE_PLATFORMS:
+        discovery.load_platform(hass, platform, DOMAIN, {}, config)
+
+    return True
+
+
+def setup_hass_services(hass):
+    """Home assistant services."""
+    from abodepy.exceptions import AbodeException
+
+    def change_setting(call):
+        """Change an Abode system setting."""
+        setting = call.data.get(ATTR_SETTING)
+        value = call.data.get(ATTR_VALUE)
+
+        try:
+            hass.data[DOMAIN].abode.set_setting(setting, value)
+        except AbodeException as ex:
+            _LOGGER.warning(ex)
+
+    def capture_image(call):
+        """Capture a new image."""
+        entity_ids = call.data.get(ATTR_ENTITY_ID)
+
+        target_devices = [device for device in hass.data[DOMAIN].devices
+                          if device.entity_id in entity_ids]
+
+        for device in target_devices:
+            device.capture()
+
+    def trigger_quick_action(call):
+        """Trigger a quick action."""
+        entity_ids = call.data.get(ATTR_ENTITY_ID, None)
+
+        target_devices = [device for device in hass.data[DOMAIN].devices
+                          if device.entity_id in entity_ids]
+
+        for device in target_devices:
+            device.trigger()
+
+    descriptions = load_yaml_config_file(
+        path.join(path.dirname(__file__), 'services.yaml'))[DOMAIN]
+
+    hass.services.register(
+        DOMAIN, SERVICE_SETTINGS, change_setting,
+        descriptions.get(SERVICE_SETTINGS),
+        schema=CHANGE_SETTING_SCHEMA)
+
+    hass.services.register(
+        DOMAIN, SERVICE_CAPTURE_IMAGE, capture_image,
+        descriptions.get(SERVICE_CAPTURE_IMAGE),
+        schema=CAPTURE_IMAGE_SCHEMA)
+
+    hass.services.register(
+        DOMAIN, SERVICE_TRIGGER, trigger_quick_action,
+        descriptions.get(SERVICE_TRIGGER),
+        schema=TRIGGER_SCHEMA)
+
+
+def setup_hass_events(hass):
+    """Home Assistant start and stop callbacks."""
+    def startup(event):
+        """Listen for push events."""
+        hass.data[DOMAIN].abode.events.start()
+
+    def logout(event):
+        """Logout of Abode."""
+        if not hass.data[DOMAIN].polling:
+            hass.data[DOMAIN].abode.events.stop()
+
+        hass.data[DOMAIN].abode.logout()
+        _LOGGER.info("Logged out of Abode")
+
+    if not hass.data[DOMAIN].polling:
+        hass.bus.listen_once(EVENT_HOMEASSISTANT_START, startup)
+
+    hass.bus.listen_once(EVENT_HOMEASSISTANT_STOP, logout)
+
+
+def setup_abode_events(hass):
+    """Event callbacks."""
+    import abodepy.helpers.timeline as TIMELINE
+
+    def event_callback(event, event_json):
+        """Handle an event callback from Abode."""
+        data = {
+            ATTR_DEVICE_ID: event_json.get(ATTR_DEVICE_ID, ''),
+            ATTR_DEVICE_NAME: event_json.get(ATTR_DEVICE_NAME, ''),
+            ATTR_DEVICE_TYPE: event_json.get(ATTR_DEVICE_TYPE, ''),
+            ATTR_EVENT_CODE: event_json.get(ATTR_EVENT_CODE, ''),
+            ATTR_EVENT_NAME: event_json.get(ATTR_EVENT_NAME, ''),
+            ATTR_EVENT_TYPE: event_json.get(ATTR_EVENT_TYPE, ''),
+            ATTR_EVENT_UTC: event_json.get(ATTR_EVENT_UTC, ''),
+            ATTR_USER_NAME: event_json.get(ATTR_USER_NAME, ''),
+            ATTR_DATE: event_json.get(ATTR_DATE, ''),
+            ATTR_TIME: event_json.get(ATTR_TIME, ''),
+        }
+
+        hass.bus.fire(event, data)
+
+    events = [TIMELINE.ALARM_GROUP, TIMELINE.ALARM_END_GROUP,
+              TIMELINE.PANEL_FAULT_GROUP, TIMELINE.PANEL_RESTORE_GROUP,
+              TIMELINE.AUTOMATION_GROUP]
+
+    for event in events:
+        hass.data[DOMAIN].abode.events.add_event_callback(
+            event,
+            partial(event_callback, event))
+
+
+class AbodeDevice(Entity):
+    """Representation of an Abode device."""
+
+    def __init__(self, data, device):
+        """Initialize a sensor for Abode device."""
+        self._data = data
+        self._device = device
+
+    @asyncio.coroutine
+    def async_added_to_hass(self):
+        """Subscribe Abode events."""
+        self.hass.async_add_job(
+            self._data.abode.events.add_device_callback,
+            self._device.device_id, self._update_callback
+        )
+
+    @property
+    def should_poll(self):
+        """Return the polling state."""
+        return self._data.polling
+
+    def update(self):
+        """Update automation state."""
+        self._device.refresh()
+
+    @property
+    def name(self):
+        """Return the name of the sensor."""
+        return self._device.name
+
+    @property
+    def device_state_attributes(self):
+        """Return the state attributes."""
+        return {
+            ATTR_ATTRIBUTION: CONF_ATTRIBUTION,
+            'device_id': self._device.device_id,
+            'battery_low': self._device.battery_low,
+            'no_response': self._device.no_response,
+            'device_type': self._device.type
+        }
+
+    def _update_callback(self, device):
+        """Update the device state."""
+        self.schedule_update_ha_state()
+
+
+class AbodeAutomation(Entity):
+    """Representation of an Abode automation."""
+
+    def __init__(self, data, automation, event=None):
+        """Initialize for Abode automation."""
+        self._data = data
+        self._automation = automation
+        self._event = event
+
+    @asyncio.coroutine
+    def async_added_to_hass(self):
+        """Subscribe Abode events."""
+        if self._event:
+            self.hass.async_add_job(
+                self._data.abode.events.add_event_callback,
+                self._event, self._update_callback
+            )
+
+    @property
+    def should_poll(self):
+        """Return the polling state."""
+        return self._data.polling
+
+    def update(self):
+        """Update automation state."""
+        self._automation.refresh()
+
+    @property
+    def name(self):
+        """Return the name of the sensor."""
+        return self._automation.name
+
+    @property
+    def device_state_attributes(self):
+        """Return the state attributes."""
+        return {
+            ATTR_ATTRIBUTION: CONF_ATTRIBUTION,
+            'automation_id': self._automation.automation_id,
+            'type': self._automation.type,
+            'sub_type': self._automation.sub_type
+        }
+
+    def _update_callback(self, device):
+        """Update the device state."""
+        self._automation.refresh()
+        self.schedule_update_ha_state()
--- a/homeassistant/components/alarm_control_panel/init.py
+++ b/homeassistant/components/alarm_control_panel/init.py
@@ -13,7 +13,8 @@ import voluptuous as vol

 from homeassistant.const import (
    ATTR_CODE, ATTR_CODE_FORMAT, ATTR_ENTITY_ID, SERVICE_ALARM_TRIGGER,
-    SERVICE_ALARM_DISARM, SERVICE_ALARM_ARM_HOME, SERVICE_ALARM_ARM_AWAY)
+    SERVICE_ALARM_DISARM, SERVICE_ALARM_ARM_HOME, SERVICE_ALARM_ARM_AWAY,
+    SERVICE_ALARM_ARM_NIGHT)
 from homeassistant.config import load_yaml_config_file
 from homeassistant.loader import bind_hass
 from homeassistant.helpers.config_validation import PLATFORM_SCHEMA  # noqa
@@ -31,6 +32,7 @@ SERVICE_TO_METHOD = {
    SERVICE_ALARM_DISARM: 'alarm_disarm',
    SERVICE_ALARM_ARM_HOME: 'alarm_arm_home',
    SERVICE_ALARM_ARM_AWAY: 'alarm_arm_away',
+    SERVICE_ALARM_ARM_NIGHT: 'alarm_arm_night',
    SERVICE_ALARM_TRIGGER: 'alarm_trigger'
 }

@@ -81,6 +83,18 @@ def alarm_arm_away(hass, code=None, entity_id=None):
    hass.services.call(DOMAIN, SERVICE_ALARM_ARM_AWAY, data)


+@bind_hass
+def alarm_arm_night(hass, code=None, entity_id=None):
+    """Send the alarm the command for arm night."""
+    data = {}
+    if code:
+        data[ATTR_CODE] = code
+    if entity_id:
+        data[ATTR_ENTITY_ID] = entity_id
+
+    hass.services.call(DOMAIN, SERVICE_ALARM_ARM_NIGHT, data)
+
+
@bind_hass
 def alarm_trigger(hass, code=None, entity_id=None):
    """Send the alarm the command for trigger."""
@@ -110,20 +124,13 @@ def async_setup(hass, config):

        method = "async_{}".format(SERVICE_TO_METHOD[service.service])

+        update_tasks = []
        for alarm in target_alarms:
            yield from getattr(alarm, method)(code)

-        update_tasks = []
-        for alarm in target_alarms:
            if not alarm.should_poll:
                continue
-
-            update_coro = hass.async_add_job(
-                alarm.async_update_ha_state(True))
-            if hasattr(alarm, 'async_update'):
-                update_tasks.append(update_coro)
-            else:
-                yield from update_coro
+            update_tasks.append(alarm.async_update_ha_state(True))

        if update_tasks:
            yield from asyncio.wait(update_tasks, loop=hass.loop)
@@ -187,6 +194,17 @@ class AlarmControlPanel(Entity):
        """
        return self.hass.async_add_job(self.alarm_arm_away, code)

+    def alarm_arm_night(self, code=None):
+        """Send arm night command."""
+        raise NotImplementedError()
+
+    def async_alarm_arm_night(self, code=None):
+        """Send arm night command.
+
+        This method must be run in the event loop and returns a coroutine.
+        """
+        return self.hass.async_add_job(self.alarm_arm_night, code)
+
    def alarm_trigger(self, code=None):
        """Send alarm trigger command."""
        raise NotImplementedError()
--- a/homeassistant/components/alarm_control_panel/abode.py
+++ b/homeassistant/components/alarm_control_panel/abode.py
@@ -0,0 +1,85 @@
+"""
+This component provides HA alarm_control_panel support for Abode System.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/alarm_control_panel.abode/
+"""
+import logging
+
+from homeassistant.components.abode import (
+    AbodeDevice, DOMAIN as ABODE_DOMAIN, CONF_ATTRIBUTION)
+from homeassistant.components.alarm_control_panel import (AlarmControlPanel)
+from homeassistant.const import (ATTR_ATTRIBUTION, STATE_ALARM_ARMED_AWAY,
+                                 STATE_ALARM_ARMED_HOME, STATE_ALARM_DISARMED)
+
+
+DEPENDENCIES = ['abode']
+
+_LOGGER = logging.getLogger(__name__)
+
+ICON = 'mdi:security'
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Set up a sensor for an Abode device."""
+    data = hass.data[ABODE_DOMAIN]
+
+    alarm_devices = [AbodeAlarm(data, data.abode.get_alarm(), data.name)]
+
+    data.devices.extend(alarm_devices)
+
+    add_devices(alarm_devices)
+
+
+class AbodeAlarm(AbodeDevice, AlarmControlPanel):
+    """An alarm_control_panel implementation for Abode."""
+
+    def __init__(self, data, device, name):
+        """Initialize the alarm control panel."""
+        super().__init__(data, device)
+        self._name = name
+
+    @property
+    def icon(self):
+        """Return icon."""
+        return ICON
+
+    @property
+    def state(self):
+        """Return the state of the device."""
+        if self._device.is_standby:
+            state = STATE_ALARM_DISARMED
+        elif self._device.is_away:
+            state = STATE_ALARM_ARMED_AWAY
+        elif self._device.is_home:
+            state = STATE_ALARM_ARMED_HOME
+        else:
+            state = None
+        return state
+
+    def alarm_disarm(self, code=None):
+        """Send disarm command."""
+        self._device.set_standby()
+
+    def alarm_arm_home(self, code=None):
+        """Send arm home command."""
+        self._device.set_home()
+
+    def alarm_arm_away(self, code=None):
+        """Send arm away command."""
+        self._device.set_away()
+
+    @property
+    def name(self):
+        """Return the name of the alarm."""
+        return self._name or super().name
+
+    @property
+    def device_state_attributes(self):
+        """Return the state attributes."""
+        return {
+            ATTR_ATTRIBUTION: CONF_ATTRIBUTION,
+            'device_id': self._device.device_id,
+            'battery_backup': self._device.battery,
+            'cellular_backup': self._device.is_cellular
+        }
--- a/homeassistant/components/alarm_control_panel/alarmdecoder.py
+++ b/homeassistant/components/alarm_control_panel/alarmdecoder.py
@@ -57,19 +57,19 @@ class AlarmDecoderAlarmPanel(alarm.AlarmControlPanel):
        if message.alarm_sounding or message.fire_alarm:
            if self._state != STATE_ALARM_TRIGGERED:
                self._state = STATE_ALARM_TRIGGERED
-                self.hass.async_add_job(self.async_update_ha_state())
+                self.async_schedule_update_ha_state()
        elif message.armed_away:
            if self._state != STATE_ALARM_ARMED_AWAY:
                self._state = STATE_ALARM_ARMED_AWAY
-                self.hass.async_add_job(self.async_update_ha_state())
+                self.async_schedule_update_ha_state()
        elif message.armed_home:
            if self._state != STATE_ALARM_ARMED_HOME:
                self._state = STATE_ALARM_ARMED_HOME
-                self.hass.async_add_job(self.async_update_ha_state())
+                self.async_schedule_update_ha_state()
        else:
            if self._state != STATE_ALARM_DISARMED:
                self._state = STATE_ALARM_DISARMED
-                self.hass.async_add_job(self.async_update_ha_state())
+                self.async_schedule_update_ha_state()

    @property
    def name(self):
--- a/homeassistant/components/alarm_control_panel/arlo.py
+++ b/homeassistant/components/alarm_control_panel/arlo.py
@@ -0,0 +1,121 @@
+"""
+Support for Arlo Alarm Control Panels.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/alarm_control_panel.arlo/
+"""
+import asyncio
+import logging
+
+import voluptuous as vol
+
+import homeassistant.helpers.config_validation as cv
+from homeassistant.components.alarm_control_panel import (
+    AlarmControlPanel, PLATFORM_SCHEMA)
+from homeassistant.components.arlo import (DATA_ARLO, CONF_ATTRIBUTION)
+from homeassistant.const import (
+    ATTR_ATTRIBUTION, STATE_ALARM_ARMED_AWAY, STATE_ALARM_ARMED_HOME,
+    STATE_ALARM_DISARMED)
+
+_LOGGER = logging.getLogger(__name__)
+
+ARMED = 'armed'
+
+CONF_HOME_MODE_NAME = 'home_mode_name'
+
+DEPENDENCIES = ['arlo']
+
+DISARMED = 'disarmed'
+
+ICON = 'mdi:security'
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Optional(CONF_HOME_MODE_NAME, default=ARMED): cv.string,
+})
+
+
+@asyncio.coroutine
+def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
+    """Set up the Arlo Alarm Control Panels."""
+    data = hass.data[DATA_ARLO]
+
+    if not data.base_stations:
+        return
+
+    home_mode_name = config.get(CONF_HOME_MODE_NAME)
+    base_stations = []
+    for base_station in data.base_stations:
+        base_stations.append(ArloBaseStation(base_station, home_mode_name))
+    async_add_devices(base_stations, True)
+
+
+class ArloBaseStation(AlarmControlPanel):
+    """Representation of an Arlo Alarm Control Panel."""
+
+    def __init__(self, data, home_mode_name):
+        """Initialize the alarm control panel."""
+        self._base_station = data
+        self._home_mode_name = home_mode_name
+        self._state = None
+
+    @property
+    def icon(self):
+        """Return icon."""
+        return ICON
+
+    @property
+    def state(self):
+        """Return the state of the device."""
+        return self._state
+
+    def update(self):
+        """Update the state of the device."""
+        # PyArlo sometimes returns None for mode. So retry 3 times before
+        # returning None.
+        num_retries = 3
+        i = 0
+        while i < num_retries:
+            mode = self._base_station.mode
+            if mode:
+                self._state = self._get_state_from_mode(mode)
+                return
+            i += 1
+        self._state = None
+
+    @asyncio.coroutine
+    def async_alarm_disarm(self, code=None):
+        """Send disarm command."""
+        self._base_station.mode = DISARMED
+
+    @asyncio.coroutine
+    def async_alarm_arm_away(self, code=None):
+        """Send arm away command."""
+        self._base_station.mode = ARMED
+
+    @asyncio.coroutine
+    def async_alarm_arm_home(self, code=None):
+        """Send arm home command. Uses custom mode."""
+        self._base_station.mode = self._home_mode_name
+
+    @property
+    def name(self):
+        """Return the name of the base station."""
+        return self._base_station.name
+
+    @property
+    def device_state_attributes(self):
+        """Return the state attributes."""
+        return {
+            ATTR_ATTRIBUTION: CONF_ATTRIBUTION,
+            'device_id': self._base_station.device_id
+        }
+
+    def _get_state_from_mode(self, mode):
+        """Convert Arlo mode to Home Assistant state."""
+        if mode == ARMED:
+            return STATE_ALARM_ARMED_AWAY
+        elif mode == DISARMED:
+            return STATE_ALARM_DISARMED
+        elif mode == self._home_mode_name:
+            return STATE_ALARM_ARMED_HOME
+        return None
--- a/homeassistant/components/alarm_control_panel/concord232.py
+++ b/homeassistant/components/alarm_control_panel/concord232.py
@@ -107,7 +107,7 @@ class Concord232Alarm(alarm.AlarmControlPanel):
            newstate = STATE_ALARM_ARMED_AWAY

        if not newstate == self._state:
-            _LOGGER.info("State Chnage from %s to %s", self._state, newstate)
+            _LOGGER.info("State Change from %s to %s", self._state, newstate)
            self._state = newstate
        return self._state

--- a/homeassistant/components/alarm_control_panel/demo.py
+++ b/homeassistant/components/alarm_control_panel/demo.py
@@ -5,10 +5,26 @@ For more details about this platform, please refer to the documentation
 https://home-assistant.io/components/demo/
 """
 import homeassistant.components.alarm_control_panel.manual as manual
+from homeassistant.const import (
+    STATE_ALARM_ARMED_AWAY, STATE_ALARM_ARMED_HOME, STATE_ALARM_ARMED_NIGHT,
+    STATE_ALARM_TRIGGERED, CONF_PENDING_TIME)


 def setup_platform(hass, config, add_devices, discovery_info=None):
    """Set up the Demo alarm control panel platform."""
    add_devices([
-        manual.ManualAlarm(hass, 'Alarm', '1234', 5, 10, False),
+        manual.ManualAlarm(hass, 'Alarm', '1234', 5, 10, False, {
+            STATE_ALARM_ARMED_AWAY: {
+                CONF_PENDING_TIME: 5
+            },
+            STATE_ALARM_ARMED_HOME: {
+                CONF_PENDING_TIME: 5
+            },
+            STATE_ALARM_ARMED_NIGHT: {
+                CONF_PENDING_TIME: 5
+            },
+            STATE_ALARM_TRIGGERED: {
+                CONF_PENDING_TIME: 5
+            },
+        }),
    ])
--- a/homeassistant/components/alarm_control_panel/egardia.py
+++ b/homeassistant/components/alarm_control_panel/egardia.py
@@ -18,18 +18,19 @@ from homeassistant.const import (
    CONF_NAME, STATE_ALARM_DISARMED, STATE_ALARM_ARMED_HOME,
    STATE_ALARM_ARMED_AWAY, STATE_ALARM_TRIGGERED)

-REQUIREMENTS = ['pythonegardia==1.0.17']
+REQUIREMENTS = ['pythonegardia==1.0.22']

 _LOGGER = logging.getLogger(__name__)

 CONF_REPORT_SERVER_CODES = 'report_server_codes'
 CONF_REPORT_SERVER_ENABLED = 'report_server_enabled'
 CONF_REPORT_SERVER_PORT = 'report_server_port'
+CONF_REPORT_SERVER_CODES_IGNORE = 'ignore'

 DEFAULT_NAME = 'Egardia'
 DEFAULT_PORT = 80
 DEFAULT_REPORT_SERVER_ENABLED = False
-DEFAULT_REPORT_SERVER_PORT = 85
+DEFAULT_REPORT_SERVER_PORT = 52010
 DOMAIN = 'egardia'

 NOTIFICATION_ID = 'egardia_notification'
@@ -148,14 +149,21 @@ class EgardiaAlarm(alarm.AlarmControlPanel):

    def parsestatus(self, status):
        """Parse the status."""
-        newstatus = ([v for k, v in STATES.items()
-                      if status.upper() == k][0])
-        self._status = newstatus
+        _LOGGER.debug("Parsing status %s", status)
+        # Ignore the statuscode if it is IGNORE
+        if status.lower().strip() != CONF_REPORT_SERVER_CODES_IGNORE:
+            _LOGGER.debug("Not ignoring status")
+            newstatus = ([v for k, v in STATES.items()
+                          if status.upper() == k][0])
+            self._status = newstatus
+        else:
+            _LOGGER.error("Ignoring status")

    def update(self):
        """Update the alarm status."""
-        status = self._egardiasystem.getstate()
-        self.parsestatus(status)
+        if not self._rs_enabled:
+            status = self._egardiasystem.getstate()
+            self.parsestatus(status)

    def alarm_disarm(self, code=None):
        """Send disarm command."""
--- a/homeassistant/components/alarm_control_panel/envisalink.py
+++ b/homeassistant/components/alarm_control_panel/envisalink.py
@@ -106,7 +106,7 @@ class EnvisalinkAlarm(EnvisalinkDevice, alarm.AlarmControlPanel):
    def _update_callback(self, partition):
        """Update Home Assistant state, if needed."""
        if partition is None or int(partition) == self._partition_number:
-            self.hass.async_add_job(self.async_update_ha_state())
+            self.async_schedule_update_ha_state()

    @property
    def code_format(self):
--- a/homeassistant/components/alarm_control_panel/manual.py
+++ b/homeassistant/components/alarm_control_panel/manual.py
@@ -4,6 +4,7 @@ Support for manual alarms.
 For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/alarm_control_panel.manual/
 """
+import copy
 import datetime
 import logging

@@ -12,9 +13,10 @@ import voluptuous as vol
 import homeassistant.components.alarm_control_panel as alarm
 import homeassistant.util.dt as dt_util
 from homeassistant.const import (
-    STATE_ALARM_ARMED_AWAY, STATE_ALARM_ARMED_HOME, STATE_ALARM_DISARMED,
-    STATE_ALARM_PENDING, STATE_ALARM_TRIGGERED, CONF_PLATFORM, CONF_NAME,
-    CONF_CODE, CONF_PENDING_TIME, CONF_TRIGGER_TIME, CONF_DISARM_AFTER_TRIGGER)
+    STATE_ALARM_ARMED_AWAY, STATE_ALARM_ARMED_HOME, STATE_ALARM_ARMED_NIGHT,
+    STATE_ALARM_DISARMED, STATE_ALARM_PENDING, STATE_ALARM_TRIGGERED,
+    CONF_PLATFORM, CONF_NAME, CONF_CODE, CONF_PENDING_TIME, CONF_TRIGGER_TIME,
+    CONF_DISARM_AFTER_TRIGGER)
 import homeassistant.helpers.config_validation as cv
 from homeassistant.helpers.event import track_point_in_time

@@ -23,7 +25,28 @@ DEFAULT_PENDING_TIME = 60
 DEFAULT_TRIGGER_TIME = 120
 DEFAULT_DISARM_AFTER_TRIGGER = False

-PLATFORM_SCHEMA = vol.Schema({
+SUPPORTED_PENDING_STATES = [STATE_ALARM_ARMED_AWAY, STATE_ALARM_ARMED_HOME,
+                            STATE_ALARM_ARMED_NIGHT, STATE_ALARM_TRIGGERED]
+
+ATTR_POST_PENDING_STATE = 'post_pending_state'
+
+
+def _state_validator(config):
+    config = copy.deepcopy(config)
+    for state in SUPPORTED_PENDING_STATES:
+        if CONF_PENDING_TIME not in config[state]:
+            config[state][CONF_PENDING_TIME] = config[CONF_PENDING_TIME]
+
+    return config
+
+
+STATE_SETTING_SCHEMA = vol.Schema({
+    vol.Optional(CONF_PENDING_TIME):
+        vol.All(vol.Coerce(int), vol.Range(min=0))
+})
+
+
+PLATFORM_SCHEMA = vol.Schema(vol.All({
    vol.Required(CONF_PLATFORM): 'manual',
    vol.Optional(CONF_NAME, default=DEFAULT_ALARM_NAME): cv.string,
    vol.Optional(CONF_CODE): cv.string,
@@ -33,7 +56,11 @@ PLATFORM_SCHEMA = vol.Schema({
        vol.All(vol.Coerce(int), vol.Range(min=1)),
    vol.Optional(CONF_DISARM_AFTER_TRIGGER,
                 default=DEFAULT_DISARM_AFTER_TRIGGER): cv.boolean,
-})
+    vol.Optional(STATE_ALARM_ARMED_AWAY, default={}): STATE_SETTING_SCHEMA,
+    vol.Optional(STATE_ALARM_ARMED_HOME, default={}): STATE_SETTING_SCHEMA,
+    vol.Optional(STATE_ALARM_ARMED_NIGHT, default={}): STATE_SETTING_SCHEMA,
+    vol.Optional(STATE_ALARM_TRIGGERED, default={}): STATE_SETTING_SCHEMA,
+}, _state_validator))

 _LOGGER = logging.getLogger(__name__)

@@ -46,7 +73,8 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
        config.get(CONF_CODE),
        config.get(CONF_PENDING_TIME, DEFAULT_PENDING_TIME),
        config.get(CONF_TRIGGER_TIME, DEFAULT_TRIGGER_TIME),
-        config.get(CONF_DISARM_AFTER_TRIGGER, DEFAULT_DISARM_AFTER_TRIGGER)
+        config.get(CONF_DISARM_AFTER_TRIGGER, DEFAULT_DISARM_AFTER_TRIGGER),
+        config
        )])


@@ -60,19 +88,23 @@ class ManualAlarm(alarm.AlarmControlPanel):
    or disarm if `disarm_after_trigger` is true.
    """

-    def __init__(self, hass, name, code, pending_time,
-                 trigger_time, disarm_after_trigger):
+    def __init__(self, hass, name, code, pending_time, trigger_time,
+                 disarm_after_trigger, config):
        """Init the manual alarm panel."""
        self._state = STATE_ALARM_DISARMED
        self._hass = hass
        self._name = name
        self._code = str(code) if code else None
-        self._pending_time = datetime.timedelta(seconds=pending_time)
        self._trigger_time = datetime.timedelta(seconds=trigger_time)
        self._disarm_after_trigger = disarm_after_trigger
        self._pre_trigger_state = self._state
        self._state_ts = None

+        self._pending_time_by_state = {}
+        for state in SUPPORTED_PENDING_STATES:
+            self._pending_time_by_state[state] = datetime.timedelta(
+                seconds=config[state][CONF_PENDING_TIME])
+
    @property
    def should_poll(self):
        """Return the plling state."""
@@ -86,23 +118,27 @@ class ManualAlarm(alarm.AlarmControlPanel):
    @property
    def state(self):
        """Return the state of the device."""
-        if self._state in (STATE_ALARM_ARMED_HOME,
-                           STATE_ALARM_ARMED_AWAY) and \
-           self._pending_time and self._state_ts + self._pending_time > \
-           dt_util.utcnow():
-            return STATE_ALARM_PENDING
-
        if self._state == STATE_ALARM_TRIGGERED and self._trigger_time:
-            if self._state_ts + self._pending_time > dt_util.utcnow():
+            if self._within_pending_time(self._state):
                return STATE_ALARM_PENDING
-            elif (self._state_ts + self._pending_time +
+            elif (self._state_ts + self._pending_time_by_state[self._state] +
                  self._trigger_time) < dt_util.utcnow():
                if self._disarm_after_trigger:
                    return STATE_ALARM_DISARMED
-                return self._pre_trigger_state
+                else:
+                    self._state = self._pre_trigger_state
+                    return self._state
+
+        if self._state in SUPPORTED_PENDING_STATES and \
+                self._within_pending_time(self._state):
+            return STATE_ALARM_PENDING

        return self._state

+    def _within_pending_time(self, state):
+        pending_time = self._pending_time_by_state[state]
+        return self._state_ts + pending_time > dt_util.utcnow()
+
    @property
    def code_format(self):
        """One or more characters."""
@@ -122,44 +158,47 @@ class ManualAlarm(alarm.AlarmControlPanel):
        if not self._validate_code(code, STATE_ALARM_ARMED_HOME):
            return

-        self._state = STATE_ALARM_ARMED_HOME
-        self._state_ts = dt_util.utcnow()
-        self.schedule_update_ha_state()
-
-        if self._pending_time:
-            track_point_in_time(
-                self._hass, self.async_update_ha_state,
-                self._state_ts + self._pending_time)
+        self._update_state(STATE_ALARM_ARMED_HOME)

    def alarm_arm_away(self, code=None):
        """Send arm away command."""
        if not self._validate_code(code, STATE_ALARM_ARMED_AWAY):
            return

-        self._state = STATE_ALARM_ARMED_AWAY
-        self._state_ts = dt_util.utcnow()
-        self.schedule_update_ha_state()
+        self._update_state(STATE_ALARM_ARMED_AWAY)

-        if self._pending_time:
-            track_point_in_time(
-                self._hass, self.async_update_ha_state,
-                self._state_ts + self._pending_time)
+    def alarm_arm_night(self, code=None):
+        """Send arm night command."""
+        if not self._validate_code(code, STATE_ALARM_ARMED_NIGHT):
+            return
+
+        self._update_state(STATE_ALARM_ARMED_NIGHT)

    def alarm_trigger(self, code=None):
        """Send alarm trigger command. No code needed."""
        self._pre_trigger_state = self._state
-        self._state = STATE_ALARM_TRIGGERED
+
+        self._update_state(STATE_ALARM_TRIGGERED)
+
+    def _update_state(self, state):
+        self._state = state
        self._state_ts = dt_util.utcnow()
        self.schedule_update_ha_state()

-        if self._trigger_time:
+        pending_time = self._pending_time_by_state[state]
+
+        if state == STATE_ALARM_TRIGGERED and self._trigger_time:
            track_point_in_time(
                self._hass, self.async_update_ha_state,
-                self._state_ts + self._pending_time)
+                self._state_ts + pending_time)

            track_point_in_time(
                self._hass, self.async_update_ha_state,
-                self._state_ts + self._pending_time + self._trigger_time)
+                self._state_ts + self._trigger_time + pending_time)
+        elif state in SUPPORTED_PENDING_STATES and pending_time:
+            track_point_in_time(
+                self._hass, self.async_update_ha_state,
+                self._state_ts + pending_time)

    def _validate_code(self, code, state):
        """Validate given code."""
@@ -167,3 +206,13 @@ class ManualAlarm(alarm.AlarmControlPanel):
        if not check:
            _LOGGER.warning("Invalid code given for %s", state)
        return check
+
+    @property
+    def device_state_attributes(self):
+        """Return the state attributes."""
+        state_attr = {}
+
+        if self.state == STATE_ALARM_PENDING:
+            state_attr[ATTR_POST_PENDING_STATE] = self._state
+
+        return state_attr
--- a/homeassistant/components/alarm_control_panel/manual_mqtt.py
+++ b/homeassistant/components/alarm_control_panel/manual_mqtt.py
@@ -5,6 +5,7 @@ For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/alarm_control_panel.manual_mqtt/
 """
 import asyncio
+import copy
 import datetime
 import logging

@@ -13,9 +14,9 @@ import voluptuous as vol
 import homeassistant.components.alarm_control_panel as alarm
 import homeassistant.util.dt as dt_util
 from homeassistant.const import (
-    STATE_ALARM_ARMED_AWAY, STATE_ALARM_ARMED_HOME, STATE_ALARM_DISARMED,
-    STATE_ALARM_PENDING, STATE_ALARM_TRIGGERED, CONF_PLATFORM,
-    CONF_NAME, CONF_CODE, CONF_PENDING_TIME, CONF_TRIGGER_TIME,
+    STATE_ALARM_ARMED_AWAY, STATE_ALARM_ARMED_HOME, STATE_ALARM_ARMED_NIGHT,
+    STATE_ALARM_DISARMED, STATE_ALARM_PENDING, STATE_ALARM_TRIGGERED,
+    CONF_PLATFORM, CONF_NAME, CONF_CODE, CONF_PENDING_TIME, CONF_TRIGGER_TIME,
    CONF_DISARM_AFTER_TRIGGER)
 import homeassistant.components.mqtt as mqtt

@@ -28,6 +29,7 @@ from homeassistant.helpers.event import track_point_in_time
 CONF_PAYLOAD_DISARM = 'payload_disarm'
 CONF_PAYLOAD_ARM_HOME = 'payload_arm_home'
 CONF_PAYLOAD_ARM_AWAY = 'payload_arm_away'
+CONF_PAYLOAD_ARM_NIGHT = 'payload_arm_night'

 DEFAULT_ALARM_NAME = 'HA Alarm'
 DEFAULT_PENDING_TIME = 60
@@ -35,11 +37,32 @@ DEFAULT_TRIGGER_TIME = 120
 DEFAULT_DISARM_AFTER_TRIGGER = False
 DEFAULT_ARM_AWAY = 'ARM_AWAY'
 DEFAULT_ARM_HOME = 'ARM_HOME'
+DEFAULT_ARM_NIGHT = 'ARM_NIGHT'
 DEFAULT_DISARM = 'DISARM'

+SUPPORTED_PENDING_STATES = [STATE_ALARM_ARMED_AWAY, STATE_ALARM_ARMED_HOME,
+                            STATE_ALARM_ARMED_NIGHT, STATE_ALARM_TRIGGERED]
+
+ATTR_POST_PENDING_STATE = 'post_pending_state'
+
+
+def _state_validator(config):
+    config = copy.deepcopy(config)
+    for state in SUPPORTED_PENDING_STATES:
+        if CONF_PENDING_TIME not in config[state]:
+            config[state][CONF_PENDING_TIME] = config[CONF_PENDING_TIME]
+
+    return config
+
+
+STATE_SETTING_SCHEMA = vol.Schema({
+    vol.Optional(CONF_PENDING_TIME):
+        vol.All(vol.Coerce(int), vol.Range(min=0))
+})
+
 DEPENDENCIES = ['mqtt']

-PLATFORM_SCHEMA = mqtt.MQTT_BASE_PLATFORM_SCHEMA.extend({
+PLATFORM_SCHEMA = vol.Schema(vol.All(mqtt.MQTT_BASE_PLATFORM_SCHEMA.extend({
    vol.Required(CONF_PLATFORM): 'manual_mqtt',
    vol.Optional(CONF_NAME, default=DEFAULT_ALARM_NAME): cv.string,
    vol.Optional(CONF_CODE): cv.string,
@@ -49,12 +72,17 @@ PLATFORM_SCHEMA = mqtt.MQTT_BASE_PLATFORM_SCHEMA.extend({
        vol.All(vol.Coerce(int), vol.Range(min=1)),
    vol.Optional(CONF_DISARM_AFTER_TRIGGER,
                 default=DEFAULT_DISARM_AFTER_TRIGGER): cv.boolean,
+    vol.Optional(STATE_ALARM_ARMED_AWAY, default={}): STATE_SETTING_SCHEMA,
+    vol.Optional(STATE_ALARM_ARMED_HOME, default={}): STATE_SETTING_SCHEMA,
+    vol.Optional(STATE_ALARM_ARMED_NIGHT, default={}): STATE_SETTING_SCHEMA,
+    vol.Optional(STATE_ALARM_TRIGGERED, default={}): STATE_SETTING_SCHEMA,
    vol.Required(mqtt.CONF_COMMAND_TOPIC): mqtt.valid_publish_topic,
    vol.Required(mqtt.CONF_STATE_TOPIC): mqtt.valid_subscribe_topic,
    vol.Optional(CONF_PAYLOAD_ARM_AWAY, default=DEFAULT_ARM_AWAY): cv.string,
    vol.Optional(CONF_PAYLOAD_ARM_HOME, default=DEFAULT_ARM_HOME): cv.string,
+    vol.Optional(CONF_PAYLOAD_ARM_NIGHT, default=DEFAULT_ARM_NIGHT): cv.string,
    vol.Optional(CONF_PAYLOAD_DISARM, default=DEFAULT_DISARM): cv.string,
-})
+}), _state_validator))

 _LOGGER = logging.getLogger(__name__)

@@ -73,7 +101,9 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
        config.get(mqtt.CONF_QOS),
        config.get(CONF_PAYLOAD_DISARM),
        config.get(CONF_PAYLOAD_ARM_HOME),
-        config.get(CONF_PAYLOAD_ARM_AWAY))])
+        config.get(CONF_PAYLOAD_ARM_AWAY),
+        config.get(CONF_PAYLOAD_ARM_NIGHT),
+        config)])


 class ManualMQTTAlarm(alarm.AlarmControlPanel):
@@ -89,7 +119,8 @@ class ManualMQTTAlarm(alarm.AlarmControlPanel):
    def __init__(self, hass, name, code, pending_time,
                 trigger_time, disarm_after_trigger,
                 state_topic, command_topic, qos,
-                 payload_disarm, payload_arm_home, payload_arm_away):
+                 payload_disarm, payload_arm_home, payload_arm_away,
+                 payload_arm_night, config):
        """Init the manual MQTT alarm panel."""
        self._state = STATE_ALARM_DISARMED
        self._hass = hass
@@ -101,12 +132,18 @@ class ManualMQTTAlarm(alarm.AlarmControlPanel):
        self._pre_trigger_state = self._state
        self._state_ts = None

+        self._pending_time_by_state = {}
+        for state in SUPPORTED_PENDING_STATES:
+            self._pending_time_by_state[state] = datetime.timedelta(
+                seconds=config[state][CONF_PENDING_TIME])
+
        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._payload_arm_night = payload_arm_night

    @property
    def should_poll(self):
@@ -121,23 +158,27 @@ class ManualMQTTAlarm(alarm.AlarmControlPanel):
    @property
    def state(self):
        """Return the state of the device."""
-        if self._state in (STATE_ALARM_ARMED_HOME,
-                           STATE_ALARM_ARMED_AWAY) and \
-           self._pending_time and self._state_ts + self._pending_time > \
-           dt_util.utcnow():
-            return STATE_ALARM_PENDING
-
        if self._state == STATE_ALARM_TRIGGERED and self._trigger_time:
-            if self._state_ts + self._pending_time > dt_util.utcnow():
+            if self._within_pending_time(self._state):
                return STATE_ALARM_PENDING
-            elif (self._state_ts + self._pending_time +
+            elif (self._state_ts + self._pending_time_by_state[self._state] +
                  self._trigger_time) < dt_util.utcnow():
                if self._disarm_after_trigger:
                    return STATE_ALARM_DISARMED
-                return self._pre_trigger_state
+                else:
+                    self._state = self._pre_trigger_state
+                    return self._state
+
+        if self._state in SUPPORTED_PENDING_STATES and \
+                self._within_pending_time(self._state):
+            return STATE_ALARM_PENDING

        return self._state

+    def _within_pending_time(self, state):
+        pending_time = self._pending_time_by_state[state]
+        return self._state_ts + pending_time > dt_util.utcnow()
+
    @property
    def code_format(self):
        """One or more characters."""
@@ -157,44 +198,47 @@ class ManualMQTTAlarm(alarm.AlarmControlPanel):
        if not self._validate_code(code, STATE_ALARM_ARMED_HOME):
            return

-        self._state = STATE_ALARM_ARMED_HOME
-        self._state_ts = dt_util.utcnow()
-        self.schedule_update_ha_state()
-
-        if self._pending_time:
-            track_point_in_time(
-                self._hass, self.async_update_ha_state,
-                self._state_ts + self._pending_time)
+        self._update_state(STATE_ALARM_ARMED_HOME)

    def alarm_arm_away(self, code=None):
        """Send arm away command."""
        if not self._validate_code(code, STATE_ALARM_ARMED_AWAY):
            return

-        self._state = STATE_ALARM_ARMED_AWAY
-        self._state_ts = dt_util.utcnow()
-        self.schedule_update_ha_state()
+        self._update_state(STATE_ALARM_ARMED_AWAY)

-        if self._pending_time:
-            track_point_in_time(
-                self._hass, self.async_update_ha_state,
-                self._state_ts + self._pending_time)
+    def alarm_arm_night(self, code=None):
+        """Send arm night command."""
+        if not self._validate_code(code, STATE_ALARM_ARMED_NIGHT):
+            return
+
+        self._update_state(STATE_ALARM_ARMED_NIGHT)

    def alarm_trigger(self, code=None):
        """Send alarm trigger command. No code needed."""
        self._pre_trigger_state = self._state
-        self._state = STATE_ALARM_TRIGGERED
+
+        self._update_state(STATE_ALARM_TRIGGERED)
+
+    def _update_state(self, state):
+        self._state = state
        self._state_ts = dt_util.utcnow()
        self.schedule_update_ha_state()

-        if self._trigger_time:
+        pending_time = self._pending_time_by_state[state]
+
+        if state == STATE_ALARM_TRIGGERED and self._trigger_time:
            track_point_in_time(
                self._hass, self.async_update_ha_state,
-                self._state_ts + self._pending_time)
+                self._state_ts + pending_time)

            track_point_in_time(
                self._hass, self.async_update_ha_state,
-                self._state_ts + self._pending_time + self._trigger_time)
+                self._state_ts + self._trigger_time + pending_time)
+        elif state in SUPPORTED_PENDING_STATES and pending_time:
+            track_point_in_time(
+                self._hass, self.async_update_ha_state,
+                self._state_ts + pending_time)

    def _validate_code(self, code, state):
        """Validate given code."""
@@ -203,6 +247,16 @@ class ManualMQTTAlarm(alarm.AlarmControlPanel):
            _LOGGER.warning("Invalid code given for %s", state)
        return check

+    @property
+    def device_state_attributes(self):
+        """Return the state attributes."""
+        state_attr = {}
+
+        if self.state == STATE_ALARM_PENDING:
+            state_attr[ATTR_POST_PENDING_STATE] = self._state
+
+        return state_attr
+
    def async_added_to_hass(self):
        """Subscribe mqtt events.

@@ -221,6 +275,8 @@ class ManualMQTTAlarm(alarm.AlarmControlPanel):
                self.async_alarm_arm_home(self._code)
            elif payload == self._payload_arm_away:
                self.async_alarm_arm_away(self._code)
+            elif payload == self._payload_arm_night:
+                self.async_alarm_arm_night(self._code)
            else:
                _LOGGER.warning("Received unexpected payload: %s", payload)
                return
--- a/homeassistant/components/alarm_control_panel/mqtt.py
+++ b/homeassistant/components/alarm_control_panel/mqtt.py
@@ -87,7 +87,7 @@ class MqttAlarm(alarm.AlarmControlPanel):
                _LOGGER.warning("Received unexpected payload: %s", payload)
                return
            self._state = payload
-            self.hass.async_add_job(self.async_update_ha_state())
+            self.async_schedule_update_ha_state()

        return mqtt.async_subscribe(
            self.hass, self._state_topic, message_received, self._qos)
--- a/homeassistant/components/alarm_control_panel/satel_integra.py
+++ b/homeassistant/components/alarm_control_panel/satel_integra.py
@@ -0,0 +1,94 @@
+"""
+Support for Satel Integra alarm, using ETHM module: https://www.satel.pl/en/ .
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/alarm_control_panel.satel_integra/
+"""
+import asyncio
+import logging
+
+import homeassistant.components.alarm_control_panel as alarm
+from homeassistant.components.satel_integra import (CONF_ARM_HOME_MODE,
+                                                    DATA_SATEL,
+                                                    SIGNAL_PANEL_MESSAGE)
+from homeassistant.core import callback
+from homeassistant.helpers.dispatcher import async_dispatcher_connect
+
+_LOGGER = logging.getLogger(__name__)
+
+DEPENDENCIES = ['satel_integra']
+
+
+@asyncio.coroutine
+def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
+    """Set up for AlarmDecoder alarm panels."""
+    if not discovery_info:
+        return
+
+    device = SatelIntegraAlarmPanel("Alarm Panel",
+                                    discovery_info.get(CONF_ARM_HOME_MODE))
+    async_add_devices([device])
+
+
+class SatelIntegraAlarmPanel(alarm.AlarmControlPanel):
+    """Representation of an AlarmDecoder-based alarm panel."""
+
+    def __init__(self, name, arm_home_mode):
+        """Initialize the alarm panel."""
+        self._name = name
+        self._state = None
+        self._arm_home_mode = arm_home_mode
+
+    @asyncio.coroutine
+    def async_added_to_hass(self):
+        """Register callbacks."""
+        async_dispatcher_connect(
+            self.hass, SIGNAL_PANEL_MESSAGE, self._message_callback)
+
+    @callback
+    def _message_callback(self, message):
+
+        if message != self._state:
+            self._state = message
+            self.async_schedule_update_ha_state()
+        else:
+            _LOGGER.warning("Ignoring alarm status message, same state")
+
+    @property
+    def name(self):
+        """Return the name of the device."""
+        return self._name
+
+    @property
+    def should_poll(self):
+        """Return the polling state."""
+        return False
+
+    @property
+    def code_format(self):
+        """Return the regex for code format or None if no code is required."""
+        return '^\\d{4,6}$'
+
+    @property
+    def state(self):
+        """Return the state of the device."""
+        return self._state
+
+    @asyncio.coroutine
+    def async_alarm_disarm(self, code=None):
+        """Send disarm command."""
+        if code:
+            yield from self.hass.data[DATA_SATEL].disarm(code)
+
+    @asyncio.coroutine
+    def async_alarm_arm_away(self, code=None):
+        """Send arm away command."""
+        if code:
+            yield from self.hass.data[DATA_SATEL].arm(code)
+
+    @asyncio.coroutine
+    def async_alarm_arm_home(self, code=None):
+        """Send arm home command."""
+        if code:
+            yield from self.hass.data[DATA_SATEL].arm(code,
+                                                      self._arm_home_mode)
--- a/homeassistant/components/alarm_control_panel/services.yaml
+++ b/homeassistant/components/alarm_control_panel/services.yaml
@@ -31,6 +31,17 @@ alarm_arm_away:
      description: An optional code to arm away the alarm control panel with
      example: 1234

+alarm_arm_night:
+  description: Send the alarm the command for arm night
+
+  fields:
+    entity_id:
+      description: Name of alarm control panel to arm night
+      example: 'alarm_control_panel.downstairs'
+    code:
+      description: An optional code to arm night the alarm control panel with
+      example: 1234
+
 alarm_trigger:
  description: Send the alarm the command for trigger

--- a/homeassistant/components/alarm_control_panel/simplisafe.py
+++ b/homeassistant/components/alarm_control_panel/simplisafe.py
@@ -16,7 +16,7 @@ from homeassistant.const import (
    EVENT_HOMEASSISTANT_STOP)
 import homeassistant.helpers.config_validation as cv

-REQUIREMENTS = ['simplisafe-python==1.0.4']
+REQUIREMENTS = ['simplisafe-python==1.0.5']

 _LOGGER = logging.getLogger(__name__)

@@ -89,11 +89,11 @@ class SimpliSafeAlarm(alarm.AlarmControlPanel):
    def state(self):
        """Return the state of the device."""
        status = self.simplisafe.state()
-        if status == 'Off':
+        if status == 'off':
            state = STATE_ALARM_DISARMED
-        elif status == 'Home':
+        elif status == 'home':
            state = STATE_ALARM_ARMED_HOME
-        elif status == 'Away':
+        elif status == 'away':
            state = STATE_ALARM_ARMED_AWAY
        else:
            state = STATE_UNKNOWN
--- a/homeassistant/components/alarm_control_panel/spc.py
+++ b/homeassistant/components/alarm_control_panel/spc.py
@@ -27,20 +27,20 @@ def _get_alarm_state(spc_mode):


@asyncio.coroutine
-def async_setup_platform(hass, config, async_add_entities,
+def async_setup_platform(hass, config, async_add_devices,
                         discovery_info=None):
    """Set up the SPC alarm control panel platform."""
    if (discovery_info is None or
            discovery_info[ATTR_DISCOVER_AREAS] is None):
        return

-    entities = [SpcAlarm(hass=hass,
-                         area_id=area['id'],
-                         name=area['name'],
-                         state=_get_alarm_state(area['mode']))
-                for area in discovery_info[ATTR_DISCOVER_AREAS]]
+    devices = [SpcAlarm(hass=hass,
+                        area_id=area['id'],
+                        name=area['name'],
+                        state=_get_alarm_state(area['mode']))
+               for area in discovery_info[ATTR_DISCOVER_AREAS]]

-    async_add_entities(entities)
+    async_add_devices(devices)


 class SpcAlarm(alarm.AlarmControlPanel):
--- a/homeassistant/components/alarm_control_panel/totalconnect.py
+++ b/homeassistant/components/alarm_control_panel/totalconnect.py
@@ -13,8 +13,8 @@ import homeassistant.components.alarm_control_panel as alarm
 from homeassistant.components.alarm_control_panel import PLATFORM_SCHEMA
 from homeassistant.const import (
    CONF_PASSWORD, CONF_USERNAME, STATE_ALARM_ARMED_AWAY,
-    STATE_ALARM_ARMED_HOME, STATE_ALARM_DISARMED, STATE_UNKNOWN,
-    CONF_NAME)
+    STATE_ALARM_ARMED_HOME, STATE_ALARM_ARMED_NIGHT, STATE_ALARM_DISARMED,
+    STATE_ALARM_ARMING, STATE_ALARM_DISARMING, STATE_UNKNOWN, CONF_NAME)

 REQUIREMENTS = ['total_connect_client==0.11']

@@ -74,6 +74,12 @@ class TotalConnect(alarm.AlarmControlPanel):
            state = STATE_ALARM_ARMED_HOME
        elif status == self._client.ARMED_AWAY:
            state = STATE_ALARM_ARMED_AWAY
+        elif status == self._client.ARMED_STAY_NIGHT:
+            state = STATE_ALARM_ARMED_NIGHT
+        elif status == self._client.ARMING:
+            state = STATE_ALARM_ARMING
+        elif status == self._client.DISARMING:
+            state = STATE_ALARM_DISARMING
        else:
            state = STATE_UNKNOWN

@@ -90,3 +96,7 @@ class TotalConnect(alarm.AlarmControlPanel):
    def alarm_arm_away(self, code=None):
        """Send arm away command."""
        self._client.arm_away()
+
+    def alarm_arm_night(self, code=None):
+        """Send arm night command."""
+        self._client.arm_stay_night()
--- a/homeassistant/components/alexa/init.py
+++ b/homeassistant/components/alexa/init.py
@@ -0,0 +1,52 @@
+"""
+Support for Alexa skill service end point.
+
+For more details about this component, please refer to the documentation at
+https://home-assistant.io/components/alexa/
+"""
+import asyncio
+import logging
+
+import voluptuous as vol
+
+from homeassistant.helpers import config_validation as cv
+
+from .const import (
+    DOMAIN, CONF_UID, CONF_TITLE, CONF_AUDIO, CONF_TEXT, CONF_DISPLAY_URL)
+from . import flash_briefings, intent
+
+_LOGGER = logging.getLogger(__name__)
+
+
+DEPENDENCIES = ['http']
+
+CONF_FLASH_BRIEFINGS = 'flash_briefings'
+
+
+CONFIG_SCHEMA = vol.Schema({
+    DOMAIN: {
+        CONF_FLASH_BRIEFINGS: {
+            cv.string: vol.All(cv.ensure_list, [{
+                vol.Optional(CONF_UID): cv.string,
+                vol.Required(CONF_TITLE): cv.template,
+                vol.Optional(CONF_AUDIO): cv.template,
+                vol.Required(CONF_TEXT, default=""): cv.template,
+                vol.Optional(CONF_DISPLAY_URL): cv.template,
+            }]),
+        }
+    }
+}, extra=vol.ALLOW_EXTRA)
+
+
+@asyncio.coroutine
+def async_setup(hass, config):
+    """Activate Alexa component."""
+    config = config.get(DOMAIN, {})
+    flash_briefings_config = config.get(CONF_FLASH_BRIEFINGS)
+
+    intent.async_setup(hass)
+
+    if flash_briefings_config:
+        flash_briefings.async_setup(hass, flash_briefings_config)
+
+    return True
--- a/homeassistant/components/alexa/const.py
+++ b/homeassistant/components/alexa/const.py
@@ -0,0 +1,18 @@
+"""Constants for the Alexa integration."""
+DOMAIN = 'alexa'
+
+# Flash briefing constants
+CONF_UID = 'uid'
+CONF_TITLE = 'title'
+CONF_AUDIO = 'audio'
+CONF_TEXT = 'text'
+CONF_DISPLAY_URL = 'display_url'
+
+ATTR_UID = 'uid'
+ATTR_UPDATE_DATE = 'updateDate'
+ATTR_TITLE_TEXT = 'titleText'
+ATTR_STREAM_URL = 'streamUrl'
+ATTR_MAIN_TEXT = 'mainText'
+ATTR_REDIRECTION_URL = 'redirectionURL'
+
+DATE_FORMAT = '%Y-%m-%dT%H:%M:%S.0Z'
--- a/homeassistant/components/alexa/flash_briefings.py
+++ b/homeassistant/components/alexa/flash_briefings.py
@@ -0,0 +1,96 @@
+"""
+Support for Alexa skill service end point.
+
+For more details about this component, please refer to the documentation at
+https://home-assistant.io/components/alexa/
+"""
+import copy
+import logging
+from datetime import datetime
+import uuid
+
+from homeassistant.core import callback
+from homeassistant.helpers import template
+from homeassistant.components import http
+
+from .const import (
+    CONF_UID, CONF_TITLE, CONF_AUDIO, CONF_TEXT, CONF_DISPLAY_URL, ATTR_UID,
+    ATTR_UPDATE_DATE, ATTR_TITLE_TEXT, ATTR_STREAM_URL, ATTR_MAIN_TEXT,
+    ATTR_REDIRECTION_URL, DATE_FORMAT)
+
+
+_LOGGER = logging.getLogger(__name__)
+
+FLASH_BRIEFINGS_API_ENDPOINT = '/api/alexa/flash_briefings/{briefing_id}'
+
+
+@callback
+def async_setup(hass, flash_briefing_config):
+    """Activate Alexa component."""
+    hass.http.register_view(
+        AlexaFlashBriefingView(hass, flash_briefing_config))
+
+
+class AlexaFlashBriefingView(http.HomeAssistantView):
+    """Handle Alexa Flash Briefing skill requests."""
+
+    url = FLASH_BRIEFINGS_API_ENDPOINT
+    name = 'api:alexa:flash_briefings'
+
+    def __init__(self, hass, flash_briefings):
+        """Initialize Alexa view."""
+        super().__init__()
+        self.flash_briefings = copy.deepcopy(flash_briefings)
+        template.attach(hass, self.flash_briefings)
+
+    @callback
+    def get(self, request, briefing_id):
+        """Handle Alexa Flash Briefing request."""
+        _LOGGER.debug('Received Alexa flash briefing request for: %s',
+                      briefing_id)
+
+        if self.flash_briefings.get(briefing_id) is None:
+            err = 'No configured Alexa flash briefing was found for: %s'
+            _LOGGER.error(err, briefing_id)
+            return b'', 404
+
+        briefing = []
+
+        for item in self.flash_briefings.get(briefing_id, []):
+            output = {}
+            if item.get(CONF_TITLE) is not None:
+                if isinstance(item.get(CONF_TITLE), template.Template):
+                    output[ATTR_TITLE_TEXT] = item[CONF_TITLE].async_render()
+                else:
+                    output[ATTR_TITLE_TEXT] = item.get(CONF_TITLE)
+
+            if item.get(CONF_TEXT) is not None:
+                if isinstance(item.get(CONF_TEXT), template.Template):
+                    output[ATTR_MAIN_TEXT] = item[CONF_TEXT].async_render()
+                else:
+                    output[ATTR_MAIN_TEXT] = item.get(CONF_TEXT)
+
+            uid = item.get(CONF_UID)
+            if uid is None:
+                uid = str(uuid.uuid4())
+            output[ATTR_UID] = uid
+
+            if item.get(CONF_AUDIO) is not None:
+                if isinstance(item.get(CONF_AUDIO), template.Template):
+                    output[ATTR_STREAM_URL] = item[CONF_AUDIO].async_render()
+                else:
+                    output[ATTR_STREAM_URL] = item.get(CONF_AUDIO)
+
+            if item.get(CONF_DISPLAY_URL) is not None:
+                if isinstance(item.get(CONF_DISPLAY_URL),
+                              template.Template):
+                    output[ATTR_REDIRECTION_URL] = \
+                        item[CONF_DISPLAY_URL].async_render()
+                else:
+                    output[ATTR_REDIRECTION_URL] = item.get(CONF_DISPLAY_URL)
+
+            output[ATTR_UPDATE_DATE] = datetime.now().strftime(DATE_FORMAT)
+
+            briefing.append(output)
+
+        return self.json(briefing)
--- a/homeassistant/components/alexa/intent.py
+++ b/homeassistant/components/alexa/intent.py
@@ -5,52 +5,19 @@ For more details about this component, please refer to the documentation at
 https://home-assistant.io/components/alexa/
 """
 import asyncio
-import copy
 import enum
 import logging
-import uuid
-from datetime import datetime
-
-import voluptuous as vol

 from homeassistant.core import callback
 from homeassistant.const import HTTP_BAD_REQUEST
-from homeassistant.helpers import intent, template, config_validation as cv
+from homeassistant.helpers import intent
 from homeassistant.components import http

-_LOGGER = logging.getLogger(__name__)
+from .const import DOMAIN

 INTENTS_API_ENDPOINT = '/api/alexa'
-FLASH_BRIEFINGS_API_ENDPOINT = '/api/alexa/flash_briefings/{briefing_id}'

-CONF_ACTION = 'action'
-CONF_CARD = 'card'
-CONF_INTENTS = 'intents'
-CONF_SPEECH = 'speech'
-
-CONF_TYPE = 'type'
-CONF_TITLE = 'title'
-CONF_CONTENT = 'content'
-CONF_TEXT = 'text'
-
-CONF_FLASH_BRIEFINGS = 'flash_briefings'
-CONF_UID = 'uid'
-CONF_TITLE = 'title'
-CONF_AUDIO = 'audio'
-CONF_TEXT = 'text'
-CONF_DISPLAY_URL = 'display_url'
-
-ATTR_UID = 'uid'
-ATTR_UPDATE_DATE = 'updateDate'
-ATTR_TITLE_TEXT = 'titleText'
-ATTR_STREAM_URL = 'streamUrl'
-ATTR_MAIN_TEXT = 'mainText'
-ATTR_REDIRECTION_URL = 'redirectionURL'
-
-DATE_FORMAT = '%Y-%m-%dT%H:%M:%S.0Z'
-
-DOMAIN = 'alexa'
-DEPENDENCIES = ['http']
+_LOGGER = logging.getLogger(__name__)


 class SpeechType(enum.Enum):
@@ -73,30 +40,10 @@ class CardType(enum.Enum):
    link_account = "LinkAccount"


-CONFIG_SCHEMA = vol.Schema({
-    DOMAIN: {
-        CONF_FLASH_BRIEFINGS: {
-            cv.string: vol.All(cv.ensure_list, [{
-                vol.Required(CONF_UID, default=str(uuid.uuid4())): cv.string,
-                vol.Required(CONF_TITLE): cv.template,
-                vol.Optional(CONF_AUDIO): cv.template,
-                vol.Required(CONF_TEXT, default=""): cv.template,
-                vol.Optional(CONF_DISPLAY_URL): cv.template,
-            }]),
-        }
-    }
-}, extra=vol.ALLOW_EXTRA)
-
-
-@asyncio.coroutine
-def async_setup(hass, config):
+@callback
+def async_setup(hass):
    """Activate Alexa component."""
-    flash_briefings = config[DOMAIN].get(CONF_FLASH_BRIEFINGS, {})
-
    hass.http.register_view(AlexaIntentsView)
-    hass.http.register_view(AlexaFlashBriefingView(hass, flash_briefings))
-
-    return True


 class AlexaIntentsView(http.HomeAssistantView):
@@ -255,66 +202,3 @@ class AlexaResponse(object):
            'sessionAttributes': self.session_attributes,
            'response': response,
        }
-
-
-class AlexaFlashBriefingView(http.HomeAssistantView):
-    """Handle Alexa Flash Briefing skill requests."""
-
-    url = FLASH_BRIEFINGS_API_ENDPOINT
-    name = 'api:alexa:flash_briefings'
-
-    def __init__(self, hass, flash_briefings):
-        """Initialize Alexa view."""
-        super().__init__()
-        self.flash_briefings = copy.deepcopy(flash_briefings)
-        template.attach(hass, self.flash_briefings)
-
-    @callback
-    def get(self, request, briefing_id):
-        """Handle Alexa Flash Briefing request."""
-        _LOGGER.debug('Received Alexa flash briefing request for: %s',
-                      briefing_id)
-
-        if self.flash_briefings.get(briefing_id) is None:
-            err = 'No configured Alexa flash briefing was found for: %s'
-            _LOGGER.error(err, briefing_id)
-            return b'', 404
-
-        briefing = []
-
-        for item in self.flash_briefings.get(briefing_id, []):
-            output = {}
-            if item.get(CONF_TITLE) is not None:
-                if isinstance(item.get(CONF_TITLE), template.Template):
-                    output[ATTR_TITLE_TEXT] = item[CONF_TITLE].async_render()
-                else:
-                    output[ATTR_TITLE_TEXT] = item.get(CONF_TITLE)
-
-            if item.get(CONF_TEXT) is not None:
-                if isinstance(item.get(CONF_TEXT), template.Template):
-                    output[ATTR_MAIN_TEXT] = item[CONF_TEXT].async_render()
-                else:
-                    output[ATTR_MAIN_TEXT] = item.get(CONF_TEXT)
-
-            if item.get(CONF_UID) is not None:
-                output[ATTR_UID] = item.get(CONF_UID)
-
-            if item.get(CONF_AUDIO) is not None:
-                if isinstance(item.get(CONF_AUDIO), template.Template):
-                    output[ATTR_STREAM_URL] = item[CONF_AUDIO].async_render()
-                else:
-                    output[ATTR_STREAM_URL] = item.get(CONF_AUDIO)
-
-            if item.get(CONF_DISPLAY_URL) is not None:
-                if isinstance(item.get(CONF_DISPLAY_URL),
-                              template.Template):
-                    output[ATTR_REDIRECTION_URL] = \
-                        item[CONF_DISPLAY_URL].async_render()
-                else:
-                    output[ATTR_REDIRECTION_URL] = item.get(CONF_DISPLAY_URL)
-
-            output[ATTR_UPDATE_DATE] = datetime.now().strftime(DATE_FORMAT)
-
-            briefing.append(output)
-
-        return self.json(briefing)
--- a/homeassistant/components/alexa/smart_home.py
+++ b/homeassistant/components/alexa/smart_home.py
@@ -0,0 +1,203 @@
+"""Support for alexa Smart Home Skill API."""
+import asyncio
+import logging
+from uuid import uuid4
+
+from homeassistant.const import (
+    ATTR_SUPPORTED_FEATURES, ATTR_ENTITY_ID, SERVICE_TURN_ON, SERVICE_TURN_OFF)
+from homeassistant.components import switch, light
+from homeassistant.util.decorator import Registry
+
+HANDLERS = Registry()
+_LOGGER = logging.getLogger(__name__)
+
+API_DIRECTIVE = 'directive'
+API_EVENT = 'event'
+API_HEADER = 'header'
+API_PAYLOAD = 'payload'
+API_ENDPOINT = 'endpoint'
+
+
+MAPPING_COMPONENT = {
+    switch.DOMAIN: ['SWITCH', ('Alexa.PowerController',), None],
+    light.DOMAIN: [
+        'LIGHT', ('Alexa.PowerController',), {
+            light.SUPPORT_BRIGHTNESS: 'Alexa.BrightnessController'
+        }
+    ],
+}
+
+
+@asyncio.coroutine
+def async_handle_message(hass, message):
+    """Handle incoming API messages."""
+    assert message[API_DIRECTIVE][API_HEADER]['payloadVersion'] == '3'
+
+    # Read head data
+    message = message[API_DIRECTIVE]
+    namespace = message[API_HEADER]['namespace']
+    name = message[API_HEADER]['name']
+
+    # Do we support this API request?
+    funct_ref = HANDLERS.get((namespace, name))
+    if not funct_ref:
+        _LOGGER.warning(
+            "Unsupported API request %s/%s", namespace, name)
+        return api_error(message)
+
+    return (yield from funct_ref(hass, message))
+
+
+def api_message(request, name='Response', namespace='Alexa', payload=None):
+    """Create a API formatted response message.
+
+    Async friendly.
+    """
+    payload = payload or {}
+
+    response = {
+        API_EVENT: {
+            API_HEADER: {
+                'namespace': namespace,
+                'name': name,
+                'messageId': str(uuid4()),
+                'payloadVersion': '3',
+            },
+            API_PAYLOAD: payload,
+        }
+    }
+
+    # If a correlation token exsits, add it to header / Need by Async requests
+    token = request[API_HEADER].get('correlationToken')
+    if token:
+        response[API_EVENT][API_HEADER]['correlationToken'] = token
+
+    # Extend event with endpoint object / Need by Async requests
+    if API_ENDPOINT in request:
+        response[API_EVENT][API_ENDPOINT] = request[API_ENDPOINT].copy()
+
+    return response
+
+
+def api_error(request, error_type='INTERNAL_ERROR', error_message=""):
+    """Create a API formatted error response.
+
+    Async friendly.
+    """
+    payload = {
+        'type': error_type,
+        'message': error_message,
+    }
+
+    return api_message(request, name='ErrorResponse', payload=payload)
+
+
+@HANDLERS.register(('Alexa.Discovery', 'Discover'))
+@asyncio.coroutine
+def async_api_discovery(hass, request):
+    """Create a API formatted discovery response.
+
+    Async friendly.
+    """
+    discovery_endpoints = []
+
+    for entity in hass.states.async_all():
+        class_data = MAPPING_COMPONENT.get(entity.domain)
+
+        if not class_data:
+            continue
+
+        endpoint = {
+            'displayCategories': [class_data[0]],
+            'additionalApplianceDetails': {},
+            'endpointId': entity.entity_id.replace('.', '#'),
+            'friendlyName': entity.name,
+            'description': '',
+            'manufacturerName': 'Unknown',
+        }
+        actions = set()
+
+        # static actions
+        if class_data[1]:
+            actions |= set(class_data[1])
+
+        # dynamic actions
+        if class_data[2]:
+            supported = entity.attributes.get(ATTR_SUPPORTED_FEATURES, 0)
+            for feature, action_name in class_data[2].items():
+                if feature & supported > 0:
+                    actions.add(action_name)
+
+        # Write action into capabilities
+        capabilities = []
+        for action in actions:
+            capabilities.append({
+                'type': 'AlexaInterface',
+                'interface': action,
+                'version': 3,
+            })
+
+        endpoint['capabilities'] = capabilities
+        discovery_endpoints.append(endpoint)
+
+    return api_message(
+        request, name='Discover.Response', namespace='Alexa.Discovery',
+        payload={'endpoints': discovery_endpoints})
+
+
+def extract_entity(funct):
+    """Decorator for extract entity object from request."""
+    @asyncio.coroutine
+    def async_api_entity_wrapper(hass, request):
+        """Process a turn on request."""
+        entity_id = request[API_ENDPOINT]['endpointId'].replace('#', '.')
+
+        # extract state object
+        entity = hass.states.get(entity_id)
+        if not entity:
+            _LOGGER.error("Can't process %s for %s",
+                          request[API_HEADER]['name'], entity_id)
+            return api_error(request, error_type='NO_SUCH_ENDPOINT')
+
+        return (yield from funct(hass, request, entity))
+
+    return async_api_entity_wrapper
+
+
+@HANDLERS.register(('Alexa.PowerController', 'TurnOn'))
+@extract_entity
+@asyncio.coroutine
+def async_api_turn_on(hass, request, entity):
+    """Process a turn on request."""
+    yield from hass.services.async_call(entity.domain, SERVICE_TURN_ON, {
+        ATTR_ENTITY_ID: entity.entity_id
+    }, blocking=True)
+
+    return api_message(request)
+
+
+@HANDLERS.register(('Alexa.PowerController', 'TurnOff'))
+@extract_entity
+@asyncio.coroutine
+def async_api_turn_off(hass, request, entity):
+    """Process a turn off request."""
+    yield from hass.services.async_call(entity.domain, SERVICE_TURN_OFF, {
+        ATTR_ENTITY_ID: entity.entity_id
+    }, blocking=True)
+
+    return api_message(request)
+
+
+@HANDLERS.register(('Alexa.BrightnessController', 'SetBrightness'))
+@extract_entity
+@asyncio.coroutine
+def async_api_set_brightness(hass, request, entity):
+    """Process a set brightness request."""
+    brightness = request[API_PAYLOAD]['brightness']
+
+    yield from hass.services.async_call(entity.domain, SERVICE_TURN_ON, {
+        ATTR_ENTITY_ID: entity.entity_id,
+        light.ATTR_BRIGHTNESS: brightness,
+    }, blocking=True)
+
+    return api_message(request)
--- a/homeassistant/components/android_ip_webcam.py
+++ b/homeassistant/components/android_ip_webcam.py
@@ -263,7 +263,7 @@ class AndroidIPCamEntity(Entity):
            """Update callback."""
            if self._host != host:
                return
-            self.hass.async_add_job(self.async_update_ha_state(True))
+            self.async_schedule_update_ha_state(True)

        async_dispatcher_connect(
            self.hass, SIGNAL_UPDATE_DATA, async_ipcam_update)
--- a/homeassistant/components/api.py
+++ b/homeassistant/components/api.py
@@ -13,7 +13,7 @@ import async_timeout

 import homeassistant.core as ha
 import homeassistant.remote as rem
-from homeassistant.bootstrap import ERROR_LOG_FILENAME
+from homeassistant.bootstrap import DATA_LOGGING
 from homeassistant.const import (
    EVENT_HOMEASSISTANT_STOP, EVENT_TIME_CHANGED,
    HTTP_BAD_REQUEST, HTTP_CREATED, HTTP_NOT_FOUND,
@@ -51,8 +51,9 @@ def setup(hass, config):
    hass.http.register_view(APIComponentsView)
    hass.http.register_view(APITemplateView)

-    hass.http.register_static_path(
-        URL_API_ERROR_LOG, hass.config.path(ERROR_LOG_FILENAME), False)
+    log_path = hass.data.get(DATA_LOGGING, None)
+    if log_path:
+        hass.http.register_static_path(URL_API_ERROR_LOG, log_path, False)

    return True

--- a/homeassistant/components/apple_tv.py
+++ b/homeassistant/components/apple_tv.py
@@ -10,6 +10,7 @@ import logging

 import voluptuous as vol

+from typing import Union, TypeVar, Sequence
 from homeassistant.const import (CONF_HOST, CONF_NAME, ATTR_ENTITY_ID)
 from homeassistant.config import load_yaml_config_file
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
@@ -17,7 +18,7 @@ from homeassistant.helpers import discovery
 from homeassistant.components.discovery import SERVICE_APPLE_TV
 import homeassistant.helpers.config_validation as cv

-REQUIREMENTS = ['pyatv==0.3.4']
+REQUIREMENTS = ['pyatv==0.3.5']

 _LOGGER = logging.getLogger(__name__)

@@ -45,8 +46,19 @@ NOTIFICATION_AUTH_TITLE = 'Apple TV Authentication'
 NOTIFICATION_SCAN_ID = 'apple_tv_scan_notification'
 NOTIFICATION_SCAN_TITLE = 'Apple TV Scan'

+T = TypeVar('T')
+
+
+# This version of ensure_list interprets an empty dict as no value
+def ensure_list(value: Union[T, Sequence[T]]) -> Sequence[T]:
+    """Wrap value in list if it is not one."""
+    if value is None or (isinstance(value, dict) and not value):
+        return []
+    return value if isinstance(value, list) else [value]
+
+
 CONFIG_SCHEMA = vol.Schema({
-    DOMAIN: vol.All(cv.ensure_list, [vol.Schema({
+    DOMAIN: vol.All(ensure_list, [vol.Schema({
        vol.Required(CONF_HOST): cv.string,
        vol.Required(CONF_LOGIN_ID): cv.string,
        vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
@@ -91,7 +103,7 @@ def request_configuration(hass, config, atv, credentials):
        hass.async_add_job(configurator.request_done, instance)

    instance = configurator.request_config(
-        hass, 'Apple TV Authentication', configuration_callback,
+        'Apple TV Authentication', configuration_callback,
        description='Please enter PIN code shown on screen.',
        submit_caption='Confirm',
        fields=[{'id': 'pin', 'name': 'PIN Code', 'type': 'password'}]
@@ -133,6 +145,10 @@ def async_setup(hass, config):
        """Handler for service calls."""
        entity_ids = service.data.get(ATTR_ENTITY_ID)

+        if service.service == SERVICE_SCAN:
+            hass.async_add_job(scan_for_apple_tvs, hass)
+            return
+
        if entity_ids:
            devices = [device for device in hass.data[DATA_ENTITIES]
                       if device.entity_id in entity_ids]
@@ -140,16 +156,16 @@ def async_setup(hass, config):
            devices = hass.data[DATA_ENTITIES]

        for device in devices:
+            if service.service != SERVICE_AUTHENTICATE:
+                continue
+
            atv = device.atv
-            if service.service == SERVICE_AUTHENTICATE:
-                credentials = yield from atv.airplay.generate_credentials()
-                yield from atv.airplay.load_credentials(credentials)
-                _LOGGER.debug('Generated new credentials: %s', credentials)
-                yield from atv.airplay.start_authentication()
-                hass.async_add_job(request_configuration,
-                                   hass, config, atv, credentials)
-            elif service.service == SERVICE_SCAN:
-                hass.async_add_job(scan_for_apple_tvs, hass)
+            credentials = yield from atv.airplay.generate_credentials()
+            yield from atv.airplay.load_credentials(credentials)
+            _LOGGER.debug('Generated new credentials: %s', credentials)
+            yield from atv.airplay.start_authentication()
+            hass.async_add_job(request_configuration,
+                               hass, config, atv, credentials)

    @asyncio.coroutine
    def atv_discovered(service, info):
--- a/homeassistant/components/arlo.py
+++ b/homeassistant/components/arlo.py
@@ -1,5 +1,5 @@
 """
-This component provides basic support for Netgear Arlo IP cameras.
+This component provides support for Netgear Arlo IP cameras.

 For more details about this component, please refer to the documentation at
 https://home-assistant.io/components/arlo/
@@ -12,7 +12,7 @@ from requests.exceptions import HTTPError, ConnectTimeout
 from homeassistant.helpers import config_validation as cv
 from homeassistant.const import CONF_USERNAME, CONF_PASSWORD

-REQUIREMENTS = ['pyarlo==0.0.4']
+REQUIREMENTS = ['pyarlo==0.0.7']

 _LOGGER = logging.getLogger(__name__)

@@ -23,7 +23,7 @@ DEFAULT_BRAND = 'Netgear Arlo'
 DOMAIN = 'arlo'

 NOTIFICATION_ID = 'arlo_notification'
-NOTIFICATION_TITLE = 'Arlo Camera Setup'
+NOTIFICATION_TITLE = 'Arlo Component Setup'

 CONFIG_SCHEMA = vol.Schema({
    DOMAIN: vol.Schema({
--- a/homeassistant/components/automation/event.py
+++ b/homeassistant/components/automation/event.py
@@ -21,7 +21,7 @@ _LOGGER = logging.getLogger(__name__)
 TRIGGER_SCHEMA = vol.Schema({
    vol.Required(CONF_PLATFORM): 'event',
    vol.Required(CONF_EVENT_TYPE): cv.string,
-    vol.Optional(CONF_EVENT_DATA): dict,
+    vol.Optional(CONF_EVENT_DATA, default={}): dict,
 })


@@ -29,18 +29,25 @@ TRIGGER_SCHEMA = vol.Schema({
 def async_trigger(hass, config, action):
    """Listen for events based on configuration."""
    event_type = config.get(CONF_EVENT_TYPE)
-    event_data = config.get(CONF_EVENT_DATA)
+    event_data_schema = vol.Schema(
+        config.get(CONF_EVENT_DATA),
+        extra=vol.ALLOW_EXTRA) if config.get(CONF_EVENT_DATA) else None

    @callback
    def handle_event(event):
        """Listen for events and calls the action when data matches."""
-        if not event_data or all(val == event.data.get(key) for key, val
-                                 in event_data.items()):
-            hass.async_run_job(action, {
-                'trigger': {
-                    'platform': 'event',
-                    'event': event,
-                },
-            })
+        if event_data_schema:
+            try:
+                event_data_schema(event.data)
+            except vol.Invalid:
+                # If event data doesn't match requested schema, skip event
+                return
+
+        hass.async_run_job(action, {
+            'trigger': {
+                'platform': 'event',
+                'event': event,
+            },
+        })

    return hass.bus.async_listen(event_type, handle_event)
--- a/homeassistant/components/automation/numeric_state.py
+++ b/homeassistant/components/automation/numeric_state.py
@@ -12,16 +12,18 @@ import voluptuous as vol
 from homeassistant.core import callback
 from homeassistant.const import (
    CONF_VALUE_TEMPLATE, CONF_PLATFORM, CONF_ENTITY_ID,
-    CONF_BELOW, CONF_ABOVE)
-from homeassistant.helpers.event import async_track_state_change
+    CONF_BELOW, CONF_ABOVE, CONF_FOR)
+from homeassistant.helpers.event import (
+    async_track_state_change, async_track_same_state)
 from homeassistant.helpers import condition, config_validation as cv

 TRIGGER_SCHEMA = vol.All(vol.Schema({
    vol.Required(CONF_PLATFORM): 'numeric_state',
    vol.Required(CONF_ENTITY_ID): cv.entity_ids,
-    CONF_BELOW: vol.Coerce(float),
-    CONF_ABOVE: vol.Coerce(float),
+    vol.Optional(CONF_BELOW): vol.Coerce(float),
+    vol.Optional(CONF_ABOVE): vol.Coerce(float),
    vol.Optional(CONF_VALUE_TEMPLATE): cv.template,
+    vol.Optional(CONF_FOR): vol.All(cv.time_period, cv.positive_timedelta),
 }), cv.has_at_least_one_key(CONF_BELOW, CONF_ABOVE))

 _LOGGER = logging.getLogger(__name__)
@@ -33,15 +35,18 @@ def async_trigger(hass, config, action):
    entity_id = config.get(CONF_ENTITY_ID)
    below = config.get(CONF_BELOW)
    above = config.get(CONF_ABOVE)
+    time_delta = config.get(CONF_FOR)
    value_template = config.get(CONF_VALUE_TEMPLATE)
+    async_remove_track_same = None
+
    if value_template is not None:
        value_template.hass = hass

    @callback
-    def state_automation_listener(entity, from_s, to_s):
-        """Listen for state changes and calls action."""
+    def check_numeric_state(entity, from_s, to_s):
+        """Return True if they should trigger."""
        if to_s is None:
-            return
+            return False

        variables = {
            'trigger': {
@@ -55,17 +60,56 @@ def async_trigger(hass, config, action):
        # If new one doesn't match, nothing to do
        if not condition.async_numeric_state(
                hass, to_s, below, above, value_template, variables):
+            return False
+
+        return True
+
+    @callback
+    def state_automation_listener(entity, from_s, to_s):
+        """Listen for state changes and calls action."""
+        nonlocal async_remove_track_same
+
+        if not check_numeric_state(entity, from_s, to_s):
            return

+        variables = {
+            'trigger': {
+                'platform': 'numeric_state',
+                'entity_id': entity,
+                'below': below,
+                'above': above,
+                'from_state': from_s,
+                'to_state': to_s,
+            }
+        }
+
        # Only match if old didn't exist or existed but didn't match
        # Written as: skip if old one did exist and matched
        if from_s is not None and condition.async_numeric_state(
                hass, from_s, below, above, value_template, variables):
            return

-        variables['trigger']['from_state'] = from_s
-        variables['trigger']['to_state'] = to_s
+        @callback
+        def call_action():
+            """Call action with right context."""
+            hass.async_run_job(action, variables)

-        hass.async_run_job(action, variables)
+        if not time_delta:
+            call_action()
+            return

-    return async_track_state_change(hass, entity_id, state_automation_listener)
+        async_remove_track_same = async_track_same_state(
+            hass, time_delta, call_action, entity_ids=entity_id,
+            async_check_same_func=check_numeric_state)
+
+    unsub = async_track_state_change(
+        hass, entity_id, state_automation_listener)
+
+    @callback
+    def async_remove():
+        """Remove state listeners async."""
+        unsub()
+        if async_remove_track_same:
+            async_remove_track_same()  # pylint: disable=not-callable
+
+    return async_remove
--- a/homeassistant/components/automation/state.py
+++ b/homeassistant/components/automation/state.py
@@ -8,28 +8,23 @@ import asyncio
 import voluptuous as vol

 from homeassistant.core import callback
-import homeassistant.util.dt as dt_util
-from homeassistant.const import MATCH_ALL, CONF_PLATFORM
+from homeassistant.const import MATCH_ALL, CONF_PLATFORM, CONF_FOR
 from homeassistant.helpers.event import (
-    async_track_state_change, async_track_point_in_utc_time)
+    async_track_state_change, async_track_same_state)
 import homeassistant.helpers.config_validation as cv

 CONF_ENTITY_ID = 'entity_id'
 CONF_FROM = 'from'
 CONF_TO = 'to'
-CONF_FOR = 'for'

-TRIGGER_SCHEMA = vol.All(
-    vol.Schema({
-        vol.Required(CONF_PLATFORM): 'state',
-        vol.Required(CONF_ENTITY_ID): cv.entity_ids,
-        # These are str on purpose. Want to catch YAML conversions
-        CONF_FROM: str,
-        CONF_TO: str,
-        CONF_FOR: vol.All(cv.time_period, cv.positive_timedelta),
-    }),
-    cv.key_dependency(CONF_FOR, CONF_TO),
-)
+TRIGGER_SCHEMA = vol.All(vol.Schema({
+    vol.Required(CONF_PLATFORM): 'state',
+    vol.Required(CONF_ENTITY_ID): cv.entity_ids,
+    # These are str on purpose. Want to catch YAML conversions
+    vol.Optional(CONF_FROM): str,
+    vol.Optional(CONF_TO): str,
+    vol.Optional(CONF_FOR): vol.All(cv.time_period, cv.positive_timedelta),
+}), cv.key_dependency(CONF_FOR, CONF_TO))


@asyncio.coroutine
@@ -39,28 +34,15 @@ def async_trigger(hass, config, action):
    from_state = config.get(CONF_FROM, MATCH_ALL)
    to_state = config.get(CONF_TO, MATCH_ALL)
    time_delta = config.get(CONF_FOR)
-    async_remove_state_for_cancel = None
-    async_remove_state_for_listener = None
    match_all = (from_state == MATCH_ALL and to_state == MATCH_ALL)
-
-    @callback
-    def clear_listener():
-        """Clear all unsub listener."""
-        nonlocal async_remove_state_for_cancel, async_remove_state_for_listener
-
-        # pylint: disable=not-callable
-        if async_remove_state_for_listener is not None:
-            async_remove_state_for_listener()
-            async_remove_state_for_listener = None
-        if async_remove_state_for_cancel is not None:
-            async_remove_state_for_cancel()
-            async_remove_state_for_cancel = None
+    async_remove_track_same = None

    @callback
    def state_automation_listener(entity, from_s, to_s):
        """Listen for state changes and calls action."""
-        nonlocal async_remove_state_for_cancel, async_remove_state_for_listener
+        nonlocal async_remove_track_same

+        @callback
        def call_action():
            """Call action with right context."""
            hass.async_run_job(action, {
@@ -78,33 +60,14 @@ def async_trigger(hass, config, action):
                from_s.last_changed == to_s.last_changed):
            return

-        if time_delta is None:
+        if not time_delta:
            call_action()
            return

-        @callback
-        def state_for_listener(now):
-            """Fire on state changes after a delay and calls action."""
-            nonlocal async_remove_state_for_listener
-            async_remove_state_for_listener = None
-            clear_listener()
-            call_action()
-
-        @callback
-        def state_for_cancel_listener(entity, inner_from_s, inner_to_s):
-            """Fire on changes and cancel for listener if changed."""
-            if inner_to_s.state == to_s.state:
-                return
-            clear_listener()
-
-        # cleanup previous listener
-        clear_listener()
-
-        async_remove_state_for_listener = async_track_point_in_utc_time(
-            hass, state_for_listener, dt_util.utcnow() + time_delta)
-
-        async_remove_state_for_cancel = async_track_state_change(
-            hass, entity, state_for_cancel_listener)
+        async_remove_track_same = async_track_same_state(
+            hass, time_delta, call_action,
+            lambda _, _2, to_state: to_state.state == to_s.state,
+            entity_ids=entity_id)

    unsub = async_track_state_change(
        hass, entity_id, state_automation_listener, from_state, to_state)
@@ -113,6 +76,7 @@ def async_trigger(hass, config, action):
    def async_remove():
        """Remove state listeners async."""
        unsub()
-        clear_listener()
+        if async_remove_track_same:
+            async_remove_track_same()  # pylint: disable=not-callable

    return async_remove
--- a/homeassistant/components/axis.py
+++ b/homeassistant/components/axis.py
@@ -14,7 +14,7 @@ import voluptuous as vol
 from homeassistant.config import load_yaml_config_file
 from homeassistant.const import (ATTR_LOCATION, ATTR_TRIPPED,
                                 CONF_HOST, CONF_INCLUDE, CONF_NAME,
-                                 CONF_PASSWORD, CONF_TRIGGER_TIME,
+                                 CONF_PASSWORD, CONF_PORT, CONF_TRIGGER_TIME,
                                 CONF_USERNAME, EVENT_HOMEASSISTANT_STOP)
 from homeassistant.components.discovery import SERVICE_AXIS
 from homeassistant.helpers import config_validation as cv
@@ -23,7 +23,7 @@ from homeassistant.helpers.dispatcher import async_dispatcher_send
 from homeassistant.helpers.entity import Entity


-REQUIREMENTS = ['axis==8']
+REQUIREMENTS = ['axis==12']

 _LOGGER = logging.getLogger(__name__)

@@ -51,6 +51,7 @@ DEVICE_SCHEMA = vol.Schema({
    vol.Optional(CONF_USERNAME, default=AXIS_DEFAULT_USERNAME): cv.string,
    vol.Optional(CONF_PASSWORD, default=AXIS_DEFAULT_PASSWORD): cv.string,
    vol.Optional(CONF_TRIGGER_TIME, default=0): cv.positive_int,
+    vol.Optional(CONF_PORT, default=80): cv.positive_int,
    vol.Optional(ATTR_LOCATION, default=''): cv.string,
 })

@@ -76,7 +77,7 @@ SERVICE_SCHEMA = vol.Schema({
 })


-def request_configuration(hass, name, host, serialnumber):
+def request_configuration(hass, config, name, host, serialnumber):
    """Request configuration steps from the user."""
    configurator = hass.components.configurator

@@ -91,15 +92,15 @@ def request_configuration(hass, name, host, serialnumber):
        if CONF_NAME not in callback_data:
            callback_data[CONF_NAME] = name
        try:
-            config = DEVICE_SCHEMA(callback_data)
+            device_config = DEVICE_SCHEMA(callback_data)
        except vol.Invalid:
            configurator.notify_errors(request_id,
                                       "Bad input, please check spelling.")
            return False

-        if setup_device(hass, config):
+        if setup_device(hass, config, device_config):
            config_file = _read_config(hass)
-            config_file[serialnumber] = dict(config)
+            config_file[serialnumber] = dict(device_config)
            del config_file[serialnumber]['hass']
            _write_config(hass, config_file)
            configurator.request_done(request_id)
@@ -110,7 +111,7 @@ def request_configuration(hass, name, host, serialnumber):

    title = '{} ({})'.format(name, host)
    request_id = configurator.request_config(
-        hass, title, configuration_callback,
+        title, configuration_callback,
        description='Functionality: ' + str(AXIS_INCLUDE),
        entity_picture="/static/images/logo_axis.png",
        link_name='Axis platform documentation',
@@ -132,6 +133,9 @@ def request_configuration(hass, name, host, serialnumber):
            {'id': ATTR_LOCATION,
             'name': "Physical location of device (optional)",
             'type': 'text'},
+            {'id': CONF_PORT,
+             'name': "HTTP port (default=80)",
+             'type': 'number'},
            {'id': CONF_TRIGGER_TIME,
             'name': "Sensor update interval (optional)",
             'type': 'number'},
@@ -139,7 +143,7 @@ def request_configuration(hass, name, host, serialnumber):
    )


-def setup(hass, base_config):
+def setup(hass, config):
    """Common setup for Axis devices."""
    def _shutdown(call):  # pylint: disable=unused-argument
        """Stop the metadatastream on shutdown."""
@@ -160,16 +164,17 @@ def setup(hass, base_config):
            if serialnumber in config_file:
                # Device config saved to file
                try:
-                    config = DEVICE_SCHEMA(config_file[serialnumber])
-                    config[CONF_HOST] = host
+                    device_config = DEVICE_SCHEMA(config_file[serialnumber])
+                    device_config[CONF_HOST] = host
                except vol.Invalid as err:
                    _LOGGER.error("Bad data from %s. %s", CONFIG_FILE, err)
                    return False
-                if not setup_device(hass, config):
-                    _LOGGER.error("Couldn\'t set up %s", config[CONF_NAME])
+                if not setup_device(hass, config, device_config):
+                    _LOGGER.error("Couldn\'t set up %s",
+                                  device_config[CONF_NAME])
            else:
                # New device, create configuration request for UI
-                request_configuration(hass, name, host, serialnumber)
+                request_configuration(hass, config, name, host, serialnumber)
        else:
            # Device already registered, but on a different IP
            device = AXIS_DEVICES[serialnumber]
@@ -181,13 +186,13 @@ def setup(hass, base_config):
    # Register discovery service
    discovery.listen(hass, SERVICE_AXIS, axis_device_discovered)

-    if DOMAIN in base_config:
-        for device in base_config[DOMAIN]:
-            config = base_config[DOMAIN][device]
-            if CONF_NAME not in config:
-                config[CONF_NAME] = device
-            if not setup_device(hass, config):
-                _LOGGER.error("Couldn\'t set up %s", config[CONF_NAME])
+    if DOMAIN in config:
+        for device in config[DOMAIN]:
+            device_config = config[DOMAIN][device]
+            if CONF_NAME not in device_config:
+                device_config[CONF_NAME] = device
+            if not setup_device(hass, config, device_config):
+                _LOGGER.error("Couldn\'t set up %s", device_config[CONF_NAME])

    # Services to communicate with device.
    descriptions = load_yaml_config_file(
@@ -215,20 +220,20 @@ def setup(hass, base_config):
    return True


-def setup_device(hass, config):
+def setup_device(hass, config, device_config):
    """Set up device."""
    from axis import AxisDevice

-    config['hass'] = hass
-    device = AxisDevice(config)  # Initialize device
+    device_config['hass'] = hass
+    device = AxisDevice(device_config)  # Initialize device
    enable_metadatastream = False

    if device.serial_number is None:
        # If there is no serial number a connection could not be made
-        _LOGGER.error("Couldn\'t connect to %s", config[CONF_HOST])
+        _LOGGER.error("Couldn\'t connect to %s", device_config[CONF_HOST])
        return False

-    for component in config[CONF_INCLUDE]:
+    for component in device_config[CONF_INCLUDE]:
        if component in EVENT_TYPES:
            # Sensors are created by device calling event_initialized
            # when receiving initialize messages on metadatastream
@@ -236,7 +241,18 @@ def setup_device(hass, config):
            if not enable_metadatastream:
                enable_metadatastream = True
        else:
-            discovery.load_platform(hass, component, DOMAIN, config)
+            camera_config = {
+                CONF_HOST: device_config[CONF_HOST],
+                CONF_NAME: device_config[CONF_NAME],
+                CONF_PORT: device_config[CONF_PORT],
+                CONF_USERNAME: device_config[CONF_USERNAME],
+                CONF_PASSWORD: device_config[CONF_PASSWORD]
+            }
+            discovery.load_platform(hass,
+                                    component,
+                                    DOMAIN,
+                                    camera_config,
+                                    config)

    if enable_metadatastream:
        device.initialize_new_event = event_initialized
--- a/homeassistant/components/binary_sensor/abode.py
+++ b/homeassistant/components/binary_sensor/abode.py
@@ -0,0 +1,74 @@
+"""
+This component provides HA binary_sensor support for Abode Security System.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/binary_sensor.abode/
+"""
+import logging
+
+from homeassistant.components.abode import (AbodeDevice, AbodeAutomation,
+                                            DOMAIN as ABODE_DOMAIN)
+from homeassistant.components.binary_sensor import BinarySensorDevice
+
+
+DEPENDENCIES = ['abode']
+
+_LOGGER = logging.getLogger(__name__)
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Set up a sensor for an Abode device."""
+    import abodepy.helpers.constants as CONST
+    import abodepy.helpers.timeline as TIMELINE
+
+    data = hass.data[ABODE_DOMAIN]
+
+    device_types = [CONST.TYPE_CONNECTIVITY, CONST.TYPE_MOISTURE,
+                    CONST.TYPE_MOTION, CONST.TYPE_OCCUPANCY,
+                    CONST.TYPE_OPENING]
+
+    devices = []
+    for device in data.abode.get_devices(generic_type=device_types):
+        if data.is_excluded(device):
+            continue
+
+        devices.append(AbodeBinarySensor(data, device))
+
+    for automation in data.abode.get_automations(
+            generic_type=CONST.TYPE_QUICK_ACTION):
+        if data.is_automation_excluded(automation):
+            continue
+
+        devices.append(AbodeQuickActionBinarySensor(
+            data, automation, TIMELINE.AUTOMATION_EDIT_GROUP))
+
+    data.devices.extend(devices)
+
+    add_devices(devices)
+
+
+class AbodeBinarySensor(AbodeDevice, BinarySensorDevice):
+    """A binary sensor implementation for Abode device."""
+
+    @property
+    def is_on(self):
+        """Return True if the binary sensor is on."""
+        return self._device.is_on
+
+    @property
+    def device_class(self):
+        """Return the class of the binary sensor."""
+        return self._device.generic_type
+
+
+class AbodeQuickActionBinarySensor(AbodeAutomation, BinarySensorDevice):
+    """A binary sensor implementation for Abode quick action automations."""
+
+    def trigger(self):
+        """Trigger a quick automation."""
+        self._automation.trigger()
+
+    @property
+    def is_on(self):
+        """Return True if the binary sensor is on."""
+        return self._automation.is_active
--- a/homeassistant/components/binary_sensor/alarmdecoder.py
+++ b/homeassistant/components/binary_sensor/alarmdecoder.py
@@ -102,11 +102,11 @@ class AlarmDecoderBinarySensor(BinarySensorDevice):
        """Update the zone's state, if needed."""
        if zone is None or int(zone) == self._zone_number:
            self._state = 1
-            self.hass.async_add_job(self.async_update_ha_state())
+            self.async_schedule_update_ha_state()

    @callback
    def _restore_callback(self, zone):
        """Update the zone's state, if needed."""
        if zone is None or int(zone) == self._zone_number:
            self._state = 0
-            self.hass.async_add_job(self.async_update_ha_state())
+            self.async_schedule_update_ha_state()
--- a/homeassistant/components/binary_sensor/bayesian.py
+++ b/homeassistant/components/binary_sensor/bayesian.py
@@ -0,0 +1,217 @@
+"""
+Use Bayesian Inference to trigger a binary sensor.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/binary_sensor.bayesian/
+"""
+import asyncio
+import logging
+from collections import OrderedDict
+
+import voluptuous as vol
+
+import homeassistant.helpers.config_validation as cv
+from homeassistant.components.binary_sensor import (
+    BinarySensorDevice, PLATFORM_SCHEMA)
+from homeassistant.const import (
+    CONF_ABOVE, CONF_BELOW, CONF_DEVICE_CLASS, CONF_ENTITY_ID, CONF_NAME,
+    CONF_PLATFORM, CONF_STATE, STATE_UNKNOWN)
+from homeassistant.core import callback
+from homeassistant.helpers import condition
+from homeassistant.helpers.event import async_track_state_change
+
+_LOGGER = logging.getLogger(__name__)
+
+CONF_OBSERVATIONS = 'observations'
+CONF_PRIOR = 'prior'
+CONF_PROBABILITY_THRESHOLD = 'probability_threshold'
+CONF_P_GIVEN_F = 'prob_given_false'
+CONF_P_GIVEN_T = 'prob_given_true'
+CONF_TO_STATE = 'to_state'
+
+DEFAULT_NAME = 'BayesianBinary'
+
+NUMERIC_STATE_SCHEMA = vol.Schema({
+    CONF_PLATFORM: 'numeric_state',
+    vol.Required(CONF_ENTITY_ID): cv.entity_id,
+    vol.Optional(CONF_ABOVE): vol.Coerce(float),
+    vol.Optional(CONF_BELOW): vol.Coerce(float),
+    vol.Required(CONF_P_GIVEN_T): vol.Coerce(float),
+    vol.Optional(CONF_P_GIVEN_F): vol.Coerce(float)
+}, required=True)
+
+STATE_SCHEMA = vol.Schema({
+    CONF_PLATFORM: CONF_STATE,
+    vol.Required(CONF_ENTITY_ID): cv.entity_id,
+    vol.Required(CONF_TO_STATE): cv.string,
+    vol.Required(CONF_P_GIVEN_T): vol.Coerce(float),
+    vol.Optional(CONF_P_GIVEN_F): vol.Coerce(float)
+}, required=True)
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Optional(CONF_NAME, default=DEFAULT_NAME):
+        cv.string,
+    vol.Optional(CONF_DEVICE_CLASS): cv.string,
+    vol.Required(CONF_OBSERVATIONS): vol.Schema(
+        vol.All(cv.ensure_list, [vol.Any(NUMERIC_STATE_SCHEMA,
+                                         STATE_SCHEMA)])
+    ),
+    vol.Required(CONF_PRIOR): vol.Coerce(float),
+    vol.Optional(CONF_PROBABILITY_THRESHOLD):
+        vol.Coerce(float),
+})
+
+
+def update_probability(prior, prob_true, prob_false):
+    """Update probability using Bayes' rule."""
+    numerator = prob_true * prior
+    denominator = numerator + prob_false * (1 - prior)
+
+    probability = numerator / denominator
+    return probability
+
+
+@asyncio.coroutine
+def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
+    """Set up the Threshold sensor."""
+    name = config.get(CONF_NAME)
+    observations = config.get(CONF_OBSERVATIONS)
+    prior = config.get(CONF_PRIOR)
+    probability_threshold = config.get(CONF_PROBABILITY_THRESHOLD, 0.5)
+    device_class = config.get(CONF_DEVICE_CLASS)
+
+    async_add_devices([
+        BayesianBinarySensor(name, prior, observations, probability_threshold,
+                             device_class)
+    ], True)
+
+
+class BayesianBinarySensor(BinarySensorDevice):
+    """Representation of a Bayesian sensor."""
+
+    def __init__(self, name, prior, observations, probability_threshold,
+                 device_class):
+        """Initialize the Bayesian sensor."""
+        self._name = name
+        self._observations = observations
+        self._probability_threshold = probability_threshold
+        self._device_class = device_class
+        self._deviation = False
+        self.prior = prior
+        self.probability = prior
+
+        self.current_obs = OrderedDict({})
+
+        to_observe = set(obs['entity_id'] for obs in self._observations)
+
+        self.entity_obs = dict.fromkeys(to_observe, [])
+
+        for ind, obs in enumerate(self._observations):
+            obs["id"] = ind
+            self.entity_obs[obs['entity_id']].append(obs)
+
+        self.watchers = {
+            'numeric_state': self._process_numeric_state,
+            'state': self._process_state
+        }
+
+    @asyncio.coroutine
+    def async_added_to_hass(self):
+        """Call when entity about to be added to hass."""
+        @callback
+        # pylint: disable=invalid-name
+        def async_threshold_sensor_state_listener(entity, old_state,
+                                                  new_state):
+            """Handle sensor state changes."""
+            if new_state.state == STATE_UNKNOWN:
+                return
+
+            entity_obs_list = self.entity_obs[entity]
+
+            for entity_obs in entity_obs_list:
+                platform = entity_obs['platform']
+
+                self.watchers[platform](entity_obs)
+
+            prior = self.prior
+            for obs in self.current_obs.values():
+                prior = update_probability(prior, obs['prob_true'],
+                                           obs['prob_false'])
+            self.probability = prior
+
+            self.hass.async_add_job(self.async_update_ha_state, True)
+
+        entities = [obs['entity_id'] for obs in self._observations]
+        async_track_state_change(
+            self.hass, entities, async_threshold_sensor_state_listener)
+
+    def _update_current_obs(self, entity_observation, should_trigger):
+        """Update current observation."""
+        obs_id = entity_observation['id']
+
+        if should_trigger:
+            prob_true = entity_observation['prob_given_true']
+            prob_false = entity_observation.get(
+                'prob_given_false', 1 - prob_true)
+
+            self.current_obs[obs_id] = {
+                'prob_true': prob_true,
+                'prob_false': prob_false
+            }
+
+        else:
+            self.current_obs.pop(obs_id, None)
+
+    def _process_numeric_state(self, entity_observation):
+        """Add entity to current_obs if numeric state conditions are met."""
+        entity = entity_observation['entity_id']
+
+        should_trigger = condition.async_numeric_state(
+            self.hass, entity,
+            entity_observation.get('below'),
+            entity_observation.get('above'), None, entity_observation)
+
+        self._update_current_obs(entity_observation, should_trigger)
+
+    def _process_state(self, entity_observation):
+        """Add entity to current observations if state conditions are met."""
+        entity = entity_observation['entity_id']
+
+        should_trigger = condition.state(
+            self.hass, entity, entity_observation.get('to_state'))
+
+        self._update_current_obs(entity_observation, should_trigger)
+
+    @property
+    def name(self):
+        """Return the name of the sensor."""
+        return self._name
+
+    @property
+    def is_on(self):
+        """Return true if sensor is on."""
+        return self._deviation
+
+    @property
+    def should_poll(self):
+        """No polling needed."""
+        return False
+
+    @property
+    def device_class(self):
+        """Return the sensor class of the sensor."""
+        return self._device_class
+
+    @property
+    def device_state_attributes(self):
+        """Return the state attributes of the sensor."""
+        return {
+            'observations': [val for val in self.current_obs.values()],
+            'probability': round(self.probability, 2),
+            'probability_threshold': self._probability_threshold
+        }
+
+    @asyncio.coroutine
+    def async_update(self):
+        """Get the latest data and update the states."""
+        self._deviation = bool(self.probability > self._probability_threshold)
--- a/homeassistant/components/binary_sensor/doorbird.py
+++ b/homeassistant/components/binary_sensor/doorbird.py
@@ -0,0 +1,60 @@
+"""Support for reading binary states from a DoorBird video doorbell."""
+from datetime import timedelta
+import logging
+
+from homeassistant.components.binary_sensor import BinarySensorDevice
+from homeassistant.components.doorbird import DOMAIN as DOORBIRD_DOMAIN
+from homeassistant.util import Throttle
+
+DEPENDENCIES = ['doorbird']
+
+_LOGGER = logging.getLogger(__name__)
+_MIN_UPDATE_INTERVAL = timedelta(milliseconds=250)
+
+SENSOR_TYPES = {
+    "doorbell": {
+        "name": "Doorbell Ringing",
+        "icon": {
+            True: "bell-ring",
+            False: "bell",
+            None: "bell-outline"
+        }
+    }
+}
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Set up the DoorBird binary sensor component."""
+    device = hass.data.get(DOORBIRD_DOMAIN)
+    add_devices([DoorBirdBinarySensor(device, "doorbell")], True)
+
+
+class DoorBirdBinarySensor(BinarySensorDevice):
+    """A binary sensor of a DoorBird device."""
+
+    def __init__(self, device, sensor_type):
+        """Initialize a binary sensor on a DoorBird device."""
+        self._device = device
+        self._sensor_type = sensor_type
+        self._state = None
+
+    @property
+    def name(self):
+        """Get the name of the sensor."""
+        return SENSOR_TYPES[self._sensor_type]["name"]
+
+    @property
+    def icon(self):
+        """Get an icon to display."""
+        state_icon = SENSOR_TYPES[self._sensor_type]["icon"][self._state]
+        return "mdi:{}".format(state_icon)
+
+    @property
+    def is_on(self):
+        """Get the state of the binary sensor."""
+        return self._state
+
+    @Throttle(_MIN_UPDATE_INTERVAL)
+    def update(self):
+        """Pull the latest value from the device."""
+        self._state = self._device.doorbell_state()
--- a/homeassistant/components/binary_sensor/envisalink.py
+++ b/homeassistant/components/binary_sensor/envisalink.py
@@ -80,4 +80,4 @@ class EnvisalinkBinarySensor(EnvisalinkDevice, BinarySensorDevice):
    def _update_callback(self, zone):
        """Update the zone's state, if needed."""
        if zone is None or int(zone) == self._zone_number:
-            self.hass.async_add_job(self.async_update_ha_state())
+            self.async_schedule_update_ha_state()
--- a/homeassistant/components/binary_sensor/ffmpeg_motion.py
+++ b/homeassistant/components/binary_sensor/ffmpeg_motion.py
@@ -73,7 +73,7 @@ class FFmpegBinarySensor(FFmpegBase, BinarySensorDevice):
    def _async_callback(self, state):
        """HA-FFmpeg callback for noise detection."""
        self._state = state
-        self.hass.async_add_job(self.async_update_ha_state())
+        self.async_schedule_update_ha_state()

    @property
    def is_on(self):
--- a/homeassistant/components/binary_sensor/hikvision.py
+++ b/homeassistant/components/binary_sensor/hikvision.py
@@ -18,7 +18,7 @@ from homeassistant.const import (
    CONF_SSL, EVENT_HOMEASSISTANT_STOP, EVENT_HOMEASSISTANT_START,
    ATTR_LAST_TRIP_TIME, CONF_CUSTOMIZE)

-REQUIREMENTS = ['pyhik==0.1.3']
+REQUIREMENTS = ['pyhik==0.1.4']
 _LOGGER = logging.getLogger(__name__)

 CONF_IGNORED = 'ignored'
@@ -47,6 +47,7 @@ DEVICE_CLASS_MAP = {
    'PIR Alarm': 'motion',
    'Face Detection': 'motion',
    'Scene Change Detection': 'motion',
+    'I/O': None,
 }

 CUSTOMIZE_SCHEMA = vol.Schema({
--- a/homeassistant/components/binary_sensor/homematic.py
+++ b/homeassistant/components/binary_sensor/homematic.py
@@ -35,8 +35,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):

    devices = []
    for conf in discovery_info[ATTR_DISCOVER_DEVICES]:
-        new_device = HMBinarySensor(hass, conf)
-        new_device.link_homematic()
+        new_device = HMBinarySensor(conf)
        devices.append(new_device)

    add_devices(devices)
--- a/homeassistant/components/binary_sensor/insteon_plm.py
+++ b/homeassistant/components/binary_sensor/insteon_plm.py
@@ -55,12 +55,12 @@ class InsteonPLMBinarySensorDevice(BinarySensorDevice):

    @property
    def address(self):
-        """Return the the address of the node."""
+        """Return the address of the node."""
        return self._address

    @property
    def name(self):
-        """Return the the name of the node."""
+        """Return the name of the node."""
        return self._name

    @property
--- a/homeassistant/components/binary_sensor/iss.py
+++ b/homeassistant/components/binary_sensor/iss.py
@@ -13,7 +13,8 @@ import voluptuous as vol
 import homeassistant.helpers.config_validation as cv
 from homeassistant.components.binary_sensor import (
    BinarySensorDevice, PLATFORM_SCHEMA)
-from homeassistant.const import (CONF_NAME, ATTR_LONGITUDE, ATTR_LATITUDE)
+from homeassistant.const import (
+    CONF_NAME, ATTR_LONGITUDE, ATTR_LATITUDE, CONF_SHOW_ON_MAP)
 from homeassistant.util import Throttle

 REQUIREMENTS = ['pyiss==1.0.1']
@@ -23,8 +24,6 @@ _LOGGER = logging.getLogger(__name__)
 ATTR_ISS_NEXT_RISE = 'next_rise'
 ATTR_ISS_NUMBER_PEOPLE_SPACE = 'number_of_people_in_space'

-CONF_SHOW_ON_MAP = 'show_on_map'
-
 DEFAULT_NAME = 'ISS'
 DEFAULT_DEVICE_CLASS = 'visible'

--- a/homeassistant/components/binary_sensor/knx.py
+++ b/homeassistant/components/binary_sensor/knx.py
@@ -1,21 +1,145 @@
 """
-Contains functionality to use a KNX group address as a binary.
+Support for KNX/IP binary sensors.

 For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/binary_sensor.knx/
 """
-from homeassistant.components.binary_sensor import BinarySensorDevice
-from homeassistant.components.knx import (KNXConfig, KNXGroupAddress)
+import asyncio
+import voluptuous as vol

+from homeassistant.components.knx import DATA_KNX, ATTR_DISCOVER_DEVICES, \
+    KNXAutomation
+from homeassistant.components.binary_sensor import PLATFORM_SCHEMA, \
+    BinarySensorDevice
+from homeassistant.const import CONF_NAME
+from homeassistant.core import callback
+import homeassistant.helpers.config_validation as cv
+
+CONF_ADDRESS = 'address'
+CONF_DEVICE_CLASS = 'device_class'
+CONF_SIGNIFICANT_BIT = 'significant_bit'
+CONF_DEFAULT_SIGNIFICANT_BIT = 1
+CONF_AUTOMATION = 'automation'
+CONF_HOOK = 'hook'
+CONF_DEFAULT_HOOK = 'on'
+CONF_COUNTER = 'counter'
+CONF_DEFAULT_COUNTER = 1
+CONF_ACTION = 'action'
+
+CONF__ACTION = 'turn_off_action'
+
+DEFAULT_NAME = 'KNX Binary Sensor'
 DEPENDENCIES = ['knx']

+AUTOMATION_SCHEMA = vol.Schema({
+    vol.Optional(CONF_HOOK, default=CONF_DEFAULT_HOOK): cv.string,
+    vol.Optional(CONF_COUNTER, default=CONF_DEFAULT_COUNTER): cv.port,
+    vol.Required(CONF_ACTION, default=None): cv.SCRIPT_SCHEMA
+})

-def setup_platform(hass, config, add_devices, discovery_info=None):
-    """Set up the KNX binary sensor platform."""
-    add_devices([KNXSwitch(hass, KNXConfig(config))])
+AUTOMATIONS_SCHEMA = vol.All(
+    cv.ensure_list,
+    [AUTOMATION_SCHEMA]
+)
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Required(CONF_ADDRESS): cv.string,
+    vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
+    vol.Optional(CONF_DEVICE_CLASS): cv.string,
+    vol.Optional(CONF_SIGNIFICANT_BIT, default=CONF_DEFAULT_SIGNIFICANT_BIT):
+        cv.positive_int,
+    vol.Optional(CONF_AUTOMATION, default=None): AUTOMATIONS_SCHEMA,
+})


-class KNXSwitch(KNXGroupAddress, BinarySensorDevice):
-    """Representation of a KNX binary sensor device."""
+@asyncio.coroutine
+def async_setup_platform(hass, config, async_add_devices,
+                         discovery_info=None):
+    """Set up binary sensor(s) for KNX platform."""
+    if DATA_KNX not in hass.data \
+            or not hass.data[DATA_KNX].initialized:
+        return False

-    pass
+    if discovery_info is not None:
+        async_add_devices_discovery(hass, discovery_info, async_add_devices)
+    else:
+        async_add_devices_config(hass, config, async_add_devices)
+
+    return True
+
+
+@callback
+def async_add_devices_discovery(hass, discovery_info, async_add_devices):
+    """Set up binary sensors for KNX platform configured via xknx.yaml."""
+    entities = []
+    for device_name in discovery_info[ATTR_DISCOVER_DEVICES]:
+        device = hass.data[DATA_KNX].xknx.devices[device_name]
+        entities.append(KNXBinarySensor(hass, device))
+    async_add_devices(entities)
+
+
+@callback
+def async_add_devices_config(hass, config, async_add_devices):
+    """Set up binary senor for KNX platform configured within plattform."""
+    name = config.get(CONF_NAME)
+    import xknx
+    binary_sensor = xknx.devices.BinarySensor(
+        hass.data[DATA_KNX].xknx,
+        name=name,
+        group_address=config.get(CONF_ADDRESS),
+        device_class=config.get(CONF_DEVICE_CLASS),
+        significant_bit=config.get(CONF_SIGNIFICANT_BIT))
+    hass.data[DATA_KNX].xknx.devices.add(binary_sensor)
+
+    entity = KNXBinarySensor(hass, binary_sensor)
+    automations = config.get(CONF_AUTOMATION)
+    if automations is not None:
+        for automation in automations:
+            counter = automation.get(CONF_COUNTER)
+            hook = automation.get(CONF_HOOK)
+            action = automation.get(CONF_ACTION)
+            entity.automations.append(KNXAutomation(
+                hass=hass, device=binary_sensor, hook=hook,
+                action=action, counter=counter))
+    async_add_devices([entity])
+
+
+class KNXBinarySensor(BinarySensorDevice):
+    """Representation of a KNX binary sensor."""
+
+    def __init__(self, hass, device):
+        """Initialization of KNXBinarySensor."""
+        self.device = device
+        self.hass = hass
+        self.async_register_callbacks()
+        self.automations = []
+
+    @callback
+    def async_register_callbacks(self):
+        """Register callbacks to update hass after device was changed."""
+        @asyncio.coroutine
+        def after_update_callback(device):
+            """Callback after device was updated."""
+            # pylint: disable=unused-argument
+            yield from self.async_update_ha_state()
+        self.device.register_device_updated_cb(after_update_callback)
+
+    @property
+    def name(self):
+        """Return the name of the KNX device."""
+        return self.device.name
+
+    @property
+    def should_poll(self):
+        """No polling needed within KNX."""
+        return False
+
+    @property
+    def device_class(self):
+        """Return the class of this sensor."""
+        return self.device.device_class
+
+    @property
+    def is_on(self):
+        """Return true if the binary sensor is on."""
+        return self.device.is_on()
--- a/homeassistant/components/binary_sensor/mqtt.py
+++ b/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,
-                 payload_off, value_template):
+    def __init__(self, name, state_topic, availability_topic, device_class,
+                 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):
-            """Handle a new received MQTT message."""
+        def state_message_received(topic, payload, qos):
+            """Handle a new received MQTT state message."""
            if self._template is not None:
                payload = self._template.async_render_with_possible_json_value(
                    payload)
@@ -86,10 +106,25 @@ class MqttBinarySensor(BinarySensorDevice):
            elif payload == self._payload_off:
                self._state = False

-            self.hass.async_add_job(self.async_update_ha_state())
+            self.async_schedule_update_ha_state()

-        return mqtt.async_subscribe(
-            self.hass, self._state_topic, message_received, self._qos)
+        yield from mqtt.async_subscribe(
+            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."""
--- a/homeassistant/components/binary_sensor/mysensors.py
+++ b/homeassistant/components/binary_sensor/mysensors.py
@@ -4,62 +4,27 @@ Support for MySensors binary sensors.
 For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/binary_sensor.mysensors/
 """
-import logging
-
 from homeassistant.components import mysensors
-from homeassistant.components.binary_sensor import (DEVICE_CLASSES,
+from homeassistant.components.binary_sensor import (DEVICE_CLASSES, DOMAIN,
                                                    BinarySensorDevice)
 from homeassistant.const import STATE_ON

-_LOGGER = logging.getLogger(__name__)
-DEPENDENCIES = []
-

 def setup_platform(hass, config, add_devices, discovery_info=None):
-    """Set up the MySensors platform for sensors."""
-    # Only act if loaded via mysensors by discovery event.
-    # Otherwise gateway is not setup.
-    if discovery_info is None:
-        return
-
-    gateways = hass.data.get(mysensors.MYSENSORS_GATEWAYS)
-    if not gateways:
-        return
-
-    for gateway in gateways:
-        # Define the S_TYPES and V_TYPES that the platform should handle as
-        # states. Map them in a dict of lists.
-        pres = gateway.const.Presentation
-        set_req = gateway.const.SetReq
-        map_sv_types = {
-            pres.S_DOOR: [set_req.V_TRIPPED],
-            pres.S_MOTION: [set_req.V_TRIPPED],
-            pres.S_SMOKE: [set_req.V_TRIPPED],
-        }
-        if float(gateway.protocol_version) >= 1.5:
-            map_sv_types.update({
-                pres.S_SPRINKLER: [set_req.V_TRIPPED],
-                pres.S_WATER_LEAK: [set_req.V_TRIPPED],
-                pres.S_SOUND: [set_req.V_TRIPPED],
-                pres.S_VIBRATION: [set_req.V_TRIPPED],
-                pres.S_MOISTURE: [set_req.V_TRIPPED],
-            })
-
-        devices = {}
-        gateway.platform_callbacks.append(mysensors.pf_callback_factory(
-            map_sv_types, devices, MySensorsBinarySensor, add_devices))
+    """Setup the mysensors platform for binary sensors."""
+    mysensors.setup_mysensors_platform(
+        hass, DOMAIN, discovery_info, MySensorsBinarySensor,
+        add_devices=add_devices)


 class MySensorsBinarySensor(
-        mysensors.MySensorsDeviceEntity, BinarySensorDevice):
+        mysensors.MySensorsEntity, BinarySensorDevice):
    """Represent the value of a MySensors Binary Sensor child node."""

    @property
    def is_on(self):
        """Return True if the binary sensor is on."""
-        if self.value_type in self._values:
-            return self._values[self.value_type] == STATE_ON
-        return False
+        return self._values.get(self.value_type) == STATE_ON

    @property
    def device_class(self):
--- a/homeassistant/components/binary_sensor/mystrom.py
+++ b/homeassistant/components/binary_sensor/mystrom.py
@@ -92,4 +92,4 @@ class MyStromBinarySensor(BinarySensorDevice):
    def async_on_update(self, value):
        """Receive an update."""
        self._state = value
-        self.hass.async_add_job(self.async_update_ha_state())
+        self.async_schedule_update_ha_state()
--- a/homeassistant/components/binary_sensor/netatmo.py
+++ b/homeassistant/components/binary_sensor/netatmo.py
@@ -14,7 +14,7 @@ from homeassistant.components.binary_sensor import (
    BinarySensorDevice, PLATFORM_SCHEMA)
 from homeassistant.components.netatmo import CameraData
 from homeassistant.loader import get_component
-from homeassistant.const import CONF_TIMEOUT, CONF_OFFSET
+from homeassistant.const import CONF_TIMEOUT
 from homeassistant.helpers import config_validation as cv

 _LOGGER = logging.getLogger(__name__)
@@ -44,14 +44,12 @@ CONF_WELCOME_SENSORS = 'welcome_sensors'
 CONF_PRESENCE_SENSORS = 'presence_sensors'
 CONF_TAG_SENSORS = 'tag_sensors'

-DEFAULT_TIMEOUT = 15
-DEFAULT_OFFSET = 90
+DEFAULT_TIMEOUT = 90

 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
    vol.Optional(CONF_CAMERAS, default=[]):
        vol.All(cv.ensure_list, [cv.string]),
    vol.Optional(CONF_HOME): cv.string,
-    vol.Optional(CONF_OFFSET, default=DEFAULT_OFFSET): cv.positive_int,
    vol.Optional(CONF_PRESENCE_SENSORS, default=PRESENCE_SENSOR_TYPES):
        vol.All(cv.ensure_list, [vol.In(PRESENCE_SENSOR_TYPES)]),
    vol.Optional(CONF_TIMEOUT, default=DEFAULT_TIMEOUT): cv.positive_int,
@@ -66,7 +64,8 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
    netatmo = get_component('netatmo')
    home = config.get(CONF_HOME)
    timeout = config.get(CONF_TIMEOUT)
-    offset = config.get(CONF_OFFSET)
+    if timeout is None:
+        timeout = DEFAULT_TIMEOUT

    module_name = None

@@ -94,7 +93,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
            for variable in welcome_sensors:
                add_devices([NetatmoBinarySensor(
                    data, camera_name, module_name, home, timeout,
-                    offset, camera_type, variable)], True)
+                    camera_type, variable)], True)
        if camera_type == 'NOC':
            if CONF_CAMERAS in config:
                if config[CONF_CAMERAS] != [] and \
@@ -102,14 +101,14 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
                    continue
            for variable in presence_sensors:
                add_devices([NetatmoBinarySensor(
-                    data, camera_name, module_name, home, timeout, offset,
+                    data, camera_name, module_name, home, timeout,
                    camera_type, variable)], True)

        for module_name in data.get_module_names(camera_name):
            for variable in tag_sensors:
                camera_type = None
                add_devices([NetatmoBinarySensor(
-                    data, camera_name, module_name, home, timeout, offset,
+                    data, camera_name, module_name, home, timeout,
                    camera_type, variable)], True)


@@ -117,14 +116,13 @@ class NetatmoBinarySensor(BinarySensorDevice):
    """Represent a single binary sensor in a Netatmo Camera device."""

    def __init__(self, data, camera_name, module_name, home,
-                 timeout, offset, camera_type, sensor):
+                 timeout, camera_type, sensor):
        """Set up for access to the Netatmo camera events."""
        self._data = data
        self._camera_name = camera_name
        self._module_name = module_name
        self._home = home
        self._timeout = timeout
-        self._offset = offset
        if home:
            self._name = '{} / {}'.format(home, camera_name)
        else:
@@ -173,40 +171,39 @@ class NetatmoBinarySensor(BinarySensorDevice):
            if self._sensor_name == "Someone known":
                self._state =\
                    self._data.camera_data.someoneKnownSeen(
-                        self._home, self._camera_name, self._timeout*60)
+                        self._home, self._camera_name, self._timeout)
            elif self._sensor_name == "Someone unknown":
                self._state =\
                    self._data.camera_data.someoneUnknownSeen(
-                        self._home, self._camera_name, self._timeout*60)
+                        self._home, self._camera_name, self._timeout)
            elif self._sensor_name == "Motion":
                self._state =\
                    self._data.camera_data.motionDetected(
-                        self._home, self._camera_name, self._timeout*60)
+                        self._home, self._camera_name, self._timeout)
        elif self._cameratype == 'NOC':
            if self._sensor_name == "Outdoor motion":
                self._state =\
                    self._data.camera_data.outdoormotionDetected(
-                        self._home, self._camera_name, self._offset)
+                        self._home, self._camera_name, self._timeout)
            elif self._sensor_name == "Outdoor human":
                self._state =\
                    self._data.camera_data.humanDetected(
-                        self._home, self._camera_name, self._offset)
+                        self._home, self._camera_name, self._timeout)
            elif self._sensor_name == "Outdoor animal":
                self._state =\
                    self._data.camera_data.animalDetected(
-                        self._home, self._camera_name, self._offset)
+                        self._home, self._camera_name, self._timeout)
            elif self._sensor_name == "Outdoor vehicle":
                self._state =\
                    self._data.camera_data.carDetected(
-                        self._home, self._camera_name, self._offset)
+                        self._home, self._camera_name, self._timeout)
        if self._sensor_name == "Tag Vibration":
            self._state =\
                self._data.camera_data.moduleMotionDetected(
                    self._home, self._module_name, self._camera_name,
-                    self._timeout*60)
+                    self._timeout)
        elif self._sensor_name == "Tag Open":
            self._state =\
                self._data.camera_data.moduleOpened(
-                    self._home, self._module_name, self._camera_name)
-        else:
-            return None
+                    self._home, self._module_name, self._camera_name,
+                    self._timeout)
--- a/homeassistant/components/binary_sensor/raincloud.py
+++ b/homeassistant/components/binary_sensor/raincloud.py
@@ -0,0 +1,72 @@
+"""
+Support for Melnor RainCloud sprinkler water timer.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/binary_sensor.raincloud/
+"""
+import logging
+
+import voluptuous as vol
+
+import homeassistant.helpers.config_validation as cv
+from homeassistant.components.raincloud import (
+    BINARY_SENSORS, DATA_RAINCLOUD, ICON_MAP, RainCloudEntity)
+from homeassistant.components.binary_sensor import (
+    BinarySensorDevice, PLATFORM_SCHEMA)
+from homeassistant.const import CONF_MONITORED_CONDITIONS
+
+DEPENDENCIES = ['raincloud']
+
+_LOGGER = logging.getLogger(__name__)
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Optional(CONF_MONITORED_CONDITIONS, default=list(BINARY_SENSORS)):
+        vol.All(cv.ensure_list, [vol.In(BINARY_SENSORS)]),
+})
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Set up a sensor for a raincloud device."""
+    raincloud = hass.data[DATA_RAINCLOUD].data
+
+    sensors = []
+    for sensor_type in config.get(CONF_MONITORED_CONDITIONS):
+        if sensor_type == 'status':
+            sensors.append(
+                RainCloudBinarySensor(raincloud.controller, sensor_type))
+            sensors.append(
+                RainCloudBinarySensor(raincloud.controller.faucet,
+                                      sensor_type))
+
+        else:
+            # create an sensor for each zone managed by faucet
+            for zone in raincloud.controller.faucet.zones:
+                sensors.append(RainCloudBinarySensor(zone, sensor_type))
+
+    add_devices(sensors, True)
+    return True
+
+
+class RainCloudBinarySensor(RainCloudEntity, BinarySensorDevice):
+    """A sensor implementation for raincloud device."""
+
+    @property
+    def is_on(self):
+        """Return true if the binary sensor is on."""
+        return self._state
+
+    def update(self):
+        """Get the latest data and updates the state."""
+        _LOGGER.debug("Updating RainCloud sensor: %s", self._name)
+        self._state = getattr(self.data, self._sensor_type)
+        if self._sensor_type == 'status':
+            self._state = self._state == 'Online'
+
+    @property
+    def icon(self):
+        """Return the icon of this device."""
+        if self._sensor_type == 'is_watering':
+            return 'mdi:water' if self.is_on else 'mdi:water-off'
+        elif self._sensor_type == 'status':
+            return 'mdi:pipe' if self.is_on else 'mdi:pipe-disconnected'
+        return ICON_MAP.get(self._sensor_type)
--- a/homeassistant/components/binary_sensor/ring.py
+++ b/homeassistant/components/binary_sensor/ring.py
@@ -103,7 +103,8 @@ class RingBinarySensor(BinarySensorDevice):
        self._data.check_alerts()

        if self._data.alert:
-            self._state = (self._sensor_type ==
-                           self._data.alert.get('kind'))
+            if self._sensor_type == self._data.alert.get('kind') and \
+               self._data.account_id == self._data.alert.get('doorbot_id'):
+                self._state = True
        else:
            self._state = False
--- a/homeassistant/components/binary_sensor/satel_integra.py
+++ b/homeassistant/components/binary_sensor/satel_integra.py
@@ -0,0 +1,90 @@
+"""
+Support for Satel Integra zone states- represented as binary sensors.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/binary_sensor.satel_integra/
+"""
+import asyncio
+import logging
+
+from homeassistant.components.binary_sensor import BinarySensorDevice
+from homeassistant.components.satel_integra import (CONF_ZONES,
+                                                    CONF_ZONE_NAME,
+                                                    CONF_ZONE_TYPE,
+                                                    SIGNAL_ZONES_UPDATED)
+from homeassistant.core import callback
+from homeassistant.helpers.dispatcher import async_dispatcher_connect
+
+DEPENDENCIES = ['satel_integra']
+
+_LOGGER = logging.getLogger(__name__)
+
+
+@asyncio.coroutine
+def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
+    """Set up the Satel Integra binary sensor devices."""
+    if not discovery_info:
+        return
+
+    configured_zones = discovery_info[CONF_ZONES]
+
+    devices = []
+
+    for zone_num, device_config_data in configured_zones.items():
+        zone_type = device_config_data[CONF_ZONE_TYPE]
+        zone_name = device_config_data[CONF_ZONE_NAME]
+        device = SatelIntegraBinarySensor(zone_num, zone_name, zone_type)
+        devices.append(device)
+
+    async_add_devices(devices)
+
+
+class SatelIntegraBinarySensor(BinarySensorDevice):
+    """Representation of an Satel Integra binary sensor."""
+
+    def __init__(self, zone_number, zone_name, zone_type):
+        """Initialize the binary_sensor."""
+        self._zone_number = zone_number
+        self._name = zone_name
+        self._zone_type = zone_type
+        self._state = 0
+
+    @asyncio.coroutine
+    def async_added_to_hass(self):
+        """Register callbacks."""
+        async_dispatcher_connect(
+            self.hass, SIGNAL_ZONES_UPDATED, self._zones_updated)
+
+    @property
+    def name(self):
+        """Return the name of the entity."""
+        return self._name
+
+    @property
+    def icon(self):
+        """Icon for device by its type."""
+        if self._zone_type == 'smoke':
+            return "mdi:fire"
+
+    @property
+    def should_poll(self):
+        """No polling needed."""
+        return False
+
+    @property
+    def is_on(self):
+        """Return true if sensor is on."""
+        return self._state == 1
+
+    @property
+    def device_class(self):
+        """Return the class of this sensor, from DEVICE_CLASSES."""
+        return self._zone_type
+
+    @callback
+    def _zones_updated(self, zones):
+        """Update the zone's state, if needed."""
+        if self._zone_number in zones \
+                and self._state != zones[self._zone_number]:
+            self._state = zones[self._zone_number]
+            self.async_schedule_update_ha_state()
--- a/homeassistant/components/binary_sensor/skybell.py
+++ b/homeassistant/components/binary_sensor/skybell.py
@@ -0,0 +1,97 @@
+"""
+Binary sensor support for the Skybell HD Doorbell.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/binary_sensor.skybell/
+"""
+from datetime import timedelta
+import logging
+
+import voluptuous as vol
+
+from homeassistant.components.binary_sensor import (
+    BinarySensorDevice, PLATFORM_SCHEMA)
+from homeassistant.components.skybell import (
+    DEFAULT_ENTITY_NAMESPACE, DOMAIN as SKYBELL_DOMAIN, SkybellDevice)
+from homeassistant.const import (
+    CONF_ENTITY_NAMESPACE, CONF_MONITORED_CONDITIONS)
+import homeassistant.helpers.config_validation as cv
+
+DEPENDENCIES = ['skybell']
+
+_LOGGER = logging.getLogger(__name__)
+
+SCAN_INTERVAL = timedelta(seconds=5)
+
+# Sensor types: Name, device_class, event
+SENSOR_TYPES = {
+    'button': ['Button', 'occupancy', 'device:sensor:button'],
+    'motion': ['Motion', 'motion', 'device:sensor:motion'],
+}
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Optional(CONF_ENTITY_NAMESPACE, default=DEFAULT_ENTITY_NAMESPACE):
+        cv.string,
+    vol.Required(CONF_MONITORED_CONDITIONS, default=[]):
+        vol.All(cv.ensure_list, [vol.In(SENSOR_TYPES)]),
+})
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Set up the platform for a Skybell device."""
+    skybell = hass.data.get(SKYBELL_DOMAIN)
+
+    sensors = []
+    for sensor_type in config.get(CONF_MONITORED_CONDITIONS):
+        for device in skybell.get_devices():
+            sensors.append(SkybellBinarySensor(device, sensor_type))
+
+    add_devices(sensors, True)
+
+
+class SkybellBinarySensor(SkybellDevice, BinarySensorDevice):
+    """A binary sensor implementation for Skybell devices."""
+
+    def __init__(self, device, sensor_type):
+        """Initialize a binary sensor for a Skybell device."""
+        super().__init__(device)
+        self._sensor_type = sensor_type
+        self._name = "{0} {1}".format(self._device.name,
+                                      SENSOR_TYPES[self._sensor_type][0])
+        self._device_class = SENSOR_TYPES[self._sensor_type][1]
+        self._event = {}
+        self._state = None
+
+    @property
+    def name(self):
+        """Return the name of the sensor."""
+        return self._name
+
+    @property
+    def is_on(self):
+        """Return True if the binary sensor is on."""
+        return self._state
+
+    @property
+    def device_class(self):
+        """Return the class of the binary sensor."""
+        return self._device_class
+
+    @property
+    def device_state_attributes(self):
+        """Return the state attributes."""
+        attrs = super().device_state_attributes
+
+        attrs['event_date'] = self._event.get('createdAt')
+
+        return attrs
+
+    def update(self):
+        """Get the latest data and updates the state."""
+        super().update()
+
+        event = self._device.latest(SENSOR_TYPES[self._sensor_type][2])
+
+        self._state = bool(event and event.get('id') != self._event.get('id'))
+
+        self._event = event
--- a/homeassistant/components/binary_sensor/spc.py
+++ b/homeassistant/components/binary_sensor/spc.py
@@ -41,14 +41,14 @@ def _create_sensor(hass, zone):


@asyncio.coroutine
-def async_setup_platform(hass, config, async_add_entities,
+def async_setup_platform(hass, config, async_add_devices,
                         discovery_info=None):
    """Initialize the platform."""
    if (discovery_info is None or
            discovery_info[ATTR_DISCOVER_DEVICES] is None):
        return

-    async_add_entities(
+    async_add_devices(
        _create_sensor(hass, zone)
        for zone in discovery_info[ATTR_DISCOVER_DEVICES]
        if _get_device_class(zone['type']))
--- a/homeassistant/components/binary_sensor/template.py
+++ b/homeassistant/components/binary_sensor/template.py
@@ -15,20 +15,27 @@ from homeassistant.components.binary_sensor import (
    DEVICE_CLASSES_SCHEMA)
 from homeassistant.const import (
    ATTR_FRIENDLY_NAME, ATTR_ENTITY_ID, CONF_VALUE_TEMPLATE,
-    CONF_SENSORS, CONF_DEVICE_CLASS, EVENT_HOMEASSISTANT_START, STATE_ON)
+    CONF_SENSORS, CONF_DEVICE_CLASS, EVENT_HOMEASSISTANT_START)
 from homeassistant.exceptions import TemplateError
 import homeassistant.helpers.config_validation as cv
 from homeassistant.helpers.entity import async_generate_entity_id
-from homeassistant.helpers.event import async_track_state_change
-from homeassistant.helpers.restore_state import async_get_last_state
+from homeassistant.helpers.event import (
+    async_track_state_change, async_track_same_state)

 _LOGGER = logging.getLogger(__name__)

+CONF_DELAY_ON = 'delay_on'
+CONF_DELAY_OFF = 'delay_off'
+
 SENSOR_SCHEMA = vol.Schema({
    vol.Required(CONF_VALUE_TEMPLATE): cv.template,
    vol.Optional(ATTR_FRIENDLY_NAME): cv.string,
    vol.Optional(ATTR_ENTITY_ID): cv.entity_ids,
    vol.Optional(CONF_DEVICE_CLASS): DEVICE_CLASSES_SCHEMA,
+    vol.Optional(CONF_DELAY_ON):
+        vol.All(cv.time_period, cv.positive_timedelta),
+    vol.Optional(CONF_DELAY_OFF):
+        vol.All(cv.time_period, cv.positive_timedelta),
 })

 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
@@ -47,6 +54,8 @@ def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
                      value_template.extract_entities())
        friendly_name = device_config.get(ATTR_FRIENDLY_NAME, device)
        device_class = device_config.get(CONF_DEVICE_CLASS)
+        delay_on = device_config.get(CONF_DELAY_ON)
+        delay_off = device_config.get(CONF_DELAY_OFF)

        if value_template is not None:
            value_template.hass = hass
@@ -54,13 +63,13 @@ def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
        sensors.append(
            BinarySensorTemplate(
                hass, device, friendly_name, device_class, value_template,
-                entity_ids)
+                entity_ids, delay_on, delay_off)
            )
    if not sensors:
        _LOGGER.error("No sensors added")
        return False

-    async_add_devices(sensors, True)
+    async_add_devices(sensors)
    return True


@@ -68,7 +77,7 @@ class BinarySensorTemplate(BinarySensorDevice):
    """A virtual binary sensor that triggers from another sensor."""

    def __init__(self, hass, device, friendly_name, device_class,
-                 value_template, entity_ids):
+                 value_template, entity_ids, delay_on, delay_off):
        """Initialize the Template binary sensor."""
        self.hass = hass
        self.entity_id = async_generate_entity_id(
@@ -78,18 +87,16 @@ class BinarySensorTemplate(BinarySensorDevice):
        self._template = value_template
        self._state = None
        self._entities = entity_ids
+        self._delay_on = delay_on
+        self._delay_off = delay_off

    @asyncio.coroutine
    def async_added_to_hass(self):
        """Register callbacks."""
-        state = yield from async_get_last_state(self.hass, self.entity_id)
-        if state:
-            self._state = state.state == STATE_ON
-
        @callback
        def template_bsensor_state_listener(entity, old_state, new_state):
            """Handle the target device state changes."""
-            self.hass.async_add_job(self.async_update_ha_state(True))
+            self.async_check_state()

        @callback
        def template_bsensor_startup(event):
@@ -97,7 +104,7 @@ class BinarySensorTemplate(BinarySensorDevice):
            async_track_state_change(
                self.hass, self._entities, template_bsensor_state_listener)

-            self.hass.async_add_job(self.async_update_ha_state(True))
+            self.hass.async_add_job(self.async_check_state)

        self.hass.bus.async_listen_once(
            EVENT_HOMEASSISTANT_START, template_bsensor_startup)
@@ -122,11 +129,11 @@ class BinarySensorTemplate(BinarySensorDevice):
        """No polling needed."""
        return False

-    @asyncio.coroutine
-    def async_update(self):
-        """Update the state from the template."""
+    @callback
+    def _async_render(self):
+        """Get the state of template."""
        try:
-            self._state = self._template.async_render().lower() == 'true'
+            return self._template.async_render().lower() == 'true'
        except TemplateError as ex:
            if ex.args and ex.args[0].startswith(
                    "UndefinedError: 'None' has no attribute"):
@@ -135,4 +142,29 @@ class BinarySensorTemplate(BinarySensorDevice):
                                "the state is unknown", self._name)
                return
            _LOGGER.error("Could not render template %s: %s", self._name, ex)
-            self._state = False
+
+    @callback
+    def async_check_state(self):
+        """Update the state from the template."""
+        state = self._async_render()
+
+        # return if the state don't change or is invalid
+        if state is None or state == self.state:
+            return
+
+        @callback
+        def set_state():
+            """Set state of template binary sensor."""
+            self._state = state
+            self.async_schedule_update_ha_state()
+
+        # state without delay
+        if (state and not self._delay_on) or \
+                (not state and not self._delay_off):
+            set_state()
+            return
+
+        period = self._delay_on if state else self._delay_off
+        async_track_same_state(
+            self.hass, period, set_state, entity_ids=self._entities,
+            async_check_same_func=lambda *args: self._async_render() == state)
--- a/homeassistant/components/binary_sensor/tesla.py
+++ b/homeassistant/components/binary_sensor/tesla.py
@@ -0,0 +1,56 @@
+"""
+Support for Tesla binary sensor.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/binary_sensor.tesla/
+"""
+import logging
+
+from homeassistant.components.binary_sensor import (
+    BinarySensorDevice, ENTITY_ID_FORMAT)
+from homeassistant.components.tesla import DOMAIN as TESLA_DOMAIN, TeslaDevice
+
+_LOGGER = logging.getLogger(__name__)
+
+DEPENDENCIES = ['tesla']
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Set up the Tesla binary sensor."""
+    devices = [
+        TeslaBinarySensor(
+            device, hass.data[TESLA_DOMAIN]['controller'], 'connectivity')
+        for device in hass.data[TESLA_DOMAIN]['devices']['binary_sensor']]
+    add_devices(devices, True)
+
+
+class TeslaBinarySensor(TeslaDevice, BinarySensorDevice):
+    """Implement an Tesla binary sensor for parking and charger."""
+
+    def __init__(self, tesla_device, controller, sensor_type):
+        """Initialisation of binary sensor."""
+        super().__init__(tesla_device, controller)
+        self._state = False
+        self.entity_id = ENTITY_ID_FORMAT.format(self.tesla_id)
+        self._sensor_type = sensor_type
+
+    @property
+    def device_class(self):
+        """Return the class of this binary sensor."""
+        return self._sensor_type
+
+    @property
+    def name(self):
+        """Return the name of the binary sensor."""
+        return self._name
+
+    @property
+    def is_on(self):
+        """Return the state of the binary sensor."""
+        return self._state
+
+    def update(self):
+        """Update the state of the device."""
+        _LOGGER.debug("Updating sensor: %s", self._name)
+        self.tesla_device.update()
+        self._state = self.tesla_device.get_value()
--- a/homeassistant/components/binary_sensor/threshold.py
+++ b/homeassistant/components/binary_sensor/threshold.py
@@ -20,15 +20,18 @@ from homeassistant.helpers.event import async_track_state_change

 _LOGGER = logging.getLogger(__name__)

+ATTR_HYSTERESIS = 'hysteresis'
 ATTR_SENSOR_VALUE = 'sensor_value'
 ATTR_THRESHOLD = 'threshold'
 ATTR_TYPE = 'type'

+CONF_HYSTERESIS = 'hysteresis'
 CONF_LOWER = 'lower'
 CONF_THRESHOLD = 'threshold'
 CONF_UPPER = 'upper'

 DEFAULT_NAME = 'Threshold'
+DEFAULT_HYSTERESIS = 0.0

 SENSOR_TYPES = [CONF_LOWER, CONF_UPPER]

@@ -36,6 +39,8 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
    vol.Required(CONF_ENTITY_ID): cv.entity_id,
    vol.Required(CONF_THRESHOLD): vol.Coerce(float),
    vol.Required(CONF_TYPE): vol.In(SENSOR_TYPES),
+    vol.Optional(
+        CONF_HYSTERESIS, default=DEFAULT_HYSTERESIS): vol.Coerce(float),
    vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
    vol.Optional(CONF_DEVICE_CLASS): DEVICE_CLASSES_SCHEMA,
 })
@@ -47,28 +52,32 @@ def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
    entity_id = config.get(CONF_ENTITY_ID)
    name = config.get(CONF_NAME)
    threshold = config.get(CONF_THRESHOLD)
+    hysteresis = config.get(CONF_HYSTERESIS)
    limit_type = config.get(CONF_TYPE)
    device_class = config.get(CONF_DEVICE_CLASS)

-    async_add_devices(
-        [ThresholdSensor(hass, entity_id, name, threshold, limit_type,
-                         device_class)], True)
+    async_add_devices([ThresholdSensor(
+        hass, entity_id, name, threshold,
+        hysteresis, limit_type, device_class)
+                      ], True)
+
    return True


 class ThresholdSensor(BinarySensorDevice):
    """Representation of a Threshold sensor."""

-    def __init__(self, hass, entity_id, name, threshold, limit_type,
-                 device_class):
+    def __init__(self, hass, entity_id, name, threshold,
+                 hysteresis, limit_type, device_class):
        """Initialize the Threshold sensor."""
        self._hass = hass
        self._entity_id = entity_id
        self.is_upper = limit_type == 'upper'
        self._name = name
        self._threshold = threshold
+        self._hysteresis = hysteresis
        self._device_class = device_class
-        self._deviation = False
+        self._state = False
        self.sensor_value = 0

        @callback
@@ -97,7 +106,7 @@ class ThresholdSensor(BinarySensorDevice):
    @property
    def is_on(self):
        """Return true if sensor is on."""
-        return self._deviation
+        return self._state

    @property
    def should_poll(self):
@@ -116,13 +125,16 @@ class ThresholdSensor(BinarySensorDevice):
            ATTR_ENTITY_ID: self._entity_id,
            ATTR_SENSOR_VALUE: self.sensor_value,
            ATTR_THRESHOLD: self._threshold,
+            ATTR_HYSTERESIS: self._hysteresis,
            ATTR_TYPE: CONF_UPPER if self.is_upper else CONF_LOWER,
        }

    @asyncio.coroutine
    def async_update(self):
        """Get the latest data and updates the states."""
-        if self.is_upper:
-            self._deviation = bool(self.sensor_value > self._threshold)
-        else:
-            self._deviation = bool(self.sensor_value < self._threshold)
+        if self._hysteresis == 0 and self.sensor_value == self._threshold:
+            self._state = False
+        elif self.sensor_value > (self._threshold + self._hysteresis):
+            self._state = self.is_upper
+        elif self.sensor_value < (self._threshold - self._hysteresis):
+            self._state = not self.is_upper
--- a/homeassistant/components/binary_sensor/wink.py
+++ b/homeassistant/components/binary_sensor/wink.py
@@ -9,7 +9,6 @@ import logging

 from homeassistant.components.binary_sensor import BinarySensorDevice
 from homeassistant.components.wink import WinkDevice, DOMAIN
-from homeassistant.helpers.entity import Entity

 _LOGGER = logging.getLogger(__name__)

@@ -87,7 +86,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
                _LOGGER.info("Device isn't a sensor, skipping")


-class WinkBinarySensorDevice(WinkDevice, BinarySensorDevice, Entity):
+class WinkBinarySensorDevice(WinkDevice, BinarySensorDevice):
    """Representation of a Wink binary sensor."""

    def __init__(self, wink, hass):
@@ -117,6 +116,11 @@ class WinkBinarySensorDevice(WinkDevice, BinarySensorDevice, Entity):
        """Return the class of this sensor, from DEVICE_CLASSES."""
        return SENSOR_TYPES.get(self.capability)

+    @property
+    def device_state_attributes(self):
+        """Return the state attributes."""
+        return super().device_state_attributes
+

 class WinkSmokeDetector(WinkBinarySensorDevice):
    """Representation of a Wink Smoke detector."""
@@ -124,9 +128,9 @@ class WinkSmokeDetector(WinkBinarySensorDevice):
    @property
    def device_state_attributes(self):
        """Return the state attributes."""
-        return {
-            'test_activated': self.wink.test_activated()
-        }
+        _attributes = super().device_state_attributes
+        _attributes['test_activated'] = self.wink.test_activated()
+        return _attributes


 class WinkHub(WinkBinarySensorDevice):
@@ -135,10 +139,11 @@ class WinkHub(WinkBinarySensorDevice):
    @property
    def device_state_attributes(self):
        """Return the state attributes."""
-        return {
-            'update needed': self.wink.update_needed(),
-            'firmware version': self.wink.firmware_version()
-        }
+        _attributes = super().device_state_attributes
+        _attributes['update_needed'] = self.wink.update_needed()
+        _attributes['firmware_version'] = self.wink.firmware_version()
+        _attributes['pairing_mode'] = self.wink.pairing_mode()
+        return _attributes


 class WinkRemote(WinkBinarySensorDevice):
@@ -147,12 +152,12 @@ class WinkRemote(WinkBinarySensorDevice):
    @property
    def device_state_attributes(self):
        """Return the state attributes."""
-        return {
-            'button_on_pressed': self.wink.button_on_pressed(),
-            'button_off_pressed': self.wink.button_off_pressed(),
-            'button_up_pressed': self.wink.button_up_pressed(),
-            'button_down_pressed': self.wink.button_down_pressed()
-        }
+        _attributes = super().device_state_attributes
+        _attributes['button_on_pressed'] = self.wink.button_on_pressed()
+        _attributes['button_off_pressed'] = self.wink.button_off_pressed()
+        _attributes['button_up_pressed'] = self.wink.button_up_pressed()
+        _attributes['button_down_pressed'] = self.wink.button_down_pressed()
+        return _attributes

    @property
    def device_class(self):
@@ -166,10 +171,10 @@ class WinkButton(WinkBinarySensorDevice):
    @property
    def device_state_attributes(self):
        """Return the state attributes."""
-        return {
-            'pressed': self.wink.pressed(),
-            'long_pressed': self.wink.long_pressed()
-        }
+        _attributes = super().device_state_attributes
+        _attributes['pressed'] = self.wink.pressed()
+        _attributes['long_pressed'] = self.wink.long_pressed()
+        return _attributes


 class WinkGang(WinkBinarySensorDevice):
--- a/homeassistant/components/binary_sensor/workday.py
+++ b/homeassistant/components/binary_sensor/workday.py
@@ -6,13 +6,12 @@ https://home-assistant.io/components/binary_sensor.workday/
 """
 import asyncio
 import logging
-import datetime
+from datetime import datetime, timedelta

 import voluptuous as vol

 from homeassistant.components.sensor import PLATFORM_SCHEMA
 from homeassistant.const import CONF_NAME, WEEKDAYS
-import homeassistant.util.dt as dt_util
 from homeassistant.components.binary_sensor import BinarySensorDevice
 import homeassistant.helpers.config_validation as cv

@@ -39,11 +38,14 @@ CONF_EXCLUDES = 'excludes'
 DEFAULT_EXCLUDES = ['sat', 'sun', 'holiday']
 DEFAULT_NAME = 'Workday Sensor'
 ALLOWED_DAYS = WEEKDAYS + ['holiday']
+CONF_OFFSET = 'days_offset'
+DEFAULT_OFFSET = 0

 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
    vol.Required(CONF_COUNTRY): vol.In(ALL_COUNTRIES),
    vol.Optional(CONF_PROVINCE, default=None): cv.string,
    vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
+    vol.Optional(CONF_OFFSET, default=DEFAULT_OFFSET): vol.Coerce(int),
    vol.Optional(CONF_WORKDAYS, default=DEFAULT_WORKDAYS):
        vol.All(cv.ensure_list, [vol.In(ALLOWED_DAYS)]),
    vol.Optional(CONF_EXCLUDES, default=DEFAULT_EXCLUDES):
@@ -60,8 +62,9 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
    province = config.get(CONF_PROVINCE)
    workdays = config.get(CONF_WORKDAYS)
    excludes = config.get(CONF_EXCLUDES)
+    days_offset = config.get(CONF_OFFSET)

-    year = datetime.datetime.now().year
+    year = (datetime.now() + timedelta(days=days_offset)).year
    obj_holidays = getattr(holidays, country)(years=year)

    if province:
@@ -85,7 +88,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
        _LOGGER.debug("%s %s", date, name)

    add_devices([IsWorkdaySensor(
-        obj_holidays, workdays, excludes, sensor_name)], True)
+        obj_holidays, workdays, excludes, days_offset, sensor_name)], True)


 def day_to_string(day):
@@ -99,12 +102,13 @@ def day_to_string(day):
 class IsWorkdaySensor(BinarySensorDevice):
    """Implementation of a Workday sensor."""

-    def __init__(self, obj_holidays, workdays, excludes, name):
+    def __init__(self, obj_holidays, workdays, excludes, days_offset, name):
        """Initialize the Workday sensor."""
        self._name = name
        self._obj_holidays = obj_holidays
        self._workdays = workdays
        self._excludes = excludes
+        self._days_offset = days_offset
        self._state = None

    @property
@@ -135,6 +139,16 @@ class IsWorkdaySensor(BinarySensorDevice):

        return False

+    @property
+    def state_attributes(self):
+        """Return the attributes of the entity."""
+        # return self._attributes
+        return {
+            CONF_WORKDAYS: self._workdays,
+            CONF_EXCLUDES: self._excludes,
+            CONF_OFFSET: self._days_offset
+        }
+
    @asyncio.coroutine
    def async_update(self):
        """Get date and look whether it is a holiday."""
@@ -142,11 +156,12 @@ class IsWorkdaySensor(BinarySensorDevice):
        self._state = False

        # Get iso day of the week (1 = Monday, 7 = Sunday)
-        day = datetime.datetime.today().isoweekday() - 1
+        date = datetime.today() + timedelta(days=self._days_offset)
+        day = date.isoweekday() - 1
        day_of_week = day_to_string(day)

-        if self.is_include(day_of_week, dt_util.now()):
+        if self.is_include(day_of_week, date):
            self._state = True

-        if self.is_exclude(day_of_week, dt_util.now()):
+        if self.is_exclude(day_of_week, date):
            self._state = False
--- a/homeassistant/components/binary_sensor/xiaomi_aqara.py
+++ b/homeassistant/components/binary_sensor/xiaomi_aqara.py
@@ -1,8 +1,9 @@
-"""Support for Xiaomi binary sensors."""
+"""Support for Xiaomi aqara binary sensors."""
 import logging

 from homeassistant.components.binary_sensor import BinarySensorDevice
-from homeassistant.components.xiaomi import (PY_XIAOMI_GATEWAY, XiaomiDevice)
+from homeassistant.components.xiaomi_aqara import (PY_XIAOMI_GATEWAY,
+                                                   XiaomiDevice)

 _LOGGER = logging.getLogger(__name__)

@@ -11,6 +12,7 @@ ATTR_OPEN_SINCE = 'Open since'

 MOTION = 'motion'
 NO_MOTION = 'no_motion'
+ATTR_LAST_ACTION = 'last_action'
 ATTR_NO_MOTION_SINCE = 'No motion since'

 DENSITY = 'density'
@@ -31,6 +33,8 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
                devices.append(XiaomiDoorSensor(device, gateway))
            elif model == 'sensor_magnet.aq2':
                devices.append(XiaomiDoorSensor(device, gateway))
+            elif model == 'sensor_wleak.aq1':
+                devices.append(XiaomiWaterLeakSensor(device, gateway))
            elif model == 'smoke':
                devices.append(XiaomiSmokeSensor(device, gateway))
            elif model == 'natgas':
@@ -214,6 +218,35 @@ class XiaomiDoorSensor(XiaomiBinarySensor):
            return False


+class XiaomiWaterLeakSensor(XiaomiBinarySensor):
+    """Representation of a XiaomiWaterLeakSensor."""
+
+    def __init__(self, device, xiaomi_hub):
+        """Initialize the XiaomiWaterLeakSensor."""
+        XiaomiBinarySensor.__init__(self, device, 'Water Leak Sensor',
+                                    xiaomi_hub, 'status', 'moisture')
+
+    def parse_data(self, data):
+        """Parse data sent by gateway."""
+        self._should_poll = False
+
+        value = data.get(self._data_key)
+        if value is None:
+            return False
+
+        if value == 'leak':
+            self._should_poll = True
+            if self._state:
+                return False
+            self._state = True
+            return True
+        elif value == 'no_leak':
+            if self._state:
+                self._state = False
+                return True
+            return False
+
+
 class XiaomiSmokeSensor(XiaomiBinarySensor):
    """Representation of a XiaomiSmokeSensor."""

@@ -295,10 +328,18 @@ class XiaomiCube(XiaomiBinarySensor):
    def __init__(self, device, hass, xiaomi_hub):
        """Initialize the Xiaomi Cube."""
        self._hass = hass
+        self._last_action = None
        self._state = False
        XiaomiBinarySensor.__init__(self, device, 'Cube', xiaomi_hub,
                                    None, None)

+    @property
+    def device_state_attributes(self):
+        """Return the state attributes."""
+        attrs = {ATTR_LAST_ACTION: self._last_action}
+        attrs.update(super().device_state_attributes)
+        return attrs
+
    def parse_data(self, data):
        """Parse data sent by gateway."""
        if 'status' in data:
@@ -306,6 +347,7 @@ class XiaomiCube(XiaomiBinarySensor):
                'entity_id': self.entity_id,
                'action_type': data['status']
            })
+            self._last_action = data['status']

        if 'rotate' in data:
            self._hass.bus.fire('cube_action', {
@@ -313,4 +355,6 @@ class XiaomiCube(XiaomiBinarySensor):
                'action_type': 'rotate',
                'action_value': float(data['rotate'].replace(",", "."))
            })
-        return False
+            self._last_action = 'rotate'
+
+        return True
--- a/homeassistant/components/calendar/init.py
+++ b/homeassistant/components/calendar/init.py
@@ -12,6 +12,7 @@ import re
 from homeassistant.components.google import (
    CONF_OFFSET, CONF_DEVICE_ID, CONF_NAME)
 from homeassistant.const import STATE_OFF, STATE_ON
+from homeassistant.helpers.config_validation import PLATFORM_SCHEMA  # noqa
 from homeassistant.helpers.config_validation import time_period_str
 from homeassistant.helpers.entity import Entity, generate_entity_id
 from homeassistant.helpers.entity_component import EntityComponent
--- a/homeassistant/components/calendar/services.yaml
+++ b/homeassistant/components/calendar/services.yaml
@@ -0,0 +1,19 @@
+todoist:
+  new_task:
+    description: Create a new task and add it to a project.
+    fields:
+      content: 
+        description: The name of the task. [Required]
+        example: Pick up the mail
+      project:
+        description: The name of the project this task should belong to. Defaults to Inbox. [Optional]
+        example: Errands
+      labels:
+        description: Any labels that you want to apply to this task, separated by a comma. [Optional]
+        example: Chores,Deliveries
+      priority:
+        description: The priority of this task, from 1 (normal) to 4 (urgent). [Optional]
+        example: 2
+      due_date:
+        description: The day this task is due, in format YYYY-MM-DD. [Optional]
+        example: "2018-04-01"
--- a/homeassistant/components/calendar/todoist.py
+++ b/homeassistant/components/calendar/todoist.py
@@ -0,0 +1,544 @@
+"""
+Support for Todoist task management (https://todoist.com).
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/calendar.todoist/
+"""
+
+
+from datetime import datetime
+from datetime import timedelta
+import logging
+import os
+
+import voluptuous as vol
+
+from homeassistant.components.calendar import (
+    CalendarEventDevice, PLATFORM_SCHEMA)
+from homeassistant.components.google import (
+    CONF_DEVICE_ID)
+from homeassistant.config import load_yaml_config_file
+from homeassistant.const import (
+    CONF_ID, CONF_NAME, CONF_TOKEN)
+import homeassistant.helpers.config_validation as cv
+from homeassistant.helpers.template import DATE_STR_FORMAT
+from homeassistant.util import dt
+from homeassistant.util import Throttle
+
+REQUIREMENTS = ['todoist-python==7.0.17']
+
+_LOGGER = logging.getLogger(__name__)
+DOMAIN = 'todoist'
+
+# Calendar Platform: Does this calendar event last all day?
+ALL_DAY = 'all_day'
+# Attribute: All tasks in this project
+ALL_TASKS = 'all_tasks'
+# Todoist API: "Completed" flag -- 1 if complete, else 0
+CHECKED = 'checked'
+# Attribute: Is this task complete?
+COMPLETED = 'completed'
+# Todoist API: What is this task about?
+# Service Call: What is this task about?
+CONTENT = 'content'
+# Calendar Platform: Get a calendar event's description
+DESCRIPTION = 'description'
+# Calendar Platform: Used in the '_get_date()' method
+DATETIME = 'dateTime'
+# Attribute: When is this task due?
+# Service Call: When is this task due?
+DUE_DATE = 'due_date'
+# Todoist API: Look up a task's due date
+DUE_DATE_UTC = 'due_date_utc'
+# Attribute: Is this task due today?
+DUE_TODAY = 'due_today'
+# Calendar Platform: When a calendar event ends
+END = 'end'
+# Todoist API: Look up a Project/Label/Task ID
+ID = 'id'
+# Todoist API: Fetch all labels
+# Service Call: What are the labels attached to this task?
+LABELS = 'labels'
+# Todoist API: "Name" value
+NAME = 'name'
+# Attribute: Is this task overdue?
+OVERDUE = 'overdue'
+# Attribute: What is this task's priority?
+# Todoist API: Get a task's priority
+# Service Call: What is this task's priority?
+PRIORITY = 'priority'
+# Todoist API: Look up the Project ID a Task belongs to
+PROJECT_ID = 'project_id'
+# Service Call: What Project do you want a Task added to?
+PROJECT_NAME = 'project'
+# Todoist API: Fetch all Projects
+PROJECTS = 'projects'
+# Calendar Platform: When does a calendar event start?
+START = 'start'
+# Calendar Platform: What is the next calendar event about?
+SUMMARY = 'summary'
+# Todoist API: Fetch all Tasks
+TASKS = 'items'
+
+SERVICE_NEW_TASK = 'new_task'
+NEW_TASK_SERVICE_SCHEMA = vol.Schema({
+    vol.Required(CONTENT): cv.string,
+    vol.Optional(PROJECT_NAME, default='inbox'): vol.All(cv.string, vol.Lower),
+    vol.Optional(LABELS): cv.ensure_list_csv,
+    vol.Optional(PRIORITY): vol.All(vol.Coerce(int),
+                                    vol.Range(min=1, max=4)),
+    vol.Optional(DUE_DATE): cv.string
+})
+
+CONF_EXTRA_PROJECTS = 'custom_projects'
+CONF_PROJECT_DUE_DATE = 'due_date_days'
+CONF_PROJECT_WHITELIST = 'include_projects'
+CONF_PROJECT_LABEL_WHITELIST = 'labels'
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Required(CONF_TOKEN): cv.string,
+    vol.Optional(CONF_EXTRA_PROJECTS, default=[]):
+        vol.All(cv.ensure_list, vol.Schema([
+            vol.Schema({
+                vol.Required(CONF_NAME): cv.string,
+                vol.Optional(CONF_PROJECT_DUE_DATE): vol.Coerce(int),
+                vol.Optional(CONF_PROJECT_WHITELIST, default=[]):
+                    vol.All(cv.ensure_list, [vol.All(cv.string, vol.Lower)]),
+                vol.Optional(CONF_PROJECT_LABEL_WHITELIST, default=[]):
+                    vol.All(cv.ensure_list, [vol.All(cv.string, vol.Lower)])
+            })
+        ]))
+})
+
+MIN_TIME_BETWEEN_UPDATES = timedelta(minutes=15)
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Setup the Todoist platform."""
+    # Check token:
+    token = config.get(CONF_TOKEN)
+
+    # Look up IDs based on (lowercase) names.
+    project_id_lookup = {}
+    label_id_lookup = {}
+
+    from todoist.api import TodoistAPI
+    api = TodoistAPI(token)
+    api.sync()
+
+    # Setup devices:
+    # Grab all projects.
+    projects = api.state[PROJECTS]
+
+    # Grab all labels
+    labels = api.state[LABELS]
+
+    # Add all Todoist-defined projects.
+    project_devices = []
+    for project in projects:
+        # Project is an object, not a dict!
+        # Because of that, we convert what we need to a dict.
+        project_data = {
+            CONF_NAME: project[NAME],
+            CONF_ID: project[ID]
+        }
+        project_devices.append(
+            TodoistProjectDevice(hass, project_data, labels, api)
+        )
+        # Cache the names so we can easily look up name->ID.
+        project_id_lookup[project[NAME].lower()] = project[ID]
+
+    # Cache all label names
+    for label in labels:
+        label_id_lookup[label[NAME].lower()] = label[ID]
+
+    # Check config for more projects.
+    extra_projects = config.get(CONF_EXTRA_PROJECTS)
+    for project in extra_projects:
+        # Special filter: By date
+        project_due_date = project.get(CONF_PROJECT_DUE_DATE)
+
+        # Special filter: By label
+        project_label_filter = project.get(CONF_PROJECT_LABEL_WHITELIST)
+
+        # Special filter: By name
+        # Names must be converted into IDs.
+        project_name_filter = project.get(CONF_PROJECT_WHITELIST)
+        project_id_filter = [
+            project_id_lookup[project_name.lower()]
+            for project_name in project_name_filter]
+
+        # Create the custom project and add it to the devices array.
+        project_devices.append(
+            TodoistProjectDevice(
+                hass, project, labels, api, project_due_date,
+                project_label_filter, project_id_filter
+            )
+        )
+
+    add_devices(project_devices)
+
+    # Services:
+    descriptions = load_yaml_config_file(
+        os.path.join(os.path.dirname(__file__), 'services.yaml'))
+
+    def handle_new_task(call):
+        """Called when a user creates a new Todoist Task from HASS."""
+        project_name = call.data[PROJECT_NAME]
+        project_id = project_id_lookup[project_name]
+
+        # Create the task
+        item = api.items.add(call.data[CONTENT], project_id)
+
+        if LABELS in call.data:
+            task_labels = call.data[LABELS]
+            label_ids = [
+                label_id_lookup[label.lower()]
+                for label in task_labels]
+            item.update(labels=label_ids)
+
+        if PRIORITY in call.data:
+            item.update(priority=call.data[PRIORITY])
+
+        if DUE_DATE in call.data:
+            due_date = dt.parse_datetime(call.data[DUE_DATE])
+            if due_date is None:
+                due = dt.parse_date(call.data[DUE_DATE])
+                due_date = datetime(due.year, due.month, due.day)
+            # Format it in the manner Todoist expects
+            due_date = dt.as_utc(due_date)
+            date_format = '%Y-%m-%dT%H:%M'
+            due_date = datetime.strftime(due_date, date_format)
+            item.update(due_date_utc=due_date)
+        # Commit changes
+        api.commit()
+        _LOGGER.debug("Created Todoist task: %s", call.data[CONTENT])
+
+    hass.services.register(DOMAIN, SERVICE_NEW_TASK, handle_new_task,
+                           descriptions[DOMAIN][SERVICE_NEW_TASK],
+                           schema=NEW_TASK_SERVICE_SCHEMA)
+
+
+class TodoistProjectDevice(CalendarEventDevice):
+    """A device for getting the next Task from a Todoist Project."""
+
+    def __init__(self, hass, data, labels, token,
+                 latest_task_due_date=None, whitelisted_labels=None,
+                 whitelisted_projects=None):
+        """Create the Todoist Calendar Event Device."""
+        self.data = TodoistProjectData(
+            data, labels, token, latest_task_due_date,
+            whitelisted_labels, whitelisted_projects
+        )
+
+        # Set up the calendar side of things
+        calendar_format = {
+            CONF_NAME: data[CONF_NAME],
+            # Set Entity ID to use the name so we can identify calendars
+            CONF_DEVICE_ID: data[CONF_NAME]
+        }
+
+        super().__init__(hass, calendar_format)
+
+    def update(self):
+        """Update all Todoist Calendars."""
+        # Set basic calendar data
+        super().update()
+
+        # Set Todoist-specific data that can't easily be grabbed
+        self._cal_data[ALL_TASKS] = [
+            task[SUMMARY] for task in self.data.all_project_tasks]
+
+    def cleanup(self):
+        """Clean up all calendar data."""
+        super().cleanup()
+        self._cal_data[ALL_TASKS] = []
+
+    @property
+    def device_state_attributes(self):
+        """Return the device state attributes."""
+        if self.data.event is None:
+            # No tasks, we don't REALLY need to show anything.
+            return {}
+
+        attributes = super().device_state_attributes
+
+        # Add additional attributes.
+        attributes[DUE_TODAY] = self.data.event[DUE_TODAY]
+        attributes[OVERDUE] = self.data.event[OVERDUE]
+        attributes[ALL_TASKS] = self._cal_data[ALL_TASKS]
+        attributes[PRIORITY] = self.data.event[PRIORITY]
+        attributes[LABELS] = self.data.event[LABELS]
+
+        return attributes
+
+
+class TodoistProjectData(object):
+    """
+    Class used by the Task Device service object to hold all Todoist Tasks.
+
+    This is analogous to the GoogleCalendarData found in the Google Calendar
+    component.
+
+    Takes an object with a 'name' field and optionally an 'id' field (either
+    user-defined or from the Todoist API), a Todoist API token, and an optional
+    integer specifying the latest number of days from now a task can be due (7
+    means everything due in the next week, 0 means today, etc.).
+
+    This object has an exposed 'event' property (used by the Calendar platform
+    to determine the next calendar event) and an exposed 'update' method (used
+    by the Calendar platform to poll for new calendar events).
+
+    The 'event' is a representation of a Todoist Task, with defined parameters
+    of 'due_today' (is the task due today?), 'all_day' (does the task have a
+    due date?), 'task_labels' (all labels assigned to the task), 'message'
+    (the content of the task, e.g. 'Fetch Mail'), 'description' (a URL pointing
+    to the task on the Todoist website), 'end_time' (what time the event is
+    due), 'start_time' (what time this event was last updated), 'overdue' (is
+    the task past its due date?), 'priority' (1-4, how important the task is,
+    with 4 being the most important), and 'all_tasks' (all tasks in this
+    project, sorted by how important they are).
+
+    'offset_reached', 'location', and 'friendly_name' are defined by the
+    platform itself, but are not used by this component at all.
+
+    The 'update' method polls the Todoist API for new projects/tasks, as well
+    as any updates to current projects/tasks. This is throttled to every
+    MIN_TIME_BETWEEN_UPDATES minutes.
+    """
+
+    def __init__(self, project_data, labels, api,
+                 latest_task_due_date=None, whitelisted_labels=None,
+                 whitelisted_projects=None):
+        """Initialize a Todoist Project."""
+        self.event = None
+
+        self._api = api
+        self._name = project_data.get(CONF_NAME)
+        # If no ID is defined, fetch all tasks.
+        self._id = project_data.get(CONF_ID)
+
+        # All labels the user has defined, for easy lookup.
+        self._labels = labels
+        # Not tracked: order, indent, comment_count.
+
+        self.all_project_tasks = []
+
+        # The latest date a task can be due (for making lists of everything
+        # due today, or everything due in the next week, for example).
+        if latest_task_due_date is not None:
+            self._latest_due_date = dt.utcnow() + timedelta(
+                days=latest_task_due_date)
+        else:
+            self._latest_due_date = None
+
+        # Only tasks with one of these labels will be included.
+        if whitelisted_labels is not None:
+            self._label_whitelist = whitelisted_labels
+        else:
+            self._label_whitelist = []
+
+        # This project includes only projects with these names.
+        if whitelisted_projects is not None:
+            self._project_id_whitelist = whitelisted_projects
+        else:
+            self._project_id_whitelist = []
+
+    def create_todoist_task(self, data):
+        """
+        Create a dictionary based on a Task passed from the Todoist API.
+
+        Will return 'None' if the task is to be filtered out.
+        """
+        task = {}
+        # Fields are required to be in all returned task objects.
+        task[SUMMARY] = data[CONTENT]
+        task[COMPLETED] = data[CHECKED] == 1
+        task[PRIORITY] = data[PRIORITY]
+        task[DESCRIPTION] = 'https://todoist.com/showTask?id={}'.format(
+            data[ID])
+
+        # All task Labels (optional parameter).
+        task[LABELS] = [
+            label[NAME].lower() for label in self._labels
+            if label[ID] in data[LABELS]]
+
+        if self._label_whitelist and (
+                not any(label in task[LABELS]
+                        for label in self._label_whitelist)):
+            # We're not on the whitelist, return invalid task.
+            return None
+
+        # Due dates (optional parameter).
+        # The due date is the END date -- the task cannot be completed
+        # past this time.
+        # That means that the START date is the earliest time one can
+        # complete the task.
+        # Generally speaking, that means right now.
+        task[START] = dt.utcnow()
+        if data[DUE_DATE_UTC] is not None:
+            due_date = data[DUE_DATE_UTC]
+
+            # Due dates are represented in RFC3339 format, in UTC.
+            # Home Assistant exclusively uses UTC, so it'll
+            # handle the conversion.
+            time_format = '%a %d %b %Y %H:%M:%S %z'
+            # HASS' built-in parse time function doesn't like
+            # Todoist's time format; strptime has to be used.
+            task[END] = datetime.strptime(due_date, time_format)
+
+            if self._latest_due_date is not None and (
+                    task[END] > self._latest_due_date):
+                # This task is out of range of our due date;
+                # it shouldn't be counted.
+                return None
+
+            task[DUE_TODAY] = task[END].date() == datetime.today().date()
+
+            # Special case: Task is overdue.
+            if task[END] <= task[START]:
+                task[OVERDUE] = True
+                # Set end time to the current time plus 1 hour.
+                # We're pretty much guaranteed to update within that 1 hour,
+                # so it should be fine.
+                task[END] = task[START] + timedelta(hours=1)
+            else:
+                task[OVERDUE] = False
+        else:
+            # If we ask for everything due before a certain date, don't count
+            # things which have no due dates.
+            if self._latest_due_date is not None:
+                return None
+
+            # Define values for tasks without due dates
+            task[END] = None
+            task[ALL_DAY] = True
+            task[DUE_TODAY] = False
+            task[OVERDUE] = False
+
+        # Not tracked: id, comments, project_id order, indent, recurring.
+        return task
+
+    @staticmethod
+    def select_best_task(project_tasks):
+        """
+        Search through a list of events for the "best" event to select.
+
+        The "best" event is determined by the following criteria:
+          * A proposed event must not be completed
+          * A proposed event must have a end date (otherwise we go with
+            the event at index 0, selected above)
+          * A proposed event must be on the same day or earlier as our
+            current event
+          * If a proposed event is an earlier day than what we have so
+            far, select it
+          * If a proposed event is on the same day as our current event
+            and the proposed event has a higher priority than our current
+            event, select it
+          * If a proposed event is on the same day as our current event,
+            has the same priority as our current event, but is due earlier
+            in the day, select it
+        """
+        # Start at the end of the list, so if tasks don't have a due date
+        # the newest ones are the most important.
+
+        event = project_tasks[-1]
+
+        for proposed_event in project_tasks:
+            if event == proposed_event:
+                continue
+            if proposed_event[COMPLETED]:
+                # Event is complete!
+                continue
+            if proposed_event[END] is None:
+                # No end time:
+                if event[END] is None and (
+                        proposed_event[PRIORITY] < event[PRIORITY]):
+                    # They also have no end time,
+                    # but we have a higher priority.
+                    event = proposed_event
+                    continue
+                else:
+                    continue
+            elif event[END] is None:
+                # We have an end time, they do not.
+                event = proposed_event
+                continue
+            if proposed_event[END].date() > event[END].date():
+                # Event is too late.
+                continue
+            elif proposed_event[END].date() < event[END].date():
+                # Event is earlier than current, select it.
+                event = proposed_event
+                continue
+            else:
+                if proposed_event[PRIORITY] > event[PRIORITY]:
+                    # Proposed event has a higher priority.
+                    event = proposed_event
+                    continue
+                elif proposed_event[PRIORITY] == event[PRIORITY] and (
+                        proposed_event[END] < event[END]):
+                    event = proposed_event
+                    continue
+        return event
+
+    @Throttle(MIN_TIME_BETWEEN_UPDATES)
+    def update(self):
+        """Get the latest data."""
+        if self._id is None:
+            project_task_data = [
+                task for task in self._api.state[TASKS]
+                if not self._project_id_whitelist or
+                task[PROJECT_ID] in self._project_id_whitelist]
+        else:
+            project_task_data = self._api.projects.get_data(self._id)[TASKS]
+
+        # If we have no data, we can just return right away.
+        if not project_task_data:
+            self.event = None
+            return True
+
+        # Keep an updated list of all tasks in this project.
+        project_tasks = []
+
+        for task in project_task_data:
+            todoist_task = self.create_todoist_task(task)
+            if todoist_task is not None:
+                # A None task means it is invalid for this project
+                project_tasks.append(todoist_task)
+
+        if not project_tasks:
+            # We had no valid tasks
+            return True
+
+        # Organize the best tasks (so users can see all the tasks
+        # they have, organized)
+        while len(project_tasks) > 0:
+            best_task = self.select_best_task(project_tasks)
+            _LOGGER.debug("Found Todoist Task: %s", best_task[SUMMARY])
+            project_tasks.remove(best_task)
+            self.all_project_tasks.append(best_task)
+
+        self.event = self.all_project_tasks[0]
+
+        # Convert datetime to a string again
+        if self.event is not None:
+            if self.event[START] is not None:
+                self.event[START] = {
+                    DATETIME: self.event[START].strftime(DATE_STR_FORMAT)
+                }
+            if self.event[END] is not None:
+                self.event[END] = {
+                    DATETIME: self.event[END].strftime(DATE_STR_FORMAT)
+                }
+            else:
+                # HASS gets cranky if a calendar event never ends
+                # Let's set our "due date" to tomorrow
+                self.event[END] = {
+                    DATETIME: (
+                        datetime.utcnow() +
+                        timedelta(days=1)
+                    ).strftime(DATE_STR_FORMAT)
+                }
+        _LOGGER.debug("Updated %s", self._name)
+        return True
--- a/homeassistant/components/camera/init.py
+++ b/homeassistant/components/camera/init.py
@@ -126,23 +126,16 @@ def async_setup(hass, config):
        """Handle calls to the camera services."""
        target_cameras = component.async_extract_from_service(service)

+        update_tasks = []
        for camera in target_cameras:
            if service.service == SERVICE_EN_MOTION:
                yield from camera.async_enable_motion_detection()
            elif service.service == SERVICE_DISEN_MOTION:
                yield from camera.async_disable_motion_detection()

-        update_tasks = []
-        for camera in target_cameras:
            if not camera.should_poll:
                continue
-
-            update_coro = hass.async_add_job(
-                camera.async_update_ha_state(True))
-            if hasattr(camera, 'async_update'):
-                update_tasks.append(update_coro)
-            else:
-                yield from update_coro
+            update_tasks.append(camera.async_update_ha_state(True))

        if update_tasks:
            yield from asyncio.wait(update_tasks, loop=hass.loop)
--- a/homeassistant/components/camera/abode.py
+++ b/homeassistant/components/camera/abode.py
@@ -0,0 +1,101 @@
+"""
+This component provides HA camera support for Abode Security System.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/camera.abode/
+"""
+import asyncio
+import logging
+
+from datetime import timedelta
+import requests
+
+from homeassistant.components.abode import AbodeDevice, DOMAIN as ABODE_DOMAIN
+from homeassistant.components.camera import Camera
+from homeassistant.util import Throttle
+
+
+DEPENDENCIES = ['abode']
+
+MIN_TIME_BETWEEN_UPDATES = timedelta(seconds=90)
+
+_LOGGER = logging.getLogger(__name__)
+
+
+def setup_platform(hass, config, add_devices, discoveryy_info=None):
+    """Set up Abode camera devices."""
+    import abodepy.helpers.constants as CONST
+    import abodepy.helpers.timeline as TIMELINE
+
+    data = hass.data[ABODE_DOMAIN]
+
+    devices = []
+    for device in data.abode.get_devices(generic_type=CONST.TYPE_CAMERA):
+        if data.is_excluded(device):
+            continue
+
+        devices.append(AbodeCamera(data, device, TIMELINE.CAPTURE_IMAGE))
+
+    data.devices.extend(devices)
+
+    add_devices(devices)
+
+
+class AbodeCamera(AbodeDevice, Camera):
+    """Representation of an Abode camera."""
+
+    def __init__(self, data, device, event):
+        """Initialize the Abode device."""
+        AbodeDevice.__init__(self, data, device)
+        Camera.__init__(self)
+        self._event = event
+        self._response = None
+
+    @asyncio.coroutine
+    def async_added_to_hass(self):
+        """Subscribe Abode events."""
+        yield from super().async_added_to_hass()
+
+        self.hass.async_add_job(
+            self._data.abode.events.add_timeline_callback,
+            self._event, self._capture_callback
+        )
+
+    def capture(self):
+        """Request a new image capture."""
+        return self._device.capture()
+
+    @Throttle(MIN_TIME_BETWEEN_UPDATES)
+    def refresh_image(self):
+        """Find a new image on the timeline."""
+        if self._device.refresh_image():
+            self.get_image()
+
+    def get_image(self):
+        """Attempt to download the most recent capture."""
+        if self._device.image_url:
+            try:
+                self._response = requests.get(
+                    self._device.image_url, stream=True)
+
+                self._response.raise_for_status()
+            except requests.HTTPError as err:
+                _LOGGER.warning("Failed to get camera image: %s", err)
+                self._response = None
+        else:
+            self._response = None
+
+    def camera_image(self):
+        """Get a camera image."""
+        self.refresh_image()
+
+        if self._response:
+            return self._response.content
+
+        return None
+
+    def _capture_callback(self, capture):
+        """Update the image with the device then refresh device."""
+        self._device.update_image_location(capture)
+        self.get_image()
+        self.schedule_update_ha_state()
--- a/homeassistant/components/camera/amcrest.py
+++ b/homeassistant/components/camera/amcrest.py
@@ -62,7 +62,7 @@ class AmcrestCam(Camera):
        self._token = self._auth = authentication

    def camera_image(self):
-        """Return a still image reponse from the camera."""
+        """Return a still image response from the camera."""
        # Send the request to snap a picture and return raw jpg data
        response = self._camera.snapshot(channel=self._resolution)
        return response.data
--- a/homeassistant/components/camera/arlo.py
+++ b/homeassistant/components/camera/arlo.py
@@ -1,30 +1,50 @@
 """
-This component provides basic support for Netgear Arlo IP cameras.
+Support for Netgear Arlo IP cameras.

 For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/camera.arlo/
 """
 import asyncio
 import logging
+from datetime import timedelta

 import voluptuous as vol

-from homeassistant.helpers import config_validation as cv
-from homeassistant.helpers.aiohttp_client import async_aiohttp_proxy_stream
+import homeassistant.helpers.config_validation as cv
 from homeassistant.components.arlo import DEFAULT_BRAND, DATA_ARLO
 from homeassistant.components.camera import Camera, PLATFORM_SCHEMA
 from homeassistant.components.ffmpeg import DATA_FFMPEG
-
-DEPENDENCIES = ['arlo', 'ffmpeg']
+from homeassistant.const import ATTR_BATTERY_LEVEL
+from homeassistant.helpers.aiohttp_client import async_aiohttp_proxy_stream

 _LOGGER = logging.getLogger(__name__)

-CONF_FFMPEG_ARGUMENTS = 'ffmpeg_arguments'
+SCAN_INTERVAL = timedelta(minutes=10)
+
 ARLO_MODE_ARMED = 'armed'
 ARLO_MODE_DISARMED = 'disarmed'

+ATTR_BRIGHTNESS = 'brightness'
+ATTR_FLIPPED = 'flipped'
+ATTR_MIRRORED = 'mirrored'
+ATTR_MOTION = 'motion_detection_sensitivity'
+ATTR_POWERSAVE = 'power_save_mode'
+ATTR_SIGNAL_STRENGTH = 'signal_strength'
+ATTR_UNSEEN_VIDEOS = 'unseen_videos'
+
+CONF_FFMPEG_ARGUMENTS = 'ffmpeg_arguments'
+
+DEPENDENCIES = ['arlo', 'ffmpeg']
+
+POWERSAVE_MODE_MAPPING = {
+    1: 'best_battery_life',
+    2: 'optimized',
+    3: 'best_video'
+}
+
 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
-    vol.Optional(CONF_FFMPEG_ARGUMENTS): cv.string,
+    vol.Optional(CONF_FFMPEG_ARGUMENTS):
+    cv.string,
 })


@@ -53,6 +73,7 @@ class ArloCam(Camera):
        self._motion_status = False
        self._ffmpeg = hass.data[DATA_FFMPEG]
        self._ffmpeg_arguments = device_info.get(CONF_FFMPEG_ARGUMENTS)
+        self.attrs = {}

    def camera_image(self):
        """Return a still image response from the camera."""
@@ -80,14 +101,28 @@ class ArloCam(Camera):
        """Return the name of this camera."""
        return self._name

+    @property
+    def device_state_attributes(self):
+        """Return the state attributes."""
+        return {
+            ATTR_BATTERY_LEVEL: self.attrs.get(ATTR_BATTERY_LEVEL),
+            ATTR_BRIGHTNESS: self.attrs.get(ATTR_BRIGHTNESS),
+            ATTR_FLIPPED: self.attrs.get(ATTR_FLIPPED),
+            ATTR_MIRRORED: self.attrs.get(ATTR_MIRRORED),
+            ATTR_MOTION: self.attrs.get(ATTR_MOTION),
+            ATTR_POWERSAVE: self.attrs.get(ATTR_POWERSAVE),
+            ATTR_SIGNAL_STRENGTH: self.attrs.get(ATTR_SIGNAL_STRENGTH),
+            ATTR_UNSEEN_VIDEOS: self.attrs.get(ATTR_UNSEEN_VIDEOS),
+        }
+
    @property
    def model(self):
-        """Camera model."""
+        """Return the camera model."""
        return self._camera.model_id

    @property
    def brand(self):
-        """Camera brand."""
+        """Return the camera brand."""
        return DEFAULT_BRAND

    @property
@@ -97,7 +132,7 @@ class ArloCam(Camera):

    @property
    def motion_detection_enabled(self):
-        """Camera Motion Detection Status."""
+        """Return the camera motion detection status."""
        return self._motion_status

    def set_base_station_mode(self, mode):
@@ -105,7 +140,7 @@ class ArloCam(Camera):
        # Get the list of base stations identified by library
        base_stations = self.hass.data[DATA_ARLO].base_stations

-        # Some Arlo cameras does not have basestation
+        # Some Arlo cameras does not have base station
        # So check if there is base station detected first
        # if yes, then choose the primary base station
        # Set the mode on the chosen base station
@@ -122,3 +157,16 @@ class ArloCam(Camera):
        """Disable the motion detection in base station (Disarm)."""
        self._motion_status = False
        self.set_base_station_mode(ARLO_MODE_DISARMED)
+
+    def update(self):
+        """Add an attribute-update task to the executor pool."""
+        self.attrs[ATTR_BATTERY_LEVEL] = self._camera.get_battery_level
+        self.attrs[ATTR_BRIGHTNESS] = self._camera.get_battery_level
+        self.attrs[ATTR_FLIPPED] = self._camera.get_flip_state,
+        self.attrs[ATTR_MIRRORED] = self._camera.get_mirror_state,
+        self.attrs[
+            ATTR_MOTION] = self._camera.get_motion_detection_sensitivity,
+        self.attrs[ATTR_POWERSAVE] = POWERSAVE_MODE_MAPPING[
+            self._camera.get_powersave_mode],
+        self.attrs[ATTR_SIGNAL_STRENGTH] = self._camera.get_signal_strength,
+        self.attrs[ATTR_UNSEEN_VIDEOS] = self._camera.unseen_videos
--- a/homeassistant/components/camera/axis.py
+++ b/homeassistant/components/camera/axis.py
@@ -7,7 +7,7 @@ https://home-assistant.io/components/camera.axis/
 import logging

 from homeassistant.const import (
-    CONF_HOST, CONF_NAME, CONF_USERNAME, CONF_PASSWORD,
+    CONF_HOST, CONF_NAME, CONF_USERNAME, CONF_PASSWORD, CONF_PORT,
    CONF_AUTHENTICATION, HTTP_DIGEST_AUTHENTICATION)
 from homeassistant.components.camera.mjpeg import (
    CONF_MJPEG_URL, CONF_STILL_IMAGE_URL, MjpegCamera)
@@ -19,38 +19,44 @@ DOMAIN = 'axis'
 DEPENDENCIES = [DOMAIN]


-def _get_image_url(host, mode):
+def _get_image_url(host, port, mode):
    if mode == 'mjpeg':
-        return 'http://{}/axis-cgi/mjpg/video.cgi'.format(host)
+        return 'http://{}:{}/axis-cgi/mjpg/video.cgi'.format(host, port)
    elif mode == 'single':
-        return 'http://{}/axis-cgi/jpg/image.cgi'.format(host)
+        return 'http://{}:{}/axis-cgi/jpg/image.cgi'.format(host, port)


 def setup_platform(hass, config, add_devices, discovery_info=None):
    """Setup Axis camera."""
-    config = {
+    camera_config = {
        CONF_NAME: discovery_info[CONF_NAME],
        CONF_USERNAME: discovery_info[CONF_USERNAME],
        CONF_PASSWORD: discovery_info[CONF_PASSWORD],
-        CONF_MJPEG_URL: _get_image_url(discovery_info[CONF_HOST], 'mjpeg'),
+        CONF_MJPEG_URL: _get_image_url(discovery_info[CONF_HOST],
+                                       str(discovery_info[CONF_PORT]),
+                                       'mjpeg'),
        CONF_STILL_IMAGE_URL: _get_image_url(discovery_info[CONF_HOST],
+                                             str(discovery_info[CONF_PORT]),
                                             'single'),
        CONF_AUTHENTICATION: HTTP_DIGEST_AUTHENTICATION,
    }
-    add_devices([AxisCamera(hass, config)])
+    add_devices([AxisCamera(hass,
+                            camera_config,
+                            str(discovery_info[CONF_PORT]))])


 class AxisCamera(MjpegCamera):
    """AxisCamera class."""

-    def __init__(self, hass, config):
+    def __init__(self, hass, config, port):
        """Initialize Axis Communications camera component."""
        super().__init__(hass, config)
+        self.port = port
        async_dispatcher_connect(hass,
                                 DOMAIN + '_' + config[CONF_NAME] + '_new_ip',
                                 self._new_ip)

    def _new_ip(self, host):
        """Set new IP for video stream."""
-        self._mjpeg_url = _get_image_url(host, 'mjpeg')
-        self._still_image_url = _get_image_url(host, 'mjpeg')
+        self._mjpeg_url = _get_image_url(host, self.port, 'mjpeg')
+        self._still_image_url = _get_image_url(host, self.port, 'single')
--- a/homeassistant/components/camera/blink.py
+++ b/homeassistant/components/camera/blink.py
@@ -76,6 +76,6 @@ class BlinkCamera(Camera):
        return self.data.camera_thumbs[self._name]

    def camera_image(self):
-        """Return a still image reponse from the camera."""
+        """Return a still image response from the camera."""
        self.request_image()
        return self.response.content
--- a/homeassistant/components/camera/doorbird.py
+++ b/homeassistant/components/camera/doorbird.py
@@ -0,0 +1,90 @@
+"""Support for viewing the camera feed from a DoorBird video doorbell."""
+
+import asyncio
+import datetime
+import logging
+import voluptuous as vol
+
+import aiohttp
+import async_timeout
+
+from homeassistant.components.camera import PLATFORM_SCHEMA, Camera
+from homeassistant.components.doorbird import DOMAIN as DOORBIRD_DOMAIN
+from homeassistant.helpers import config_validation as cv
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
+
+DEPENDENCIES = ['doorbird']
+
+_CAMERA_LIVE = "DoorBird Live"
+_CAMERA_LAST_VISITOR = "DoorBird Last Ring"
+_LIVE_INTERVAL = datetime.timedelta(seconds=1)
+_LAST_VISITOR_INTERVAL = datetime.timedelta(minutes=1)
+_LOGGER = logging.getLogger(__name__)
+_TIMEOUT = 10  # seconds
+
+CONF_SHOW_LAST_VISITOR = 'last_visitor'
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Optional(CONF_SHOW_LAST_VISITOR, default=False): cv.boolean
+})
+
+
+@asyncio.coroutine
+def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
+    """Set up the DoorBird camera platform."""
+    device = hass.data.get(DOORBIRD_DOMAIN)
+
+    _LOGGER.debug("Adding DoorBird camera %s", _CAMERA_LIVE)
+    entities = [DoorBirdCamera(device.live_image_url, _CAMERA_LIVE,
+                               _LIVE_INTERVAL)]
+
+    if config.get(CONF_SHOW_LAST_VISITOR):
+        _LOGGER.debug("Adding DoorBird camera %s", _CAMERA_LAST_VISITOR)
+        entities.append(DoorBirdCamera(device.history_image_url(1),
+                                       _CAMERA_LAST_VISITOR,
+                                       _LAST_VISITOR_INTERVAL))
+
+    async_add_devices(entities)
+    _LOGGER.info("Added DoorBird camera(s)")
+
+
+class DoorBirdCamera(Camera):
+    """The camera on a DoorBird device."""
+
+    def __init__(self, url, name, interval=None):
+        """Initialize the camera on a DoorBird device."""
+        self._url = url
+        self._name = name
+        self._last_image = None
+        self._interval = interval or datetime.timedelta
+        self._last_update = datetime.datetime.min
+        super().__init__()
+
+    @property
+    def name(self):
+        """Get the name of the camera."""
+        return self._name
+
+    @asyncio.coroutine
+    def async_camera_image(self):
+        """Pull a still image from the camera."""
+        now = datetime.datetime.now()
+
+        if self._last_image and now - self._last_update < self._interval:
+            return self._last_image
+
+        try:
+            websession = async_get_clientsession(self.hass)
+
+            with async_timeout.timeout(_TIMEOUT, loop=self.hass.loop):
+                response = yield from websession.get(self._url)
+
+            self._last_image = yield from response.read()
+            self._last_update = now
+            return self._last_image
+        except asyncio.TimeoutError:
+            _LOGGER.error("Camera image timed out")
+            return self._last_image
+        except aiohttp.ClientError as error:
+            _LOGGER.error("Error getting camera image: %s", error)
+            return self._last_image
--- a/homeassistant/components/camera/ffmpeg.py
+++ b/homeassistant/components/camera/ffmpeg.py
@@ -55,9 +55,9 @@ class FFmpegCamera(Camera):
        from haffmpeg import ImageFrame, IMAGE_JPEG
        ffmpeg = ImageFrame(self._manager.binary, loop=self.hass.loop)

-        image = yield from ffmpeg.get_image(
+        image = yield from asyncio.shield(ffmpeg.get_image(
            self._input, output_format=IMAGE_JPEG,
-            extra_cmd=self._extra_arguments)
+            extra_cmd=self._extra_arguments), loop=self.hass.loop)
        return image

    @asyncio.coroutine
--- a/homeassistant/components/camera/foscam.py
+++ b/homeassistant/components/camera/foscam.py
@@ -15,7 +15,7 @@ from homeassistant.helpers import config_validation as cv

 _LOGGER = logging.getLogger(__name__)

-REQUIREMENTS = ['pyfoscam==1.2']
+REQUIREMENTS = ['libpyfoscam==1.0']

 CONF_IP = 'ip'

@@ -53,13 +53,13 @@ class FoscamCam(Camera):
        self._name = device_info.get(CONF_NAME)
        self._motion_status = False

-        from foscam import FoscamCamera
+        from libpyfoscam import FoscamCamera

        self._foscam_session = FoscamCamera(ip_address, port, self._username,
-                                            self._password)
+                                            self._password, verbose=False)

    def camera_image(self):
-        """Return a still image reponse from the camera."""
+        """Return a still image response from the camera."""
        # Send the request to snap a picture and return raw jpg data
        # Handle exception if host is not reachable or url failed
        result, response = self._foscam_session.snap_picture_2()
--- a/homeassistant/components/camera/onvif.py
+++ b/homeassistant/components/camera/onvif.py
@@ -78,9 +78,9 @@ class ONVIFCamera(Camera):
        ffmpeg = ImageFrame(
            self.hass.data[DATA_FFMPEG].binary, loop=self.hass.loop)

-        image = yield from ffmpeg.get_image(
+        image = yield from asyncio.shield(ffmpeg.get_image(
            self._input, output_format=IMAGE_JPEG,
-            extra_cmd=self._ffmpeg_arguments)
+            extra_cmd=self._ffmpeg_arguments), loop=self.hass.loop)
        return image

    @asyncio.coroutine
--- a/homeassistant/components/camera/skybell.py
+++ b/homeassistant/components/camera/skybell.py
@@ -0,0 +1,67 @@
+"""
+Camera support for the Skybell HD Doorbell.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/camera.skybell/
+"""
+from datetime import timedelta
+import logging
+
+import requests
+
+from homeassistant.components.camera import Camera
+from homeassistant.components.skybell import (
+    DOMAIN as SKYBELL_DOMAIN, SkybellDevice)
+
+DEPENDENCIES = ['skybell']
+
+_LOGGER = logging.getLogger(__name__)
+
+SCAN_INTERVAL = timedelta(seconds=90)
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Set up the platform for a Skybell device."""
+    skybell = hass.data.get(SKYBELL_DOMAIN)
+
+    sensors = []
+    for device in skybell.get_devices():
+        sensors.append(SkybellCamera(device))
+
+    add_devices(sensors, True)
+
+
+class SkybellCamera(SkybellDevice, Camera):
+    """A camera implementation for Skybell devices."""
+
+    def __init__(self, device):
+        """Initialize a camera for a Skybell device."""
+        SkybellDevice.__init__(self, device)
+        Camera.__init__(self)
+        self._name = self._device.name
+        self._url = None
+        self._response = None
+
+    @property
+    def name(self):
+        """Return the name of the sensor."""
+        return self._name
+
+    def camera_image(self):
+        """Get the latest camera image."""
+        super().update()
+
+        if self._url != self._device.image:
+            self._url = self._device.image
+
+            try:
+                self._response = requests.get(
+                    self._url, stream=True, timeout=10)
+            except requests.HTTPError as err:
+                _LOGGER.warning("Failed to get camera image: %s", err)
+                self._response = None
+
+        if not self._response:
+            return None
+
+        return self._response.content
--- a/homeassistant/components/camera/synology.py
+++ b/homeassistant/components/camera/synology.py
@@ -7,44 +7,25 @@ https://home-assistant.io/components/camera.synology/
 import asyncio
 import logging

+import requests
 import voluptuous as vol

-import aiohttp
-import async_timeout
-
 from homeassistant.const import (
    CONF_NAME, CONF_USERNAME, CONF_PASSWORD,
    CONF_URL, CONF_WHITELIST, CONF_VERIFY_SSL, CONF_TIMEOUT)
 from homeassistant.components.camera import (
    Camera, PLATFORM_SCHEMA)
 from homeassistant.helpers.aiohttp_client import (
-    async_get_clientsession, async_create_clientsession,
-    async_aiohttp_proxy_web)
+    async_aiohttp_proxy_web,
+    async_get_clientsession)
 import homeassistant.helpers.config_validation as cv
-from homeassistant.util.async import run_coroutine_threadsafe
+
+REQUIREMENTS = ['py-synology==0.1.5']

 _LOGGER = logging.getLogger(__name__)

 DEFAULT_NAME = 'Synology Camera'
-DEFAULT_STREAM_ID = '0'
 DEFAULT_TIMEOUT = 5
-CONF_CAMERA_NAME = 'camera_name'
-CONF_STREAM_ID = 'stream_id'
-
-QUERY_CGI = 'query.cgi'
-QUERY_API = 'SYNO.API.Info'
-AUTH_API = 'SYNO.API.Auth'
-CAMERA_API = 'SYNO.SurveillanceStation.Camera'
-STREAMING_API = 'SYNO.SurveillanceStation.VideoStream'
-SESSION_ID = '0'
-
-WEBAPI_PATH = '/webapi/'
-AUTH_PATH = 'auth.cgi'
-CAMERA_PATH = 'camera.cgi'
-STREAMING_PATH = 'SurveillanceStation/videoStreaming.cgi'
-CONTENT_TYPE_HEADER = 'Content-Type'
-
-SYNO_API_URL = '{0}{1}{2}'

 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
    vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
@@ -62,189 +43,90 @@ def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
    """Set up a Synology IP Camera."""
    verify_ssl = config.get(CONF_VERIFY_SSL)
    timeout = config.get(CONF_TIMEOUT)
-    websession_init = async_get_clientsession(hass, verify_ssl)

-    # Determine API to use for authentication
-    syno_api_url = SYNO_API_URL.format(
-        config.get(CONF_URL), WEBAPI_PATH, QUERY_CGI)
-
-    query_payload = {
-        'api': QUERY_API,
-        'method': 'Query',
-        'version': '1',
-        'query': 'SYNO.'
-    }
    try:
-        with async_timeout.timeout(timeout, loop=hass.loop):
-            query_req = yield from websession_init.get(
-                syno_api_url,
-                params=query_payload
-            )
-
-        # Skip content type check because Synology doesn't return JSON with
-        # right content type
-        query_resp = yield from query_req.json(content_type=None)
-        auth_path = query_resp['data'][AUTH_API]['path']
-        camera_api = query_resp['data'][CAMERA_API]['path']
-        camera_path = query_resp['data'][CAMERA_API]['path']
-        streaming_path = query_resp['data'][STREAMING_API]['path']
-
-    except (asyncio.TimeoutError, aiohttp.ClientError):
-        _LOGGER.exception("Error on %s", syno_api_url)
+        from synology.surveillance_station import SurveillanceStation
+        surveillance = SurveillanceStation(
+            config.get(CONF_URL),
+            config.get(CONF_USERNAME),
+            config.get(CONF_PASSWORD),
+            verify_ssl=verify_ssl,
+            timeout=timeout
+        )
+    except (requests.exceptions.RequestException, ValueError):
+        _LOGGER.exception("Error when initializing SurveillanceStation")
        return False

-    # Authticate to NAS to get a session id
-    syno_auth_url = SYNO_API_URL.format(
-        config.get(CONF_URL), WEBAPI_PATH, auth_path)
-
-    session_id = yield from get_session_id(
-        hass,
-        websession_init,
-        config.get(CONF_USERNAME),
-        config.get(CONF_PASSWORD),
-        syno_auth_url,
-        timeout
-    )
-
-    # init websession
-    websession = async_create_clientsession(
-        hass, verify_ssl, cookies={'id': session_id})
-
-    # Use SessionID to get cameras in system
-    syno_camera_url = SYNO_API_URL.format(
-        config.get(CONF_URL), WEBAPI_PATH, camera_api)
-
-    camera_payload = {
-        'api': CAMERA_API,
-        'method': 'List',
-        'version': '1'
-    }
-    try:
-        with async_timeout.timeout(timeout, loop=hass.loop):
-            camera_req = yield from websession.get(
-                syno_camera_url,
-                params=camera_payload
-            )
-    except (asyncio.TimeoutError, aiohttp.ClientError):
-        _LOGGER.exception("Error on %s", syno_camera_url)
-        return False
-
-    camera_resp = yield from camera_req.json(content_type=None)
-    cameras = camera_resp['data']['cameras']
+    cameras = surveillance.get_all_cameras()

    # add cameras
    devices = []
    for camera in cameras:
        if not config.get(CONF_WHITELIST):
-            camera_id = camera['id']
-            snapshot_path = camera['snapshot_path']
-
-            device = SynologyCamera(
-                hass, websession, config, camera_id, camera['name'],
-                snapshot_path, streaming_path, camera_path, auth_path, timeout
-            )
+            device = SynologyCamera(surveillance, camera.camera_id, verify_ssl)
            devices.append(device)

    async_add_devices(devices)


-@asyncio.coroutine
-def get_session_id(hass, websession, username, password, login_url, timeout):
-    """Get a session id."""
-    auth_payload = {
-        'api': AUTH_API,
-        'method': 'Login',
-        'version': '2',
-        'account': username,
-        'passwd': password,
-        'session': 'SurveillanceStation',
-        'format': 'sid'
-    }
-    try:
-        with async_timeout.timeout(timeout, loop=hass.loop):
-            auth_req = yield from websession.get(
-                login_url,
-                params=auth_payload
-            )
-        auth_resp = yield from auth_req.json(content_type=None)
-        return auth_resp['data']['sid']
-
-    except (asyncio.TimeoutError, aiohttp.ClientError):
-        _LOGGER.exception("Error on %s", login_url)
-        return False
-
-
 class SynologyCamera(Camera):
    """An implementation of a Synology NAS based IP camera."""

-    def __init__(self, hass, websession, config, camera_id,
-                 camera_name, snapshot_path, streaming_path, camera_path,
-                 auth_path, timeout):
+    def __init__(self, surveillance, camera_id, verify_ssl):
        """Initialize a Synology Surveillance Station camera."""
        super().__init__()
-        self.hass = hass
-        self._websession = websession
-        self._name = camera_name
-        self._synology_url = config.get(CONF_URL)
-        self._camera_name = config.get(CONF_CAMERA_NAME)
-        self._stream_id = config.get(CONF_STREAM_ID)
+        self._surveillance = surveillance
        self._camera_id = camera_id
-        self._snapshot_path = snapshot_path
-        self._streaming_path = streaming_path
-        self._camera_path = camera_path
-        self._auth_path = auth_path
-        self._timeout = timeout
+        self._verify_ssl = verify_ssl
+        self._camera = self._surveillance.get_camera(camera_id)
+        self._motion_setting = self._surveillance.get_motion_setting(camera_id)
+        self.is_streaming = self._camera.is_enabled

    def camera_image(self):
        """Return bytes of camera image."""
-        return run_coroutine_threadsafe(
-            self.async_camera_image(), self.hass.loop).result()
-
-    @asyncio.coroutine
-    def async_camera_image(self):
-        """Return a still image response from the camera."""
-        image_url = SYNO_API_URL.format(
-            self._synology_url, WEBAPI_PATH, self._camera_path)
-
-        image_payload = {
-            'api': CAMERA_API,
-            'method': 'GetSnapshot',
-            'version': '1',
-            'cameraId': self._camera_id
-        }
-        try:
-            with async_timeout.timeout(self._timeout, loop=self.hass.loop):
-                response = yield from self._websession.get(
-                    image_url,
-                    params=image_payload
-                )
-        except (asyncio.TimeoutError, aiohttp.ClientError):
-            _LOGGER.error("Error fetching %s", image_url)
-            return None
-
-        image = yield from response.read()
-
-        return image
+        return self._surveillance.get_camera_image(self._camera_id)

    @asyncio.coroutine
    def handle_async_mjpeg_stream(self, request):
        """Return a MJPEG stream image response directly from the camera."""
-        streaming_url = SYNO_API_URL.format(
-            self._synology_url, WEBAPI_PATH, self._streaming_path)
+        streaming_url = self._camera.video_stream_url

-        streaming_payload = {
-            'api': STREAMING_API,
-            'method': 'Stream',
-            'version': '1',
-            'cameraId': self._camera_id,
-            'format': 'mjpeg'
-        }
-        stream_coro = self._websession.get(
-            streaming_url, params=streaming_payload)
+        websession = async_get_clientsession(self.hass, self._verify_ssl)
+        stream_coro = websession.get(streaming_url)

        yield from async_aiohttp_proxy_web(self.hass, request, stream_coro)

    @property
    def name(self):
        """Return the name of this device."""
-        return self._name
+        return self._camera.name
+
+    @property
+    def is_recording(self):
+        """Return true if the device is recording."""
+        return self._camera.is_recording
+
+    def should_poll(self):
+        """Update the recording state periodically."""
+        return True
+
+    def update(self):
+        """Update the status of the camera."""
+        self._surveillance.update()
+        self._camera = self._surveillance.get_camera(self._camera.camera_id)
+        self._motion_setting = self._surveillance.get_motion_setting(
+            self._camera.camera_id)
+        self.is_streaming = self._camera.is_enabled
+
+    @property
+    def motion_detection_enabled(self):
+        """Return the camera motion detection status."""
+        return self._motion_setting.is_enabled
+
+    def enable_motion_detection(self):
+        """Enable motion detection in the camera."""
+        self._surveillance.enable_motion_detection(self._camera_id)
+
+    def disable_motion_detection(self):
+        """Disable motion detection in camera."""
+        self._surveillance.disable_motion_detection(self._camera_id)
--- a/homeassistant/components/camera/usps.py
+++ b/homeassistant/components/camera/usps.py
@@ -0,0 +1,94 @@
+"""
+Support for a camera made up of usps mail images.
+
+For more details about this component, please refer to the documentation at
+https://home-assistant.io/components/camera.usps/
+"""
+from datetime import timedelta
+import logging
+
+from homeassistant.components.camera import Camera
+from homeassistant.components.usps import DATA_USPS
+
+_LOGGER = logging.getLogger(__name__)
+
+DEPENDENCIES = ['usps']
+
+SCAN_INTERVAL = timedelta(seconds=10)
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Set up USPS mail camera."""
+    if discovery_info is None:
+        return
+
+    usps = hass.data[DATA_USPS]
+    add_devices([USPSCamera(usps)])
+
+
+class USPSCamera(Camera):
+    """Representation of the images available from USPS."""
+
+    def __init__(self, usps):
+        """Initialize the USPS camera images."""
+        super().__init__()
+
+        self._usps = usps
+        self._name = self._usps.name
+        self._session = self._usps.session
+
+        self._mail_img = []
+        self._last_mail = None
+        self._mail_index = 0
+        self._mail_count = 0
+
+        self._timer = None
+
+    def camera_image(self):
+        """Update the camera's image if it has changed."""
+        self._usps.update()
+        try:
+            self._mail_count = len(self._usps.mail)
+        except TypeError:
+            # No mail
+            return None
+
+        if self._usps.mail != self._last_mail:
+            # Mail items must have changed
+            self._mail_img = []
+            if len(self._usps.mail) >= 1:
+                self._last_mail = self._usps.mail
+                for article in self._usps.mail:
+                    _LOGGER.debug("Fetching article image: %s", article)
+                    img = self._session.get(article['image']).content
+                    self._mail_img.append(img)
+
+        try:
+            return self._mail_img[self._mail_index]
+        except IndexError:
+            return None
+
+    @property
+    def name(self):
+        """Return the name of this camera."""
+        return '{} mail'.format(self._name)
+
+    @property
+    def model(self):
+        """Return date of mail as model."""
+        try:
+            return 'Date: {}'.format(str(self._usps.mail[0]['date']))
+        except IndexError:
+            return None
+
+    @property
+    def should_poll(self):
+        """Update the mail image index periodically."""
+        return True
+
+    def update(self):
+        """Update mail image index."""
+        if self._mail_index < (self._mail_count - 1):
+            self._mail_index += 1
+        else:
+            self._mail_index = 0
--- a/homeassistant/components/camera/uvc.py
+++ b/homeassistant/components/camera/uvc.py
@@ -14,7 +14,7 @@ from homeassistant.const import CONF_PORT
 from homeassistant.components.camera import Camera, PLATFORM_SCHEMA
 import homeassistant.helpers.config_validation as cv

-REQUIREMENTS = ['uvcclient==0.10.0']
+REQUIREMENTS = ['uvcclient==0.10.1']

 _LOGGER = logging.getLogger(__name__)

--- a/homeassistant/components/camera/yi.py
+++ b/homeassistant/components/camera/yi.py
@@ -0,0 +1,137 @@
+"""
+This component provides support for Xiaomi Cameras (HiSilicon Hi3518e V200).
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/camera.yi/
+"""
+import asyncio
+import logging
+
+import voluptuous as vol
+
+from homeassistant.components.camera import Camera, PLATFORM_SCHEMA
+from homeassistant.components.ffmpeg import DATA_FFMPEG
+from homeassistant.const import (CONF_HOST, CONF_NAME, CONF_PATH,
+                                 CONF_PASSWORD, CONF_PORT, CONF_USERNAME)
+from homeassistant.helpers import config_validation as cv
+from homeassistant.helpers.aiohttp_client import async_aiohttp_proxy_stream
+
+DEPENDENCIES = ['ffmpeg']
+_LOGGER = logging.getLogger(__name__)
+
+DEFAULT_BRAND = 'YI Home Camera'
+DEFAULT_PASSWORD = ''
+DEFAULT_PATH = '/tmp/sd/record'
+DEFAULT_PORT = 21
+DEFAULT_USERNAME = 'root'
+
+CONF_FFMPEG_ARGUMENTS = 'ffmpeg_arguments'
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Required(CONF_NAME): cv.string,
+    vol.Required(CONF_HOST): cv.string,
+    vol.Optional(CONF_PORT, default=DEFAULT_PORT): cv.string,
+    vol.Optional(CONF_PATH, default=DEFAULT_PATH): cv.string,
+    vol.Optional(CONF_USERNAME, default=DEFAULT_USERNAME): cv.string,
+    vol.Required(CONF_PASSWORD): cv.string,
+    vol.Optional(CONF_FFMPEG_ARGUMENTS): cv.string
+})
+
+
+@asyncio.coroutine
+def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
+    """Set up a Yi Camera."""
+    _LOGGER.debug('Received configuration: %s', config)
+    async_add_devices([YiCamera(hass, config)], True)
+
+
+class YiCamera(Camera):
+    """Define an implementation of a Yi Camera."""
+
+    def __init__(self, hass, config):
+        """Initialize."""
+        super().__init__()
+        self._extra_arguments = config.get(CONF_FFMPEG_ARGUMENTS)
+        self._last_image = None
+        self._last_url = None
+        self._manager = hass.data[DATA_FFMPEG]
+        self._name = config.get(CONF_NAME)
+        self.host = config.get(CONF_HOST)
+        self.port = config.get(CONF_PORT)
+        self.path = config.get(CONF_PATH)
+        self.user = config.get(CONF_USERNAME)
+        self.passwd = config.get(CONF_PASSWORD)
+
+    @property
+    def name(self):
+        """Return the name of this camera."""
+        return self._name
+
+    @property
+    def brand(self):
+        """Camera brand."""
+        return DEFAULT_BRAND
+
+    def get_latest_video_url(self):
+        """Retrieve the latest video file from the customized Yi FTP server."""
+        from ftplib import FTP, error_perm
+
+        ftp = FTP(self.host)
+        try:
+            ftp.login(self.user, self.passwd)
+        except error_perm as exc:
+            _LOGGER.error('There was an error while logging into the camera')
+            _LOGGER.debug(exc)
+            return False
+
+        try:
+            ftp.cwd(self.path)
+        except error_perm as exc:
+            _LOGGER.error('Unable to find path: %s', self.path)
+            _LOGGER.debug(exc)
+            return False
+
+        dirs = [d for d in ftp.nlst() if '.' not in d]
+        if not dirs:
+            _LOGGER.warning("There don't appear to be any uploaded videos")
+            return False
+
+        latest_dir = dirs[-1]
+        ftp.cwd(latest_dir)
+        videos = ftp.nlst()
+        if not videos:
+            _LOGGER.info('Video folder "%s" is empty; delaying', latest_dir)
+            return False
+
+        return 'ftp://{0}:{1}@{2}:{3}{4}/{5}/{6}'.format(
+            self.user, self.passwd, self.host, self.port, self.path,
+            latest_dir, videos[-1])
+
+    @asyncio.coroutine
+    def async_camera_image(self):
+        """Return a still image response from the camera."""
+        from haffmpeg import ImageFrame, IMAGE_JPEG
+
+        url = yield from self.hass.async_add_job(self.get_latest_video_url)
+        if url != self._last_url:
+            ffmpeg = ImageFrame(self._manager.binary, loop=self.hass.loop)
+            self._last_image = yield from asyncio.shield(ffmpeg.get_image(
+                url, output_format=IMAGE_JPEG,
+                extra_cmd=self._extra_arguments), loop=self.hass.loop)
+            self._last_url = url
+
+        return self._last_image
+
+    @asyncio.coroutine
+    def handle_async_mjpeg_stream(self, request):
+        """Generate an HTTP MJPEG stream from the camera."""
+        from haffmpeg import CameraMjpeg
+
+        stream = CameraMjpeg(self._manager.binary, loop=self.hass.loop)
+        yield from stream.open_camera(
+            self._last_url, extra_cmd=self._extra_arguments)
+
+        yield from async_aiohttp_proxy_stream(
+            self.hass, request, stream,
+            'multipart/x-mixed-replace;boundary=ffserver')
+        yield from stream.close()
--- a/homeassistant/components/climate/init.py
+++ b/homeassistant/components/climate/init.py
@@ -44,6 +44,12 @@ STATE_IDLE = 'idle'
 STATE_AUTO = 'auto'
 STATE_DRY = 'dry'
 STATE_FAN_ONLY = 'fan_only'
+STATE_ECO = 'eco'
+STATE_ELECTRIC = 'electric'
+STATE_PERFORMANCE = 'performance'
+STATE_HIGH_DEMAND = 'high_demand'
+STATE_HEAT_PUMP = 'heat_pump'
+STATE_GAS = 'gas'

 ATTR_CURRENT_TEMPERATURE = 'current_temperature'
 ATTR_MAX_TEMP = 'max_temp'
@@ -147,7 +153,7 @@ def set_hold_mode(hass, hold_mode, entity_id=None):

@bind_hass
 def set_aux_heat(hass, aux_heat, entity_id=None):
-    """Turn all or specified climate devices auxillary heater on."""
+    """Turn all or specified climate devices auxiliary heater on."""
    data = {
        ATTR_AUX_HEAT: aux_heat
    }
@@ -230,24 +236,6 @@ def async_setup(hass, config):
        load_yaml_config_file,
        os.path.join(os.path.dirname(__file__), 'services.yaml'))

-    @asyncio.coroutine
-    def _async_update_climate(target_climate):
-        """Update climate entity after service stuff."""
-        update_tasks = []
-        for climate in target_climate:
-            if not climate.should_poll:
-                continue
-
-            update_coro = hass.async_add_job(
-                climate.async_update_ha_state(True))
-            if hasattr(climate, 'async_update'):
-                update_tasks.append(update_coro)
-            else:
-                yield from update_coro
-
-        if update_tasks:
-            yield from asyncio.wait(update_tasks, loop=hass.loop)
-
    @asyncio.coroutine
    def async_away_mode_set_service(service):
        """Set away mode on target climate devices."""
@@ -255,13 +243,19 @@ def async_setup(hass, config):

        away_mode = service.data.get(ATTR_AWAY_MODE)

+        update_tasks = []
        for climate in target_climate:
            if away_mode:
                yield from climate.async_turn_away_mode_on()
            else:
                yield from climate.async_turn_away_mode_off()

-        yield from _async_update_climate(target_climate)
+            if not climate.should_poll:
+                continue
+            update_tasks.append(climate.async_update_ha_state(True))
+
+        if update_tasks:
+            yield from asyncio.wait(update_tasks, loop=hass.loop)

    hass.services.async_register(
        DOMAIN, SERVICE_SET_AWAY_MODE, async_away_mode_set_service,
@@ -275,10 +269,16 @@ def async_setup(hass, config):

        hold_mode = service.data.get(ATTR_HOLD_MODE)

+        update_tasks = []
        for climate in target_climate:
            yield from climate.async_set_hold_mode(hold_mode)

-        yield from _async_update_climate(target_climate)
+            if not climate.should_poll:
+                continue
+            update_tasks.append(climate.async_update_ha_state(True))
+
+        if update_tasks:
+            yield from asyncio.wait(update_tasks, loop=hass.loop)

    hass.services.async_register(
        DOMAIN, SERVICE_SET_HOLD_MODE, async_hold_mode_set_service,
@@ -292,13 +292,19 @@ def async_setup(hass, config):

        aux_heat = service.data.get(ATTR_AUX_HEAT)

+        update_tasks = []
        for climate in target_climate:
            if aux_heat:
                yield from climate.async_turn_aux_heat_on()
            else:
                yield from climate.async_turn_aux_heat_off()

-        yield from _async_update_climate(target_climate)
+            if not climate.should_poll:
+                continue
+            update_tasks.append(climate.async_update_ha_state(True))
+
+        if update_tasks:
+            yield from asyncio.wait(update_tasks, loop=hass.loop)

    hass.services.async_register(
        DOMAIN, SERVICE_SET_AUX_HEAT, async_aux_heat_set_service,
@@ -310,6 +316,7 @@ def async_setup(hass, config):
        """Set temperature on the target climate devices."""
        target_climate = component.async_extract_from_service(service)

+        update_tasks = []
        for climate in target_climate:
            kwargs = {}
            for value, temp in service.data.items():
@@ -324,7 +331,12 @@ def async_setup(hass, config):

            yield from climate.async_set_temperature(**kwargs)

-        yield from _async_update_climate(target_climate)
+            if not climate.should_poll:
+                continue
+            update_tasks.append(climate.async_update_ha_state(True))
+
+        if update_tasks:
+            yield from asyncio.wait(update_tasks, loop=hass.loop)

    hass.services.async_register(
        DOMAIN, SERVICE_SET_TEMPERATURE, async_temperature_set_service,
@@ -338,10 +350,15 @@ def async_setup(hass, config):

        humidity = service.data.get(ATTR_HUMIDITY)

+        update_tasks = []
        for climate in target_climate:
            yield from climate.async_set_humidity(humidity)
+            if not climate.should_poll:
+                continue
+            update_tasks.append(climate.async_update_ha_state(True))

-        yield from _async_update_climate(target_climate)
+        if update_tasks:
+            yield from asyncio.wait(update_tasks, loop=hass.loop)

    hass.services.async_register(
        DOMAIN, SERVICE_SET_HUMIDITY, async_humidity_set_service,
@@ -355,10 +372,15 @@ def async_setup(hass, config):

        fan = service.data.get(ATTR_FAN_MODE)

+        update_tasks = []
        for climate in target_climate:
            yield from climate.async_set_fan_mode(fan)
+            if not climate.should_poll:
+                continue
+            update_tasks.append(climate.async_update_ha_state(True))

-        yield from _async_update_climate(target_climate)
+        if update_tasks:
+            yield from asyncio.wait(update_tasks, loop=hass.loop)

    hass.services.async_register(
        DOMAIN, SERVICE_SET_FAN_MODE, async_fan_mode_set_service,
@@ -372,10 +394,15 @@ def async_setup(hass, config):

        operation_mode = service.data.get(ATTR_OPERATION_MODE)

+        update_tasks = []
        for climate in target_climate:
            yield from climate.async_set_operation_mode(operation_mode)
+            if not climate.should_poll:
+                continue
+            update_tasks.append(climate.async_update_ha_state(True))

-        yield from _async_update_climate(target_climate)
+        if update_tasks:
+            yield from asyncio.wait(update_tasks, loop=hass.loop)

    hass.services.async_register(
        DOMAIN, SERVICE_SET_OPERATION_MODE, async_operation_set_service,
@@ -389,10 +416,15 @@ def async_setup(hass, config):

        swing_mode = service.data.get(ATTR_SWING_MODE)

+        update_tasks = []
        for climate in target_climate:
            yield from climate.async_set_swing_mode(swing_mode)
+            if not climate.should_poll:
+                continue
+            update_tasks.append(climate.async_update_ha_state(True))

-        yield from _async_update_climate(target_climate)
+        if update_tasks:
+            yield from asyncio.wait(update_tasks, loop=hass.loop)

    hass.services.async_register(
        DOMAIN, SERVICE_SET_SWING_MODE, async_swing_set_service,
@@ -661,22 +693,22 @@ class ClimateDevice(Entity):
        return self.hass.async_add_job(self.set_hold_mode, hold_mode)

    def turn_aux_heat_on(self):
-        """Turn auxillary heater on."""
+        """Turn auxiliary heater on."""
        raise NotImplementedError()

    def async_turn_aux_heat_on(self):
-        """Turn auxillary heater on.
+        """Turn auxiliary heater on.

        This method must be run in the event loop and returns a coroutine.
        """
        return self.hass.async_add_job(self.turn_aux_heat_on)

    def turn_aux_heat_off(self):
-        """Turn auxillary heater off."""
+        """Turn auxiliary heater off."""
        raise NotImplementedError()

    def async_turn_aux_heat_off(self):
-        """Turn auxillary heater off.
+        """Turn auxiliary heater off.

        This method must be run in the event loop and returns a coroutine.
        """
--- a/homeassistant/components/climate/demo.py
+++ b/homeassistant/components/climate/demo.py
@@ -114,7 +114,7 @@ class DemoClimate(ClimateDevice):

    @property
    def is_aux_heat_on(self):
-        """Return true if away mode is on."""
+        """Return true if aux heat is on."""
        return self._aux

    @property
@@ -183,11 +183,11 @@ class DemoClimate(ClimateDevice):
        self.schedule_update_ha_state()

    def turn_aux_heat_on(self):
-        """Turn away auxillary heater on."""
+        """Turn auxillary heater on."""
        self._aux = True
        self.schedule_update_ha_state()

    def turn_aux_heat_off(self):
-        """Turn auxillary heater off."""
+        """Turn auxiliary heater off."""
        self._aux = False
        self.schedule_update_ha_state()
--- a/homeassistant/components/climate/ecobee.py
+++ b/homeassistant/components/climate/ecobee.py
@@ -27,6 +27,7 @@ ATTR_RESUME_ALL = 'resume_all'
 DEFAULT_RESUME_ALL = False
 TEMPERATURE_HOLD = 'temp'
 VACATION_HOLD = 'vacation'
+AWAY_MODE = 'awayMode'

 DEPENDENCIES = ['ecobee']

@@ -144,20 +145,20 @@ class Thermostat(ClimateDevice):
    @property
    def current_temperature(self):
        """Return the current temperature."""
-        return self.thermostat['runtime']['actualTemperature'] / 10
+        return self.thermostat['runtime']['actualTemperature'] / 10.0

    @property
    def target_temperature_low(self):
        """Return the lower bound temperature we try to reach."""
        if self.current_operation == STATE_AUTO:
-            return int(self.thermostat['runtime']['desiredHeat'] / 10)
+            return self.thermostat['runtime']['desiredHeat'] / 10.0
        return None

    @property
    def target_temperature_high(self):
        """Return the upper bound temperature we try to reach."""
        if self.current_operation == STATE_AUTO:
-            return int(self.thermostat['runtime']['desiredCool'] / 10)
+            return self.thermostat['runtime']['desiredCool'] / 10.0
        return None

    @property
@@ -166,9 +167,9 @@ class Thermostat(ClimateDevice):
        if self.current_operation == STATE_AUTO:
            return None
        if self.current_operation == STATE_HEAT:
-            return int(self.thermostat['runtime']['desiredHeat'] / 10)
+            return self.thermostat['runtime']['desiredHeat'] / 10.0
        elif self.current_operation == STATE_COOL:
-            return int(self.thermostat['runtime']['desiredCool'] / 10)
+            return self.thermostat['runtime']['desiredCool'] / 10.0
        return None

    @property
@@ -186,6 +187,11 @@ class Thermostat(ClimateDevice):
    @property
    def current_hold_mode(self):
        """Return current hold mode."""
+        mode = self._current_hold_mode
+        return None if mode == AWAY_MODE else mode
+
+    @property
+    def _current_hold_mode(self):
        events = self.thermostat['events']
        for event in events:
            if event['running']:
@@ -195,8 +201,8 @@ class Thermostat(ClimateDevice):
                           int(event['startDate'][0:4]) <= 1:
                            # A temporary hold from away climate is a hold
                            return 'away'
-                        # A permanent hold from away climate is away_mode
-                        return None
+                        # A permanent hold from away climate
+                        return AWAY_MODE
                    elif event['holdClimateRef'] != "":
                        # Any other hold based on climate
                        return event['holdClimateRef']
@@ -269,7 +275,7 @@ class Thermostat(ClimateDevice):
    @property
    def is_away_mode_on(self):
        """Return true if away mode is on."""
-        return self.current_hold_mode == 'away'
+        return self._current_hold_mode == AWAY_MODE

    @property
    def is_aux_heat_on(self):
@@ -277,12 +283,17 @@ class Thermostat(ClimateDevice):
        return 'auxHeat' in self.thermostat['equipmentStatus']

    def turn_away_mode_on(self):
-        """Turn away on."""
-        self.set_hold_mode('away')
+        """Turn away mode on by setting it on away hold indefinitely."""
+        if self._current_hold_mode != AWAY_MODE:
+            self.data.ecobee.set_climate_hold(self.thermostat_index, 'away',
+                                              'indefinite')
+            self.update_without_throttle = True

    def turn_away_mode_off(self):
        """Turn away off."""
-        self.set_hold_mode(None)
+        if self._current_hold_mode == AWAY_MODE:
+            self.data.ecobee.resume_program(self.thermostat_index)
+            self.update_without_throttle = True

    def set_hold_mode(self, hold_mode):
        """Set hold mode (away, home, temp, sleep, etc.)."""
@@ -299,7 +310,7 @@ class Thermostat(ClimateDevice):
                self.data.ecobee.resume_program(self.thermostat_index)
        else:
            if hold_mode == TEMPERATURE_HOLD:
-                self.set_temp_hold(int(self.current_temperature))
+                self.set_temp_hold(self.current_temperature)
            else:
                self.data.ecobee.set_climate_hold(
                    self.thermostat_index, hold_mode, self.hold_preference())
@@ -325,15 +336,11 @@ class Thermostat(ClimateDevice):
        elif self.current_operation == STATE_COOL:
            heat_temp = temp - 20
            cool_temp = temp
-
-        self.data.ecobee.set_hold_temp(self.thermostat_index, cool_temp,
-                                       heat_temp, self.hold_preference())
-        _LOGGER.debug("Setting ecobee hold_temp to: low=%s, is=%s, "
-                      "cool=%s, is=%s", heat_temp, isinstance(
-                          heat_temp, (int, float)), cool_temp,
-                      isinstance(cool_temp, (int, float)))
-
-        self.update_without_throttle = True
+        else:
+            # In auto mode set temperature between
+            heat_temp = temp - 10
+            cool_temp = temp + 10
+        self.set_auto_temp_hold(heat_temp, cool_temp)

    def set_temperature(self, **kwargs):
        """Set new target temperature."""
@@ -343,9 +350,9 @@ class Thermostat(ClimateDevice):

        if self.current_operation == STATE_AUTO and low_temp is not None \
           and high_temp is not None:
-            self.set_auto_temp_hold(int(low_temp), int(high_temp))
+            self.set_auto_temp_hold(low_temp, high_temp)
        elif temp is not None:
-            self.set_temp_hold(int(temp))
+            self.set_temp_hold(temp)
        else:
            _LOGGER.error(
                "Missing valid arguments for set_temperature in %s", kwargs)
@@ -364,7 +371,7 @@ class Thermostat(ClimateDevice):
    def resume_program(self, resume_all):
        """Resume the thermostat schedule program."""
        self.data.ecobee.resume_program(
-            self.thermostat_index, str(resume_all).lower())
+            self.thermostat_index, 'true' if resume_all else 'false')
        self.update_without_throttle = True

    def hold_preference(self):
--- a/homeassistant/components/climate/eq3btsmart.py
+++ b/homeassistant/components/climate/eq3btsmart.py
@@ -17,7 +17,7 @@ from homeassistant.const import (

 import homeassistant.helpers.config_validation as cv

-REQUIREMENTS = ['python-eq3bt==0.1.5']
+REQUIREMENTS = ['python-eq3bt==0.1.6']

 _LOGGER = logging.getLogger(__name__)

@@ -164,4 +164,8 @@ class EQ3BTSmartThermostat(ClimateDevice):

    def update(self):
        """Update the data from the thermostat."""
-        self._thermostat.update()
+        from bluepy.btle import BTLEException
+        try:
+            self._thermostat.update()
+        except BTLEException as ex:
+            _LOGGER.warning("Updating the state failed: %s", ex)
--- a/homeassistant/components/climate/generic_thermostat.py
+++ b/homeassistant/components/climate/generic_thermostat.py
@@ -211,7 +211,7 @@ class GenericThermostat(ClimateDevice):
        """Handle heater switch state changes."""
        if new_state is None:
            return
-        self.hass.async_add_job(self.async_update_ha_state())
+        self.async_schedule_update_ha_state()

    @callback
    def _async_keep_alive(self, time):
--- a/homeassistant/components/climate/homematic.py
+++ b/homeassistant/components/climate/homematic.py
@@ -47,8 +47,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):

    devices = []
    for conf in discovery_info[ATTR_DISCOVER_DEVICES]:
-        new_device = HMThermostat(hass, conf)
-        new_device.link_homematic()
+        new_device = HMThermostat(conf)
        devices.append(new_device)

    add_devices(devices)
--- a/homeassistant/components/climate/honeywell.py
+++ b/homeassistant/components/climate/honeywell.py
@@ -196,6 +196,11 @@ class RoundThermostat(ClimateDevice):
                if val['id'] == self._id:
                    data = val

+        except KeyError:
+            _LOGGER.error("Update failed from Honeywell server")
+            self.client.user_data = None
+            return
+
        except StopIteration:
            _LOGGER.error("Did not receive any temperature data from the "
                          "evohomeclient API")
--- a/homeassistant/components/climate/knx.py
+++ b/homeassistant/components/climate/knx.py
@@ -1,68 +1,144 @@
 """
-Support for KNX thermostats.
+Support for KNX/IP climate devices.

-For more details about this platform, please refer to the documentation
+For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/climate.knx/
 """
-import logging
-
+import asyncio
 import voluptuous as vol

-from homeassistant.components.climate import (ClimateDevice, PLATFORM_SCHEMA)
-from homeassistant.components.knx import (KNXConfig, KNXMultiAddressDevice)
-from homeassistant.const import (CONF_NAME, TEMP_CELSIUS, ATTR_TEMPERATURE)
+from homeassistant.components.knx import DATA_KNX, ATTR_DISCOVER_DEVICES
+from homeassistant.components.climate import PLATFORM_SCHEMA, ClimateDevice
+from homeassistant.const import CONF_NAME, TEMP_CELSIUS, ATTR_TEMPERATURE
+from homeassistant.core import callback
 import homeassistant.helpers.config_validation as cv

-_LOGGER = logging.getLogger(__name__)
-
-CONF_ADDRESS = 'address'
 CONF_SETPOINT_ADDRESS = 'setpoint_address'
+CONF_SETPOINT_SHIFT_ADDRESS = 'setpoint_shift_address'
+CONF_SETPOINT_SHIFT_STATE_ADDRESS = 'setpoint_shift_state_address'
 CONF_TEMPERATURE_ADDRESS = 'temperature_address'
+CONF_TARGET_TEMPERATURE_ADDRESS = 'target_temperature_address'
+CONF_OPERATION_MODE_ADDRESS = 'operation_mode_address'
+CONF_OPERATION_MODE_STATE_ADDRESS = 'operation_mode_state_address'
+CONF_CONTROLLER_STATUS_ADDRESS = 'controller_status_address'
+CONF_CONTROLLER_STATUS_STATE_ADDRESS = 'controller_status_state_address'
+CONF_OPERATION_MODE_FROST_PROTECTION_ADDRESS = \
+    'operation_mode_frost_protection_address'
+CONF_OPERATION_MODE_NIGHT_ADDRESS = 'operation_mode_night_address'
+CONF_OPERATION_MODE_COMFORT_ADDRESS = 'operation_mode_comfort_address'

-DEFAULT_NAME = 'KNX Thermostat'
+DEFAULT_NAME = 'KNX Climate'
 DEPENDENCIES = ['knx']

 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
-    vol.Required(CONF_ADDRESS): cv.string,
+    vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
    vol.Required(CONF_SETPOINT_ADDRESS): cv.string,
    vol.Required(CONF_TEMPERATURE_ADDRESS): cv.string,
-    vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
+    vol.Required(CONF_TARGET_TEMPERATURE_ADDRESS): cv.string,
+    vol.Optional(CONF_SETPOINT_SHIFT_ADDRESS): cv.string,
+    vol.Optional(CONF_SETPOINT_SHIFT_STATE_ADDRESS): cv.string,
+    vol.Optional(CONF_OPERATION_MODE_ADDRESS): cv.string,
+    vol.Optional(CONF_OPERATION_MODE_STATE_ADDRESS): cv.string,
+    vol.Optional(CONF_CONTROLLER_STATUS_ADDRESS): cv.string,
+    vol.Optional(CONF_CONTROLLER_STATUS_STATE_ADDRESS): cv.string,
+    vol.Optional(CONF_OPERATION_MODE_FROST_PROTECTION_ADDRESS): cv.string,
+    vol.Optional(CONF_OPERATION_MODE_NIGHT_ADDRESS): cv.string,
+    vol.Optional(CONF_OPERATION_MODE_COMFORT_ADDRESS): cv.string,
 })


-def setup_platform(hass, config, add_devices, discovery_info=None):
-    """Create and add an entity based on the configuration."""
-    add_devices([KNXThermostat(hass, KNXConfig(config))])
+@asyncio.coroutine
+def async_setup_platform(hass, config, async_add_devices,
+                         discovery_info=None):
+    """Set up climate(s) for KNX platform."""
+    if DATA_KNX not in hass.data \
+            or not hass.data[DATA_KNX].initialized:
+        return False
+
+    if discovery_info is not None:
+        async_add_devices_discovery(hass, discovery_info, async_add_devices)
+    else:
+        async_add_devices_config(hass, config, async_add_devices)
+
+    return True


-class KNXThermostat(KNXMultiAddressDevice, ClimateDevice):
-    """Representation of a KNX thermostat.
+@callback
+def async_add_devices_discovery(hass, discovery_info, async_add_devices):
+    """Set up climates for KNX platform configured within plattform."""
+    entities = []
+    for device_name in discovery_info[ATTR_DISCOVER_DEVICES]:
+        device = hass.data[DATA_KNX].xknx.devices[device_name]
+        entities.append(KNXClimate(hass, device))
+    async_add_devices(entities)

-    A KNX thermostat will has the following parameters:
-    - temperature (current temperature)
-    - setpoint (target temperature in HASS terms)
-    - operation mode selection (comfort/night/frost protection)

-    This version supports only polling. Messages from the KNX bus do not
-    automatically update the state of the thermostat (to be implemented
-    in future releases)
-    """
+@callback
+def async_add_devices_config(hass, config, async_add_devices):
+    """Set up climate for KNX platform configured within plattform."""
+    import xknx
+    climate = xknx.devices.Climate(
+        hass.data[DATA_KNX].xknx,
+        name=config.get(CONF_NAME),
+        group_address_temperature=config.get(
+            CONF_TEMPERATURE_ADDRESS),
+        group_address_target_temperature=config.get(
+            CONF_TARGET_TEMPERATURE_ADDRESS),
+        group_address_setpoint=config.get(
+            CONF_SETPOINT_ADDRESS),
+        group_address_setpoint_shift=config.get(
+            CONF_SETPOINT_SHIFT_ADDRESS),
+        group_address_setpoint_shift_state=config.get(
+            CONF_SETPOINT_SHIFT_STATE_ADDRESS),
+        group_address_operation_mode=config.get(
+            CONF_OPERATION_MODE_ADDRESS),
+        group_address_operation_mode_state=config.get(
+            CONF_OPERATION_MODE_STATE_ADDRESS),
+        group_address_controller_status=config.get(
+            CONF_CONTROLLER_STATUS_ADDRESS),
+        group_address_controller_status_state=config.get(
+            CONF_CONTROLLER_STATUS_STATE_ADDRESS),
+        group_address_operation_mode_protection=config.get(
+            CONF_OPERATION_MODE_FROST_PROTECTION_ADDRESS),
+        group_address_operation_mode_night=config.get(
+            CONF_OPERATION_MODE_NIGHT_ADDRESS),
+        group_address_operation_mode_comfort=config.get(
+            CONF_OPERATION_MODE_COMFORT_ADDRESS))
+    hass.data[DATA_KNX].xknx.devices.add(climate)
+    async_add_devices([KNXClimate(hass, climate)])

-    def __init__(self, hass, config):
-        """Initialize the thermostat based on the given configuration."""
-        KNXMultiAddressDevice.__init__(
-            self, hass, config, ['temperature', 'setpoint'], ['mode'])

-        self._unit_of_measurement = TEMP_CELSIUS  # KNX always used celsius
+class KNXClimate(ClimateDevice):
+    """Representation of a KNX climate."""
+
+    def __init__(self, hass, device):
+        """Initialization of KNXClimate."""
+        self.device = device
+        self.hass = hass
+        self.async_register_callbacks()
+
+        self._unit_of_measurement = TEMP_CELSIUS
        self._away = False  # not yet supported
        self._is_fan_on = False  # not yet supported
-        self._current_temp = None
-        self._target_temp = None
+
+    def async_register_callbacks(self):
+        """Register callbacks to update hass after device was changed."""
+        @asyncio.coroutine
+        def after_update_callback(device):
+            """Callback after device was updated."""
+            # pylint: disable=unused-argument
+            yield from self.async_update_ha_state()
+        self.device.register_device_updated_cb(after_update_callback)
+
+    @property
+    def name(self):
+        """Return the name of the KNX device."""
+        return self.device.name

    @property
    def should_poll(self):
-        """Return the polling state, is needed for the KNX thermostat."""
-        return True
+        """No polling needed within KNX."""
+        return False

    @property
    def temperature_unit(self):
@@ -72,32 +148,58 @@ class KNXThermostat(KNXMultiAddressDevice, ClimateDevice):
    @property
    def current_temperature(self):
        """Return the current temperature."""
-        return self._current_temp
+        return self.device.temperature.value

    @property
    def target_temperature(self):
        """Return the temperature we try to reach."""
-        return self._target_temp
+        return self.device.target_temperature_comfort

-    def set_temperature(self, **kwargs):
+    @property
+    def target_temperature_high(self):
+        """Return the highbound target temperature we try to reach."""
+        if self.device.target_temperature_comfort:
+            return max(
+                self.device.target_temperature_comfort,
+                self.device.target_temperature.value)
+        return None
+
+    @property
+    def target_temperature_low(self):
+        """Return the lowbound target temperature we try to reach."""
+        if self.device.target_temperature_comfort:
+            return min(
+                self.device.target_temperature_comfort,
+                self.device.target_temperature.value)
+        return None
+
+    @asyncio.coroutine
+    def async_set_temperature(self, **kwargs):
        """Set new target temperature."""
        temperature = kwargs.get(ATTR_TEMPERATURE)
        if temperature is None:
            return
-        from knxip.conversion import float_to_knx2
+        yield from self.device.set_target_temperature_comfort(temperature)
+        yield from self.async_update_ha_state()

-        self.set_value('setpoint', float_to_knx2(temperature))
-        _LOGGER.debug("Set target temperature to %s", temperature)
+    @property
+    def current_operation(self):
+        """Return current operation ie. heat, cool, idle."""
+        if self.device.supports_operation_mode:
+            return self.device.operation_mode.value
+        return None

-    def set_operation_mode(self, operation_mode):
+    @property
+    def operation_list(self):
+        """Return the list of available operation modes."""
+        return [operation_mode.value for
+                operation_mode in
+                self.device.get_supported_operation_modes()]
+
+    @asyncio.coroutine
+    def async_set_operation_mode(self, operation_mode):
        """Set operation mode."""
-        raise NotImplementedError()
-
-    def update(self):
-        """Update KNX climate."""
-        from knxip.conversion import knx2_to_float
-
-        super().update()
-
-        self._current_temp = knx2_to_float(self.value('temperature'))
-        self._target_temp = knx2_to_float(self.value('setpoint'))
+        if self.device.supports_operation_mode:
+            from xknx.knx import HVACOperationMode
+            knx_operation_mode = HVACOperationMode(operation_mode)
+            yield from self.device.set_operation_mode(knx_operation_mode)
--- a/homeassistant/components/climate/mqtt.py
+++ b/homeassistant/components/climate/mqtt.py
@@ -0,0 +1,485 @@
+"""
+Support for MQTT climate devices.
+
+For more details about this platform, please refer to the documentation
+https://home-assistant.io/components/climate.mqtt/
+"""
+import asyncio
+import logging
+
+import voluptuous as vol
+
+from homeassistant.core import callback
+import homeassistant.components.mqtt as mqtt
+
+from homeassistant.components.climate import (
+    STATE_HEAT, STATE_COOL, STATE_DRY, STATE_FAN_ONLY, ClimateDevice,
+    PLATFORM_SCHEMA as CLIMATE_PLATFORM_SCHEMA, STATE_AUTO,
+    ATTR_OPERATION_MODE)
+from homeassistant.const import (
+    STATE_ON, STATE_OFF, ATTR_TEMPERATURE, CONF_NAME)
+from homeassistant.components.mqtt import (CONF_QOS, CONF_RETAIN,
+                                           MQTT_BASE_PLATFORM_SCHEMA)
+import homeassistant.helpers.config_validation as cv
+from homeassistant.components.fan import (SPEED_LOW, SPEED_MEDIUM,
+                                          SPEED_HIGH)
+
+_LOGGER = logging.getLogger(__name__)
+
+DEPENDENCIES = ['mqtt']
+
+DEFAULT_NAME = 'MQTT HVAC'
+
+CONF_POWER_COMMAND_TOPIC = 'power_command_topic'
+CONF_POWER_STATE_TOPIC = 'power_state_topic'
+CONF_MODE_COMMAND_TOPIC = 'mode_command_topic'
+CONF_MODE_STATE_TOPIC = 'mode_state_topic'
+CONF_TEMPERATURE_COMMAND_TOPIC = 'temperature_command_topic'
+CONF_TEMPERATURE_STATE_TOPIC = 'temperature_state_topic'
+CONF_FAN_MODE_COMMAND_TOPIC = 'fan_mode_command_topic'
+CONF_FAN_MODE_STATE_TOPIC = 'fan_mode_state_topic'
+CONF_SWING_MODE_COMMAND_TOPIC = 'swing_mode_command_topic'
+CONF_SWING_MODE_STATE_TOPIC = 'swing_mode_state_topic'
+CONF_AWAY_MODE_COMMAND_TOPIC = 'away_mode_command_topic'
+CONF_AWAY_MODE_STATE_TOPIC = 'away_mode_state_topic'
+CONF_HOLD_COMMAND_TOPIC = 'hold_command_topic'
+CONF_HOLD_STATE_TOPIC = 'hold_state_topic'
+CONF_AUX_COMMAND_TOPIC = 'aux_command_topic'
+CONF_AUX_STATE_TOPIC = 'aux_state_topic'
+
+CONF_CURRENT_TEMPERATURE_TOPIC = 'current_temperature_topic'
+
+CONF_PAYLOAD_ON = 'payload_on'
+CONF_PAYLOAD_OFF = 'payload_off'
+
+CONF_FAN_MODE_LIST = 'fan_modes'
+CONF_MODE_LIST = 'modes'
+CONF_SWING_MODE_LIST = 'swing_modes'
+CONF_INITIAL = 'initial'
+CONF_SEND_IF_OFF = 'send_if_off'
+
+SCHEMA_BASE = CLIMATE_PLATFORM_SCHEMA.extend(MQTT_BASE_PLATFORM_SCHEMA.schema)
+PLATFORM_SCHEMA = SCHEMA_BASE.extend({
+    vol.Optional(CONF_POWER_COMMAND_TOPIC): mqtt.valid_publish_topic,
+    vol.Optional(CONF_MODE_COMMAND_TOPIC): mqtt.valid_publish_topic,
+    vol.Optional(CONF_TEMPERATURE_COMMAND_TOPIC): mqtt.valid_publish_topic,
+    vol.Optional(CONF_FAN_MODE_COMMAND_TOPIC): mqtt.valid_publish_topic,
+    vol.Optional(CONF_SWING_MODE_COMMAND_TOPIC): mqtt.valid_publish_topic,
+    vol.Optional(CONF_AWAY_MODE_COMMAND_TOPIC): mqtt.valid_publish_topic,
+    vol.Optional(CONF_HOLD_COMMAND_TOPIC): mqtt.valid_publish_topic,
+    vol.Optional(CONF_AUX_COMMAND_TOPIC): mqtt.valid_publish_topic,
+    vol.Optional(CONF_POWER_STATE_TOPIC): mqtt.valid_subscribe_topic,
+    vol.Optional(CONF_MODE_STATE_TOPIC): mqtt.valid_subscribe_topic,
+    vol.Optional(CONF_TEMPERATURE_STATE_TOPIC): mqtt.valid_subscribe_topic,
+    vol.Optional(CONF_FAN_MODE_STATE_TOPIC): mqtt.valid_subscribe_topic,
+    vol.Optional(CONF_SWING_MODE_STATE_TOPIC): mqtt.valid_subscribe_topic,
+    vol.Optional(CONF_AWAY_MODE_STATE_TOPIC): mqtt.valid_subscribe_topic,
+    vol.Optional(CONF_HOLD_STATE_TOPIC): mqtt.valid_subscribe_topic,
+    vol.Optional(CONF_AUX_STATE_TOPIC): mqtt.valid_subscribe_topic,
+    vol.Optional(CONF_CURRENT_TEMPERATURE_TOPIC):
+        mqtt.valid_subscribe_topic,
+    vol.Optional(CONF_FAN_MODE_LIST,
+                 default=[STATE_AUTO, SPEED_LOW,
+                          SPEED_MEDIUM, SPEED_HIGH]): cv.ensure_list,
+    vol.Optional(CONF_SWING_MODE_LIST,
+                 default=[STATE_ON, STATE_OFF]): cv.ensure_list,
+    vol.Optional(CONF_MODE_LIST,
+                 default=[STATE_AUTO, STATE_OFF, STATE_COOL, STATE_HEAT,
+                          STATE_DRY, STATE_FAN_ONLY]): cv.ensure_list,
+    vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
+    vol.Optional(CONF_INITIAL, default=21): cv.positive_int,
+    vol.Optional(CONF_SEND_IF_OFF, default=True): cv.boolean,
+    vol.Optional(CONF_PAYLOAD_ON, default="ON"): cv.string,
+    vol.Optional(CONF_PAYLOAD_OFF, default="OFF"): cv.string,
+})
+
+
+@asyncio.coroutine
+def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
+    """Set up the MQTT climate devices."""
+    async_add_devices([
+        MqttClimate(
+            hass,
+            config.get(CONF_NAME),
+            {
+                key: config.get(key) for key in (
+                    CONF_POWER_COMMAND_TOPIC,
+                    CONF_MODE_COMMAND_TOPIC,
+                    CONF_TEMPERATURE_COMMAND_TOPIC,
+                    CONF_FAN_MODE_COMMAND_TOPIC,
+                    CONF_SWING_MODE_COMMAND_TOPIC,
+                    CONF_AWAY_MODE_COMMAND_TOPIC,
+                    CONF_HOLD_COMMAND_TOPIC,
+                    CONF_AUX_COMMAND_TOPIC,
+                    CONF_POWER_STATE_TOPIC,
+                    CONF_MODE_STATE_TOPIC,
+                    CONF_TEMPERATURE_STATE_TOPIC,
+                    CONF_FAN_MODE_STATE_TOPIC,
+                    CONF_SWING_MODE_STATE_TOPIC,
+                    CONF_AWAY_MODE_STATE_TOPIC,
+                    CONF_HOLD_STATE_TOPIC,
+                    CONF_AUX_STATE_TOPIC,
+                    CONF_CURRENT_TEMPERATURE_TOPIC
+                )
+            },
+            config.get(CONF_QOS),
+            config.get(CONF_RETAIN),
+            config.get(CONF_MODE_LIST),
+            config.get(CONF_FAN_MODE_LIST),
+            config.get(CONF_SWING_MODE_LIST),
+            config.get(CONF_INITIAL),
+            False, None, SPEED_LOW,
+            STATE_OFF, STATE_OFF, False,
+            config.get(CONF_SEND_IF_OFF),
+            config.get(CONF_PAYLOAD_ON),
+            config.get(CONF_PAYLOAD_OFF))
+    ])
+
+
+class MqttClimate(ClimateDevice):
+    """Representation of a demo climate device."""
+
+    def __init__(self, hass, name, topic, qos, retain, mode_list,
+                 fan_mode_list, swing_mode_list, target_temperature, away,
+                 hold, current_fan_mode, current_swing_mode,
+                 current_operation, aux, send_if_off, payload_on,
+                 payload_off):
+        """Initialize the climate device."""
+        self.hass = hass
+        self._name = name
+        self._topic = topic
+        self._qos = qos
+        self._retain = retain
+        self._target_temperature = target_temperature
+        self._unit_of_measurement = hass.config.units.temperature_unit
+        self._away = away
+        self._hold = hold
+        self._current_temperature = None
+        self._current_fan_mode = current_fan_mode
+        self._current_operation = current_operation
+        self._aux = aux
+        self._current_swing_mode = current_swing_mode
+        self._fan_list = fan_mode_list
+        self._operation_list = mode_list
+        self._swing_list = swing_mode_list
+        self._target_temperature_step = 1
+        self._send_if_off = send_if_off
+        self._payload_on = payload_on
+        self._payload_off = payload_off
+
+    def async_added_to_hass(self):
+        """Handle being added to home assistant."""
+        @callback
+        def handle_current_temp_received(topic, payload, qos):
+            """Handle current temperature coming via MQTT."""
+            try:
+                self._current_temperature = float(payload)
+                self.async_schedule_update_ha_state()
+            except ValueError:
+                _LOGGER.error("Could not parse temperature from %s", payload)
+
+        if self._topic[CONF_CURRENT_TEMPERATURE_TOPIC] is not None:
+            yield from mqtt.async_subscribe(
+                self.hass, self._topic[CONF_CURRENT_TEMPERATURE_TOPIC],
+                handle_current_temp_received, self._qos)
+
+        @callback
+        def handle_mode_received(topic, payload, qos):
+            """Handle receiving mode via MQTT."""
+            if payload not in self._operation_list:
+                _LOGGER.error("Invalid mode: %s", payload)
+            else:
+                self._current_operation = payload
+                self.async_schedule_update_ha_state()
+
+        if self._topic[CONF_MODE_STATE_TOPIC] is not None:
+            yield from mqtt.async_subscribe(
+                self.hass, self._topic[CONF_MODE_STATE_TOPIC],
+                handle_mode_received, self._qos)
+
+        @callback
+        def handle_temperature_received(topic, payload, qos):
+            """Handle target temperature coming via MQTT."""
+            try:
+                self._target_temperature = float(payload)
+                self.async_schedule_update_ha_state()
+            except ValueError:
+                _LOGGER.error("Could not parse temperature from %s", payload)
+
+        if self._topic[CONF_TEMPERATURE_STATE_TOPIC] is not None:
+            yield from mqtt.async_subscribe(
+                self.hass, self._topic[CONF_TEMPERATURE_STATE_TOPIC],
+                handle_temperature_received, self._qos)
+
+        @callback
+        def handle_fan_mode_received(topic, payload, qos):
+            """Handle receiving fan mode via MQTT."""
+            if payload not in self._fan_list:
+                _LOGGER.error("Invalid fan mode: %s", payload)
+            else:
+                self._current_fan_mode = payload
+                self.async_schedule_update_ha_state()
+
+        if self._topic[CONF_FAN_MODE_STATE_TOPIC] is not None:
+            yield from mqtt.async_subscribe(
+                self.hass, self._topic[CONF_FAN_MODE_STATE_TOPIC],
+                handle_fan_mode_received, self._qos)
+
+        @callback
+        def handle_swing_mode_received(topic, payload, qos):
+            """Handle receiving swing mode via MQTT."""
+            if payload not in self._swing_list:
+                _LOGGER.error("Invalid swing mode: %s", payload)
+            else:
+                self._current_swing_mode = payload
+                self.async_schedule_update_ha_state()
+
+        if self._topic[CONF_SWING_MODE_STATE_TOPIC] is not None:
+            yield from mqtt.async_subscribe(
+                self.hass, self._topic[CONF_SWING_MODE_STATE_TOPIC],
+                handle_swing_mode_received, self._qos)
+
+        @callback
+        def handle_away_mode_received(topic, payload, qos):
+            """Handle receiving away mode via MQTT."""
+            if payload == self._payload_on:
+                self._away = True
+            elif payload == self._payload_off:
+                self._away = False
+            else:
+                _LOGGER.error("Invalid away mode: %s", payload)
+
+            self.async_schedule_update_ha_state()
+
+        if self._topic[CONF_AWAY_MODE_STATE_TOPIC] is not None:
+            yield from mqtt.async_subscribe(
+                self.hass, self._topic[CONF_AWAY_MODE_STATE_TOPIC],
+                handle_away_mode_received, self._qos)
+
+        @callback
+        def handle_aux_mode_received(topic, payload, qos):
+            """Handle receiving aux mode via MQTT."""
+            if payload == self._payload_on:
+                self._aux = True
+            elif payload == self._payload_off:
+                self._aux = False
+            else:
+                _LOGGER.error("Invalid aux mode: %s", payload)
+
+            self.async_schedule_update_ha_state()
+
+        if self._topic[CONF_AUX_STATE_TOPIC] is not None:
+            yield from mqtt.async_subscribe(
+                self.hass, self._topic[CONF_AUX_STATE_TOPIC],
+                handle_aux_mode_received, self._qos)
+
+        @callback
+        def handle_hold_mode_received(topic, payload, qos):
+            """Handle receiving hold mode via MQTT."""
+            self._hold = payload
+            self.async_schedule_update_ha_state()
+
+        if self._topic[CONF_HOLD_STATE_TOPIC] is not None:
+            yield from mqtt.async_subscribe(
+                self.hass, self._topic[CONF_HOLD_STATE_TOPIC],
+                handle_hold_mode_received, self._qos)
+
+    @property
+    def should_poll(self):
+        """Return the polling state."""
+        return False
+
+    @property
+    def name(self):
+        """Return the name of the climate device."""
+        return self._name
+
+    @property
+    def temperature_unit(self):
+        """Return the unit of measurement."""
+        return self._unit_of_measurement
+
+    @property
+    def current_temperature(self):
+        """Return the current temperature."""
+        return self._current_temperature
+
+    @property
+    def target_temperature(self):
+        """Return the temperature we try to reach."""
+        return self._target_temperature
+
+    @property
+    def current_operation(self):
+        """Return current operation ie. heat, cool, idle."""
+        return self._current_operation
+
+    @property
+    def operation_list(self):
+        """Return the list of available operation modes."""
+        return self._operation_list
+
+    @property
+    def target_temperature_step(self):
+        """Return the supported step of target temperature."""
+        return self._target_temperature_step
+
+    @property
+    def is_away_mode_on(self):
+        """Return if away mode is on."""
+        return self._away
+
+    @property
+    def current_hold_mode(self):
+        """Return hold mode setting."""
+        return self._hold
+
+    @property
+    def is_aux_heat_on(self):
+        """Return true if away mode is on."""
+        return self._aux
+
+    @property
+    def current_fan_mode(self):
+        """Return the fan setting."""
+        return self._current_fan_mode
+
+    @property
+    def fan_list(self):
+        """Return the list of available fan modes."""
+        return self._fan_list
+
+    @asyncio.coroutine
+    def async_set_temperature(self, **kwargs):
+        """Set new target temperatures."""
+        if kwargs.get(ATTR_OPERATION_MODE) is not None:
+            operation_mode = kwargs.get(ATTR_OPERATION_MODE)
+            yield from self.async_set_operation_mode(operation_mode)
+
+        if kwargs.get(ATTR_TEMPERATURE) is not None:
+            if self._topic[CONF_TEMPERATURE_STATE_TOPIC] is None:
+                # optimistic mode
+                self._target_temperature = kwargs.get(ATTR_TEMPERATURE)
+
+            if self._send_if_off or self._current_operation != STATE_OFF:
+                mqtt.async_publish(
+                    self.hass, self._topic[CONF_TEMPERATURE_COMMAND_TOPIC],
+                    kwargs.get(ATTR_TEMPERATURE), self._qos, self._retain)
+
+        self.async_schedule_update_ha_state()
+
+    @asyncio.coroutine
+    def async_set_swing_mode(self, swing_mode):
+        """Set new swing mode."""
+        if self._send_if_off or self._current_operation != STATE_OFF:
+            mqtt.async_publish(
+                self.hass, self._topic[CONF_SWING_MODE_COMMAND_TOPIC],
+                swing_mode, self._qos, self._retain)
+
+        if self._topic[CONF_SWING_MODE_STATE_TOPIC] is None:
+            self._current_swing_mode = swing_mode
+            self.async_schedule_update_ha_state()
+
+    @asyncio.coroutine
+    def async_set_fan_mode(self, fan):
+        """Set new target temperature."""
+        if self._send_if_off or self._current_operation != STATE_OFF:
+            mqtt.async_publish(
+                self.hass, self._topic[CONF_FAN_MODE_COMMAND_TOPIC],
+                fan, self._qos, self._retain)
+
+        if self._topic[CONF_FAN_MODE_STATE_TOPIC] is None:
+            self._current_fan_mode = fan
+            self.async_schedule_update_ha_state()
+
+    @asyncio.coroutine
+    def async_set_operation_mode(self, operation_mode) -> None:
+        """Set new operation mode."""
+        if self._topic[CONF_POWER_COMMAND_TOPIC] is not None:
+            if (self._current_operation == STATE_OFF and
+                    operation_mode != STATE_OFF):
+                mqtt.async_publish(
+                    self.hass, self._topic[CONF_POWER_COMMAND_TOPIC],
+                    self._payload_on, self._qos, self._retain)
+            elif (self._current_operation != STATE_OFF and
+                  operation_mode == STATE_OFF):
+                mqtt.async_publish(
+                    self.hass, self._topic[CONF_POWER_COMMAND_TOPIC],
+                    self._payload_off, self._qos, self._retain)
+
+        if self._topic[CONF_MODE_COMMAND_TOPIC] is not None:
+            mqtt.async_publish(
+                self.hass, self._topic[CONF_MODE_COMMAND_TOPIC],
+                operation_mode, self._qos, self._retain)
+
+        if self._topic[CONF_MODE_STATE_TOPIC] is None:
+            self._current_operation = operation_mode
+            self.async_schedule_update_ha_state()
+
+    @property
+    def current_swing_mode(self):
+        """Return the swing setting."""
+        return self._current_swing_mode
+
+    @property
+    def swing_list(self):
+        """List of available swing modes."""
+        return self._swing_list
+
+    @asyncio.coroutine
+    def async_turn_away_mode_on(self):
+        """Turn away mode on."""
+        if self._topic[CONF_AWAY_MODE_COMMAND_TOPIC] is not None:
+            mqtt.async_publish(self.hass,
+                               self._topic[CONF_AWAY_MODE_COMMAND_TOPIC],
+                               self._payload_on, self._qos, self._retain)
+
+        if self._topic[CONF_AWAY_MODE_STATE_TOPIC] is None:
+            self._away = True
+            self.async_schedule_update_ha_state()
+
+    @asyncio.coroutine
+    def async_turn_away_mode_off(self):
+        """Turn away mode off."""
+        if self._topic[CONF_AWAY_MODE_COMMAND_TOPIC] is not None:
+            mqtt.async_publish(self.hass,
+                               self._topic[CONF_AWAY_MODE_COMMAND_TOPIC],
+                               self._payload_off, self._qos, self._retain)
+
+        if self._topic[CONF_AWAY_MODE_STATE_TOPIC] is None:
+            self._away = False
+            self.async_schedule_update_ha_state()
+
+    @asyncio.coroutine
+    def async_set_hold_mode(self, hold):
+        """Update hold mode on."""
+        if self._topic[CONF_HOLD_COMMAND_TOPIC] is not None:
+            mqtt.async_publish(self.hass,
+                               self._topic[CONF_HOLD_COMMAND_TOPIC],
+                               hold, self._qos, self._retain)
+
+        if self._topic[CONF_HOLD_STATE_TOPIC] is None:
+            self._hold = hold
+            self.async_schedule_update_ha_state()
+
+    @asyncio.coroutine
+    def async_turn_aux_heat_on(self):
+        """Turn auxillary heater on."""
+        if self._topic[CONF_AUX_COMMAND_TOPIC] is not None:
+            mqtt.async_publish(self.hass, self._topic[CONF_AUX_COMMAND_TOPIC],
+                               self._payload_on, self._qos, self._retain)
+
+        if self._topic[CONF_AUX_STATE_TOPIC] is None:
+            self._aux = True
+            self.async_schedule_update_ha_state()
+
+    @asyncio.coroutine
+    def async_turn_aux_heat_off(self):
+        """Turn auxillary heater off."""
+        if self._topic[CONF_AUX_COMMAND_TOPIC] is not None:
+            mqtt.async_publish(self.hass, self._topic[CONF_AUX_COMMAND_TOPIC],
+                               self._payload_off, self._qos, self._retain)
+
+        if self._topic[CONF_AUX_STATE_TOPIC] is None:
+            self._aux = False
+            self.async_schedule_update_ha_state()
--- a/homeassistant/components/climate/mysensors.py
+++ b/homeassistant/components/climate/mysensors.py
@@ -4,15 +4,11 @@ MySensors platform that offers a Climate (MySensors-HVAC) component.
 For more details about this platform, please refer to the documentation
 https://home-assistant.io/components/climate.mysensors/
 """
-import logging
-
 from homeassistant.components import mysensors
 from homeassistant.components.climate import (
-    STATE_COOL, STATE_HEAT, STATE_OFF, STATE_AUTO, ClimateDevice,
-    ATTR_TARGET_TEMP_HIGH, ATTR_TARGET_TEMP_LOW)
-from homeassistant.const import TEMP_CELSIUS, TEMP_FAHRENHEIT, ATTR_TEMPERATURE
-
-_LOGGER = logging.getLogger(__name__)
+    ATTR_TARGET_TEMP_HIGH, ATTR_TARGET_TEMP_LOW, DOMAIN, STATE_AUTO,
+    STATE_COOL, STATE_HEAT, STATE_OFF, ClimateDevice)
+from homeassistant.const import ATTR_TEMPERATURE, TEMP_CELSIUS, TEMP_FAHRENHEIT

 DICT_HA_TO_MYS = {
    STATE_AUTO: 'AutoChangeOver',
@@ -29,28 +25,12 @@ DICT_MYS_TO_HA = {


 def setup_platform(hass, config, add_devices, discovery_info=None):
-    """Set up the mysensors climate."""
-    if discovery_info is None:
-        return
-
-    gateways = hass.data.get(mysensors.MYSENSORS_GATEWAYS)
-    if not gateways:
-        return
-
-    for gateway in gateways:
-        if float(gateway.protocol_version) < 1.5:
-            continue
-        pres = gateway.const.Presentation
-        set_req = gateway.const.SetReq
-        map_sv_types = {
-            pres.S_HVAC: [set_req.V_HVAC_FLOW_STATE],
-        }
-        devices = {}
-        gateway.platform_callbacks.append(mysensors.pf_callback_factory(
-            map_sv_types, devices, MySensorsHVAC, add_devices))
+    """Setup the mysensors climate."""
+    mysensors.setup_mysensors_platform(
+        hass, DOMAIN, discovery_info, MySensorsHVAC, add_devices=add_devices)


-class MySensorsHVAC(mysensors.MySensorsDeviceEntity, ClimateDevice):
+class MySensorsHVAC(mysensors.MySensorsEntity, ClimateDevice):
    """Representation of a MySensors HVAC."""

    @property
@@ -84,26 +64,28 @@ class MySensorsHVAC(mysensors.MySensorsDeviceEntity, ClimateDevice):
        temp = self._values.get(set_req.V_HVAC_SETPOINT_COOL)
        if temp is None:
            temp = self._values.get(set_req.V_HVAC_SETPOINT_HEAT)
-        return float(temp)
+        return float(temp) if temp is not None else None

    @property
    def target_temperature_high(self):
        """Return the highbound target temperature we try to reach."""
        set_req = self.gateway.const.SetReq
        if set_req.V_HVAC_SETPOINT_HEAT in self._values:
-            return float(self._values.get(set_req.V_HVAC_SETPOINT_COOL))
+            temp = self._values.get(set_req.V_HVAC_SETPOINT_COOL)
+            return float(temp) if temp is not None else None

    @property
    def target_temperature_low(self):
        """Return the lowbound target temperature we try to reach."""
        set_req = self.gateway.const.SetReq
        if set_req.V_HVAC_SETPOINT_COOL in self._values:
-            return float(self._values.get(set_req.V_HVAC_SETPOINT_HEAT))
+            temp = self._values.get(set_req.V_HVAC_SETPOINT_HEAT)
+            return float(temp) if temp is not None else None

    @property
    def current_operation(self):
        """Return current operation ie. heat, cool, idle."""
-        return self._values.get(self.gateway.const.SetReq.V_HVAC_FLOW_STATE)
+        return self._values.get(self.value_type)

    @property
    def operation_list(self):
@@ -128,7 +110,7 @@ class MySensorsHVAC(mysensors.MySensorsDeviceEntity, ClimateDevice):
        high = kwargs.get(ATTR_TARGET_TEMP_HIGH)
        heat = self._values.get(set_req.V_HVAC_SETPOINT_HEAT)
        cool = self._values.get(set_req.V_HVAC_SETPOINT_COOL)
-        updates = ()
+        updates = []
        if temp is not None:
            if heat is not None:
                # Set HEAT Target temperature
@@ -146,7 +128,7 @@ class MySensorsHVAC(mysensors.MySensorsDeviceEntity, ClimateDevice):
            self.gateway.set_child_value(
                self.node_id, self.child_id, value_type, value)
            if self.gateway.optimistic:
-                # optimistically assume that switch has changed state
+                # optimistically assume that device has changed state
                self._values[value_type] = value
                self.schedule_update_ha_state()

@@ -156,54 +138,22 @@ class MySensorsHVAC(mysensors.MySensorsDeviceEntity, ClimateDevice):
        self.gateway.set_child_value(
            self.node_id, self.child_id, set_req.V_HVAC_SPEED, fan)
        if self.gateway.optimistic:
-            # optimistically assume that switch has changed state
+            # optimistically assume that device has changed state
            self._values[set_req.V_HVAC_SPEED] = fan
            self.schedule_update_ha_state()

    def set_operation_mode(self, operation_mode):
        """Set new target temperature."""
-        set_req = self.gateway.const.SetReq
        self.gateway.set_child_value(
-            self.node_id, self.child_id, set_req.V_HVAC_FLOW_STATE,
+            self.node_id, self.child_id, self.value_type,
            DICT_HA_TO_MYS[operation_mode])
        if self.gateway.optimistic:
-            # optimistically assume that switch has changed state
-            self._values[set_req.V_HVAC_FLOW_STATE] = operation_mode
+            # optimistically assume that device has changed state
+            self._values[self.value_type] = operation_mode
            self.schedule_update_ha_state()

    def update(self):
        """Update the controller with the latest value from a sensor."""
-        set_req = self.gateway.const.SetReq
-        node = self.gateway.sensors[self.node_id]
-        child = node.children[self.child_id]
-        for value_type, value in child.values.items():
-            _LOGGER.debug(
-                "%s: value_type %s, value = %s", self._name, value_type, value)
-            if value_type == set_req.V_HVAC_FLOW_STATE:
-                self._values[value_type] = DICT_MYS_TO_HA[value]
-            else:
-                self._values[value_type] = value
-
-    def set_humidity(self, humidity):
-        """Set new target humidity."""
-        _LOGGER.error("Service Not Implemented yet")
-
-    def set_swing_mode(self, swing_mode):
-        """Set new target swing operation."""
-        _LOGGER.error("Service Not Implemented yet")
-
-    def turn_away_mode_on(self):
-        """Turn away mode on."""
-        _LOGGER.error("Service Not Implemented yet")
-
-    def turn_away_mode_off(self):
-        """Turn away mode off."""
-        _LOGGER.error("Service Not Implemented yet")
-
-    def turn_aux_heat_on(self):
-        """Turn auxillary heater on."""
-        _LOGGER.error("Service Not Implemented yet")
-
-    def turn_aux_heat_off(self):
-        """Turn auxillary heater off."""
-        _LOGGER.error("Service Not Implemented yet")
+        super().update()
+        self._values[self.value_type] = DICT_MYS_TO_HA[
+            self._values[self.value_type]]
--- a/homeassistant/components/climate/services.yaml
+++ b/homeassistant/components/climate/services.yaml
@@ -1,5 +1,5 @@
 set_aux_heat:
-  description: Turn auxillary heater on/off for climate device
+  description: Turn auxiliary heater on/off for climate device

  fields:
    entity_id:
@@ -101,11 +101,11 @@ set_swing_mode:
  fields:
    entity_id:
      description: Name(s) of entities to change
-      example: '.nest'
+      example: 'climate.nest'

    swing_mode:
-    description: New value of swing mode
-    example: 1
+      description: New value of swing mode
+      example: 1

 ecobee_set_fan_min_on_time:
  description: Set the minimum fan on time
--- a/homeassistant/components/climate/tesla.py
+++ b/homeassistant/components/climate/tesla.py
@@ -0,0 +1,92 @@
+"""
+Support for Tesla HVAC system.
+
+For more details about this platform, please refer to the documentation
+https://home-assistant.io/components/climate.tesla/
+"""
+import logging
+
+from homeassistant.const import STATE_ON, STATE_OFF
+from homeassistant.components.climate import ClimateDevice, ENTITY_ID_FORMAT
+from homeassistant.components.tesla import DOMAIN as TESLA_DOMAIN, TeslaDevice
+from homeassistant.const import (
+    TEMP_FAHRENHEIT, TEMP_CELSIUS, ATTR_TEMPERATURE)
+
+_LOGGER = logging.getLogger(__name__)
+
+DEPENDENCIES = ['tesla']
+
+OPERATION_LIST = [STATE_ON, STATE_OFF]
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Set up the Tesla climate platform."""
+    devices = [TeslaThermostat(device, hass.data[TESLA_DOMAIN]['controller'])
+               for device in hass.data[TESLA_DOMAIN]['devices']['climate']]
+    add_devices(devices, True)
+
+
+class TeslaThermostat(TeslaDevice, ClimateDevice):
+    """Representation of a Tesla climate."""
+
+    def __init__(self, tesla_device, controller):
+        """Initialize the Tesla device."""
+        super().__init__(tesla_device, controller)
+        self.entity_id = ENTITY_ID_FORMAT.format(self.tesla_id)
+        self._target_temperature = None
+        self._temperature = None
+
+    @property
+    def current_operation(self):
+        """Return current operation ie. On or Off."""
+        mode = self.tesla_device.is_hvac_enabled()
+        if mode:
+            return OPERATION_LIST[0]  # On
+        else:
+            return OPERATION_LIST[1]  # Off
+
+    @property
+    def operation_list(self):
+        """List of available operation modes."""
+        return OPERATION_LIST
+
+    def update(self):
+        """Called by the Tesla device callback to update state."""
+        _LOGGER.debug("Updating: %s", self._name)
+        self.tesla_device.update()
+        self._target_temperature = self.tesla_device.get_goal_temp()
+        self._temperature = self.tesla_device.get_current_temp()
+
+    @property
+    def temperature_unit(self):
+        """Return the unit of measurement."""
+        tesla_temp_units = self.tesla_device.measurement
+
+        if tesla_temp_units == 'F':
+            return TEMP_FAHRENHEIT
+        return TEMP_CELSIUS
+
+    @property
+    def current_temperature(self):
+        """Return the current temperature."""
+        return self._temperature
+
+    @property
+    def target_temperature(self):
+        """Return the temperature we try to reach."""
+        return self._target_temperature
+
+    def set_temperature(self, **kwargs):
+        """Set new target temperatures."""
+        _LOGGER.debug("Setting temperature for: %s", self._name)
+        temperature = kwargs.get(ATTR_TEMPERATURE)
+        if temperature:
+            self.tesla_device.set_temperature(temperature)
+
+    def set_operation_mode(self, operation_mode):
+        """Set HVAC mode (auto, cool, heat, off)."""
+        _LOGGER.debug("Setting mode for: %s", self._name)
+        if operation_mode == OPERATION_LIST[1]:  # off
+            self.tesla_device.set_status(False)
+        elif operation_mode == OPERATION_LIST[0]:  # heat
+            self.tesla_device.set_status(True)
--- a/homeassistant/components/climate/toon.py
+++ b/homeassistant/components/climate/toon.py
@@ -0,0 +1,95 @@
+"""
+Toon van Eneco Thermostat Support.
+
+This provides a component for the rebranded Quby thermostat as provided by
+Eneco.
+"""
+
+from homeassistant.components.climate import (ClimateDevice,
+                                              ATTR_TEMPERATURE,
+                                              STATE_PERFORMANCE,
+                                              STATE_HEAT,
+                                              STATE_ECO,
+                                              STATE_COOL)
+from homeassistant.const import TEMP_CELSIUS
+
+import homeassistant.components.toon as toon_main
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Setup thermostat."""
+    # Add toon
+    add_devices((ThermostatDevice(hass), ), True)
+
+
+class ThermostatDevice(ClimateDevice):
+    """Interface class for the toon module and HA."""
+
+    def __init__(self, hass):
+        """Initialize the device."""
+        self._name = 'Toon van Eneco'
+        self.hass = hass
+        self.thermos = hass.data[toon_main.TOON_HANDLE]
+
+        # set up internal state vars
+        self._state = None
+        self._temperature = None
+        self._setpoint = None
+        self._operation_list = [STATE_PERFORMANCE,
+                                STATE_HEAT,
+                                STATE_ECO,
+                                STATE_COOL]
+
+    @property
+    def name(self):
+        """Name of this Thermostat."""
+        return self._name
+
+    @property
+    def should_poll(self):
+        """Polling is required."""
+        return True
+
+    @property
+    def temperature_unit(self):
+        """The unit of measurement used by the platform."""
+        return TEMP_CELSIUS
+
+    @property
+    def current_operation(self):
+        """Return current operation i.e. comfort, home, away."""
+        state = self.thermos.get_data('state')
+        return state
+
+    @property
+    def operation_list(self):
+        """List of available operation modes."""
+        return self._operation_list
+
+    @property
+    def current_temperature(self):
+        """Return the current temperature."""
+        return self.thermos.get_data('temp')
+
+    @property
+    def target_temperature(self):
+        """Return the temperature we try to reach."""
+        return self.thermos.get_data('setpoint')
+
+    def set_temperature(self, **kwargs):
+        """Change the setpoint of the thermostat."""
+        temp = kwargs.get(ATTR_TEMPERATURE)
+        self.thermos.set_temp(temp)
+
+    def set_operation_mode(self, operation_mode):
+        """Set new operation mode as toonlib requires it."""
+        toonlib_values = {STATE_PERFORMANCE: 'Comfort',
+                          STATE_HEAT: 'Home',
+                          STATE_ECO: 'Away',
+                          STATE_COOL: 'Sleep'}
+
+        self.thermos.set_state(toonlib_values[operation_mode])
+
+    def update(self):
+        """Update local state."""
+        self.thermos.update()
--- a/homeassistant/components/climate/wink.py
+++ b/homeassistant/components/climate/wink.py
@@ -1,30 +1,45 @@
 """
-Support for Wink thermostats.
+Support for Wink thermostats, Air Conditioners, and Water Heaters.

 For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/climate.wink/
 """
+import logging
 import asyncio

 from homeassistant.components.wink import WinkDevice, DOMAIN
 from homeassistant.components.climate import (
    STATE_AUTO, STATE_COOL, STATE_HEAT, ClimateDevice,
    ATTR_TARGET_TEMP_HIGH, ATTR_TARGET_TEMP_LOW,
-    ATTR_TEMPERATURE,
-    ATTR_CURRENT_HUMIDITY)
+    ATTR_TEMPERATURE, STATE_FAN_ONLY,
+    ATTR_CURRENT_HUMIDITY, STATE_ECO, STATE_ELECTRIC,
+    STATE_PERFORMANCE, STATE_HIGH_DEMAND,
+    STATE_HEAT_PUMP, STATE_GAS)
 from homeassistant.const import (
    TEMP_CELSIUS, STATE_ON,
    STATE_OFF, STATE_UNKNOWN)

+_LOGGER = logging.getLogger(__name__)
+
 DEPENDENCIES = ['wink']

-STATE_AUX = 'aux'
-STATE_ECO = 'eco'
-STATE_FAN = 'fan'
 SPEED_LOW = 'low'
 SPEED_MEDIUM = 'medium'
 SPEED_HIGH = 'high'

+HA_STATE_TO_WINK = {STATE_AUTO: 'auto',
+                    STATE_ECO: 'eco',
+                    STATE_FAN_ONLY: 'fan_only',
+                    STATE_HEAT: 'heat_only',
+                    STATE_COOL: 'cool_only',
+                    STATE_PERFORMANCE: 'performance',
+                    STATE_HIGH_DEMAND: 'high_demand',
+                    STATE_HEAT_PUMP: 'heat_pump',
+                    STATE_ELECTRIC: 'electric_only',
+                    STATE_GAS: 'gas',
+                    STATE_OFF: 'off'}
+WINK_STATE_TO_HA = {value: key for key, value in HA_STATE_TO_WINK.items()}
+
 ATTR_EXTERNAL_TEMPERATURE = "external_temperature"
 ATTR_SMART_TEMPERATURE = "smart_temperature"
 ATTR_ECO_TARGET = "eco_target"
@@ -32,28 +47,26 @@ ATTR_OCCUPIED = "occupied"


 def setup_platform(hass, config, add_devices, discovery_info=None):
-    """Set up the Wink thermostat."""
+    """Set up the Wink climate devices."""
    import pywink
-    temp_unit = hass.config.units.temperature_unit
    for climate in pywink.get_thermostats():
        _id = climate.object_id() + climate.name()
        if _id not in hass.data[DOMAIN]['unique_ids']:
-            add_devices([WinkThermostat(climate, hass, temp_unit)])
+            add_devices([WinkThermostat(climate, hass)])
    for climate in pywink.get_air_conditioners():
        _id = climate.object_id() + climate.name()
        if _id not in hass.data[DOMAIN]['unique_ids']:
-            add_devices([WinkAC(climate, hass, temp_unit)])
+            add_devices([WinkAC(climate, hass)])
+    for water_heater in pywink.get_water_heaters():
+        _id = water_heater.object_id() + water_heater.name()
+        if _id not in hass.data[DOMAIN]['unique_ids']:
+            add_devices([WinkWaterHeater(water_heater, hass)])


 # pylint: disable=abstract-method
 class WinkThermostat(WinkDevice, ClimateDevice):
    """Representation of a Wink thermostat."""

-    def __init__(self, wink, hass, temp_unit):
-        """Initialize the Wink device."""
-        super().__init__(wink, hass)
-        self._config_temp_unit = temp_unit
-
    @asyncio.coroutine
    def async_added_to_hass(self):
        """Callback when entity is added to hass."""
@@ -139,18 +152,12 @@ class WinkThermostat(WinkDevice, ClimateDevice):
        """Return current operation ie. heat, cool, idle."""
        if not self.wink.is_on():
            current_op = STATE_OFF
-        elif self.wink.current_hvac_mode() == 'cool_only':
-            current_op = STATE_COOL
-        elif self.wink.current_hvac_mode() == 'heat_only':
-            current_op = STATE_HEAT
-        elif self.wink.current_hvac_mode() == 'aux':
-            current_op = STATE_HEAT
-        elif self.wink.current_hvac_mode() == 'auto':
-            current_op = STATE_AUTO
-        elif self.wink.current_hvac_mode() == 'eco':
-            current_op = STATE_ECO
        else:
-            current_op = STATE_UNKNOWN
+            current_op = WINK_STATE_TO_HA.get(self.wink.current_hvac_mode())
+            if current_op == 'aux':
+                return STATE_HEAT
+            if current_op is None:
+                current_op = STATE_UNKNOWN
        return current_op

    @property
@@ -199,11 +206,12 @@ class WinkThermostat(WinkDevice, ClimateDevice):
    @property
    def is_aux_heat_on(self):
        """Return true if aux heater."""
-        if self.wink.current_hvac_mode() == 'aux' and self.wink.is_on():
+        if 'aux' not in self.wink.hvac_modes():
+            return None
+
+        if self.wink.current_hvac_mode() == 'aux':
            return True
-        elif self.wink.current_hvac_mode() == 'aux' and not self.wink.is_on():
-            return False
-        return None
+        return False

    def set_temperature(self, **kwargs):
        """Set new target temperature."""
@@ -223,32 +231,27 @@ class WinkThermostat(WinkDevice, ClimateDevice):

    def set_operation_mode(self, operation_mode):
        """Set operation mode."""
-        if operation_mode == STATE_HEAT:
-            self.wink.set_operation_mode('heat_only')
-        elif operation_mode == STATE_COOL:
-            self.wink.set_operation_mode('cool_only')
-        elif operation_mode == STATE_AUTO:
-            self.wink.set_operation_mode('auto')
-        elif operation_mode == STATE_OFF:
-            self.wink.set_operation_mode('off')
-        elif operation_mode == STATE_AUX:
-            self.wink.set_operation_mode('aux')
-        elif operation_mode == STATE_ECO:
-            self.wink.set_operation_mode('eco')
+        op_mode_to_set = HA_STATE_TO_WINK.get(operation_mode)
+        # The only way to disable aux heat is with the toggle
+        if self.is_aux_heat_on and op_mode_to_set == STATE_HEAT:
+            return
+        self.wink.set_operation_mode(op_mode_to_set)

    @property
    def operation_list(self):
        """List of available operation modes."""
        op_list = ['off']
        modes = self.wink.hvac_modes()
-        if 'cool_only' in modes:
-            op_list.append(STATE_COOL)
-        if 'heat_only' in modes or 'aux' in modes:
-            op_list.append(STATE_HEAT)
-        if 'auto' in modes:
-            op_list.append(STATE_AUTO)
-        if 'eco' in modes:
-            op_list.append(STATE_ECO)
+        for mode in modes:
+            if mode == 'aux':
+                continue
+            ha_mode = WINK_STATE_TO_HA.get(mode)
+            if ha_mode is not None:
+                op_list.append(ha_mode)
+            else:
+                error = "Invaid operation mode mapping. " + mode + \
+                    " doesn't map. Please report this."
+                _LOGGER.error(error)
        return op_list

    def turn_away_mode_on(self):
@@ -281,12 +284,12 @@ class WinkThermostat(WinkDevice, ClimateDevice):
        self.wink.set_fan_mode(fan.lower())

    def turn_aux_heat_on(self):
-        """Turn auxillary heater on."""
-        self.set_operation_mode(STATE_AUX)
+        """Turn auxiliary heater on."""
+        self.wink.set_operation_mode('aux')

    def turn_aux_heat_off(self):
-        """Turn auxillary heater off."""
-        self.set_operation_mode(STATE_AUTO)
+        """Turn auxiliary heater off."""
+        self.set_operation_mode(STATE_HEAT)

    @property
    def min_temp(self):
@@ -344,11 +347,6 @@ class WinkThermostat(WinkDevice, ClimateDevice):
 class WinkAC(WinkDevice, ClimateDevice):
    """Representation of a Wink air conditioner."""

-    def __init__(self, wink, hass, temp_unit):
-        """Initialize the Wink device."""
-        super().__init__(wink, hass)
-        self._config_temp_unit = temp_unit
-
    @property
    def temperature_unit(self):
        """Return the unit of measurement."""
@@ -382,14 +380,10 @@ class WinkAC(WinkDevice, ClimateDevice):
        """Return current operation ie. heat, cool, idle."""
        if not self.wink.is_on():
            current_op = STATE_OFF
-        elif self.wink.current_mode() == 'cool_only':
-            current_op = STATE_COOL
-        elif self.wink.current_mode() == 'auto_eco':
-            current_op = STATE_ECO
-        elif self.wink.current_mode() == 'fan_only':
-            current_op = STATE_FAN
        else:
-            current_op = STATE_UNKNOWN
+            current_op = WINK_STATE_TO_HA.get(self.wink.current_hvac_mode())
+            if current_op is None:
+                current_op = STATE_UNKNOWN
        return current_op

    @property
@@ -397,12 +391,14 @@ class WinkAC(WinkDevice, ClimateDevice):
        """List of available operation modes."""
        op_list = ['off']
        modes = self.wink.modes()
-        if 'cool_only' in modes:
-            op_list.append(STATE_COOL)
-        if 'auto_eco' in modes:
-            op_list.append(STATE_ECO)
-        if 'fan_only' in modes:
-            op_list.append(STATE_FAN)
+        for mode in modes:
+            ha_mode = WINK_STATE_TO_HA.get(mode)
+            if ha_mode is not None:
+                op_list.append(ha_mode)
+            else:
+                error = "Invaid operation mode mapping. " + mode + \
+                    " doesn't map. Please report this."
+                _LOGGER.error(error)
        return op_list

    def set_temperature(self, **kwargs):
@@ -412,30 +408,16 @@ class WinkAC(WinkDevice, ClimateDevice):

    def set_operation_mode(self, operation_mode):
        """Set operation mode."""
-        if operation_mode == STATE_COOL:
-            self.wink.set_operation_mode('cool_only')
-        elif operation_mode == STATE_ECO:
-            self.wink.set_operation_mode('auto_eco')
-        elif operation_mode == STATE_OFF:
-            self.wink.set_operation_mode('off')
-        elif operation_mode == STATE_FAN:
-            self.wink.set_operation_mode('fan_only')
+        op_mode_to_set = HA_STATE_TO_WINK.get(operation_mode)
+        if op_mode_to_set == 'eco':
+            op_mode_to_set = 'auto_eco'
+        self.wink.set_operation_mode(op_mode_to_set)

    @property
    def target_temperature(self):
        """Return the temperature we try to reach."""
        return self.wink.current_max_set_point()

-    @property
-    def target_temperature_low(self):
-        """Only supports cool."""
-        return None
-
-    @property
-    def target_temperature_high(self):
-        """Only supports cool."""
-        return None
-
    @property
    def current_fan_mode(self):
        """Return the current fan mode."""
@@ -453,12 +435,97 @@ class WinkAC(WinkDevice, ClimateDevice):
        """Return a list of available fan modes."""
        return [SPEED_LOW, SPEED_MEDIUM, SPEED_HIGH]

-    def set_fan_mode(self, mode):
+    def set_fan_mode(self, fan):
        """Set fan speed."""
-        if mode == SPEED_LOW:
+        if fan == SPEED_LOW:
            speed = 0.4
-        elif mode == SPEED_MEDIUM:
+        elif fan == SPEED_MEDIUM:
            speed = 0.8
-        elif mode == SPEED_HIGH:
+        elif fan == SPEED_HIGH:
            speed = 1.0
        self.wink.set_ac_fan_speed(speed)
+
+
+class WinkWaterHeater(WinkDevice, ClimateDevice):
+    """Representation of a Wink water heater."""
+
+    @property
+    def temperature_unit(self):
+        """Return the unit of measurement."""
+        # The Wink API always returns temp in Celsius
+        return TEMP_CELSIUS
+
+    @property
+    def device_state_attributes(self):
+        """Return the optional state attributes."""
+        data = {}
+        data["vacation_mode"] = self.wink.vacation_mode_enabled()
+        data["rheem_type"] = self.wink.rheem_type()
+
+        return data
+
+    @property
+    def current_operation(self):
+        """
+        Return current operation one of the following.
+
+        ["eco", "performance", "heat_pump",
+        "high_demand", "electric_only", "gas]
+        """
+        if not self.wink.is_on():
+            current_op = STATE_OFF
+        else:
+            current_op = WINK_STATE_TO_HA.get(self.wink.current_mode())
+            if current_op is None:
+                current_op = STATE_UNKNOWN
+        return current_op
+
+    @property
+    def operation_list(self):
+        """List of available operation modes."""
+        op_list = ['off']
+        modes = self.wink.modes()
+        for mode in modes:
+            if mode == 'aux':
+                continue
+            ha_mode = WINK_STATE_TO_HA.get(mode)
+            if ha_mode is not None:
+                op_list.append(ha_mode)
+            else:
+                error = "Invaid operation mode mapping. " + mode + \
+                    " doesn't map. Please report this."
+                _LOGGER.error(error)
+        return op_list
+
+    def set_temperature(self, **kwargs):
+        """Set new target temperature."""
+        target_temp = kwargs.get(ATTR_TEMPERATURE)
+        self.wink.set_temperature(target_temp)
+
+    def set_operation_mode(self, operation_mode):
+        """Set operation mode."""
+        op_mode_to_set = HA_STATE_TO_WINK.get(operation_mode)
+        self.wink.set_operation_mode(op_mode_to_set)
+
+    @property
+    def target_temperature(self):
+        """Return the temperature we try to reach."""
+        return self.wink.current_set_point()
+
+    def turn_away_mode_on(self):
+        """Turn away on."""
+        self.wink.set_vacation_mode(True)
+
+    def turn_away_mode_off(self):
+        """Turn away off."""
+        self.wink.set_vacation_mode(False)
+
+    @property
+    def min_temp(self):
+        """Return the minimum temperature."""
+        return self.wink.min_set_point()
+
+    @property
+    def max_temp(self):
+        """Return the maximum temperature."""
+        return self.wink.max_set_point()
--- a/homeassistant/components/cloud/init.py
+++ b/homeassistant/components/cloud/init.py
@@ -0,0 +1,147 @@
+"""Component to integrate the Home Assistant cloud."""
+import asyncio
+import json
+import logging
+import os
+
+import voluptuous as vol
+
+from homeassistant.const import EVENT_HOMEASSISTANT_START
+
+from . import http_api, iot
+from .const import CONFIG_DIR, DOMAIN, SERVERS
+
+
+REQUIREMENTS = ['warrant==0.5.0']
+DEPENDENCIES = ['http']
+CONF_MODE = 'mode'
+CONF_COGNITO_CLIENT_ID = 'cognito_client_id'
+CONF_USER_POOL_ID = 'user_pool_id'
+CONF_REGION = 'region'
+CONF_RELAYER = 'relayer'
+MODE_DEV = 'development'
+DEFAULT_MODE = MODE_DEV
+_LOGGER = logging.getLogger(__name__)
+
+CONFIG_SCHEMA = vol.Schema({
+    DOMAIN: vol.Schema({
+        vol.Optional(CONF_MODE, default=DEFAULT_MODE):
+            vol.In([MODE_DEV] + list(SERVERS)),
+        # Change to optional when we include real servers
+        vol.Required(CONF_COGNITO_CLIENT_ID): str,
+        vol.Required(CONF_USER_POOL_ID): str,
+        vol.Required(CONF_REGION): str,
+        vol.Required(CONF_RELAYER): str,
+    }),
+}, extra=vol.ALLOW_EXTRA)
+
+
+@asyncio.coroutine
+def async_setup(hass, config):
+    """Initialize the Home Assistant cloud."""
+    if DOMAIN in config:
+        kwargs = config[DOMAIN]
+    else:
+        kwargs = {CONF_MODE: DEFAULT_MODE}
+
+    cloud = hass.data[DOMAIN] = Cloud(hass, **kwargs)
+
+    @asyncio.coroutine
+    def init_cloud(event):
+        """Initialize connection."""
+        yield from cloud.initialize()
+
+    hass.bus.async_listen_once(EVENT_HOMEASSISTANT_START, init_cloud)
+
+    yield from http_api.async_setup(hass)
+    return True
+
+
+class Cloud:
+    """Store the configuration of the cloud connection."""
+
+    def __init__(self, hass, mode, cognito_client_id=None, user_pool_id=None,
+                 region=None, relayer=None):
+        """Create an instance of Cloud."""
+        self.hass = hass
+        self.mode = mode
+        self.email = None
+        self.id_token = None
+        self.access_token = None
+        self.refresh_token = None
+        self.iot = iot.CloudIoT(self)
+
+        if mode == MODE_DEV:
+            self.cognito_client_id = cognito_client_id
+            self.user_pool_id = user_pool_id
+            self.region = region
+            self.relayer = relayer
+
+        else:
+            info = SERVERS[mode]
+
+            self.cognito_client_id = info['cognito_client_id']
+            self.user_pool_id = info['user_pool_id']
+            self.region = info['region']
+            self.relayer = info['relayer']
+
+    @property
+    def is_logged_in(self):
+        """Get if cloud is logged in."""
+        return self.email is not None
+
+    @property
+    def user_info_path(self):
+        """Get path to the stored auth."""
+        return self.path('{}_auth.json'.format(self.mode))
+
+    @asyncio.coroutine
+    def initialize(self):
+        """Initialize and load cloud info."""
+        def load_config():
+            """Load the configuration."""
+            # Ensure config dir exists
+            path = self.hass.config.path(CONFIG_DIR)
+            if not os.path.isdir(path):
+                os.mkdir(path)
+
+            user_info = self.user_info_path
+            if os.path.isfile(user_info):
+                with open(user_info, 'rt') as file:
+                    info = json.loads(file.read())
+                self.email = info['email']
+                self.id_token = info['id_token']
+                self.access_token = info['access_token']
+                self.refresh_token = info['refresh_token']
+
+        yield from self.hass.async_add_job(load_config)
+
+        if self.email is not None:
+            yield from self.iot.connect()
+
+    def path(self, *parts):
+        """Get config path inside cloud dir."""
+        return self.hass.config.path(CONFIG_DIR, *parts)
+
+    @asyncio.coroutine
+    def logout(self):
+        """Close connection and remove all credentials."""
+        yield from self.iot.disconnect()
+
+        self.email = None
+        self.id_token = None
+        self.access_token = None
+        self.refresh_token = None
+
+        yield from self.hass.async_add_job(
+            lambda: os.remove(self.user_info_path))
+
+    def write_user_info(self):
+        """Write user info to a file."""
+        with open(self.user_info_path, 'wt') as file:
+            file.write(json.dumps({
+                'email': self.email,
+                'id_token': self.id_token,
+                'access_token': self.access_token,
+                'refresh_token': self.refresh_token,
+            }, indent=4))
--- a/homeassistant/components/cloud/auth_api.py
+++ b/homeassistant/components/cloud/auth_api.py
@@ -0,0 +1,177 @@
+"""Package to communicate with the authentication API."""
+import hashlib
+import logging
+
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class CloudError(Exception):
+    """Base class for cloud related errors."""
+
+
+class Unauthenticated(CloudError):
+    """Raised when authentication failed."""
+
+
+class UserNotFound(CloudError):
+    """Raised when a user is not found."""
+
+
+class UserNotConfirmed(CloudError):
+    """Raised when a user has not confirmed email yet."""
+
+
+class ExpiredCode(CloudError):
+    """Raised when an expired code is encoutered."""
+
+
+class InvalidCode(CloudError):
+    """Raised when an invalid code is submitted."""
+
+
+class PasswordChangeRequired(CloudError):
+    """Raised when a password change is required."""
+
+    def __init__(self, message='Password change required.'):
+        """Initialize a password change required error."""
+        super().__init__(message)
+
+
+class UnknownError(CloudError):
+    """Raised when an unknown error occurrs."""
+
+
+AWS_EXCEPTIONS = {
+    'UserNotFoundException': UserNotFound,
+    'NotAuthorizedException': Unauthenticated,
+    'ExpiredCodeException': ExpiredCode,
+    'UserNotConfirmedException': UserNotConfirmed,
+    'PasswordResetRequiredException': PasswordChangeRequired,
+    'CodeMismatchException': InvalidCode,
+}
+
+
+def _map_aws_exception(err):
+    """Map AWS exception to our exceptions."""
+    ex = AWS_EXCEPTIONS.get(err.response['Error']['Code'], UnknownError)
+    return ex(err.response['Error']['Message'])
+
+
+def _generate_username(email):
+    """Generate a username from an email address."""
+    return hashlib.sha512(email.encode('utf-8')).hexdigest()
+
+
+def register(cloud, email, password):
+    """Register a new account."""
+    from botocore.exceptions import ClientError
+
+    cognito = _cognito(cloud)
+    try:
+        cognito.register(_generate_username(email), password, email=email)
+    except ClientError as err:
+        raise _map_aws_exception(err)
+
+
+def confirm_register(cloud, confirmation_code, email):
+    """Confirm confirmation code after registration."""
+    from botocore.exceptions import ClientError
+
+    cognito = _cognito(cloud)
+    try:
+        cognito.confirm_sign_up(confirmation_code, _generate_username(email))
+    except ClientError as err:
+        raise _map_aws_exception(err)
+
+
+def forgot_password(cloud, email):
+    """Initiate forgotten password flow."""
+    from botocore.exceptions import ClientError
+
+    cognito = _cognito(cloud, username=_generate_username(email))
+    try:
+        cognito.initiate_forgot_password()
+    except ClientError as err:
+        raise _map_aws_exception(err)
+
+
+def confirm_forgot_password(cloud, confirmation_code, email, new_password):
+    """Confirm forgotten password code and change password."""
+    from botocore.exceptions import ClientError
+
+    cognito = _cognito(cloud, username=_generate_username(email))
+    try:
+        cognito.confirm_forgot_password(confirmation_code, new_password)
+    except ClientError as err:
+        raise _map_aws_exception(err)
+
+
+def login(cloud, email, password):
+    """Log user in and fetch certificate."""
+    cognito = _authenticate(cloud, email, password)
+    cloud.id_token = cognito.id_token
+    cloud.access_token = cognito.access_token
+    cloud.refresh_token = cognito.refresh_token
+    cloud.email = email
+    cloud.write_user_info()
+
+
+def check_token(cloud):
+    """Check that the token is valid and verify if needed."""
+    from botocore.exceptions import ClientError
+
+    cognito = _cognito(
+        cloud,
+        access_token=cloud.access_token,
+        refresh_token=cloud.refresh_token)
+
+    try:
+        if cognito.check_token():
+            cloud.id_token = cognito.id_token
+            cloud.access_token = cognito.access_token
+            cloud.write_user_info()
+    except ClientError as err:
+        raise _map_aws_exception(err)
+
+
+def _authenticate(cloud, email, password):
+    """Log in and return an authenticated Cognito instance."""
+    from botocore.exceptions import ClientError
+    from warrant.exceptions import ForceChangePasswordException
+
+    assert not cloud.is_logged_in, 'Cannot login if already logged in.'
+
+    cognito = _cognito(cloud, username=email)
+
+    try:
+        cognito.authenticate(password=password)
+        return cognito
+
+    except ForceChangePasswordException as err:
+        raise PasswordChangeRequired
+
+    except ClientError as err:
+        raise _map_aws_exception(err)
+
+
+def _cognito(cloud, **kwargs):
+    """Get the client credentials."""
+    import botocore
+    import boto3
+    from warrant import Cognito
+
+    cognito = Cognito(
+        user_pool_id=cloud.user_pool_id,
+        client_id=cloud.cognito_client_id,
+        user_pool_region=cloud.region,
+        **kwargs
+    )
+    cognito.client = boto3.client(
+        'cognito-idp',
+        region_name=cloud.region,
+        config=botocore.config.Config(
+            signature_version=botocore.UNSIGNED
+        )
+    )
+    return cognito
--- a/homeassistant/components/cloud/const.py
+++ b/homeassistant/components/cloud/const.py
@@ -0,0 +1,14 @@
+"""Constants for the cloud component."""
+DOMAIN = 'cloud'
+CONFIG_DIR = '.cloud'
+REQUEST_TIMEOUT = 10
+
+SERVERS = {
+    # Example entry:
+    # 'production': {
+    #     'cognito_client_id': '',
+    #     'user_pool_id': '',
+    #     'region': '',
+    #     'relayer': ''
+    # }
+}
--- a/Show More
+++ b/Show More