Merge pull request #10898 from home-assistant/release-0-59

0.59
Bugfix #10902 (#10904 )
2017-12-03 13:24:22 +01:00 · 2017-12-03 10:09:44 +01:00 · 2017-12-03 10:09:40 +01:00 · 2017-12-02 01:09:43 +01:00 · 2017-12-01 12:53:46 -08:00 · 2017-12-01 12:53:15 -08:00
682 changed files with 22972 additions and 11891 deletions
@@ -53,6 +53,8 @@ omit =
    homeassistant/components/digital_ocean.py
    homeassistant/components/*/digital_ocean.py

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

@@ -71,12 +73,18 @@ omit =
    homeassistant/components/envisalink.py
    homeassistant/components/*/envisalink.py

+    homeassistant/components/gc100.py
+    homeassistant/components/*/gc100.py
+
    homeassistant/components/google.py
    homeassistant/components/*/google.py

    homeassistant/components/hdmi_cec.py
    homeassistant/components/*/hdmi_cec.py

+    homeassistant/components/hive.py
+    homeassistant/components/*/hive.py
+
    homeassistant/components/homematic.py
    homeassistant/components/*/homematic.py

@@ -107,6 +115,9 @@ omit =
    homeassistant/components/lametric.py
    homeassistant/components/*/lametric.py

+    homeassistant/components/linode.py
+    homeassistant/components/*/linode.py
+
    homeassistant/components/lutron.py
    homeassistant/components/*/lutron.py

@@ -176,6 +187,9 @@ omit =
    homeassistant/components/tado.py
    homeassistant/components/*/tado.py

+    homeassistant/components/tahoma.py
+    homeassistant/components/*/tahoma.py
+
    homeassistant/components/tellduslive.py
    homeassistant/components/*/tellduslive.py

@@ -272,8 +286,10 @@ omit =
    homeassistant/components/camera/mjpeg.py
    homeassistant/components/camera/rpi_camera.py
    homeassistant/components/camera/onvif.py
+    homeassistant/components/camera/ring.py
    homeassistant/components/camera/synology.py
    homeassistant/components/camera/yi.py
+    homeassistant/components/climate/ephember.py
    homeassistant/components/climate/eq3btsmart.py
    homeassistant/components/climate/flexit.py
    homeassistant/components/climate/heatmiser.py
@@ -301,6 +317,7 @@ omit =
    homeassistant/components/device_tracker/cisco_ios.py
    homeassistant/components/device_tracker/fritz.py
    homeassistant/components/device_tracker/gpslogger.py
+    homeassistant/components/device_tracker/hitron_coda.py
    homeassistant/components/device_tracker/huawei_router.py
    homeassistant/components/device_tracker/icloud.py
    homeassistant/components/device_tracker/keenetic_ndms2.py
@@ -317,6 +334,7 @@ omit =
    homeassistant/components/device_tracker/thomson.py
    homeassistant/components/device_tracker/tomato.py
    homeassistant/components/device_tracker/tado.py
+    homeassistant/components/device_tracker/tile.py
    homeassistant/components/device_tracker/tplink.py
    homeassistant/components/device_tracker/trackr.py
    homeassistant/components/device_tracker/ubus.py
@@ -324,6 +342,7 @@ omit =
    homeassistant/components/emoncms_history.py
    homeassistant/components/emulated_hue/upnp.py
    homeassistant/components/fan/mqtt.py
+    homeassistant/components/fan/xiaomi_miio.py
    homeassistant/components/feedreader.py
    homeassistant/components/foursquare.py
    homeassistant/components/ifttt.py
@@ -411,10 +430,10 @@ omit =
    homeassistant/components/notify/aws_sns.py
    homeassistant/components/notify/aws_sqs.py
    homeassistant/components/notify/ciscospark.py
+    homeassistant/components/notify/clickatell.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
@@ -444,8 +463,10 @@ omit =
    homeassistant/components/notify/telstra.py
    homeassistant/components/notify/twitter.py
    homeassistant/components/notify/xmpp.py
+    homeassistant/components/notify/yessssms.py
    homeassistant/components/nuimo_controller.py
    homeassistant/components/prometheus.py
+    homeassistant/components/remember_the_milk/__init__.py
    homeassistant/components/remote/harmony.py
    homeassistant/components/remote/itach.py
    homeassistant/components/scene/hunterdouglas_powerview.py
@@ -462,7 +483,6 @@ omit =
    homeassistant/components/sensor/broadlink.py
    homeassistant/components/sensor/buienradar.py
    homeassistant/components/sensor/citybikes.py
-    homeassistant/components/sensor/coinmarketcap.py
    homeassistant/components/sensor/cert_expiry.py
    homeassistant/components/sensor/comed_hourly_pricing.py
    homeassistant/components/sensor/cpuspeed.py
@@ -470,6 +490,7 @@ omit =
    homeassistant/components/sensor/cups.py
    homeassistant/components/sensor/currencylayer.py
    homeassistant/components/sensor/darksky.py
+    homeassistant/components/sensor/deluge.py
    homeassistant/components/sensor/deutsche_bahn.py
    homeassistant/components/sensor/dht.py
    homeassistant/components/sensor/dnsip.py
@@ -497,17 +518,19 @@ omit =
    homeassistant/components/sensor/gpsd.py
    homeassistant/components/sensor/gtfs.py
    homeassistant/components/sensor/haveibeenpwned.py
-    homeassistant/components/sensor/hddtemp.py
    homeassistant/components/sensor/hp_ilo.py
    homeassistant/components/sensor/htu21d.py
    homeassistant/components/sensor/hydroquebec.py
    homeassistant/components/sensor/imap.py
    homeassistant/components/sensor/imap_email_content.py
    homeassistant/components/sensor/influxdb.py
+    homeassistant/components/sensor/irish_rail_transport.py
    homeassistant/components/sensor/kwb.py
+    homeassistant/components/sensor/lacrosse.py
    homeassistant/components/sensor/lastfm.py
    homeassistant/components/sensor/linux_battery.py
    homeassistant/components/sensor/loopenergy.py
+    homeassistant/components/sensor/luftdaten.py
    homeassistant/components/sensor/lyft.py
    homeassistant/components/sensor/metoffice.py
    homeassistant/components/sensor/miflora.py
@@ -515,6 +538,7 @@ omit =
    homeassistant/components/sensor/mopar.py
    homeassistant/components/sensor/mqtt_room.py
    homeassistant/components/sensor/mvglive.py
+    homeassistant/components/sensor/nederlandse_spoorwegen.py
    homeassistant/components/sensor/netdata.py
    homeassistant/components/sensor/neurio_energy.py
    homeassistant/components/sensor/nut.py
@@ -531,6 +555,7 @@ omit =
    homeassistant/components/sensor/pocketcasts.py
    homeassistant/components/sensor/pushbullet.py
    homeassistant/components/sensor/pvoutput.py
+    homeassistant/components/sensor/pyload.py
    homeassistant/components/sensor/qnap.py
    homeassistant/components/sensor/radarr.py
    homeassistant/components/sensor/ripple.py
@@ -551,6 +576,7 @@ omit =
    homeassistant/components/sensor/swiss_public_transport.py
    homeassistant/components/sensor/synologydsm.py
    homeassistant/components/sensor/systemmonitor.py
+    homeassistant/components/sensor/sytadin.py
    homeassistant/components/sensor/tank_utility.py
    homeassistant/components/sensor/ted5000.py
    homeassistant/components/sensor/temper.py
@@ -564,11 +590,12 @@ omit =
    homeassistant/components/sensor/upnp.py
    homeassistant/components/sensor/ups.py
    homeassistant/components/sensor/vasttrafik.py
+    homeassistant/components/sensor/viaggiatreno.py
    homeassistant/components/sensor/waqi.py
+    homeassistant/components/sensor/whois.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
    homeassistant/components/shiftr.py
    homeassistant/components/spc.py
@@ -576,6 +603,7 @@ omit =
    homeassistant/components/switch/anel_pwrctrl.py
    homeassistant/components/switch/arest.py
    homeassistant/components/switch/broadlink.py
+    homeassistant/components/switch/deluge.py
    homeassistant/components/switch/digitalloggers.py
    homeassistant/components/switch/dlink.py
    homeassistant/components/switch/edimax.py
@@ -588,17 +616,20 @@ omit =
    homeassistant/components/switch/orvibo.py
    homeassistant/components/switch/pilight.py
    homeassistant/components/switch/pulseaudio_loopback.py
+    homeassistant/components/switch/rainbird.py
    homeassistant/components/switch/rainmachine.py
    homeassistant/components/switch/rest.py
    homeassistant/components/switch/rpi_rf.py
+    homeassistant/components/switch/snmp.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/baidu.py
+    homeassistant/components/tts/microsoft.py
    homeassistant/components/tts/picotts.py
    homeassistant/components/vacuum/roomba.py
    homeassistant/components/weather/bom.py
@@ -611,7 +642,6 @@ omit =
    homeassistant/components/zwave/util.py
    homeassistant/components/vacuum/mqtt.py

-
 [report]
 # Regexes for lines to exclude from consideration
 exclude_lines =
@@ -96,4 +96,4 @@ docs/build
 desktop.ini
 /home-assistant.pyproj
 /home-assistant.sln
-/.vs/home-assistant/v14
+/.vs/*
@@ -1,3 +0,0 @@
-[submodule "homeassistant/components/frontend/www_static/home-assistant-polymer"]
-	path = homeassistant/components/frontend/www_static/home-assistant-polymer
-	url = https://github.com/home-assistant/home-assistant-polymer.git
@@ -8,18 +8,18 @@ matrix:
  include:
    - python: "3.4.2"
      env: TOXENV=lint
+    - python: "3.4.2"
+      env: TOXENV=pylint
    - python: "3.4.2"
      env: TOXENV=py34
    # - python: "3.5"
    #   env: TOXENV=typing
-    - python: "3.5"
+    - python: "3.5.3"
      env: TOXENV=py35
    - python: "3.6"
      env: TOXENV=py36
    # - python: "3.6-dev"
    #   env: TOXENV=py36
-    - python: "3.4.2"
-      env: TOXENV=requirements
  # allow_failures:
  #   - python: "3.5"
  #     env: TOXENV=typing
@@ -29,5 +29,5 @@ cache:
    - $HOME/.cache/pip
 install: pip install -U tox coveralls
 language: python
-script: travis_wait tox
+script: travis_wait 30 tox --develop
 after_success: coveralls
@@ -41,26 +41,42 @@ 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/ephember.py @ttroy50
 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/device_tracker/tile.py @bachya
 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/media_player/yamaha_musiccast.py @jalmeroth
 homeassistant/components/sensor/airvisual.py @bachya
+homeassistant/components/sensor/irish_rail_transport.py @ttroy50
 homeassistant/components/sensor/miflora.py @danielhiversen
+homeassistant/components/sensor/sytadin.py @gautric
 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/xiaomi_aqara.py @danielhiversen @syssi

-homeassistant/components/*/axis.py @Kane610
 homeassistant/components/*/broadlink.py @danielhiversen
+homeassistant/components/hive.py @Rendili @KJonline
+homeassistant/components/*/hive.py @Rendili @KJonline
 homeassistant/components/*/rfxtrx.py @danielhiversen
+homeassistant/components/velux.py @Julius2342
+homeassistant/components/*/velux.py @Julius2342
+homeassistant/components/knx.py @Julius2342
+homeassistant/components/*/knx.py @Julius2342
+homeassistant/components/tahoma.py @philklei
+homeassistant/components/*/tahoma.py @philklei
 homeassistant/components/tesla.py @zabuldon
 homeassistant/components/*/tesla.py @zabuldon
-homeassistant/components/*/xiaomi_aqara.py @danielhiversen
-homeassistant/components/*/xiaomi_miio.py @rytilahti
+homeassistant/components/tellduslive.py @molobrakos @fredrike
+homeassistant/components/*/tellduslive.py @molobrakos @fredrike
+homeassistant/components/*/tradfri.py @ggravlingen
+homeassistant/components/*/xiaomi_aqara.py @danielhiversen @syssi
+homeassistant/components/*/xiaomi_miio.py @rytilahti @syssi
@@ -3,7 +3,7 @@
 # This way, the development image and the production image are kept in sync.

 FROM python:3.6
-MAINTAINER Paulus Schoutsen <Paulus@PaulusSchoutsen.nl>
+LABEL maintainer="Paulus Schoutsen <Paulus@PaulusSchoutsen.nl>"

 # Uncomment any of the following lines to disable the installation.
 #ENV INSTALL_TELLSTICK no
@@ -1,5 +1,4 @@
 include README.rst
 include LICENSE.md
 graft homeassistant
-prune homeassistant/components/frontend/www_static/home-assistant-polymer
 recursive-exclude * *.py[co]
@@ -19,15 +19,13 @@
 #
 import sys
 import os
-from os.path import relpath
 import inspect
-from homeassistant.const import (__version__, __short_version__, PROJECT_NAME,
-                                 PROJECT_LONG_DESCRIPTION,
-                                 PROJECT_COPYRIGHT, PROJECT_AUTHOR,
-                                 PROJECT_GITHUB_USERNAME,
-                                 PROJECT_GITHUB_REPOSITORY,
-                                 GITHUB_PATH, GITHUB_URL)

+from homeassistant.const import __version__, __short_version__
+from setup import (
+    PROJECT_NAME, PROJECT_LONG_DESCRIPTION, PROJECT_COPYRIGHT, PROJECT_AUTHOR,
+    PROJECT_GITHUB_USERNAME, PROJECT_GITHUB_REPOSITORY, GITHUB_PATH,
+    GITHUB_URL)

 sys.path.insert(0, os.path.abspath('_ext'))
 sys.path.insert(0, os.path.abspath('../homeassistant'))
@@ -87,9 +85,7 @@ edit_on_github_src_path = 'docs/source/'


 def linkcode_resolve(domain, info):
-    """
-    Determine the URL corresponding to Python object
-    """
+    """Determine the URL corresponding to Python object."""
    if domain != 'py':
        return None
    modname = info['module']
@@ -30,8 +30,8 @@ ERROR_LOG_FILENAME = 'home-assistant.log'
 DATA_LOGGING = 'logging'

 FIRST_INIT_COMPONENT = set((
-    'recorder', 'mqtt', 'mqtt_eventstream', 'logger', 'introduction',
-    'frontend', 'history'))
+    'system_log', 'recorder', 'mqtt', 'mqtt_eventstream', 'logger',
+    'introduction', 'frontend', 'history'))


 def from_config_dict(config: Dict[str, Any],
@@ -88,7 +88,7 @@ def async_from_config_dict(config: Dict[str, Any],
    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 '
+            'the beginning of 2018. Please upgrade Python or your operating '
            'system. More info: https://home-assistant.io/blog/2017/10/06/'
            'deprecating-python-3.4-support/'
        )
@@ -21,7 +21,7 @@ from homeassistant.helpers import discovery
 from homeassistant.helpers.entity import Entity
 from requests.exceptions import HTTPError, ConnectTimeout

-REQUIREMENTS = ['abodepy==0.12.1']
+REQUIREMENTS = ['abodepy==0.12.2']

 _LOGGER = logging.getLogger(__name__)

@@ -14,7 +14,7 @@ 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_ARM_NIGHT)
+    SERVICE_ALARM_ARM_NIGHT, SERVICE_ALARM_ARM_CUSTOM_BYPASS)
 from homeassistant.config import load_yaml_config_file
 from homeassistant.loader import bind_hass
 from homeassistant.helpers.config_validation import PLATFORM_SCHEMA  # noqa
@@ -33,6 +33,7 @@ SERVICE_TO_METHOD = {
    SERVICE_ALARM_ARM_HOME: 'alarm_arm_home',
    SERVICE_ALARM_ARM_AWAY: 'alarm_arm_away',
    SERVICE_ALARM_ARM_NIGHT: 'alarm_arm_night',
+    SERVICE_ALARM_ARM_CUSTOM_BYPASS: 'alarm_arm_custom_bypass',
    SERVICE_ALARM_TRIGGER: 'alarm_trigger'
 }

@@ -107,6 +108,18 @@ def alarm_trigger(hass, code=None, entity_id=None):
    hass.services.call(DOMAIN, SERVICE_ALARM_TRIGGER, data)


+@bind_hass
+def alarm_arm_custom_bypass(hass, code=None, entity_id=None):
+    """Send the alarm the command for arm custom bypass."""
+    data = {}
+    if code:
+        data[ATTR_CODE] = code
+    if entity_id:
+        data[ATTR_ENTITY_ID] = entity_id
+
+    hass.services.call(DOMAIN, SERVICE_ALARM_ARM_CUSTOM_BYPASS, data)
+
+
@asyncio.coroutine
 def async_setup(hass, config):
    """Track states and offer events for sensors."""
@@ -216,6 +229,17 @@ class AlarmControlPanel(Entity):
        """
        return self.hass.async_add_job(self.alarm_trigger, code)

+    def alarm_arm_custom_bypass(self, code=None):
+        """Send arm custom bypass command."""
+        raise NotImplementedError()
+
+    def async_alarm_arm_custom_bypass(self, code=None):
+        """Send arm custom bypass command.
+
+        This method must be run in the event loop and returns a coroutine.
+        """
+        return self.hass.async_add_job(self.alarm_arm_custom_bypass, code)
+
    @property
    def state_attributes(self):
        """Return the state attributes."""
@@ -22,6 +22,7 @@ _LOGGER = logging.getLogger(__name__)
 ARMED = 'armed'

 CONF_HOME_MODE_NAME = 'home_mode_name'
+CONF_AWAY_MODE_NAME = 'away_mode_name'

 DEPENDENCIES = ['arlo']

@@ -31,6 +32,7 @@ ICON = 'mdi:security'

 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
    vol.Optional(CONF_HOME_MODE_NAME, default=ARMED): cv.string,
+    vol.Optional(CONF_AWAY_MODE_NAME, default=ARMED): cv.string,
 })


@@ -43,19 +45,22 @@ def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
        return

    home_mode_name = config.get(CONF_HOME_MODE_NAME)
+    away_mode_name = config.get(CONF_AWAY_MODE_NAME)
    base_stations = []
    for base_station in data.base_stations:
-        base_stations.append(ArloBaseStation(base_station, home_mode_name))
+        base_stations.append(ArloBaseStation(base_station, home_mode_name,
+                                             away_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):
+    def __init__(self, data, home_mode_name, away_mode_name):
        """Initialize the alarm control panel."""
        self._base_station = data
        self._home_mode_name = home_mode_name
+        self._away_mode_name = away_mode_name
        self._state = None

    @property
@@ -89,8 +94,8 @@ class ArloBaseStation(AlarmControlPanel):

    @asyncio.coroutine
    def async_alarm_arm_away(self, code=None):
-        """Send arm away command."""
-        self._base_station.mode = ARMED
+        """Send arm away command. Uses custom mode."""
+        self._base_station.mode = self._away_mode_name

    @asyncio.coroutine
    def async_alarm_arm_home(self, code=None):
@@ -118,4 +123,6 @@ class ArloBaseStation(AlarmControlPanel):
            return STATE_ALARM_DISARMED
        elif mode == self._home_mode_name:
            return STATE_ALARM_ARMED_HOME
+        elif mode == self._away_mode_name:
+            return STATE_ALARM_ARMED_AWAY
        return None
@@ -7,7 +7,7 @@ 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)
+    STATE_ALARM_ARMED_CUSTOM_BYPASS, STATE_ALARM_TRIGGERED, CONF_PENDING_TIME)


 def setup_platform(hass, config, add_devices, discovery_info=None):
@@ -23,6 +23,9 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
            STATE_ALARM_ARMED_NIGHT: {
                CONF_PENDING_TIME: 5
            },
+            STATE_ALARM_ARMED_CUSTOM_BYPASS: {
+                CONF_PENDING_TIME: 5
+            },
            STATE_ALARM_TRIGGERED: {
                CONF_PENDING_TIME: 5
            },
@@ -14,9 +14,9 @@ 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_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)
+    STATE_ALARM_ARMED_CUSTOM_BYPASS, 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

@@ -26,7 +26,8 @@ DEFAULT_TRIGGER_TIME = 120
 DEFAULT_DISARM_AFTER_TRIGGER = False

 SUPPORTED_PENDING_STATES = [STATE_ALARM_ARMED_AWAY, STATE_ALARM_ARMED_HOME,
-                            STATE_ALARM_ARMED_NIGHT, STATE_ALARM_TRIGGERED]
+                            STATE_ALARM_ARMED_NIGHT, STATE_ALARM_TRIGGERED,
+                            STATE_ALARM_ARMED_CUSTOM_BYPASS]

 ATTR_POST_PENDING_STATE = 'post_pending_state'

@@ -59,6 +60,8 @@ PLATFORM_SCHEMA = vol.Schema(vol.All({
    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_ARMED_CUSTOM_BYPASS,
+                 default={}): STATE_SETTING_SCHEMA,
    vol.Optional(STATE_ALARM_TRIGGERED, default={}): STATE_SETTING_SCHEMA,
 }, _state_validator))

@@ -174,6 +177,13 @@ class ManualAlarm(alarm.AlarmControlPanel):

        self._update_state(STATE_ALARM_ARMED_NIGHT)

+    def alarm_arm_custom_bypass(self, code=None):
+        """Send arm custom bypass command."""
+        if not self._validate_code(code, STATE_ALARM_ARMED_CUSTOM_BYPASS):
+            return
+
+        self._update_state(STATE_ALARM_ARMED_CUSTOM_BYPASS)
+
    def alarm_trigger(self, code=None):
        """Send alarm trigger command. No code needed."""
        self._pre_trigger_state = self._state
@@ -1,65 +1,61 @@
-alarm_disarm:
-  description: Send the alarm the command for disarm
+# Describes the format for available alarm control panel services

+alarm_disarm:
+  description: Send the alarm the command for disarm.
  fields:
    entity_id:
-      description: Name of alarm control panel to disarm
+      description: Name of alarm control panel to disarm.
      example: 'alarm_control_panel.downstairs'
    code:
-      description: An optional code to disarm the alarm control panel with
+      description: An optional code to disarm the alarm control panel with.
      example: 1234

 alarm_arm_home:
-  description: Send the alarm the command for arm home
-
+  description: Send the alarm the command for arm home.
  fields:
    entity_id:
-      description: Name of alarm control panel to arm home
+      description: Name of alarm control panel to arm home.
      example: 'alarm_control_panel.downstairs'
    code:
-      description: An optional code to arm home the alarm control panel with
+      description: An optional code to arm home the alarm control panel with.
      example: 1234

 alarm_arm_away:
-  description: Send the alarm the command for arm away
-
+  description: Send the alarm the command for arm away.
  fields:
    entity_id:
-      description: Name of alarm control panel to arm away
+      description: Name of alarm control panel to arm away.
      example: 'alarm_control_panel.downstairs'
    code:
-      description: An optional code to arm away the alarm control panel with
+      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
-
+  description: Send the alarm the command for arm night.
  fields:
    entity_id:
-      description: Name of alarm control panel to arm night
+      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
+      description: An optional code to arm night the alarm control panel with.
      example: 1234

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

 envisalink_alarm_keypress:
-  description: Send custom keypresses to the alarm
-
+  description: Send custom keypresses to the alarm.
  fields:
    entity_id:
-      description: Name of the alarm control panel to trigger
+      description: Name of the alarm control panel to trigger.
      example: 'alarm_control_panel.downstairs'
    keypress:
-      description: 'String to send to the alarm panel (1-6 characters)'
+      description: 'String to send to the alarm panel (1-6 characters).'
      example: '*71'
@@ -34,10 +34,8 @@ def async_setup_platform(hass, config, async_add_devices,
            discovery_info[ATTR_DISCOVER_AREAS] is None):
        return

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

    async_add_devices(devices)
@@ -46,21 +44,29 @@ def async_setup_platform(hass, config, async_add_devices,
 class SpcAlarm(alarm.AlarmControlPanel):
    """Represents the SPC alarm panel."""

-    def __init__(self, hass, area_id, name, state):
+    def __init__(self, api, area):
        """Initialize the SPC alarm panel."""
-        self._hass = hass
-        self._area_id = area_id
-        self._name = name
-        self._state = state
-        self._api = hass.data[DATA_API]
-
-        hass.data[DATA_REGISTRY].register_alarm_device(area_id, self)
+        self._area_id = area['id']
+        self._name = area['name']
+        self._state = _get_alarm_state(area['mode'])
+        if self._state == STATE_ALARM_DISARMED:
+            self._changed_by = area.get('last_unset_user_name', 'unknown')
+        else:
+            self._changed_by = area.get('last_set_user_name', 'unknown')
+        self._api = api

    @asyncio.coroutine
-    def async_update_from_spc(self, state):
+    def async_added_to_hass(self):
+        """Calbback for init handlers."""
+        self.hass.data[DATA_REGISTRY].register_alarm_device(
+            self._area_id, self)
+
+    @asyncio.coroutine
+    def async_update_from_spc(self, state, extra):
        """Update the alarm panel with a new state."""
        self._state = state
-        yield from self.async_update_ha_state()
+        self._changed_by = extra.get('changed_by', 'unknown')
+        self.async_schedule_update_ha_state()

    @property
    def should_poll(self):
@@ -72,6 +78,11 @@ class SpcAlarm(alarm.AlarmControlPanel):
        """Return the name of the device."""
        return self._name

+    @property
+    def changed_by(self):
+        """Return the user the last change was triggered by."""
+        return self._changed_by
+
    @property
    def state(self):
        """Return the state of the device."""
@@ -16,7 +16,7 @@ from homeassistant.const import (
    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']
+REQUIREMENTS = ['total_connect_client==0.16']

 _LOGGER = logging.getLogger(__name__)

@@ -15,4 +15,6 @@ ATTR_STREAM_URL = 'streamUrl'
 ATTR_MAIN_TEXT = 'mainText'
 ATTR_REDIRECTION_URL = 'redirectionURL'

+SYN_RESOLUTION_MATCH = 'ER_SUCCESS_MATCH'
+
 DATE_FORMAT = '%Y-%m-%dT%H:%M:%S.0Z'
@@ -3,6 +3,7 @@ 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 enum
@@ -13,7 +14,7 @@ from homeassistant.const import HTTP_BAD_REQUEST
 from homeassistant.helpers import intent
 from homeassistant.components import http

-from .const import DOMAIN
+from .const import DOMAIN, SYN_RESOLUTION_MATCH

 INTENTS_API_ENDPOINT = '/api/alexa'

@@ -123,6 +124,43 @@ class AlexaIntentsView(http.HomeAssistantView):
        return self.json(alexa_response)


+def resolve_slot_synonyms(key, request):
+    """Check slot request for synonym resolutions."""
+    # Default to the spoken slot value if more than one or none are found. For
+    # reference to the request object structure, see the Alexa docs:
+    # https://tinyurl.com/ybvm7jhs
+    resolved_value = request['value']
+
+    if ('resolutions' in request and
+            'resolutionsPerAuthority' in request['resolutions'] and
+            len(request['resolutions']['resolutionsPerAuthority']) >= 1):
+
+        # Extract all of the possible values from each authority with a
+        # successful match
+        possible_values = []
+
+        for entry in request['resolutions']['resolutionsPerAuthority']:
+            if entry['status']['code'] != SYN_RESOLUTION_MATCH:
+                continue
+
+            possible_values.extend([item['value']['name']
+                                    for item
+                                    in entry['values']])
+
+        # If there is only one match use the resolved value, otherwise the
+        # resolution cannot be determined, so use the spoken slot value
+        if len(possible_values) == 1:
+            resolved_value = possible_values[0]
+        else:
+            _LOGGER.debug(
+                'Found multiple synonym resolutions for slot value: {%s: %s}',
+                key,
+                request['value']
+            )
+
+    return resolved_value
+
+
 class AlexaResponse(object):
    """Help generating the response for Alexa."""

@@ -135,12 +173,17 @@ class AlexaResponse(object):
        self.session_attributes = {}
        self.should_end_session = True
        self.variables = {}
+
        # Intent is None if request was a LaunchRequest or SessionEndedRequest
        if intent_info is not None:
            for key, value in intent_info.get('slots', {}).items():
-                if 'value' in value:
-                    underscored_key = key.replace('.', '_')
-                    self.variables[underscored_key] = value['value']
+                # Only include slots with values
+                if 'value' not in value:
+                    continue
+
+                _key = key.replace('.', '_')
+
+                self.variables[_key] = resolve_slot_synonyms(key, value)

    def add_card(self, card_type, title, content):
        """Add a card to the response."""
@@ -1,35 +1,83 @@
 """Support for alexa Smart Home Skill API."""
 import asyncio
+from collections import namedtuple
 import logging
+import math
 from uuid import uuid4

+import homeassistant.core as ha
 from homeassistant.const import (
-    ATTR_SUPPORTED_FEATURES, ATTR_ENTITY_ID, SERVICE_TURN_ON, SERVICE_TURN_OFF)
-from homeassistant.components import switch, light
+    ATTR_ENTITY_ID, ATTR_SUPPORTED_FEATURES, SERVICE_LOCK,
+    SERVICE_MEDIA_NEXT_TRACK, SERVICE_MEDIA_PAUSE, SERVICE_MEDIA_PLAY,
+    SERVICE_MEDIA_PREVIOUS_TRACK, SERVICE_MEDIA_STOP,
+    SERVICE_SET_COVER_POSITION, SERVICE_TURN_OFF, SERVICE_TURN_ON,
+    SERVICE_UNLOCK, SERVICE_VOLUME_SET)
+from homeassistant.components import (
+    alert, automation, cover, fan, group, input_boolean, light, lock,
+    media_player, scene, script, switch)
+import homeassistant.util.color as color_util
 from homeassistant.util.decorator import Registry

 HANDLERS = Registry()
 _LOGGER = logging.getLogger(__name__)

 API_DIRECTIVE = 'directive'
+API_ENDPOINT = 'endpoint'
 API_EVENT = 'event'
 API_HEADER = 'header'
 API_PAYLOAD = 'payload'
-API_ENDPOINT = 'endpoint'
+
+ATTR_ALEXA_DESCRIPTION = 'alexa_description'
+ATTR_ALEXA_DISPLAY_CATEGORIES = 'alexa_display_categories'
+ATTR_ALEXA_HIDDEN = 'alexa_hidden'
+ATTR_ALEXA_NAME = 'alexa_name'


 MAPPING_COMPONENT = {
-    switch.DOMAIN: ['SWITCH', ('Alexa.PowerController',), None],
-    light.DOMAIN: [
-        'LIGHT', ('Alexa.PowerController',), {
-            light.SUPPORT_BRIGHTNESS: 'Alexa.BrightnessController'
+    alert.DOMAIN: ['OTHER', ('Alexa.PowerController',), None],
+    automation.DOMAIN: ['OTHER', ('Alexa.PowerController',), None],
+    cover.DOMAIN: [
+        'DOOR', ('Alexa.PowerController',), {
+            cover.SUPPORT_SET_POSITION: 'Alexa.PercentageController',
        }
    ],
+    fan.DOMAIN: [
+        'OTHER', ('Alexa.PowerController',), {
+            fan.SUPPORT_SET_SPEED: 'Alexa.PercentageController',
+        }
+    ],
+    group.DOMAIN: ['OTHER', ('Alexa.PowerController',), None],
+    input_boolean.DOMAIN: ['OTHER', ('Alexa.PowerController',), None],
+    light.DOMAIN: [
+        'LIGHT', ('Alexa.PowerController',), {
+            light.SUPPORT_BRIGHTNESS: 'Alexa.BrightnessController',
+            light.SUPPORT_RGB_COLOR: 'Alexa.ColorController',
+            light.SUPPORT_XY_COLOR: 'Alexa.ColorController',
+            light.SUPPORT_COLOR_TEMP: 'Alexa.ColorTemperatureController',
+        }
+    ],
+    lock.DOMAIN: ['SMARTLOCK', ('Alexa.LockController',), None],
+    media_player.DOMAIN: [
+        'TV', ('Alexa.PowerController',), {
+            media_player.SUPPORT_VOLUME_SET: 'Alexa.Speaker',
+            media_player.SUPPORT_PLAY: 'Alexa.PlaybackController',
+            media_player.SUPPORT_PAUSE: 'Alexa.PlaybackController',
+            media_player.SUPPORT_STOP: 'Alexa.PlaybackController',
+            media_player.SUPPORT_NEXT_TRACK: 'Alexa.PlaybackController',
+            media_player.SUPPORT_PREVIOUS_TRACK: 'Alexa.PlaybackController',
+        }
+    ],
+    scene.DOMAIN: ['ACTIVITY_TRIGGER', ('Alexa.SceneController',), None],
+    script.DOMAIN: ['OTHER', ('Alexa.PowerController',), None],
+    switch.DOMAIN: ['SWITCH', ('Alexa.PowerController',), None],
 }


+Config = namedtuple('AlexaConfig', 'filter')
+
+
@asyncio.coroutine
-def async_handle_message(hass, message):
+def async_handle_message(hass, config, message):
    """Handle incoming API messages."""
    assert message[API_DIRECTIVE][API_HEADER]['payloadVersion'] == '3'

@@ -45,7 +93,7 @@ def async_handle_message(hass, message):
            "Unsupported API request %s/%s", namespace, name)
        return api_error(message)

-    return (yield from funct_ref(hass, message))
+    return (yield from funct_ref(hass, config, message))


 def api_message(request, name='Response', namespace='Alexa', payload=None):
@@ -94,7 +142,7 @@ def api_error(request, error_type='INTERNAL_ERROR', error_message=""):

@HANDLERS.register(('Alexa.Discovery', 'Discover'))
@asyncio.coroutine
-def async_api_discovery(hass, request):
+def async_api_discovery(hass, config, request):
    """Create a API formatted discovery response.

    Async friendly.
@@ -102,18 +150,40 @@ def async_api_discovery(hass, request):
    discovery_endpoints = []

    for entity in hass.states.async_all():
+        if not config.filter(entity.entity_id):
+            _LOGGER.debug("Not exposing %s because filtered by config",
+                          entity.entity_id)
+            continue
+
+        if entity.attributes.get(ATTR_ALEXA_HIDDEN, False):
+            _LOGGER.debug("Not exposing %s because alexa_hidden is true",
+                          entity.entity_id)
+            continue
+
        class_data = MAPPING_COMPONENT.get(entity.domain)

        if not class_data:
            continue

+        friendly_name = entity.attributes.get(ATTR_ALEXA_NAME, entity.name)
+        description = entity.attributes.get(ATTR_ALEXA_DESCRIPTION,
+                                            entity.entity_id)
+
+        # Required description as per Amazon Scene docs
+        if entity.domain == scene.DOMAIN:
+            scene_fmt = '{} (Scene connected via Home Assistant)'
+            description = scene_fmt.format(description)
+
+        cat_key = ATTR_ALEXA_DISPLAY_CATEGORIES
+        display_categories = entity.attributes.get(cat_key, class_data[0])
+
        endpoint = {
-            'displayCategories': [class_data[0]],
+            'displayCategories': [display_categories],
            'additionalApplianceDetails': {},
            'endpointId': entity.entity_id.replace('.', '#'),
-            'friendlyName': entity.name,
-            'description': '',
-            'manufacturerName': 'Unknown',
+            'friendlyName': friendly_name,
+            'description': description,
+            'manufacturerName': 'Home Assistant',
        }
        actions = set()

@@ -148,7 +218,7 @@ def async_api_discovery(hass, request):
 def extract_entity(funct):
    """Decorator for extract entity object from request."""
    @asyncio.coroutine
-    def async_api_entity_wrapper(hass, request):
+    def async_api_entity_wrapper(hass, config, request):
        """Process a turn on request."""
        entity_id = request[API_ENDPOINT]['endpointId'].replace('#', '.')

@@ -159,7 +229,7 @@ def extract_entity(funct):
                          request[API_HEADER]['name'], entity_id)
            return api_error(request, error_type='NO_SUCH_ENDPOINT')

-        return (yield from funct(hass, request, entity))
+        return (yield from funct(hass, config, request, entity))

    return async_api_entity_wrapper

@@ -167,9 +237,13 @@ def extract_entity(funct):
@HANDLERS.register(('Alexa.PowerController', 'TurnOn'))
@extract_entity
@asyncio.coroutine
-def async_api_turn_on(hass, request, entity):
+def async_api_turn_on(hass, config, request, entity):
    """Process a turn on request."""
-    yield from hass.services.async_call(entity.domain, SERVICE_TURN_ON, {
+    domain = entity.domain
+    if entity.domain == group.DOMAIN:
+        domain = ha.DOMAIN
+
+    yield from hass.services.async_call(domain, SERVICE_TURN_ON, {
        ATTR_ENTITY_ID: entity.entity_id
    }, blocking=True)

@@ -179,9 +253,13 @@ def async_api_turn_on(hass, request, entity):
@HANDLERS.register(('Alexa.PowerController', 'TurnOff'))
@extract_entity
@asyncio.coroutine
-def async_api_turn_off(hass, request, entity):
+def async_api_turn_off(hass, config, request, entity):
    """Process a turn off request."""
-    yield from hass.services.async_call(entity.domain, SERVICE_TURN_OFF, {
+    domain = entity.domain
+    if entity.domain == group.DOMAIN:
+        domain = ha.DOMAIN
+
+    yield from hass.services.async_call(domain, SERVICE_TURN_OFF, {
        ATTR_ENTITY_ID: entity.entity_id
    }, blocking=True)

@@ -191,13 +269,375 @@ def async_api_turn_off(hass, request, entity):
@HANDLERS.register(('Alexa.BrightnessController', 'SetBrightness'))
@extract_entity
@asyncio.coroutine
-def async_api_set_brightness(hass, request, entity):
+def async_api_set_brightness(hass, config, request, entity):
    """Process a set brightness request."""
-    brightness = request[API_PAYLOAD]['brightness']
+    brightness = int(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,
+        light.ATTR_BRIGHTNESS_PCT: brightness,
    }, blocking=True)

    return api_message(request)
+
+
+@HANDLERS.register(('Alexa.BrightnessController', 'AdjustBrightness'))
+@extract_entity
+@asyncio.coroutine
+def async_api_adjust_brightness(hass, config, request, entity):
+    """Process a adjust brightness request."""
+    brightness_delta = int(request[API_PAYLOAD]['brightnessDelta'])
+
+    # read current state
+    try:
+        current = math.floor(
+            int(entity.attributes.get(light.ATTR_BRIGHTNESS)) / 255 * 100)
+    except ZeroDivisionError:
+        current = 0
+
+    # set brightness
+    brightness = max(0, brightness_delta + current)
+    yield from hass.services.async_call(entity.domain, SERVICE_TURN_ON, {
+        ATTR_ENTITY_ID: entity.entity_id,
+        light.ATTR_BRIGHTNESS_PCT: brightness,
+    }, blocking=True)
+
+    return api_message(request)
+
+
+@HANDLERS.register(('Alexa.ColorController', 'SetColor'))
+@extract_entity
+@asyncio.coroutine
+def async_api_set_color(hass, config, request, entity):
+    """Process a set color request."""
+    supported = entity.attributes.get(ATTR_SUPPORTED_FEATURES)
+    rgb = color_util.color_hsb_to_RGB(
+        float(request[API_PAYLOAD]['color']['hue']),
+        float(request[API_PAYLOAD]['color']['saturation']),
+        float(request[API_PAYLOAD]['color']['brightness'])
+    )
+
+    if supported & light.SUPPORT_RGB_COLOR > 0:
+        yield from hass.services.async_call(entity.domain, SERVICE_TURN_ON, {
+            ATTR_ENTITY_ID: entity.entity_id,
+            light.ATTR_RGB_COLOR: rgb,
+        }, blocking=True)
+    else:
+        xyz = color_util.color_RGB_to_xy(*rgb)
+        yield from hass.services.async_call(entity.domain, SERVICE_TURN_ON, {
+            ATTR_ENTITY_ID: entity.entity_id,
+            light.ATTR_XY_COLOR: (xyz[0], xyz[1]),
+            light.ATTR_BRIGHTNESS: xyz[2],
+        }, blocking=True)
+
+    return api_message(request)
+
+
+@HANDLERS.register(('Alexa.ColorTemperatureController', 'SetColorTemperature'))
+@extract_entity
+@asyncio.coroutine
+def async_api_set_color_temperature(hass, config, request, entity):
+    """Process a set color temperature request."""
+    kelvin = int(request[API_PAYLOAD]['colorTemperatureInKelvin'])
+
+    yield from hass.services.async_call(entity.domain, SERVICE_TURN_ON, {
+        ATTR_ENTITY_ID: entity.entity_id,
+        light.ATTR_KELVIN: kelvin,
+    }, blocking=True)
+
+    return api_message(request)
+
+
+@HANDLERS.register(
+    ('Alexa.ColorTemperatureController', 'DecreaseColorTemperature'))
+@extract_entity
+@asyncio.coroutine
+def async_api_decrease_color_temp(hass, config, request, entity):
+    """Process a decrease color temperature request."""
+    current = int(entity.attributes.get(light.ATTR_COLOR_TEMP))
+    max_mireds = int(entity.attributes.get(light.ATTR_MAX_MIREDS))
+
+    value = min(max_mireds, current + 50)
+    yield from hass.services.async_call(entity.domain, SERVICE_TURN_ON, {
+        ATTR_ENTITY_ID: entity.entity_id,
+        light.ATTR_COLOR_TEMP: value,
+    }, blocking=True)
+
+    return api_message(request)
+
+
+@HANDLERS.register(
+    ('Alexa.ColorTemperatureController', 'IncreaseColorTemperature'))
+@extract_entity
+@asyncio.coroutine
+def async_api_increase_color_temp(hass, config, request, entity):
+    """Process a increase color temperature request."""
+    current = int(entity.attributes.get(light.ATTR_COLOR_TEMP))
+    min_mireds = int(entity.attributes.get(light.ATTR_MIN_MIREDS))
+
+    value = max(min_mireds, current - 50)
+    yield from hass.services.async_call(entity.domain, SERVICE_TURN_ON, {
+        ATTR_ENTITY_ID: entity.entity_id,
+        light.ATTR_COLOR_TEMP: value,
+    }, blocking=True)
+
+    return api_message(request)
+
+
+@HANDLERS.register(('Alexa.SceneController', 'Activate'))
+@extract_entity
+@asyncio.coroutine
+def async_api_activate(hass, config, request, entity):
+    """Process a activate 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.PercentageController', 'SetPercentage'))
+@extract_entity
+@asyncio.coroutine
+def async_api_set_percentage(hass, config, request, entity):
+    """Process a set percentage request."""
+    percentage = int(request[API_PAYLOAD]['percentage'])
+    service = None
+    data = {ATTR_ENTITY_ID: entity.entity_id}
+
+    if entity.domain == fan.DOMAIN:
+        service = fan.SERVICE_SET_SPEED
+        speed = "off"
+
+        if percentage <= 33:
+            speed = "low"
+        elif percentage <= 66:
+            speed = "medium"
+        elif percentage <= 100:
+            speed = "high"
+        data[fan.ATTR_SPEED] = speed
+
+    elif entity.domain == cover.DOMAIN:
+        service = SERVICE_SET_COVER_POSITION
+        data[cover.ATTR_POSITION] = percentage
+
+    yield from hass.services.async_call(entity.domain, service,
+                                        data, blocking=True)
+
+    return api_message(request)
+
+
+@HANDLERS.register(('Alexa.PercentageController', 'AdjustPercentage'))
+@extract_entity
+@asyncio.coroutine
+def async_api_adjust_percentage(hass, config, request, entity):
+    """Process a adjust percentage request."""
+    percentage_delta = int(request[API_PAYLOAD]['percentageDelta'])
+    service = None
+    data = {ATTR_ENTITY_ID: entity.entity_id}
+
+    if entity.domain == fan.DOMAIN:
+        service = fan.SERVICE_SET_SPEED
+        speed = entity.attributes.get(fan.ATTR_SPEED)
+
+        if speed == "off":
+            current = 0
+        elif speed == "low":
+            current = 33
+        elif speed == "medium":
+            current = 66
+        elif speed == "high":
+            current = 100
+
+        # set percentage
+        percentage = max(0, percentage_delta + current)
+        speed = "off"
+
+        if percentage <= 33:
+            speed = "low"
+        elif percentage <= 66:
+            speed = "medium"
+        elif percentage <= 100:
+            speed = "high"
+
+        data[fan.ATTR_SPEED] = speed
+
+    elif entity.domain == cover.DOMAIN:
+        service = SERVICE_SET_COVER_POSITION
+
+        current = entity.attributes.get(cover.ATTR_POSITION)
+
+        data[cover.ATTR_POSITION] = max(0, percentage_delta + current)
+
+    yield from hass.services.async_call(entity.domain, service,
+                                        data, blocking=True)
+
+    return api_message(request)
+
+
+@HANDLERS.register(('Alexa.LockController', 'Lock'))
+@extract_entity
+@asyncio.coroutine
+def async_api_lock(hass, config, request, entity):
+    """Process a lock request."""
+    yield from hass.services.async_call(entity.domain, SERVICE_LOCK, {
+        ATTR_ENTITY_ID: entity.entity_id
+    }, blocking=True)
+
+    return api_message(request)
+
+
+# Not supported by Alexa yet
+@HANDLERS.register(('Alexa.LockController', 'Unlock'))
+@extract_entity
+@asyncio.coroutine
+def async_api_unlock(hass, config, request, entity):
+    """Process a unlock request."""
+    yield from hass.services.async_call(entity.domain, SERVICE_UNLOCK, {
+        ATTR_ENTITY_ID: entity.entity_id
+    }, blocking=True)
+
+    return api_message(request)
+
+
+@HANDLERS.register(('Alexa.Speaker', 'SetVolume'))
+@extract_entity
+@asyncio.coroutine
+def async_api_set_volume(hass, config, request, entity):
+    """Process a set volume request."""
+    volume = round(float(request[API_PAYLOAD]['volume'] / 100), 2)
+
+    data = {
+        ATTR_ENTITY_ID: entity.entity_id,
+        media_player.ATTR_MEDIA_VOLUME_LEVEL: volume,
+    }
+
+    yield from hass.services.async_call(entity.domain, SERVICE_VOLUME_SET,
+                                        data, blocking=True)
+
+    return api_message(request)
+
+
+@HANDLERS.register(('Alexa.Speaker', 'AdjustVolume'))
+@extract_entity
+@asyncio.coroutine
+def async_api_adjust_volume(hass, config, request, entity):
+    """Process a adjust volume request."""
+    volume_delta = int(request[API_PAYLOAD]['volume'])
+
+    current_level = entity.attributes.get(media_player.ATTR_MEDIA_VOLUME_LEVEL)
+
+    # read current state
+    try:
+        current = math.floor(int(current_level * 100))
+    except ZeroDivisionError:
+        current = 0
+
+    volume = float(max(0, volume_delta + current) / 100)
+
+    data = {
+        ATTR_ENTITY_ID: entity.entity_id,
+        media_player.ATTR_MEDIA_VOLUME_LEVEL: volume,
+    }
+
+    yield from hass.services.async_call(entity.domain,
+                                        media_player.SERVICE_VOLUME_SET,
+                                        data, blocking=True)
+
+    return api_message(request)
+
+
+@HANDLERS.register(('Alexa.Speaker', 'SetMute'))
+@extract_entity
+@asyncio.coroutine
+def async_api_set_mute(hass, config, request, entity):
+    """Process a set mute request."""
+    mute = bool(request[API_PAYLOAD]['mute'])
+
+    data = {
+        ATTR_ENTITY_ID: entity.entity_id,
+        media_player.ATTR_MEDIA_VOLUME_MUTED: mute,
+    }
+
+    yield from hass.services.async_call(entity.domain,
+                                        media_player.SERVICE_VOLUME_MUTE,
+                                        data, blocking=True)
+
+    return api_message(request)
+
+
+@HANDLERS.register(('Alexa.PlaybackController', 'Play'))
+@extract_entity
+@asyncio.coroutine
+def async_api_play(hass, config, request, entity):
+    """Process a play request."""
+    data = {
+        ATTR_ENTITY_ID: entity.entity_id
+    }
+
+    yield from hass.services.async_call(entity.domain, SERVICE_MEDIA_PLAY,
+                                        data, blocking=True)
+
+    return api_message(request)
+
+
+@HANDLERS.register(('Alexa.PlaybackController', 'Pause'))
+@extract_entity
+@asyncio.coroutine
+def async_api_pause(hass, config, request, entity):
+    """Process a pause request."""
+    data = {
+        ATTR_ENTITY_ID: entity.entity_id
+    }
+
+    yield from hass.services.async_call(entity.domain, SERVICE_MEDIA_PAUSE,
+                                        data, blocking=True)
+
+    return api_message(request)
+
+
+@HANDLERS.register(('Alexa.PlaybackController', 'Stop'))
+@extract_entity
+@asyncio.coroutine
+def async_api_stop(hass, config, request, entity):
+    """Process a stop request."""
+    data = {
+        ATTR_ENTITY_ID: entity.entity_id
+    }
+
+    yield from hass.services.async_call(entity.domain, SERVICE_MEDIA_STOP,
+                                        data, blocking=True)
+
+    return api_message(request)
+
+
+@HANDLERS.register(('Alexa.PlaybackController', 'Next'))
+@extract_entity
+@asyncio.coroutine
+def async_api_next(hass, config, request, entity):
+    """Process a next request."""
+    data = {
+        ATTR_ENTITY_ID: entity.entity_id
+    }
+
+    yield from hass.services.async_call(entity.domain,
+                                        SERVICE_MEDIA_NEXT_TRACK,
+                                        data, blocking=True)
+
+    return api_message(request)
+
+
+@HANDLERS.register(('Alexa.PlaybackController', 'Previous'))
+@extract_entity
+@asyncio.coroutine
+def async_api_previous(hass, config, request, entity):
+    """Process a previous request."""
+    data = {
+        ATTR_ENTITY_ID: entity.entity_id
+    }
+
+    yield from hass.services.async_call(entity.domain,
+                                        SERVICE_MEDIA_PREVIOUS_TRACK,
+                                        data, blocking=True)
+
+    return api_message(request)
@@ -89,6 +89,7 @@ def setup(hass, config):
    """Set up the Amcrest IP Camera component."""
    from amcrest import AmcrestCamera

+    hass.data[DATA_AMCREST] = {}
    amcrest_cams = config[DOMAIN]

    for device in amcrest_cams:
@@ -126,22 +127,34 @@ def setup(hass, config):
            else:
                authentication = None

+        hass.data[DATA_AMCREST][name] = AmcrestDevice(
+            camera, name, authentication, ffmpeg_arguments, stream_source,
+            resolution)
+
        discovery.load_platform(
            hass, 'camera', DOMAIN, {
-                'device': camera,
-                CONF_AUTHENTICATION: authentication,
-                CONF_FFMPEG_ARGUMENTS: ffmpeg_arguments,
                CONF_NAME: name,
-                CONF_RESOLUTION: resolution,
-                CONF_STREAM_SOURCE: stream_source,
            }, config)

        if sensors:
            discovery.load_platform(
                hass, 'sensor', DOMAIN, {
-                    'device': camera,
                    CONF_NAME: name,
                    CONF_SENSORS: sensors,
                }, config)

    return True
+
+
+class AmcrestDevice(object):
+    """Representation of a base Amcrest discovery device."""
+
+    def __init__(self, camera, name, authentication, ffmpeg_arguments,
+                 stream_source, resolution):
+        """Initialize the entity."""
+        self.device = camera
+        self.name = name
+        self.authentication = authentication
+        self.ffmpeg_arguments = ffmpeg_arguments
+        self.stream_source = stream_source
+        self.resolution = resolution
@@ -262,7 +262,11 @@ class APIEventView(HomeAssistantView):
    def post(self, request, event_type):
        """Fire events."""
        body = yield from request.text()
-        event_data = json.loads(body) if body else None
+        try:
+            event_data = json.loads(body) if body else None
+        except ValueError:
+            return self.json_message('Event data should be valid JSON',
+                                     HTTP_BAD_REQUEST)

        if event_data is not None and not isinstance(event_data, dict):
            return self.json_message('Event data should be a JSON object',
@@ -309,7 +313,11 @@ class APIDomainServicesView(HomeAssistantView):
        """
        hass = request.app['hass']
        body = yield from request.text()
-        data = json.loads(body) if body else None
+        try:
+            data = json.loads(body) if body else None
+        except ValueError:
+            return self.json_message('Data should be valid JSON',
+                                     HTTP_BAD_REQUEST)

        with AsyncTrackStates(hass) as changed_states:
            yield from hass.services.async_call(domain, service, data, True)
@@ -18,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.5']
+REQUIREMENTS = ['pyatv==0.3.8']

 _LOGGER = logging.getLogger(__name__)

@@ -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.7']
+REQUIREMENTS = ['pyarlo==0.1.0']

 _LOGGER = logging.getLogger(__name__)

@@ -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, default={}): dict,
+    vol.Optional(CONF_EVENT_DATA): dict,
 })


@@ -31,16 +31,19 @@ def async_trigger(hass, config, action):
    event_type = config.get(CONF_EVENT_TYPE)
    event_data_schema = vol.Schema(
        config.get(CONF_EVENT_DATA),
-        extra=vol.ALLOW_EXTRA)
+        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."""
-        try:
-            event_data_schema(event.data)
-        except vol.Invalid:
-            # If event data doesn't match requested schema, skip event
-            return
+        if event_data_schema:
+            # Check that the event data matches the configured
+            # schema if one was provided
+            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': {
@@ -37,14 +37,15 @@ def async_trigger(hass, config, action):
    above = config.get(CONF_ABOVE)
    time_delta = config.get(CONF_FOR)
    value_template = config.get(CONF_VALUE_TEMPLATE)
-    async_remove_track_same = None
+    unsub_track_same = {}
+    entities_triggered = set()

    if value_template is not None:
        value_template.hass = hass

    @callback
    def check_numeric_state(entity, from_s, to_s):
-        """Return True if they should trigger."""
+        """Return True if criteria are now met."""
        if to_s is None:
            return False

@@ -56,51 +57,39 @@ def async_trigger(hass, config, action):
                'above': above,
            }
        }
-
-        # 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
+        return condition.async_numeric_state(
+            hass, to_s, below, above, value_template, variables)

    @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
-
        @callback
        def call_action():
            """Call action with right context."""
-            hass.async_run_job(action, variables)
+            hass.async_run_job(action, {
+                'trigger': {
+                    'platform': 'numeric_state',
+                    'entity_id': entity,
+                    'below': below,
+                    'above': above,
+                    'from_state': from_s,
+                    'to_state': to_s,
+                }
+            })

-        if not time_delta:
-            call_action()
-            return
+        matching = check_numeric_state(entity, from_s, to_s)

-        async_remove_track_same = async_track_same_state(
-            hass, time_delta, call_action, entity_ids=entity_id,
-            async_check_same_func=check_numeric_state)
+        if not matching:
+            entities_triggered.discard(entity)
+        elif entity not in entities_triggered:
+            entities_triggered.add(entity)
+
+            if time_delta:
+                unsub_track_same[entity] = async_track_same_state(
+                    hass, time_delta, call_action, entity_ids=entity_id,
+                    async_check_same_func=check_numeric_state)
+            else:
+                call_action()

    unsub = async_track_state_change(
        hass, entity_id, state_automation_listener)
@@ -109,7 +98,8 @@ def async_trigger(hass, config, action):
    def async_remove():
        """Remove state listeners async."""
        unsub()
-        if async_remove_track_same:
-            async_remove_track_same()  # pylint: disable=not-callable
+        for async_remove in unsub_track_same.values():
+            async_remove()
+        unsub_track_same.clear()

    return async_remove
@@ -1,6 +1,7 @@
+# Describes the format for available automation services
+
 turn_on:
  description: Enable an automation.
-
  fields:
    entity_id:
      description: Name of the automation to turn on.
@@ -8,7 +9,6 @@ turn_on:

 turn_off:
  description: Disable an automation.
-
  fields:
    entity_id:
      description: Name of the automation to turn off.
@@ -16,7 +16,6 @@ turn_off:

 toggle:
  description: Toggle an automation.
-
  fields:
    entity_id:
      description: Name of the automation to toggle on/off.
@@ -24,7 +23,6 @@ toggle:

 trigger:
  description: Trigger the action of an automation.
-
  fields:
    entity_id:
      description: Name of the automation to trigger.
@@ -35,13 +35,11 @@ def async_trigger(hass, config, action):
    to_state = config.get(CONF_TO, MATCH_ALL)
    time_delta = config.get(CONF_FOR)
    match_all = (from_state == MATCH_ALL and to_state == MATCH_ALL)
-    async_remove_track_same = None
+    unsub_track_same = {}

    @callback
    def state_automation_listener(entity, from_s, to_s):
        """Listen for state changes and calls action."""
-        nonlocal async_remove_track_same
-
        @callback
        def call_action():
            """Call action with right context."""
@@ -64,7 +62,7 @@ def async_trigger(hass, config, action):
            call_action()
            return

-        async_remove_track_same = async_track_same_state(
+        unsub_track_same[entity] = async_track_same_state(
            hass, time_delta, call_action,
            lambda _, _2, to_state: to_state.state == to_s.state,
            entity_ids=entity_id)
@@ -76,7 +74,8 @@ def async_trigger(hass, config, action):
    def async_remove():
        """Remove state listeners async."""
        unsub()
-        if async_remove_track_same:
-            async_remove_track_same()  # pylint: disable=not-callable
+        for async_remove in unsub_track_same.values():
+            async_remove()
+        unsub_track_same.clear()

    return async_remove
@@ -5,25 +5,26 @@ For more details about this component, please refer to the documentation at
 https://home-assistant.io/components/axis/
 """

-import json
 import logging
 import os

 import voluptuous as vol

+from homeassistant.components.discovery import SERVICE_AXIS
 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_PORT, CONF_TRIGGER_TIME,
-                                 CONF_USERNAME, EVENT_HOMEASSISTANT_STOP)
-from homeassistant.components.discovery import SERVICE_AXIS
+                                 CONF_EVENT, CONF_HOST, CONF_INCLUDE,
+                                 CONF_NAME, CONF_PASSWORD, CONF_PORT,
+                                 CONF_TRIGGER_TIME, CONF_USERNAME,
+                                 EVENT_HOMEASSISTANT_STOP)
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers import discovery
-from homeassistant.helpers.dispatcher import async_dispatcher_send
+from homeassistant.helpers.dispatcher import dispatcher_send
 from homeassistant.helpers.entity import Entity
+from homeassistant.util.json import load_json, save_json


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

 _LOGGER = logging.getLogger(__name__)

@@ -87,10 +88,13 @@ def request_configuration(hass, config, name, host, serialnumber):
            configurator.notify_errors(request_id,
                                       "Functionality mandatory.")
            return False
+
        callback_data[CONF_INCLUDE] = callback_data[CONF_INCLUDE].split()
        callback_data[CONF_HOST] = host
+
        if CONF_NAME not in callback_data:
            callback_data[CONF_NAME] = name
+
        try:
            device_config = DEVICE_SCHEMA(callback_data)
        except vol.Invalid:
@@ -99,10 +103,9 @@ def request_configuration(hass, config, name, host, serialnumber):
            return False

        if setup_device(hass, config, device_config):
-            config_file = _read_config(hass)
+            config_file = load_json(hass.config.path(CONFIG_FILE))
            config_file[serialnumber] = dict(device_config)
-            del config_file[serialnumber]['hass']
-            _write_config(hass, config_file)
+            save_json(hass.config.path(CONFIG_FILE), config_file)
            configurator.request_done(request_id)
        else:
            configurator.notify_errors(request_id,
@@ -146,10 +149,10 @@ def request_configuration(hass, config, name, host, serialnumber):
 def setup(hass, config):
    """Common setup for Axis devices."""
    def _shutdown(call):  # pylint: disable=unused-argument
-        """Stop the metadatastream on shutdown."""
+        """Stop the event stream on shutdown."""
        for serialnumber, device in AXIS_DEVICES.items():
-            _LOGGER.info("Stopping metadatastream for %s.", serialnumber)
-            device.stop_metadatastream()
+            _LOGGER.info("Stopping event stream for %s.", serialnumber)
+            device.stop()

    hass.bus.listen_once(EVENT_HOMEASSISTANT_STOP, _shutdown)

@@ -160,9 +163,9 @@ def setup(hass, config):
        serialnumber = discovery_info['properties']['macaddress']

        if serialnumber not in AXIS_DEVICES:
-            config_file = _read_config(hass)
+            config_file = load_json(hass.config.path(CONFIG_FILE))
            if serialnumber in config_file:
-                # Device config saved to file
+                # Device config previously saved to file
                try:
                    device_config = DEVICE_SCHEMA(config_file[serialnumber])
                    device_config[CONF_HOST] = host
@@ -178,10 +181,8 @@ def setup(hass, config):
        else:
            # Device already registered, but on a different IP
            device = AXIS_DEVICES[serialnumber]
-            device.url = host
-            async_dispatcher_send(hass,
-                                  DOMAIN + '_' + device.name + '_new_ip',
-                                  host)
+            device.config.host = host
+            dispatcher_send(hass, DOMAIN + '_' + device.name + '_new_ip', host)

    # Register discovery service
    discovery.listen(hass, SERVICE_AXIS, axis_device_discovered)
@@ -202,10 +203,11 @@ def setup(hass, config):
        """Service to send a message."""
        for _, device in AXIS_DEVICES.items():
            if device.name == call.data[CONF_NAME]:
-                response = device.do_request(call.data[SERVICE_CGI],
-                                             call.data[SERVICE_ACTION],
-                                             call.data[SERVICE_PARAM])
-                hass.bus.async_fire(SERVICE_VAPIX_CALL_RESPONSE, response)
+                response = device.vapix.do_request(
+                    call.data[SERVICE_CGI],
+                    call.data[SERVICE_ACTION],
+                    call.data[SERVICE_PARAM])
+                hass.bus.fire(SERVICE_VAPIX_CALL_RESPONSE, response)
                return True
        _LOGGER.info("Couldn\'t find device %s", call.data[CONF_NAME])
        return False
@@ -216,7 +218,6 @@ def setup(hass, config):
                           vapix_service,
                           descriptions[DOMAIN][SERVICE_VAPIX_CALL],
                           schema=SERVICE_SCHEMA)
-
    return True


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

-    device_config['hass'] = hass
-    device = AxisDevice(device_config)  # Initialize device
-    enable_metadatastream = False
+    def signal_callback(action, event):
+        """Callback to configure events when initialized on event stream."""
+        if action == 'add':
+            event_config = {
+                CONF_EVENT: event,
+                CONF_NAME: device_config[CONF_NAME],
+                ATTR_LOCATION: device_config[ATTR_LOCATION],
+                CONF_TRIGGER_TIME: device_config[CONF_TRIGGER_TIME]
+            }
+            component = event.event_platform
+            discovery.load_platform(hass,
+                                    component,
+                                    DOMAIN,
+                                    event_config,
+                                    config)
+
+    event_types = list(filter(lambda x: x in device_config[CONF_INCLUDE],
+                              EVENT_TYPES))
+    device_config['events'] = event_types
+    device_config['signal'] = signal_callback
+    device = AxisDevice(hass.loop, **device_config)
+    device.name = device_config[CONF_NAME]

    if device.serial_number is None:
        # If there is no serial number a connection could not be made
@@ -234,16 +254,10 @@ def setup_device(hass, config, device_config):
        return False

    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
-            device.add_event_topic(convert(component, 'type', 'subscribe'))
-            if not enable_metadatastream:
-                enable_metadatastream = True
-        else:
+        if component == 'camera':
            camera_config = {
-                CONF_HOST: device_config[CONF_HOST],
                CONF_NAME: device_config[CONF_NAME],
+                CONF_HOST: device_config[CONF_HOST],
                CONF_PORT: device_config[CONF_PORT],
                CONF_USERNAME: device_config[CONF_USERNAME],
                CONF_PASSWORD: device_config[CONF_PASSWORD]
@@ -254,58 +268,22 @@ def setup_device(hass, config, device_config):
                                    camera_config,
                                    config)

-    if enable_metadatastream:
-        device.initialize_new_event = event_initialized
-        if not device.initiate_metadatastream():
-            hass.components.persistent_notification.create(
-                'Dependency missing for sensors, '
-                'please check documentation',
-                title=DOMAIN,
-                notification_id='axis_notification')
-
    AXIS_DEVICES[device.serial_number] = device
-
+    if event_types:
+        hass.add_job(device.start)
    return True


-def _read_config(hass):
-    """Read Axis config."""
-    path = hass.config.path(CONFIG_FILE)
-
-    if not os.path.isfile(path):
-        return {}
-
-    with open(path) as f_handle:
-        # Guard against empty file
-        return json.loads(f_handle.read() or '{}')
-
-
-def _write_config(hass, config):
-    """Write Axis config."""
-    data = json.dumps(config)
-    with open(hass.config.path(CONFIG_FILE), 'w', encoding='utf-8') as outfile:
-        outfile.write(data)
-
-
-def event_initialized(event):
-    """Register event initialized on metadatastream here."""
-    hass = event.device_config('hass')
-    discovery.load_platform(hass,
-                            convert(event.topic, 'topic', 'platform'),
-                            DOMAIN, {'axis_event': event})
-
-
 class AxisDeviceEvent(Entity):
    """Representation of a Axis device event."""

-    def __init__(self, axis_event):
+    def __init__(self, event_config):
        """Initialize the event."""
-        self.axis_event = axis_event
-        self._event_class = convert(self.axis_event.topic, 'topic', 'class')
-        self._name = '{}_{}_{}'.format(self.axis_event.device_name,
-                                       convert(self.axis_event.topic,
-                                               'topic', 'type'),
+        self.axis_event = event_config[CONF_EVENT]
+        self._name = '{}_{}_{}'.format(event_config[CONF_NAME],
+                                       self.axis_event.event_type,
                                       self.axis_event.id)
+        self.location = event_config[ATTR_LOCATION]
        self.axis_event.callback = self._update_callback

    def _update_callback(self):
@@ -321,7 +299,7 @@ class AxisDeviceEvent(Entity):
    @property
    def device_class(self):
        """Return the class of the event."""
-        return self._event_class
+        return self.axis_event.event_class

    @property
    def should_poll(self):
@@ -336,52 +314,6 @@ class AxisDeviceEvent(Entity):
        tripped = self.axis_event.is_tripped
        attr[ATTR_TRIPPED] = 'True' if tripped else 'False'

-        location = self.axis_event.device_config(ATTR_LOCATION)
-        if location:
-            attr[ATTR_LOCATION] = location
+        attr[ATTR_LOCATION] = self.location

        return attr
-
-
-def convert(item, from_key, to_key):
-    """Translate between Axis and HASS syntax."""
-    for entry in REMAP:
-        if entry[from_key] == item:
-            return entry[to_key]
-
-
-REMAP = [{'type': 'motion',
-          'class': 'motion',
-          'topic': 'tns1:VideoAnalytics/tnsaxis:MotionDetection',
-          'subscribe': 'onvif:VideoAnalytics/axis:MotionDetection',
-          'platform': 'binary_sensor'},
-         {'type': 'vmd3',
-          'class': 'motion',
-          'topic': 'tns1:RuleEngine/tnsaxis:VMD3/vmd3_video_1',
-          'subscribe': 'onvif:RuleEngine/axis:VMD3/vmd3_video_1',
-          'platform': 'binary_sensor'},
-         {'type': 'pir',
-          'class': 'motion',
-          'topic': 'tns1:Device/tnsaxis:Sensor/PIR',
-          'subscribe': 'onvif:Device/axis:Sensor/axis:PIR',
-          'platform': 'binary_sensor'},
-         {'type': 'sound',
-          'class': 'sound',
-          'topic': 'tns1:AudioSource/tnsaxis:TriggerLevel',
-          'subscribe': 'onvif:AudioSource/axis:TriggerLevel',
-          'platform': 'binary_sensor'},
-         {'type': 'daynight',
-          'class': 'light',
-          'topic': 'tns1:VideoSource/tnsaxis:DayNightVision',
-          'subscribe': 'onvif:VideoSource/axis:DayNightVision',
-          'platform': 'binary_sensor'},
-         {'type': 'tampering',
-          'class': 'safety',
-          'topic': 'tns1:VideoSource/tnsaxis:Tampering',
-          'subscribe': 'onvif:VideoSource/axis:Tampering',
-          'platform': 'binary_sensor'},
-         {'type': 'input',
-          'class': 'input',
-          'topic': 'tns1:Device/tnsaxis:IO/Port',
-          'subscribe': 'onvif:Device/axis:IO/Port',
-          'platform': 'binary_sensor'}, ]
@@ -20,6 +20,7 @@ SCAN_INTERVAL = timedelta(seconds=30)

 ENTITY_ID_FORMAT = DOMAIN + '.{}'
 DEVICE_CLASSES = [
+    'battery',       # On means low, Off means normal
    'cold',          # On means cold (or too cold)
    'connectivity',  # On means connection present, Off = no connection
    'gas',           # CO, CO2, etc.
@@ -30,7 +31,9 @@ DEVICE_CLASSES = [
    'moving',        # On means moving, Off means stopped
    'occupancy',     # On means occupied, Off means not occupied
    'opening',       # Door, window, etc.
+    'plug',          # On means plugged in, Off means unplugged
    'power',         # Power, over-current, etc
+    'presence',      # On means home, Off means away
    'safety',        # Generic on=unsafe, off=safe
    'smoke',         # Smoke detector
    'sound',         # On means sound detected, Off means no sound
@@ -7,25 +7,32 @@ https://home-assistant.io/components/binary_sensor.aurora/
 from datetime import timedelta
 import logging

+from aiohttp.hdrs import USER_AGENT
 import requests
 import voluptuous as vol

-from homeassistant.components.binary_sensor \
-    import (BinarySensorDevice, PLATFORM_SCHEMA)
-from homeassistant.const import (CONF_NAME)
+from homeassistant.components.binary_sensor import (
+    PLATFORM_SCHEMA, BinarySensorDevice)
+from homeassistant.const import CONF_NAME, ATTR_ATTRIBUTION
 import homeassistant.helpers.config_validation as cv
 from homeassistant.util import Throttle

-CONF_THRESHOLD = "forecast_threshold"
-
 _LOGGER = logging.getLogger(__name__)

+CONF_ATTRIBUTION = "Data provided by the National Oceanic and Atmospheric" \
+                   "Administration"
+CONF_THRESHOLD = 'forecast_threshold'
+
+DEFAULT_DEVICE_CLASS = 'visible'
 DEFAULT_NAME = 'Aurora Visibility'
-DEFAULT_DEVICE_CLASS = "visible"
 DEFAULT_THRESHOLD = 75

+HA_USER_AGENT = "Home Assistant Aurora Tracker v.0.1.0"
+
 MIN_TIME_BETWEEN_UPDATES = timedelta(minutes=5)

+URL = "http://services.swpc.noaa.gov/text/aurora-nowcast-map.txt"
+
 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
    vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
    vol.Optional(CONF_THRESHOLD, default=DEFAULT_THRESHOLD): cv.positive_int,
@@ -43,10 +50,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):

    try:
        aurora_data = AuroraData(
-            hass.config.latitude,
-            hass.config.longitude,
-            threshold
-        )
+            hass.config.latitude, hass.config.longitude, threshold)
        aurora_data.update()
    except requests.exceptions.HTTPError as error:
        _LOGGER.error(
@@ -85,9 +89,9 @@ class AuroraSensor(BinarySensorDevice):
        attrs = {}

        if self.aurora_data:
-            attrs["visibility_level"] = self.aurora_data.visibility_level
-            attrs["message"] = self.aurora_data.is_visible_text
-
+            attrs['visibility_level'] = self.aurora_data.visibility_level
+            attrs['message'] = self.aurora_data.is_visible_text
+            attrs[ATTR_ATTRIBUTION] = CONF_ATTRIBUTION
        return attrs

    def update(self):
@@ -104,10 +108,7 @@ class AuroraData(object):
        self.longitude = longitude
        self.number_of_latitude_intervals = 513
        self.number_of_longitude_intervals = 1024
-        self.api_url = \
-            "http://services.swpc.noaa.gov/text/aurora-nowcast-map.txt"
-        self.headers = {"User-Agent": "Home Assistant Aurora Tracker v.0.1.0"}
-
+        self.headers = {USER_AGENT: HA_USER_AGENT}
        self.threshold = int(threshold)
        self.is_visible = None
        self.is_visible_text = None
@@ -132,14 +133,14 @@ class AuroraData(object):

    def get_aurora_forecast(self):
        """Get forecast data and parse for given long/lat."""
-        raw_data = requests.get(self.api_url, headers=self.headers).text
+        raw_data = requests.get(URL, headers=self.headers, timeout=5).text
        forecast_table = [
            row.strip(" ").split("   ")
            for row in raw_data.split("\n")
            if not row.startswith("#")
        ]

-        # convert lat and long for data points in table
+        # Convert lat and long for data points in table
        converted_latitude = round((self.latitude / 180)
                                   * self.number_of_latitude_intervals)
        converted_longitude = round((self.longitude / 360)
@@ -21,19 +21,19 @@ _LOGGER = logging.getLogger(__name__)

 def setup_platform(hass, config, add_devices, discovery_info=None):
    """Setup Axis device event."""
-    add_devices([AxisBinarySensor(discovery_info['axis_event'], hass)], True)
+    add_devices([AxisBinarySensor(hass, discovery_info)], True)


 class AxisBinarySensor(AxisDeviceEvent, BinarySensorDevice):
    """Representation of a binary Axis event."""

-    def __init__(self, axis_event, hass):
+    def __init__(self, hass, event_config):
        """Initialize the binary sensor."""
        self.hass = hass
        self._state = False
-        self._delay = axis_event.device_config(CONF_TRIGGER_TIME)
+        self._delay = event_config[CONF_TRIGGER_TIME]
        self._timer = None
-        AxisDeviceEvent.__init__(self, axis_event)
+        AxisDeviceEvent.__init__(self, event_config)

    @property
    def is_on(self):
@@ -22,6 +22,10 @@ from homeassistant.helpers.event import async_track_state_change

 _LOGGER = logging.getLogger(__name__)

+ATTR_OBSERVATIONS = 'observations'
+ATTR_PROBABILITY = 'probability'
+ATTR_PROBABILITY_THRESHOLD = 'probability_threshold'
+
 CONF_OBSERVATIONS = 'observations'
 CONF_PRIOR = 'prior'
 CONF_PROBABILITY_THRESHOLD = 'probability_threshold'
@@ -29,7 +33,8 @@ CONF_P_GIVEN_F = 'prob_given_false'
 CONF_P_GIVEN_T = 'prob_given_true'
 CONF_TO_STATE = 'to_state'

-DEFAULT_NAME = 'BayesianBinary'
+DEFAULT_NAME = "Bayesian Binary Sensor"
+DEFAULT_PROBABILITY_THRESHOLD = 0.5

 NUMERIC_STATE_SCHEMA = vol.Schema({
    CONF_PLATFORM: 'numeric_state',
@@ -49,16 +54,14 @@ STATE_SCHEMA = vol.Schema({
 }, required=True)

 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
-    vol.Optional(CONF_NAME, default=DEFAULT_NAME):
-        cv.string,
+    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_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),
+    vol.Optional(CONF_PROBABILITY_THRESHOLD,
+                 default=DEFAULT_PROBABILITY_THRESHOLD): vol.Coerce(float),
 })


@@ -73,16 +76,16 @@ def update_probability(prior, prob_true, prob_false):

@asyncio.coroutine
 def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
-    """Set up the Threshold sensor."""
+    """Set up the Bayesian Binary 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)
+    probability_threshold = config.get(CONF_PROBABILITY_THRESHOLD)
    device_class = config.get(CONF_DEVICE_CLASS)

    async_add_devices([
-        BayesianBinarySensor(name, prior, observations, probability_threshold,
-                             device_class)
+        BayesianBinarySensor(
+            name, prior, observations, probability_threshold, device_class)
    ], True)


@@ -107,7 +110,7 @@ class BayesianBinarySensor(BinarySensorDevice):
        self.entity_obs = dict.fromkeys(to_observe, [])

        for ind, obs in enumerate(self._observations):
-            obs["id"] = ind
+            obs['id'] = ind
            self.entity_obs[obs['entity_id']].append(obs)

        self.watchers = {
@@ -117,7 +120,7 @@ class BayesianBinarySensor(BinarySensorDevice):

    @asyncio.coroutine
    def async_added_to_hass(self):
-        """Call when entity about to be added to hass."""
+        """Call when entity about to be added."""
        @callback
        # pylint: disable=invalid-name
        def async_threshold_sensor_state_listener(entity, old_state,
@@ -135,8 +138,8 @@ class BayesianBinarySensor(BinarySensorDevice):

            prior = self.prior
            for obs in self.current_obs.values():
-                prior = update_probability(prior, obs['prob_true'],
-                                           obs['prob_false'])
+                prior = update_probability(
+                    prior, obs['prob_true'], obs['prob_false'])
            self.probability = prior

            self.hass.async_add_job(self.async_update_ha_state, True)
@@ -206,9 +209,9 @@ class BayesianBinarySensor(BinarySensorDevice):
    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
+            ATTR_OBSERVATIONS: [val for val in self.current_obs.values()],
+            ATTR_PROBABILITY: round(self.probability, 2),
+            ATTR_PROBABILITY_THRESHOLD: self._probability_threshold,
        }

    @asyncio.coroutine
@@ -0,0 +1,69 @@
+"""
+Support for binary sensor using GC100.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/binary_sensor.gc100/
+"""
+import voluptuous as vol
+
+from homeassistant.components.gc100 import DATA_GC100, CONF_PORTS
+from homeassistant.components.binary_sensor import (
+    BinarySensorDevice, PLATFORM_SCHEMA)
+from homeassistant.const import DEVICE_DEFAULT_NAME
+import homeassistant.helpers.config_validation as cv
+
+DEPENDENCIES = ['gc100']
+
+_SENSORS_SCHEMA = vol.Schema({
+    cv.string: cv.string,
+})
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Required(CONF_PORTS): vol.All(cv.ensure_list, [_SENSORS_SCHEMA])
+})
+
+
+# pylint: disable=unused-argument
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Set up the GC100 devices."""
+    binary_sensors = []
+    ports = config.get(CONF_PORTS)
+    for port in ports:
+        for port_addr, port_name in port.items():
+            binary_sensors.append(GC100BinarySensor(
+                port_name, port_addr, hass.data[DATA_GC100]))
+    add_devices(binary_sensors, True)
+
+
+class GC100BinarySensor(BinarySensorDevice):
+    """Representation of a binary sensor from GC100."""
+
+    def __init__(self, name, port_addr, gc100):
+        """Initialize the GC100 binary sensor."""
+        # pylint: disable=no-member
+        self._name = name or DEVICE_DEFAULT_NAME
+        self._port_addr = port_addr
+        self._gc100 = gc100
+        self._state = None
+
+        # Subscribe to be notified about state changes (PUSH)
+        self._gc100.subscribe(self._port_addr, self.set_state)
+
+    @property
+    def name(self):
+        """Return the name of the sensor."""
+        return self._name
+
+    @property
+    def is_on(self):
+        """Return the state of the entity."""
+        return self._state
+
+    def update(self):
+        """Update the sensor state."""
+        self._gc100.read_sensor(self._port_addr, self.set_state)
+
+    def set_state(self, state):
+        """Set the current state."""
+        self._state = state == 1
+        self.schedule_update_ha_state()
@@ -0,0 +1,63 @@
+"""
+Support for the Hive devices.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/binary_sensor.hive/
+"""
+from homeassistant.components.binary_sensor import BinarySensorDevice
+from homeassistant.components.hive import DATA_HIVE
+
+DEPENDENCIES = ['hive']
+
+DEVICETYPE_DEVICE_CLASS = {'motionsensor': 'motion',
+                           'contactsensor': 'opening'}
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Set up Hive sensor devices."""
+    if discovery_info is None:
+        return
+    session = hass.data.get(DATA_HIVE)
+
+    add_devices([HiveBinarySensorEntity(session, discovery_info)])
+
+
+class HiveBinarySensorEntity(BinarySensorDevice):
+    """Representation of a Hive binary sensor."""
+
+    def __init__(self, hivesession, hivedevice):
+        """Initialize the hive sensor."""
+        self.node_id = hivedevice["Hive_NodeID"]
+        self.node_name = hivedevice["Hive_NodeName"]
+        self.device_type = hivedevice["HA_DeviceType"]
+        self.node_device_type = hivedevice["Hive_DeviceType"]
+        self.session = hivesession
+        self.data_updatesource = '{}.{}'.format(self.device_type,
+                                                self.node_id)
+
+        self.session.entities.append(self)
+
+    def handle_update(self, updatesource):
+        """Handle the new update request."""
+        if '{}.{}'.format(self.device_type, self.node_id) not in updatesource:
+            self.schedule_update_ha_state()
+
+    @property
+    def device_class(self):
+        """Return the class of this sensor."""
+        return DEVICETYPE_DEVICE_CLASS.get(self.node_device_type)
+
+    @property
+    def name(self):
+        """Return the name of the binary sensor."""
+        return self.node_name
+
+    @property
+    def is_on(self):
+        """Return true if the binary sensor is on."""
+        return self.session.sensor.get_state(self.node_id,
+                                             self.node_device_type)
+
+    def update(self):
+        """Update all Node data frome Hive."""
+        self.session.core.update_data(self.node_id)
@@ -25,6 +25,7 @@ SENSOR_TYPES_CLASS = {
    'RemoteMotion': None,
    'WeatherSensor': None,
    'TiltSensor': None,
+    'PresenceIP': 'motion',
 }


@@ -0,0 +1,96 @@
+"""
+Support for monitoring the state of Linode Nodes.
+
+For more details about this component, please refer to the documentation at
+https://home-assistant.io/components/binary_sensor.linode/
+"""
+import logging
+
+import voluptuous as vol
+
+import homeassistant.helpers.config_validation as cv
+from homeassistant.components.binary_sensor import (
+    BinarySensorDevice, PLATFORM_SCHEMA)
+from homeassistant.components.linode import (
+    CONF_NODES, ATTR_CREATED, ATTR_NODE_ID, ATTR_NODE_NAME,
+    ATTR_IPV4_ADDRESS, ATTR_IPV6_ADDRESS, ATTR_MEMORY,
+    ATTR_REGION, ATTR_VCPUS, DATA_LINODE)
+
+_LOGGER = logging.getLogger(__name__)
+
+DEFAULT_NAME = 'Node'
+DEFAULT_DEVICE_CLASS = 'moving'
+DEPENDENCIES = ['linode']
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Required(CONF_NODES): vol.All(cv.ensure_list, [cv.string]),
+})
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Set up the Linode droplet sensor."""
+    linode = hass.data.get(DATA_LINODE)
+    nodes = config.get(CONF_NODES)
+
+    dev = []
+    for node in nodes:
+        node_id = linode.get_node_id(node)
+        if node_id is None:
+            _LOGGER.error("Node %s is not available", node)
+            return
+        dev.append(LinodeBinarySensor(linode, node_id))
+
+    add_devices(dev, True)
+
+
+class LinodeBinarySensor(BinarySensorDevice):
+    """Representation of a Linode droplet sensor."""
+
+    def __init__(self, li, node_id):
+        """Initialize a new Linode sensor."""
+        self._linode = li
+        self._node_id = node_id
+        self._state = None
+        self.data = None
+
+    @property
+    def name(self):
+        """Return the name of the sensor."""
+        if self.data is not None:
+            return self.data.label
+
+    @property
+    def is_on(self):
+        """Return true if the binary sensor is on."""
+        if self.data is not None:
+            return self.data.status == 'running'
+        return False
+
+    @property
+    def device_class(self):
+        """Return the class of this sensor."""
+        return DEFAULT_DEVICE_CLASS
+
+    @property
+    def device_state_attributes(self):
+        """Return the state attributes of the Linode Node."""
+        if self.data:
+            return {
+                ATTR_CREATED: self.data.created,
+                ATTR_NODE_ID: self.data.id,
+                ATTR_NODE_NAME: self.data.label,
+                ATTR_IPV4_ADDRESS: self.data.ipv4,
+                ATTR_IPV6_ADDRESS: self.data.ipv6,
+                ATTR_MEMORY: self.data.specs.memory,
+                ATTR_REGION: self.data.region.country,
+                ATTR_VCPUS: self.data.specs.vcpus,
+            }
+        return {}
+
+    def update(self):
+        """Update state of sensor."""
+        self._linode.update()
+        if self._linode.data is not None:
+            for node in self._linode.data:
+                if node.id == self._node_id:
+                    self.data = node
@@ -0,0 +1,64 @@
+"""
+Support for showing random states.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/binary_sensor.random/
+"""
+import asyncio
+import logging
+
+import voluptuous as vol
+
+import homeassistant.helpers.config_validation as cv
+from homeassistant.components.binary_sensor import (
+    BinarySensorDevice, PLATFORM_SCHEMA, DEVICE_CLASSES_SCHEMA)
+from homeassistant.const import CONF_NAME, CONF_DEVICE_CLASS
+
+_LOGGER = logging.getLogger(__name__)
+
+DEFAULT_NAME = 'Random Binary Sensor'
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
+    vol.Optional(CONF_DEVICE_CLASS): DEVICE_CLASSES_SCHEMA,
+})
+
+
+@asyncio.coroutine
+def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
+    """Set up the Random binary sensor."""
+    name = config.get(CONF_NAME)
+    device_class = config.get(CONF_DEVICE_CLASS)
+
+    async_add_devices([RandomSensor(name, device_class)], True)
+
+
+class RandomSensor(BinarySensorDevice):
+    """Representation of a Random binary sensor."""
+
+    def __init__(self, name, device_class):
+        """Initialize the Random binary sensor."""
+        self._name = name
+        self._device_class = device_class
+        self._state = None
+
+    @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._state
+
+    @property
+    def device_class(self):
+        """Return the sensor class of the sensor."""
+        return self._device_class
+
+    @asyncio.coroutine
+    def async_update(self):
+        """Get new state and update the sensor's state."""
+        from random import getrandbits
+        self._state = bool(getrandbits(1))
@@ -62,7 +62,6 @@ def setup_platform(hass, config, add_devices_callback, discovery_info=None):
                                    entity[CONF_COMMAND_ON],
                                    entity[CONF_COMMAND_OFF])
        device.hass = hass
-        device.is_lighting4 = (packet_id[2:4] == '13')
        sensors.append(device)
        rfxtrx.RFX_DEVICES[device_id] = device

@@ -86,17 +85,16 @@ def setup_platform(hass, config, add_devices_callback, discovery_info=None):
            if not config[ATTR_AUTOMATIC_ADD]:
                return

-            poss_dev = rfxtrx.find_possible_pt2262_device(device_id)
-
-            if poss_dev is not None:
-                poss_id = slugify(poss_dev.event.device.id_string.lower())
-                _LOGGER.info("Found possible matching deviceid %s.",
-                             poss_id)
+            if event.device.packettype == 0x13:
+                poss_dev = rfxtrx.find_possible_pt2262_device(device_id)
+                if poss_dev is not None:
+                    poss_id = slugify(poss_dev.event.device.id_string.lower())
+                    _LOGGER.info("Found possible matching deviceid %s.",
+                                 poss_id)

            pkt_id = "".join("{0:02x}".format(x) for x in event.data)
            sensor = RfxtrxBinarySensor(event, pkt_id)
            sensor.hass = hass
-            sensor.is_lighting4 = (pkt_id[2:4] == '13')
            rfxtrx.RFX_DEVICES[device_id] = sensor
            add_devices_callback([sensor])
            _LOGGER.info("Added binary sensor %s "
@@ -114,6 +112,7 @@ def setup_platform(hass, config, add_devices_callback, discovery_info=None):
                         slugify(event.device.id_string.lower()),
                         event.device.__class__.__name__,
                         event.device.subtype)
+
        if sensor.is_lighting4:
            if sensor.data_bits is not None:
                cmd = rfxtrx.get_pt2262_cmd(device_id, sensor.data_bits)
@@ -154,7 +153,7 @@ class RfxtrxBinarySensor(BinarySensorDevice):
        self._device_class = device_class
        self._off_delay = off_delay
        self._state = False
-        self.is_lighting4 = False
+        self.is_lighting4 = (event.device.packettype == 0x13)
        self.delay_listener = None
        self._data_bits = data_bits
        self._cmd_on = cmd_on
@@ -11,7 +11,7 @@ import voluptuous as vol
 import homeassistant.helpers.config_validation as cv

 from homeassistant.components.ring import (
-    CONF_ATTRIBUTION, DEFAULT_ENTITY_NAMESPACE)
+    CONF_ATTRIBUTION, DEFAULT_ENTITY_NAMESPACE, DATA_RING)

 from homeassistant.const import (
    ATTR_ATTRIBUTION, CONF_ENTITY_NAMESPACE, CONF_MONITORED_CONDITIONS)
@@ -28,20 +28,20 @@ SCAN_INTERVAL = timedelta(seconds=5)
 # Sensor types: Name, category, device_class
 SENSOR_TYPES = {
    'ding': ['Ding', ['doorbell'], 'occupancy'],
-    'motion': ['Motion', ['doorbell'], 'motion'],
+    'motion': ['Motion', ['doorbell', 'stickup_cams'], 'motion'],
 }

 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
    vol.Optional(CONF_ENTITY_NAMESPACE, default=DEFAULT_ENTITY_NAMESPACE):
        cv.string,
-    vol.Required(CONF_MONITORED_CONDITIONS, default=[]):
+    vol.Required(CONF_MONITORED_CONDITIONS, default=list(SENSOR_TYPES)):
        vol.All(cv.ensure_list, [vol.In(SENSOR_TYPES)]),
 })


 def setup_platform(hass, config, add_devices, discovery_info=None):
    """Set up a sensor for a Ring device."""
-    ring = hass.data.get('ring')
+    ring = hass.data[DATA_RING]

    sensors = []
    for sensor_type in config.get(CONF_MONITORED_CONDITIONS):
@@ -50,6 +50,12 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
                sensors.append(RingBinarySensor(hass,
                                                device,
                                                sensor_type))
+
+        for device in ring.stickup_cams:
+            if 'stickup_cams' in SENSOR_TYPES[sensor_type][1]:
+                sensors.append(RingBinarySensor(hass,
+                                                device,
+                                                sensor_type))
    add_devices(sensors, True)
    return True

@@ -67,7 +67,7 @@ class SpcBinarySensor(BinarySensorDevice):
        spc_registry.register_sensor_device(zone_id, self)

    @asyncio.coroutine
-    def async_update_from_spc(self, state):
+    def async_update_from_spc(self, state, extra):
        """Update the state of the device."""
        self._state = state
        yield from self.async_update_ha_state()
@@ -0,0 +1,34 @@
+"""
+Support for binary sensors using Tellstick Net.
+
+This platform uses the Telldus Live online service.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/binary_sensor.tellduslive/
+
+"""
+import logging
+
+from homeassistant.components.tellduslive import TelldusLiveEntity
+from homeassistant.components.binary_sensor import BinarySensorDevice
+
+_LOGGER = logging.getLogger(__name__)
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Set up Tellstick sensors."""
+    if discovery_info is None:
+        return
+    add_devices(
+        TelldusLiveSensor(hass, binary_sensor)
+        for binary_sensor in discovery_info
+    )
+
+
+class TelldusLiveSensor(TelldusLiveEntity, BinarySensorDevice):
+    """Representation of a Tellstick sensor."""
+
+    @property
+    def is_on(self):
+        """Return true if switch is on."""
+        return self.device.is_on
@@ -1,11 +1,13 @@
 """
-A sensor that monitors trands in other components.
+A sensor that monitors trends in other components.

 For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/sensor.trend/
 """
 import asyncio
+from collections import deque
 import logging
+import math

 import voluptuous as vol

@@ -16,21 +18,40 @@ from homeassistant.components.binary_sensor import (
    BinarySensorDevice, ENTITY_ID_FORMAT, PLATFORM_SCHEMA,
    DEVICE_CLASSES_SCHEMA)
 from homeassistant.const import (
-    ATTR_FRIENDLY_NAME, ATTR_ENTITY_ID, CONF_DEVICE_CLASS, STATE_UNKNOWN)
+    ATTR_ENTITY_ID, ATTR_FRIENDLY_NAME,
+    CONF_DEVICE_CLASS, CONF_ENTITY_ID, CONF_FRIENDLY_NAME,
+    STATE_UNKNOWN)
 from homeassistant.helpers.entity import generate_entity_id
-from homeassistant.helpers.event import track_state_change
+from homeassistant.helpers.event import async_track_state_change
+from homeassistant.util import utcnow
+
+REQUIREMENTS = ['numpy==1.13.3']

 _LOGGER = logging.getLogger(__name__)
+
+ATTR_ATTRIBUTE = 'attribute'
+ATTR_GRADIENT = 'gradient'
+ATTR_MIN_GRADIENT = 'min_gradient'
+ATTR_INVERT = 'invert'
+ATTR_SAMPLE_DURATION = 'sample_duration'
+ATTR_SAMPLE_COUNT = 'sample_count'
+
 CONF_SENSORS = 'sensors'
 CONF_ATTRIBUTE = 'attribute'
+CONF_MAX_SAMPLES = 'max_samples'
+CONF_MIN_GRADIENT = 'min_gradient'
 CONF_INVERT = 'invert'
+CONF_SAMPLE_DURATION = 'sample_duration'

 SENSOR_SCHEMA = vol.Schema({
-    vol.Required(ATTR_ENTITY_ID): cv.entity_id,
+    vol.Required(CONF_ENTITY_ID): cv.entity_id,
    vol.Optional(CONF_ATTRIBUTE): cv.string,
-    vol.Optional(ATTR_FRIENDLY_NAME): cv.string,
-    vol.Optional(CONF_INVERT, default=False): cv.boolean,
    vol.Optional(CONF_DEVICE_CLASS): DEVICE_CLASSES_SCHEMA,
+    vol.Optional(CONF_FRIENDLY_NAME): cv.string,
+    vol.Optional(CONF_MAX_SAMPLES, default=2): cv.positive_int,
+    vol.Optional(CONF_MIN_GRADIENT, default=0.0): vol.Coerce(float),
+    vol.Optional(CONF_INVERT, default=False): cv.boolean,
+    vol.Optional(CONF_SAMPLE_DURATION, default=0): cv.positive_int,
 })

 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
@@ -43,17 +64,21 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
    """Set up the trend sensors."""
    sensors = []

-    for device, device_config in config[CONF_SENSORS].items():
+    for device_id, device_config in config[CONF_SENSORS].items():
        entity_id = device_config[ATTR_ENTITY_ID]
        attribute = device_config.get(CONF_ATTRIBUTE)
-        friendly_name = device_config.get(ATTR_FRIENDLY_NAME, device)
        device_class = device_config.get(CONF_DEVICE_CLASS)
+        friendly_name = device_config.get(ATTR_FRIENDLY_NAME, device_id)
        invert = device_config[CONF_INVERT]
+        max_samples = device_config[CONF_MAX_SAMPLES]
+        min_gradient = device_config[CONF_MIN_GRADIENT]
+        sample_duration = device_config[CONF_SAMPLE_DURATION]

        sensors.append(
            SensorTrend(
-                hass, device, friendly_name, entity_id, attribute,
-                device_class, invert)
+                hass, device_id, friendly_name, entity_id, attribute,
+                device_class, invert, max_samples, min_gradient,
+                sample_duration)
            )
    if not sensors:
        _LOGGER.error("No sensors added")
@@ -65,30 +90,23 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
 class SensorTrend(BinarySensorDevice):
    """Representation of a trend Sensor."""

-    def __init__(self, hass, device_id, friendly_name,
-                 target_entity, attribute, device_class, invert):
+    def __init__(self, hass, device_id, friendly_name, entity_id,
+                 attribute, device_class, invert, max_samples,
+                 min_gradient, sample_duration):
        """Initialize the sensor."""
        self._hass = hass
        self.entity_id = generate_entity_id(
            ENTITY_ID_FORMAT, device_id, hass=hass)
        self._name = friendly_name
-        self._target_entity = target_entity
+        self._entity_id = entity_id
        self._attribute = attribute
        self._device_class = device_class
        self._invert = invert
+        self._sample_duration = sample_duration
+        self._min_gradient = min_gradient
+        self._gradient = None
        self._state = None
-        self.from_state = None
-        self.to_state = None
-
-        @callback
-        def trend_sensor_state_listener(entity, old_state, new_state):
-            """Handle the target device state changes."""
-            self.from_state = old_state
-            self.to_state = new_state
-            hass.async_add_job(self.async_update_ha_state(True))
-
-        track_state_change(hass, target_entity,
-                           trend_sensor_state_listener)
+        self.samples = deque(maxlen=max_samples)

    @property
    def name(self):
@@ -105,33 +123,77 @@ class SensorTrend(BinarySensorDevice):
        """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 {
+            ATTR_ENTITY_ID: self._entity_id,
+            ATTR_FRIENDLY_NAME: self._name,
+            ATTR_INVERT: self._invert,
+            ATTR_GRADIENT: self._gradient,
+            ATTR_MIN_GRADIENT: self._min_gradient,
+            ATTR_SAMPLE_DURATION: self._sample_duration,
+            ATTR_SAMPLE_COUNT: len(self.samples),
+        }
+
    @property
    def should_poll(self):
        """No polling needed."""
        return False

+    @asyncio.coroutine
+    def async_added_to_hass(self):
+        """Complete device setup after being added to hass."""
+        @callback
+        def trend_sensor_state_listener(entity, old_state, new_state):
+            """Handle state changes on the observed device."""
+            try:
+                if self._attribute:
+                    state = new_state.attributes.get(self._attribute)
+                else:
+                    state = new_state.state
+                if state != STATE_UNKNOWN:
+                    sample = (utcnow().timestamp(), float(state))
+                    self.samples.append(sample)
+                    self.async_schedule_update_ha_state(True)
+            except (ValueError, TypeError) as ex:
+                _LOGGER.error(ex)
+
+        async_track_state_change(
+            self.hass, self._entity_id,
+            trend_sensor_state_listener)
+
    @asyncio.coroutine
    def async_update(self):
        """Get the latest data and update the states."""
-        if self.from_state is None or self.to_state is None:
-            return
-        if (self.from_state.state == STATE_UNKNOWN or
-                self.to_state.state == STATE_UNKNOWN):
-            return
-        try:
-            if self._attribute:
-                from_value = float(
-                    self.from_state.attributes.get(self._attribute))
-                to_value = float(
-                    self.to_state.attributes.get(self._attribute))
-            else:
-                from_value = float(self.from_state.state)
-                to_value = float(self.to_state.state)
+        # Remove outdated samples
+        if self._sample_duration > 0:
+            cutoff = utcnow().timestamp() - self._sample_duration
+            while self.samples and self.samples[0][0] < cutoff:
+                self.samples.popleft()

-            self._state = to_value > from_value
-            if self._invert:
-                self._state = not self._state
+        if len(self.samples) < 2:
+            return

-        except (ValueError, TypeError) as ex:
-            self._state = None
-            _LOGGER.error(ex)
+        # Calculate gradient of linear trend
+        yield from self.hass.async_add_job(self._calculate_gradient)
+
+        # Update state
+        self._state = (
+            abs(self._gradient) > abs(self._min_gradient) and
+            math.copysign(self._gradient, self._min_gradient) == self._gradient
+        )
+
+        if self._invert:
+            self._state = not self._state
+
+    def _calculate_gradient(self):
+        """Compute the linear trend gradient of the current samples.
+
+        This need run inside executor.
+        """
+        import numpy as np
+        timestamps = np.array([t for t, _ in self.samples])
+        values = np.array([s for _, s in self.samples])
+        coeffs = np.polyfit(timestamps, values, 1)
+        self._gradient = coeffs[0]
@@ -0,0 +1,103 @@
+"""
+Support for monitoring the state of Vultr subscriptions (VPS).
+
+For more details about this component, please refer to the documentation at
+https://home-assistant.io/components/binary_sensor.vultr/
+"""
+import logging
+
+import voluptuous as vol
+
+import homeassistant.helpers.config_validation as cv
+from homeassistant.const import CONF_NAME
+from homeassistant.components.binary_sensor import (
+    BinarySensorDevice, PLATFORM_SCHEMA)
+from homeassistant.components.vultr import (
+    CONF_SUBSCRIPTION, ATTR_AUTO_BACKUPS, ATTR_ALLOWED_BANDWIDTH,
+    ATTR_CREATED_AT, ATTR_SUBSCRIPTION_ID, ATTR_SUBSCRIPTION_NAME,
+    ATTR_IPV4_ADDRESS, ATTR_IPV6_ADDRESS, ATTR_MEMORY, ATTR_DISK,
+    ATTR_COST_PER_MONTH, ATTR_OS, ATTR_REGION, ATTR_VCPUS, DATA_VULTR)
+
+_LOGGER = logging.getLogger(__name__)
+
+DEFAULT_DEVICE_CLASS = 'power'
+DEFAULT_NAME = 'Vultr {}'
+DEPENDENCIES = ['vultr']
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Required(CONF_SUBSCRIPTION): cv.string,
+    vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string
+})
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Set up the Vultr subscription (server) sensor."""
+    vultr = hass.data[DATA_VULTR]
+
+    subscription = config.get(CONF_SUBSCRIPTION)
+    name = config.get(CONF_NAME)
+
+    if subscription not in vultr.data:
+        _LOGGER.error("Subscription %s not found", subscription)
+        return False
+
+    add_devices([VultrBinarySensor(vultr, subscription, name)], True)
+
+
+class VultrBinarySensor(BinarySensorDevice):
+    """Representation of a Vultr subscription sensor."""
+
+    def __init__(self, vultr, subscription, name):
+        """Initialize a new Vultr sensor."""
+        self._vultr = vultr
+        self._name = name
+
+        self.subscription = subscription
+        self.data = None
+
+    @property
+    def name(self):
+        """Return the name of the sensor."""
+        try:
+            return self._name.format(self.data['label'])
+        except (KeyError, TypeError):
+            return self._name
+
+    @property
+    def icon(self):
+        """Return the icon of this server."""
+        return 'mdi:server' if self.is_on else 'mdi:server-off'
+
+    @property
+    def is_on(self):
+        """Return true if the binary sensor is on."""
+        return self.data['power_status'] == 'running'
+
+    @property
+    def device_class(self):
+        """Return the class of this sensor."""
+        return DEFAULT_DEVICE_CLASS
+
+    @property
+    def device_state_attributes(self):
+        """Return the state attributes of the Vultr subscription."""
+        return {
+            ATTR_ALLOWED_BANDWIDTH: self.data.get('allowed_bandwidth_gb'),
+            ATTR_AUTO_BACKUPS: self.data.get('auto_backups'),
+            ATTR_COST_PER_MONTH: self.data.get('cost_per_month'),
+            ATTR_CREATED_AT: self.data.get('date_created'),
+            ATTR_DISK: self.data.get('disk'),
+            ATTR_IPV4_ADDRESS: self.data.get('main_ip'),
+            ATTR_IPV6_ADDRESS: self.data.get('v6_main_ip'),
+            ATTR_MEMORY: self.data.get('ram'),
+            ATTR_OS: self.data.get('os'),
+            ATTR_REGION: self.data.get('location'),
+            ATTR_SUBSCRIPTION_ID: self.data.get('SUBID'),
+            ATTR_SUBSCRIPTION_NAME: self.data.get('label'),
+            ATTR_VCPUS: self.data.get('vcpu_count')
+        }
+
+    def update(self):
+        """Update state of sensor."""
+        self._vultr.update()
+        self.data = self._vultr.data[self.subscription]
@@ -25,13 +25,9 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
    for (_, gateway) in hass.data[PY_XIAOMI_GATEWAY].gateways.items():
        for device in gateway.devices['binary_sensor']:
            model = device['model']
-            if model == 'motion':
+            if model in ['motion', 'sensor_motion.aq2']:
                devices.append(XiaomiMotionSensor(device, hass, gateway))
-            elif model == 'sensor_motion.aq2':
-                devices.append(XiaomiMotionSensor(device, hass, gateway))
-            elif model == 'magnet':
-                devices.append(XiaomiDoorSensor(device, gateway))
-            elif model == 'sensor_magnet.aq2':
+            elif model in ['magnet', 'sensor_magnet.aq2']:
                devices.append(XiaomiDoorSensor(device, gateway))
            elif model == 'sensor_wleak.aq1':
                devices.append(XiaomiWaterLeakSensor(device, gateway))
@@ -39,10 +35,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
                devices.append(XiaomiSmokeSensor(device, gateway))
            elif model == 'natgas':
                devices.append(XiaomiNatgasSensor(device, gateway))
-            elif model == 'switch':
-                devices.append(XiaomiButton(device, 'Switch', 'status',
-                                            hass, gateway))
-            elif model == 'sensor_switch.aq2':
+            elif model in ['switch', 'sensor_switch.aq2', 'sensor_switch.aq3']:
                devices.append(XiaomiButton(device, 'Switch', 'status',
                                            hass, gateway))
            elif model == '86sw1':
@@ -289,9 +282,17 @@ class XiaomiButton(XiaomiBinarySensor):
    def __init__(self, device, name, data_key, hass, xiaomi_hub):
        """Initialize the XiaomiButton."""
        self._hass = hass
+        self._last_action = None
        XiaomiBinarySensor.__init__(self, device, name, xiaomi_hub,
                                    data_key, None)

+    @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."""
        value = data.get(self._data_key)
@@ -317,6 +318,8 @@ class XiaomiButton(XiaomiBinarySensor):
            'entity_id': self.entity_id,
            'click_type': click_type
        })
+        self._last_action = click_type
+
        if value in ['long_click_press', 'long_click_release']:
            return True
        return False
@@ -4,16 +4,17 @@ Support for BloomSky weather station.
 For more details about this component, please refer to the documentation at
 https://home-assistant.io/components/bloomsky/
 """
-import logging
 from datetime import timedelta
+import logging

+from aiohttp.hdrs import AUTHORIZATION
 import requests
 import voluptuous as vol

 from homeassistant.const import CONF_API_KEY
 from homeassistant.helpers import discovery
-from homeassistant.util import Throttle
 import homeassistant.helpers.config_validation as cv
+from homeassistant.util import Throttle

 _LOGGER = logging.getLogger(__name__)

@@ -68,7 +69,7 @@ class BloomSky(object):
        """Use the API to retrieve a list of devices."""
        _LOGGER.debug("Fetching BloomSky update")
        response = requests.get(
-            self.API_URL, headers={"Authorization": self._api_key}, timeout=10)
+            self.API_URL, headers={AUTHORIZATION: self._api_key}, timeout=10)
        if response.status_code == 401:
            raise RuntimeError("Invalid API_KEY")
        elif response.status_code != 200:
@@ -1,19 +1,21 @@
+# Describes the format for available calendar services
+
 todoist:
  new_task:
    description: Create a new task and add it to a project.
    fields:
      content: 
-        description: The name of the task. [Required]
+        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]
+        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]
+        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]
+        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]
+        description: The day this task is due, in format YYYY-MM-DD (Optional).
        example: "2018-04-01"
@@ -29,18 +29,22 @@ from homeassistant.helpers.entity import Entity
 from homeassistant.helpers.entity_component import EntityComponent
 from homeassistant.helpers.config_validation import PLATFORM_SCHEMA  # noqa
 from homeassistant.components.http import HomeAssistantView, KEY_AUTHENTICATED
-from homeassistant.helpers.event import async_track_time_interval
 import homeassistant.helpers.config_validation as cv

+DOMAIN = 'camera'
+DEPENDENCIES = ['http']
+
 _LOGGER = logging.getLogger(__name__)

-SERVICE_EN_MOTION = 'enable_motion_detection'
-SERVICE_DISEN_MOTION = 'disable_motion_detection'
-DOMAIN = 'camera'
-DEPENDENCIES = ['http']
+SERVICE_ENABLE_MOTION = 'enable_motion_detection'
+SERVICE_DISABLE_MOTION = 'disable_motion_detection'
+SERVICE_SNAPSHOT = 'snapshot'
+
 SCAN_INTERVAL = timedelta(seconds=30)
 ENTITY_ID_FORMAT = DOMAIN + '.{}'

+ATTR_FILENAME = 'filename'
+
 STATE_RECORDING = 'recording'
 STATE_STREAMING = 'streaming'
 STATE_IDLE = 'idle'
@@ -55,13 +59,17 @@ CAMERA_SERVICE_SCHEMA = vol.Schema({
    vol.Optional(ATTR_ENTITY_ID): cv.entity_ids,
 })

+CAMERA_SERVICE_SNAPSHOT = CAMERA_SERVICE_SCHEMA.extend({
+    vol.Required(ATTR_FILENAME): cv.template
+})
+

@bind_hass
 def enable_motion_detection(hass, entity_id=None):
    """Enable Motion Detection."""
    data = {ATTR_ENTITY_ID: entity_id} if entity_id else None
    hass.async_add_job(hass.services.async_call(
-        DOMAIN, SERVICE_EN_MOTION, data))
+        DOMAIN, SERVICE_ENABLE_MOTION, data))


@bind_hass
@@ -69,9 +77,20 @@ def disable_motion_detection(hass, entity_id=None):
    """Disable Motion Detection."""
    data = {ATTR_ENTITY_ID: entity_id} if entity_id else None
    hass.async_add_job(hass.services.async_call(
-        DOMAIN, SERVICE_DISEN_MOTION, data))
+        DOMAIN, SERVICE_DISABLE_MOTION, data))


+@bind_hass
+def async_snapshot(hass, filename, entity_id=None):
+    """Make a snapshot from a camera."""
+    data = {ATTR_ENTITY_ID: entity_id} if entity_id else {}
+    data[ATTR_FILENAME] = filename
+
+    hass.async_add_job(hass.services.async_call(
+        DOMAIN, SERVICE_SNAPSHOT, data))
+
+
+@bind_hass
@asyncio.coroutine
 def async_get_image(hass, entity_id, timeout=10):
    """Fetch a image from a camera entity."""
@@ -119,7 +138,8 @@ def async_setup(hass, config):
            entity.async_update_token()
            hass.async_add_job(entity.async_update_ha_state())

-    async_track_time_interval(hass, update_tokens, TOKEN_CHANGE_INTERVAL)
+    hass.helpers.event.async_track_time_interval(
+        update_tokens, TOKEN_CHANGE_INTERVAL)

    @asyncio.coroutine
    def async_handle_camera_service(service):
@@ -128,9 +148,9 @@ def async_setup(hass, config):

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

            if not camera.should_poll:
@@ -140,16 +160,50 @@ def async_setup(hass, config):
        if update_tasks:
            yield from asyncio.wait(update_tasks, loop=hass.loop)

+    @asyncio.coroutine
+    def async_handle_snapshot_service(service):
+        """Handle snapshot services calls."""
+        target_cameras = component.async_extract_from_service(service)
+        filename = service.data[ATTR_FILENAME]
+        filename.hass = hass
+
+        for camera in target_cameras:
+            snapshot_file = filename.async_render(
+                variables={ATTR_ENTITY_ID: camera})
+
+            # check if we allow to access to that file
+            if not hass.config.is_allowed_path(snapshot_file):
+                _LOGGER.error(
+                    "Can't write %s, no access to path!", snapshot_file)
+                continue
+
+            image = yield from camera.async_camera_image()
+
+            def _write_image(to_file, image_data):
+                """Executor helper to write image."""
+                with open(to_file, 'wb') as img_file:
+                    img_file.write(image_data)
+
+            try:
+                yield from hass.async_add_job(
+                    _write_image, snapshot_file, image)
+            except OSError as err:
+                _LOGGER.error("Can't write image to file: %s", err)
+
    descriptions = yield from hass.async_add_job(
        load_yaml_config_file, os.path.join(
            os.path.dirname(__file__), 'services.yaml'))

    hass.services.async_register(
-        DOMAIN, SERVICE_EN_MOTION, async_handle_camera_service,
-        descriptions.get(SERVICE_EN_MOTION), schema=CAMERA_SERVICE_SCHEMA)
+        DOMAIN, SERVICE_ENABLE_MOTION, async_handle_camera_service,
+        descriptions.get(SERVICE_ENABLE_MOTION), schema=CAMERA_SERVICE_SCHEMA)
    hass.services.async_register(
-        DOMAIN, SERVICE_DISEN_MOTION, async_handle_camera_service,
-        descriptions.get(SERVICE_DISEN_MOTION), schema=CAMERA_SERVICE_SCHEMA)
+        DOMAIN, SERVICE_DISABLE_MOTION, async_handle_camera_service,
+        descriptions.get(SERVICE_DISABLE_MOTION), schema=CAMERA_SERVICE_SCHEMA)
+    hass.services.async_register(
+        DOMAIN, SERVICE_SNAPSHOT, async_handle_snapshot_service,
+        descriptions.get(SERVICE_SNAPSHOT),
+        schema=CAMERA_SERVICE_SNAPSHOT)

    return True

@@ -8,9 +8,10 @@ import asyncio
 import logging

 from homeassistant.components.amcrest import (
-    STREAM_SOURCE_LIST, TIMEOUT)
+    DATA_AMCREST, STREAM_SOURCE_LIST, TIMEOUT)
 from homeassistant.components.camera import Camera
 from homeassistant.components.ffmpeg import DATA_FFMPEG
+from homeassistant.const import CONF_NAME
 from homeassistant.helpers.aiohttp_client import (
    async_get_clientsession, async_aiohttp_proxy_web,
    async_aiohttp_proxy_stream)
@@ -26,21 +27,10 @@ def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
    if discovery_info is None:
        return

-    device = discovery_info['device']
-    authentication = discovery_info['authentication']
-    ffmpeg_arguments = discovery_info['ffmpeg_arguments']
-    name = discovery_info['name']
-    resolution = discovery_info['resolution']
-    stream_source = discovery_info['stream_source']
+    device_name = discovery_info[CONF_NAME]
+    amcrest = hass.data[DATA_AMCREST][device_name]

-    async_add_devices([
-        AmcrestCam(hass,
-                   name,
-                   device,
-                   authentication,
-                   ffmpeg_arguments,
-                   stream_source,
-                   resolution)], True)
+    async_add_devices([AmcrestCam(hass, amcrest)], True)

    return True

@@ -48,18 +38,17 @@ def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
 class AmcrestCam(Camera):
    """An implementation of an Amcrest IP camera."""

-    def __init__(self, hass, name, camera, authentication,
-                 ffmpeg_arguments, stream_source, resolution):
+    def __init__(self, hass, amcrest):
        """Initialize an Amcrest camera."""
        super(AmcrestCam, self).__init__()
-        self._name = name
-        self._camera = camera
+        self._name = amcrest.name
+        self._camera = amcrest.device
        self._base_url = self._camera.get_base_url()
        self._ffmpeg = hass.data[DATA_FFMPEG]
-        self._ffmpeg_arguments = ffmpeg_arguments
-        self._stream_source = stream_source
-        self._resolution = resolution
-        self._token = self._auth = authentication
+        self._ffmpeg_arguments = amcrest.ffmpeg_arguments
+        self._stream_source = amcrest.stream_source
+        self._resolution = amcrest.resolution
+        self._token = self._auth = amcrest.authentication

    def camera_image(self):
        """Return a still image response from the camera."""
@@ -19,7 +19,7 @@ from homeassistant.helpers.aiohttp_client import async_aiohttp_proxy_stream

 _LOGGER = logging.getLogger(__name__)

-SCAN_INTERVAL = timedelta(minutes=10)
+SCAN_INTERVAL = timedelta(seconds=90)

 ARLO_MODE_ARMED = 'armed'
 ARLO_MODE_DISARMED = 'disarmed'
@@ -31,6 +31,7 @@ ATTR_MOTION = 'motion_detection_sensitivity'
 ATTR_POWERSAVE = 'power_save_mode'
 ATTR_SIGNAL_STRENGTH = 'signal_strength'
 ATTR_UNSEEN_VIDEOS = 'unseen_videos'
+ATTR_LAST_REFRESH = 'last_refresh'

 CONF_FFMPEG_ARGUMENTS = 'ffmpeg_arguments'

@@ -73,6 +74,8 @@ class ArloCam(Camera):
        self._motion_status = False
        self._ffmpeg = hass.data[DATA_FFMPEG]
        self._ffmpeg_arguments = device_info.get(CONF_FFMPEG_ARGUMENTS)
+        self._last_refresh = None
+        self._camera.base_station.refresh_rate = SCAN_INTERVAL.total_seconds()
        self.attrs = {}

    def camera_image(self):
@@ -105,14 +108,17 @@ class ArloCam(Camera):
    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),
+            name: value for name, value in (
+                (ATTR_BATTERY_LEVEL, self._camera.battery_level),
+                (ATTR_BRIGHTNESS, self._camera.brightness),
+                (ATTR_FLIPPED, self._camera.flip_state),
+                (ATTR_MIRRORED, self._camera.mirror_state),
+                (ATTR_MOTION, self._camera.motion_detection_sensitivity),
+                (ATTR_POWERSAVE, POWERSAVE_MODE_MAPPING.get(
+                    self._camera.powersave_mode)),
+                (ATTR_SIGNAL_STRENGTH, self._camera.signal_strength),
+                (ATTR_UNSEEN_VIDEOS, self._camera.unseen_videos),
+            ) if value is not None
        }

    @property
@@ -160,13 +166,4 @@ class ArloCam(Camera):

    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
+        self._camera.update()
@@ -11,7 +11,7 @@ from homeassistant.const import (
    CONF_AUTHENTICATION, HTTP_DIGEST_AUTHENTICATION)
 from homeassistant.components.camera.mjpeg import (
    CONF_MJPEG_URL, CONF_STILL_IMAGE_URL, MjpegCamera)
-from homeassistant.helpers.dispatcher import async_dispatcher_connect
+from homeassistant.helpers.dispatcher import dispatcher_connect

 _LOGGER = logging.getLogger(__name__)

@@ -52,9 +52,9 @@ class AxisCamera(MjpegCamera):
        """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)
+        dispatcher_connect(hass,
+                           DOMAIN + '_' + config[CONF_NAME] + '_new_ip',
+                           self._new_ip)

    def _new_ip(self, host):
        """Set new IP for video stream."""
@@ -0,0 +1,167 @@
+"""
+This component provides support to the Ring Door Bell camera.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/camera.ring/
+"""
+import asyncio
+import logging
+
+from datetime import timedelta
+
+import voluptuous as vol
+
+from homeassistant.helpers import config_validation as cv
+from homeassistant.components.ring import (
+    DATA_RING, CONF_ATTRIBUTION, NOTIFICATION_ID)
+from homeassistant.components.camera import Camera, PLATFORM_SCHEMA
+from homeassistant.components.ffmpeg import DATA_FFMPEG
+from homeassistant.const import ATTR_ATTRIBUTION, CONF_SCAN_INTERVAL
+from homeassistant.helpers.aiohttp_client import async_aiohttp_proxy_stream
+from homeassistant.util import dt as dt_util
+
+CONF_FFMPEG_ARGUMENTS = 'ffmpeg_arguments'
+
+DEPENDENCIES = ['ring', 'ffmpeg']
+
+FORCE_REFRESH_INTERVAL = timedelta(minutes=45)
+
+_LOGGER = logging.getLogger(__name__)
+
+NOTIFICATION_TITLE = 'Ring Camera Setup'
+
+SCAN_INTERVAL = timedelta(seconds=90)
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Optional(CONF_FFMPEG_ARGUMENTS): cv.string,
+    vol.Optional(CONF_SCAN_INTERVAL, default=SCAN_INTERVAL):
+        cv.time_period,
+})
+
+
+@asyncio.coroutine
+def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
+    """Set up a Ring Door Bell and StickUp Camera."""
+    ring = hass.data[DATA_RING]
+
+    cams = []
+    cams_no_plan = []
+    for camera in ring.doorbells:
+        if camera.has_subscription:
+            cams.append(RingCam(hass, camera, config))
+        else:
+            cams_no_plan.append(camera)
+
+    for camera in ring.stickup_cams:
+        if camera.has_subscription:
+            cams.append(RingCam(hass, camera, config))
+        else:
+            cams_no_plan.append(camera)
+
+    # show notification for all cameras without an active subscription
+    if cams_no_plan:
+        cameras = str(', '.join([camera.name for camera in cams_no_plan]))
+
+        err_msg = '''A Ring Protect Plan is required for the''' \
+                  ''' following cameras: {}.'''.format(cameras)
+
+        _LOGGER.error(err_msg)
+        hass.components.persistent_notification.async_create(
+            'Error: {}<br />'
+            'You will need to restart hass after fixing.'
+            ''.format(err_msg),
+            title=NOTIFICATION_TITLE,
+            notification_id=NOTIFICATION_ID)
+
+    async_add_devices(cams, True)
+    return True
+
+
+class RingCam(Camera):
+    """An implementation of a Ring Door Bell camera."""
+
+    def __init__(self, hass, camera, device_info):
+        """Initialize a Ring Door Bell camera."""
+        super(RingCam, self).__init__()
+        self._camera = camera
+        self._hass = hass
+        self._name = self._camera.name
+        self._ffmpeg = hass.data[DATA_FFMPEG]
+        self._ffmpeg_arguments = device_info.get(CONF_FFMPEG_ARGUMENTS)
+        self._last_video_id = self._camera.last_recording_id
+        self._video_url = self._camera.recording_url(self._last_video_id)
+        self._utcnow = dt_util.utcnow()
+        self._expires_at = FORCE_REFRESH_INTERVAL + self._utcnow
+
+    @property
+    def name(self):
+        """Return the name of this camera."""
+        return self._name
+
+    @property
+    def device_state_attributes(self):
+        """Return the state attributes."""
+        return {
+            ATTR_ATTRIBUTION: CONF_ATTRIBUTION,
+            'device_id': self._camera.id,
+            'firmware': self._camera.firmware,
+            'kind': self._camera.kind,
+            'timezone': self._camera.timezone,
+            'type': self._camera.family,
+            'video_url': self._video_url,
+        }
+
+    @asyncio.coroutine
+    def async_camera_image(self):
+        """Return a still image response from the camera."""
+        from haffmpeg import ImageFrame, IMAGE_JPEG
+        ffmpeg = ImageFrame(self._ffmpeg.binary, loop=self.hass.loop)
+
+        if self._video_url is None:
+            return
+
+        image = yield from asyncio.shield(ffmpeg.get_image(
+            self._video_url, output_format=IMAGE_JPEG,
+            extra_cmd=self._ffmpeg_arguments), loop=self.hass.loop)
+        return image
+
+    @asyncio.coroutine
+    def handle_async_mjpeg_stream(self, request):
+        """Generate an HTTP MJPEG stream from the camera."""
+        from haffmpeg import CameraMjpeg
+
+        if self._video_url is None:
+            return
+
+        stream = CameraMjpeg(self._ffmpeg.binary, loop=self.hass.loop)
+        yield from stream.open_camera(
+            self._video_url, extra_cmd=self._ffmpeg_arguments)
+
+        yield from async_aiohttp_proxy_stream(
+            self.hass, request, stream,
+            'multipart/x-mixed-replace;boundary=ffserver')
+        yield from stream.close()
+
+    @property
+    def should_poll(self):
+        """Update the image periodically."""
+        return True
+
+    def update(self):
+        """Update camera entity and refresh attributes."""
+        _LOGGER.debug("Checking if Ring DoorBell needs to refresh video_url")
+
+        self._camera.update()
+        self._utcnow = dt_util.utcnow()
+
+        last_recording_id = self._camera.last_recording_id
+
+        if self._last_video_id != last_recording_id or \
+           self._utcnow >= self._expires_at:
+
+            _LOGGER.info("Ring DoorBell properties refreshed")
+
+            # update attributes if new video or if URL has expired
+            self._last_video_id = self._camera.last_recording_id
+            self._video_url = self._camera.recording_url(self._last_video_id)
+            self._expires_at = FORCE_REFRESH_INTERVAL + self._utcnow
@@ -1,17 +1,25 @@
 # Describes the format for available camera services

 enable_motion_detection:
-  description: Enable the motion detection in a camera
-
+  description: Enable the motion detection in a camera.
  fields:
    entity_id:
-      description: Name(s) of entities to enable motion detection
+      description: Name(s) of entities to enable motion detection.
      example: 'camera.living_room_camera'

 disable_motion_detection:
-  description: Disable the motion detection in a camera
-  
+  description: Disable the motion detection in a camera.
  fields:
    entity_id:
-      description: Name(s) of entities to disable motion detection
+      description: Name(s) of entities to disable motion detection.
      example: 'camera.living_room_camera'
+
+snapshot:
+  description: Take a snapshot from a camera.
+  fields:
+    entity_id:
+      description: Name(s) of entities to create snapshots from.
+      example: 'camera.living_room_camera'
+    filename:
+      description: Template of a Filename. Variable is entity_id.
+      example: '/tmp/snapshot_{{ entity_id }}'
@@ -9,12 +9,12 @@ from datetime import timedelta
 import logging
 import os
 import functools as ft
-from numbers import Number

 import voluptuous as vol

 from homeassistant.config import load_yaml_config_file
 from homeassistant.loader import bind_hass
+from homeassistant.helpers.temperature import display_temp as show_temp
 from homeassistant.util.temperature import convert as convert_temperature
 from homeassistant.helpers.entity_component import EntityComponent
 from homeassistant.helpers.entity import Entity
@@ -22,7 +22,7 @@ from homeassistant.helpers.config_validation import PLATFORM_SCHEMA  # noqa
 import homeassistant.helpers.config_validation as cv
 from homeassistant.const import (
    ATTR_ENTITY_ID, ATTR_TEMPERATURE, STATE_ON, STATE_OFF, STATE_UNKNOWN,
-    TEMP_CELSIUS)
+    TEMP_CELSIUS, PRECISION_WHOLE, PRECISION_TENTHS)

 DOMAIN = 'climate'

@@ -51,6 +51,19 @@ STATE_HIGH_DEMAND = 'high_demand'
 STATE_HEAT_PUMP = 'heat_pump'
 STATE_GAS = 'gas'

+SUPPORT_TARGET_TEMPERATURE = 1
+SUPPORT_TARGET_TEMPERATURE_HIGH = 2
+SUPPORT_TARGET_TEMPERATURE_LOW = 4
+SUPPORT_TARGET_HUMIDITY = 8
+SUPPORT_TARGET_HUMIDITY_HIGH = 16
+SUPPORT_TARGET_HUMIDITY_LOW = 32
+SUPPORT_FAN_MODE = 64
+SUPPORT_OPERATION_MODE = 128
+SUPPORT_HOLD_MODE = 256
+SUPPORT_SWING_MODE = 512
+SUPPORT_AWAY_MODE = 1024
+SUPPORT_AUX_HEAT = 2048
+
 ATTR_CURRENT_TEMPERATURE = 'current_temperature'
 ATTR_MAX_TEMP = 'max_temp'
 ATTR_MIN_TEMP = 'min_temp'
@@ -71,11 +84,6 @@ ATTR_OPERATION_LIST = 'operation_list'
 ATTR_SWING_MODE = 'swing_mode'
 ATTR_SWING_LIST = 'swing_list'

-# The degree of precision for each platform
-PRECISION_WHOLE = 1
-PRECISION_HALVES = 0.5
-PRECISION_TENTHS = 0.1
-
 CONVERTIBLE_ATTRIBUTE = [
    ATTR_TEMPERATURE,
    ATTR_TARGET_TEMP_LOW,
@@ -456,12 +464,18 @@ class ClimateDevice(Entity):
    def state_attributes(self):
        """Return the optional state attributes."""
        data = {
-            ATTR_CURRENT_TEMPERATURE:
-            self._convert_for_display(self.current_temperature),
-            ATTR_MIN_TEMP: self._convert_for_display(self.min_temp),
-            ATTR_MAX_TEMP: self._convert_for_display(self.max_temp),
-            ATTR_TEMPERATURE:
-            self._convert_for_display(self.target_temperature),
+            ATTR_CURRENT_TEMPERATURE: show_temp(
+                self.hass, self.current_temperature, self.temperature_unit,
+                self.precision),
+            ATTR_MIN_TEMP: show_temp(
+                self.hass, self.min_temp, self.temperature_unit,
+                self.precision),
+            ATTR_MAX_TEMP: show_temp(
+                self.hass, self.max_temp, self.temperature_unit,
+                self.precision),
+            ATTR_TEMPERATURE: show_temp(
+                self.hass, self.target_temperature, self.temperature_unit,
+                self.precision),
        }

        if self.target_temperature_step is not None:
@@ -469,10 +483,12 @@ class ClimateDevice(Entity):

        target_temp_high = self.target_temperature_high
        if target_temp_high is not None:
-            data[ATTR_TARGET_TEMP_HIGH] = self._convert_for_display(
-                self.target_temperature_high)
-            data[ATTR_TARGET_TEMP_LOW] = self._convert_for_display(
-                self.target_temperature_low)
+            data[ATTR_TARGET_TEMP_HIGH] = show_temp(
+                self.hass, self.target_temperature_high, self.temperature_unit,
+                self.precision)
+            data[ATTR_TARGET_TEMP_LOW] = show_temp(
+                self.hass, self.target_temperature_low, self.temperature_unit,
+                self.precision)

        humidity = self.target_humidity
        if humidity is not None:
@@ -714,6 +730,11 @@ class ClimateDevice(Entity):
        """
        return self.hass.async_add_job(self.turn_aux_heat_off)

+    @property
+    def supported_features(self):
+        """Return the list of supported features."""
+        raise NotImplementedError()
+
    @property
    def min_temp(self):
        """Return the minimum temperature."""
@@ -733,24 +754,3 @@ class ClimateDevice(Entity):
    def max_humidity(self):
        """Return the maximum humidity."""
        return 99
-
-    def _convert_for_display(self, temp):
-        """Convert temperature into preferred units for display purposes."""
-        if temp is None:
-            return temp
-
-        # if the temperature is not a number this can cause issues
-        # with polymer components, so bail early there.
-        if not isinstance(temp, Number):
-            raise TypeError("Temperature is not a number: %s" % temp)
-
-        if self.temperature_unit != self.unit_of_measurement:
-            temp = convert_temperature(
-                temp, self.temperature_unit, self.unit_of_measurement)
-        # Round in the units appropriate
-        if self.precision == PRECISION_HALVES:
-            return round(temp * 2) / 2.0
-        elif self.precision == PRECISION_TENTHS:
-            return round(temp, 1)
-        # PRECISION_WHOLE as a fall back
-        return round(temp)
@@ -5,9 +5,19 @@ For more details about this platform, please refer to the documentation
 https://home-assistant.io/components/demo/
 """
 from homeassistant.components.climate import (
-    ClimateDevice, ATTR_TARGET_TEMP_HIGH, ATTR_TARGET_TEMP_LOW)
+    ClimateDevice, ATTR_TARGET_TEMP_HIGH, ATTR_TARGET_TEMP_LOW,
+    SUPPORT_TARGET_TEMPERATURE, SUPPORT_TARGET_HUMIDITY,
+    SUPPORT_AWAY_MODE, SUPPORT_HOLD_MODE, SUPPORT_FAN_MODE,
+    SUPPORT_OPERATION_MODE, SUPPORT_AUX_HEAT, SUPPORT_SWING_MODE,
+    SUPPORT_TARGET_TEMPERATURE_HIGH, SUPPORT_TARGET_TEMPERATURE_LOW)
 from homeassistant.const import TEMP_CELSIUS, TEMP_FAHRENHEIT, ATTR_TEMPERATURE

+SUPPORT_FLAGS = (SUPPORT_TARGET_TEMPERATURE | SUPPORT_TARGET_HUMIDITY |
+                 SUPPORT_AWAY_MODE | SUPPORT_HOLD_MODE | SUPPORT_FAN_MODE |
+                 SUPPORT_OPERATION_MODE | SUPPORT_AUX_HEAT |
+                 SUPPORT_SWING_MODE | SUPPORT_TARGET_TEMPERATURE_HIGH |
+                 SUPPORT_TARGET_TEMPERATURE_LOW)
+

 def setup_platform(hass, config, add_devices, discovery_info=None):
    """Set up the Demo climate devices."""
@@ -47,6 +57,11 @@ class DemoClimate(ClimateDevice):
        self._target_temperature_high = target_temp_high
        self._target_temperature_low = target_temp_low

+    @property
+    def supported_features(self):
+        """Return the list of supported features."""
+        return SUPPORT_FLAGS
+
    @property
    def should_poll(self):
        """Return the polling state."""
@@ -12,7 +12,9 @@ import voluptuous as vol
 from homeassistant.components import ecobee
 from homeassistant.components.climate import (
    DOMAIN, STATE_COOL, STATE_HEAT, STATE_AUTO, STATE_IDLE, ClimateDevice,
-    ATTR_TARGET_TEMP_LOW, ATTR_TARGET_TEMP_HIGH)
+    ATTR_TARGET_TEMP_LOW, ATTR_TARGET_TEMP_HIGH, SUPPORT_TARGET_TEMPERATURE,
+    SUPPORT_AWAY_MODE, SUPPORT_HOLD_MODE, SUPPORT_OPERATION_MODE,
+    SUPPORT_TARGET_HUMIDITY_LOW, SUPPORT_TARGET_HUMIDITY_HIGH)
 from homeassistant.const import (
    ATTR_ENTITY_ID, STATE_OFF, STATE_ON, ATTR_TEMPERATURE, TEMP_FAHRENHEIT)
 from homeassistant.config import load_yaml_config_file
@@ -44,6 +46,10 @@ RESUME_PROGRAM_SCHEMA = vol.Schema({
    vol.Optional(ATTR_RESUME_ALL, default=DEFAULT_RESUME_ALL): cv.boolean,
 })

+SUPPORT_FLAGS = (SUPPORT_TARGET_TEMPERATURE | SUPPORT_AWAY_MODE |
+                 SUPPORT_HOLD_MODE | SUPPORT_OPERATION_MODE |
+                 SUPPORT_TARGET_HUMIDITY_LOW | SUPPORT_TARGET_HUMIDITY_HIGH)
+

 def setup_platform(hass, config, add_devices, discovery_info=None):
    """Set up the Ecobee Thermostat Platform."""
@@ -132,6 +138,11 @@ class Thermostat(ClimateDevice):
        self.thermostat = self.data.ecobee.get_thermostat(
            self.thermostat_index)

+    @property
+    def supported_features(self):
+        """Return the list of supported features."""
+        return SUPPORT_FLAGS
+
    @property
    def name(self):
        """Return the name of the Ecobee Thermostat."""
@@ -318,8 +329,21 @@ class Thermostat(ClimateDevice):

    def set_auto_temp_hold(self, heat_temp, cool_temp):
        """Set temperature hold in auto mode."""
-        self.data.ecobee.set_hold_temp(self.thermostat_index, cool_temp,
-                                       heat_temp, self.hold_preference())
+        if cool_temp is not None:
+            cool_temp_setpoint = cool_temp
+        else:
+            cool_temp_setpoint = (
+                self.thermostat['runtime']['desiredCool'] / 10.0)
+
+        if heat_temp is not None:
+            heat_temp_setpoint = heat_temp
+        else:
+            heat_temp_setpoint = (
+                self.thermostat['runtime']['desiredCool'] / 10.0)
+
+        self.data.ecobee.set_hold_temp(self.thermostat_index,
+                                       cool_temp_setpoint, heat_temp_setpoint,
+                                       self.hold_preference())
        _LOGGER.debug("Setting ecobee hold_temp to: heat=%s, is=%s, "
                      "cool=%s, is=%s", heat_temp, isinstance(
                          heat_temp, (int, float)), cool_temp,
@@ -348,8 +372,8 @@ class Thermostat(ClimateDevice):
        high_temp = kwargs.get(ATTR_TARGET_TEMP_HIGH)
        temp = kwargs.get(ATTR_TEMPERATURE)

-        if self.current_operation == STATE_AUTO and low_temp is not None \
-           and high_temp is not None:
+        if self.current_operation == STATE_AUTO and (low_temp is not None or
+                                                     high_temp is not None):
            self.set_auto_temp_hold(low_temp, high_temp)
        elif temp is not None:
            self.set_temp_hold(temp)
@@ -357,6 +381,10 @@ class Thermostat(ClimateDevice):
            _LOGGER.error(
                "Missing valid arguments for set_temperature in %s", kwargs)

+    def set_humidity(self, humidity):
+        """Set the humidity level."""
+        self.data.ecobee.set_humidity(self.thermostat_index, humidity)
+
    def set_operation_mode(self, operation_mode):
        """Set HVAC mode (auto, auxHeatOnly, cool, heat, off)."""
        self.data.ecobee.set_hvac_mode(self.thermostat_index, operation_mode)
@@ -0,0 +1,122 @@
+"""
+Support for the EPH Controls Ember themostats.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/climate.ephember/
+"""
+import logging
+from datetime import timedelta
+import voluptuous as vol
+
+from homeassistant.components.climate import (
+    ClimateDevice, PLATFORM_SCHEMA, STATE_HEAT, STATE_IDLE, SUPPORT_AUX_HEAT)
+from homeassistant.const import (
+    TEMP_CELSIUS, CONF_USERNAME, CONF_PASSWORD)
+import homeassistant.helpers.config_validation as cv
+
+REQUIREMENTS = ['pyephember==0.1.1']
+
+_LOGGER = logging.getLogger(__name__)
+
+# Return cached results if last scan was less then this time ago
+SCAN_INTERVAL = timedelta(seconds=120)
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Required(CONF_USERNAME): cv.string,
+    vol.Required(CONF_PASSWORD): cv.string
+})
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Set up the ephember thermostat."""
+    from pyephember.pyephember import EphEmber
+
+    username = config.get(CONF_USERNAME)
+    password = config.get(CONF_PASSWORD)
+
+    try:
+        ember = EphEmber(username, password)
+        zones = ember.get_zones()
+        for zone in zones:
+            add_devices([EphEmberThermostat(ember, zone)])
+    except RuntimeError:
+        _LOGGER.error("Cannot connect to EphEmber")
+        return
+
+    return
+
+
+class EphEmberThermostat(ClimateDevice):
+    """Representation of a HeatmiserV3 thermostat."""
+
+    def __init__(self, ember, zone):
+        """Initialize the thermostat."""
+        self._ember = ember
+        self._zone_name = zone['name']
+        self._zone = zone
+        self._hot_water = zone['isHotWater']
+
+    @property
+    def supported_features(self):
+        """Return the list of supported features."""
+        return SUPPORT_AUX_HEAT
+
+    @property
+    def name(self):
+        """Return the name of the thermostat, if any."""
+        return self._zone_name
+
+    @property
+    def temperature_unit(self):
+        """Return the unit of measurement which this thermostat uses."""
+        return TEMP_CELSIUS
+
+    @property
+    def current_temperature(self):
+        """Return the current temperature."""
+        return self._zone['currentTemperature']
+
+    @property
+    def target_temperature(self):
+        """Return the temperature we try to reach."""
+        return self._zone['targetTemperature']
+
+    @property
+    def current_operation(self):
+        """Return current operation ie. heat, cool, idle."""
+        if self._zone['isCurrentlyActive']:
+            return STATE_HEAT
+        else:
+            return STATE_IDLE
+
+    @property
+    def is_aux_heat_on(self):
+        """Return true if aux heater."""
+        return self._zone['isBoostActive']
+
+    def turn_aux_heat_on(self):
+        """Turn auxiliary heater on."""
+        self._ember.activate_boost_by_name(
+            self._zone_name, self._zone['targetTemperature'])
+
+    def turn_aux_heat_off(self):
+        """Turn auxiliary heater off."""
+        self._ember.deactivate_boost_by_name(self._zone_name)
+
+    def set_temperature(self, **kwargs):
+        """Set new target temperature."""
+        return
+
+    @property
+    def min_temp(self):
+        """Return the minimum temperature."""
+        return self._zone['targetTemperature']
+
+    @property
+    def max_temp(self):
+        """Return the maximum temperature."""
+        return self._zone['targetTemperature']
+
+    def update(self):
+        """Get the latest data."""
+        self._zone = self._ember.get_zone(self._zone_name)
@@ -9,12 +9,10 @@ import logging
 import voluptuous as vol

 from homeassistant.components.climate import (
-    ClimateDevice, PLATFORM_SCHEMA, PRECISION_HALVES,
-    STATE_AUTO, STATE_ON, STATE_OFF,
-)
+    STATE_ON, STATE_OFF, STATE_AUTO, PLATFORM_SCHEMA, ClimateDevice,
+    SUPPORT_TARGET_TEMPERATURE, SUPPORT_OPERATION_MODE, SUPPORT_AWAY_MODE)
 from homeassistant.const import (
-    CONF_MAC, TEMP_CELSIUS, CONF_DEVICES, ATTR_TEMPERATURE)
-
+    CONF_MAC, CONF_DEVICES, TEMP_CELSIUS, ATTR_TEMPERATURE, PRECISION_HALVES)
 import homeassistant.helpers.config_validation as cv

 REQUIREMENTS = ['python-eq3bt==0.1.6']
@@ -40,6 +38,9 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
        vol.Schema({cv.string: DEVICE_SCHEMA}),
 })

+SUPPORT_FLAGS = (SUPPORT_TARGET_TEMPERATURE | SUPPORT_OPERATION_MODE |
+                 SUPPORT_AWAY_MODE)
+

 def setup_platform(hass, config, add_devices, discovery_info=None):
    """Set up the eQ-3 BLE thermostats."""
@@ -58,21 +59,28 @@ class EQ3BTSmartThermostat(ClimateDevice):

    def __init__(self, _mac, _name):
        """Initialize the thermostat."""
-        # we want to avoid name clash with this module..
+        # We want to avoid name clash with this module.
        import eq3bt as eq3

-        self.modes = {eq3.Mode.Open: STATE_ON,
-                      eq3.Mode.Closed: STATE_OFF,
-                      eq3.Mode.Auto: STATE_AUTO,
-                      eq3.Mode.Manual: STATE_MANUAL,
-                      eq3.Mode.Boost: STATE_BOOST,
-                      eq3.Mode.Away: STATE_AWAY}
+        self.modes = {
+            eq3.Mode.Open: STATE_ON,
+            eq3.Mode.Closed: STATE_OFF,
+            eq3.Mode.Auto: STATE_AUTO,
+            eq3.Mode.Manual: STATE_MANUAL,
+            eq3.Mode.Boost: STATE_BOOST,
+            eq3.Mode.Away: STATE_AWAY,
+        }

        self.reverse_modes = {v: k for k, v in self.modes.items()}

        self._name = _name
        self._thermostat = eq3.Thermostat(_mac)

+    @property
+    def supported_features(self):
+        """Return the list of supported features."""
+        return SUPPORT_FLAGS
+
    @property
    def available(self) -> bool:
        """Return if thermostat is available."""
@@ -153,11 +161,11 @@ class EQ3BTSmartThermostat(ClimateDevice):
    def device_state_attributes(self):
        """Return the device specific state attributes."""
        dev_specific = {
+            ATTR_STATE_AWAY_END: self._thermostat.away_end,
            ATTR_STATE_LOCKED: self._thermostat.locked,
            ATTR_STATE_LOW_BAT: self._thermostat.low_battery,
            ATTR_STATE_VALVE: self._thermostat.valve_state,
            ATTR_STATE_WINDOW_OPEN: self._thermostat.window_open,
-            ATTR_STATE_AWAY_END: self._thermostat.away_end,
        }

        return dev_specific
@@ -17,7 +17,9 @@ import voluptuous as vol
 from homeassistant.const import (
    CONF_NAME, CONF_SLAVE, TEMP_CELSIUS,
    ATTR_TEMPERATURE, DEVICE_DEFAULT_NAME)
-from homeassistant.components.climate import (ClimateDevice, PLATFORM_SCHEMA)
+from homeassistant.components.climate import (
+    ClimateDevice, PLATFORM_SCHEMA, SUPPORT_TARGET_TEMPERATURE,
+    SUPPORT_FAN_MODE)
 import homeassistant.components.modbus as modbus
 import homeassistant.helpers.config_validation as cv

@@ -31,6 +33,8 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({

 _LOGGER = logging.getLogger(__name__)

+SUPPORT_FLAGS = SUPPORT_TARGET_TEMPERATURE | SUPPORT_FAN_MODE
+

 def setup_platform(hass, config, add_devices, discovery_info=None):
    """Set up the Flexit Platform."""
@@ -62,6 +66,11 @@ class Flexit(ClimateDevice):
        self._alarm = False
        self.unit = pyflexit.pyflexit(modbus.HUB, modbus_slave)

+    @property
+    def supported_features(self):
+        """Return the list of supported features."""
+        return SUPPORT_FLAGS
+
    def update(self):
        """Update unit attributes."""
        if not self.unit.update():
@@ -10,17 +10,18 @@ import logging
 import voluptuous as vol

 from homeassistant.core import callback
-from homeassistant.components import switch
+from homeassistant.core import DOMAIN as HA_DOMAIN
 from homeassistant.components.climate import (
    STATE_HEAT, STATE_COOL, STATE_IDLE, ClimateDevice, PLATFORM_SCHEMA,
-    STATE_AUTO)
+    STATE_AUTO, SUPPORT_OPERATION_MODE, SUPPORT_TARGET_TEMPERATURE)
 from homeassistant.const import (
    ATTR_UNIT_OF_MEASUREMENT, STATE_ON, STATE_OFF, ATTR_TEMPERATURE,
-    CONF_NAME)
+    CONF_NAME, ATTR_ENTITY_ID, SERVICE_TURN_ON, SERVICE_TURN_OFF)
 from homeassistant.helpers import condition
 from homeassistant.helpers.event import (
    async_track_state_change, async_track_time_interval)
 import homeassistant.helpers.config_validation as cv
+from homeassistant.helpers.restore_state import async_get_last_state

 _LOGGER = logging.getLogger(__name__)

@@ -36,9 +37,11 @@ CONF_MAX_TEMP = 'max_temp'
 CONF_TARGET_TEMP = 'target_temp'
 CONF_AC_MODE = 'ac_mode'
 CONF_MIN_DUR = 'min_cycle_duration'
-CONF_TOLERANCE = 'tolerance'
+CONF_COLD_TOLERANCE = 'cold_tolerance'
+CONF_HOT_TOLERANCE = 'hot_tolerance'
 CONF_KEEP_ALIVE = 'keep_alive'

+SUPPORT_FLAGS = SUPPORT_TARGET_TEMPERATURE | SUPPORT_OPERATION_MODE

 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
    vol.Required(CONF_HEATER): cv.entity_id,
@@ -48,7 +51,10 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
    vol.Optional(CONF_MIN_DUR): vol.All(cv.time_period, cv.positive_timedelta),
    vol.Optional(CONF_MIN_TEMP): vol.Coerce(float),
    vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
-    vol.Optional(CONF_TOLERANCE, default=DEFAULT_TOLERANCE): vol.Coerce(float),
+    vol.Optional(CONF_COLD_TOLERANCE, default=DEFAULT_TOLERANCE): vol.Coerce(
+        float),
+    vol.Optional(CONF_HOT_TOLERANCE, default=DEFAULT_TOLERANCE): vol.Coerce(
+        float),
    vol.Optional(CONF_TARGET_TEMP): vol.Coerce(float),
    vol.Optional(CONF_KEEP_ALIVE): vol.All(
        cv.time_period, cv.positive_timedelta),
@@ -66,12 +72,14 @@ def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
    target_temp = config.get(CONF_TARGET_TEMP)
    ac_mode = config.get(CONF_AC_MODE)
    min_cycle_duration = config.get(CONF_MIN_DUR)
-    tolerance = config.get(CONF_TOLERANCE)
+    cold_tolerance = config.get(CONF_COLD_TOLERANCE)
+    hot_tolerance = config.get(CONF_HOT_TOLERANCE)
    keep_alive = config.get(CONF_KEEP_ALIVE)

    async_add_devices([GenericThermostat(
        hass, name, heater_entity_id, sensor_entity_id, min_temp, max_temp,
-        target_temp, ac_mode, min_cycle_duration, tolerance, keep_alive)])
+        target_temp, ac_mode, min_cycle_duration, cold_tolerance,
+        hot_tolerance, keep_alive)])


 class GenericThermostat(ClimateDevice):
@@ -79,14 +87,15 @@ class GenericThermostat(ClimateDevice):

    def __init__(self, hass, name, heater_entity_id, sensor_entity_id,
                 min_temp, max_temp, target_temp, ac_mode, min_cycle_duration,
-                 tolerance, keep_alive):
+                 cold_tolerance, hot_tolerance, keep_alive):
        """Initialize the thermostat."""
        self.hass = hass
        self._name = name
        self.heater_entity_id = heater_entity_id
        self.ac_mode = ac_mode
        self.min_cycle_duration = min_cycle_duration
-        self._tolerance = tolerance
+        self._cold_tolerance = cold_tolerance
+        self._hot_tolerance = hot_tolerance
        self._keep_alive = keep_alive
        self._enabled = True

@@ -110,6 +119,17 @@ class GenericThermostat(ClimateDevice):
        if sensor_state:
            self._async_update_temp(sensor_state)

+    @asyncio.coroutine
+    def async_added_to_hass(self):
+        """Run when entity about to be added."""
+        # If we have an old state and no target temp, restore
+        if self._target_temp is None:
+            old_state = yield from async_get_last_state(self.hass,
+                                                        self.entity_id)
+            if old_state is not None:
+                self._target_temp = float(
+                    old_state.attributes[ATTR_TEMPERATURE])
+
    @property
    def should_poll(self):
        """Return the polling state."""
@@ -156,10 +176,11 @@ class GenericThermostat(ClimateDevice):
        """Set operation mode."""
        if operation_mode == STATE_AUTO:
            self._enabled = True
+            self._async_control_heating()
        elif operation_mode == STATE_OFF:
            self._enabled = False
            if self._is_device_active:
-                switch.async_turn_off(self.hass, self.heater_entity_id)
+                self._heater_turn_off()
        else:
            _LOGGER.error('Unrecognized operation mode: %s', operation_mode)
            return
@@ -217,9 +238,9 @@ class GenericThermostat(ClimateDevice):
    def _async_keep_alive(self, time):
        """Call at constant intervals for keep-alive purposes."""
        if self.current_operation in [STATE_COOL, STATE_HEAT]:
-            switch.async_turn_on(self.hass, self.heater_entity_id)
+            self._heater_turn_on()
        else:
-            switch.async_turn_off(self.hass, self.heater_entity_id)
+            self._heater_turn_off()

    @callback
    def _async_update_temp(self, state):
@@ -261,30 +282,53 @@ class GenericThermostat(ClimateDevice):
        if self.ac_mode:
            is_cooling = self._is_device_active
            if is_cooling:
-                too_cold = self._target_temp - self._cur_temp > self._tolerance
+                too_cold = self._target_temp - self._cur_temp >= \
+                    self._cold_tolerance
                if too_cold:
                    _LOGGER.info('Turning off AC %s', self.heater_entity_id)
-                    switch.async_turn_off(self.hass, self.heater_entity_id)
+                    self._heater_turn_off()
            else:
-                too_hot = self._cur_temp - self._target_temp > self._tolerance
+                too_hot = self._cur_temp - self._target_temp >= \
+                    self._hot_tolerance
                if too_hot:
                    _LOGGER.info('Turning on AC %s', self.heater_entity_id)
-                    switch.async_turn_on(self.hass, self.heater_entity_id)
+                    self._heater_turn_on()
        else:
            is_heating = self._is_device_active
            if is_heating:
-                too_hot = self._cur_temp - self._target_temp > self._tolerance
+                too_hot = self._cur_temp - self._target_temp >= \
+                    self._hot_tolerance
                if too_hot:
                    _LOGGER.info('Turning off heater %s',
                                 self.heater_entity_id)
-                    switch.async_turn_off(self.hass, self.heater_entity_id)
+                    self._heater_turn_off()
            else:
-                too_cold = self._target_temp - self._cur_temp > self._tolerance
+                too_cold = self._target_temp - self._cur_temp >= \
+                    self._cold_tolerance
                if too_cold:
                    _LOGGER.info('Turning on heater %s', self.heater_entity_id)
-                    switch.async_turn_on(self.hass, self.heater_entity_id)
+                    self._heater_turn_on()

    @property
    def _is_device_active(self):
        """If the toggleable device is currently active."""
-        return switch.is_on(self.hass, self.heater_entity_id)
+        return self.hass.states.is_state(self.heater_entity_id, STATE_ON)
+
+    @property
+    def supported_features(self):
+        """Return the list of supported features."""
+        return SUPPORT_FLAGS
+
+    @callback
+    def _heater_turn_on(self):
+        """Turn heater toggleable device on."""
+        data = {ATTR_ENTITY_ID: self.heater_entity_id}
+        self.hass.async_add_job(
+            self.hass.services.async_call(HA_DOMAIN, SERVICE_TURN_ON, data))
+
+    @callback
+    def _heater_turn_off(self):
+        """Turn heater toggleable device off."""
+        data = {ATTR_ENTITY_ID: self.heater_entity_id}
+        self.hass.async_add_job(
+            self.hass.services.async_call(HA_DOMAIN, SERVICE_TURN_OFF, data))
@@ -8,7 +8,8 @@ import logging

 import voluptuous as vol

-from homeassistant.components.climate import ClimateDevice, PLATFORM_SCHEMA
+from homeassistant.components.climate import (
+    ClimateDevice, PLATFORM_SCHEMA, SUPPORT_TARGET_TEMPERATURE)
 from homeassistant.const import (
    TEMP_CELSIUS, ATTR_TEMPERATURE, CONF_PORT, CONF_NAME, CONF_ID)
 import homeassistant.helpers.config_validation as cv
@@ -68,6 +69,11 @@ class HeatmiserV3Thermostat(ClimateDevice):
        self.update()
        self._target_temperature = int(self.dcb.get('roomset'))

+    @property
+    def supported_features(self):
+        """Return the list of supported features."""
+        return SUPPORT_TARGET_TEMPERATURE
+
    @property
    def name(self):
        """Return the name of the thermostat, if any."""
@@ -0,0 +1,139 @@
+"""
+Support for the Hive devices.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/climate.hive/
+"""
+from homeassistant.components.climate import (
+    ClimateDevice, STATE_AUTO, STATE_HEAT, STATE_OFF, STATE_ON,
+    SUPPORT_TARGET_TEMPERATURE, SUPPORT_OPERATION_MODE)
+from homeassistant.const import ATTR_TEMPERATURE, TEMP_CELSIUS
+from homeassistant.components.hive import DATA_HIVE
+
+DEPENDENCIES = ['hive']
+HIVE_TO_HASS_STATE = {'SCHEDULE': STATE_AUTO, 'MANUAL': STATE_HEAT,
+                      'ON': STATE_ON, 'OFF': STATE_OFF}
+HASS_TO_HIVE_STATE = {STATE_AUTO: 'SCHEDULE', STATE_HEAT: 'MANUAL',
+                      STATE_ON: 'ON', STATE_OFF: 'OFF'}
+
+SUPPORT_FLAGS = SUPPORT_TARGET_TEMPERATURE | SUPPORT_OPERATION_MODE
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Set up Hive climate devices."""
+    if discovery_info is None:
+        return
+    session = hass.data.get(DATA_HIVE)
+
+    add_devices([HiveClimateEntity(session, discovery_info)])
+
+
+class HiveClimateEntity(ClimateDevice):
+    """Hive Climate Device."""
+
+    def __init__(self, hivesession, hivedevice):
+        """Initialize the Climate device."""
+        self.node_id = hivedevice["Hive_NodeID"]
+        self.node_name = hivedevice["Hive_NodeName"]
+        self.device_type = hivedevice["HA_DeviceType"]
+        self.session = hivesession
+        self.data_updatesource = '{}.{}'.format(self.device_type,
+                                                self.node_id)
+
+        if self.device_type == "Heating":
+            self.modes = [STATE_AUTO, STATE_HEAT, STATE_OFF]
+        elif self.device_type == "HotWater":
+            self.modes = [STATE_AUTO, STATE_ON, STATE_OFF]
+
+        self.session.entities.append(self)
+
+    @property
+    def supported_features(self):
+        """Return the list of supported features."""
+        return SUPPORT_FLAGS
+
+    def handle_update(self, updatesource):
+        """Handle the new update request."""
+        if '{}.{}'.format(self.device_type, self.node_id) not in updatesource:
+            self.schedule_update_ha_state()
+
+    @property
+    def name(self):
+        """Return the name of the Climate device."""
+        friendly_name = "Climate Device"
+        if self.device_type == "Heating":
+            friendly_name = "Heating"
+            if self.node_name is not None:
+                friendly_name = '{} {}'.format(self.node_name, friendly_name)
+        elif self.device_type == "HotWater":
+            friendly_name = "Hot Water"
+        return friendly_name
+
+    @property
+    def temperature_unit(self):
+        """Return the unit of measurement."""
+        return TEMP_CELSIUS
+
+    @property
+    def current_temperature(self):
+        """Return the current temperature."""
+        if self.device_type == "Heating":
+            return self.session.heating.current_temperature(self.node_id)
+
+    @property
+    def target_temperature(self):
+        """Return the target temperature."""
+        if self.device_type == "Heating":
+            return self.session.heating.get_target_temperature(self.node_id)
+
+    @property
+    def min_temp(self):
+        """Return minimum temperature."""
+        if self.device_type == "Heating":
+            return self.session.heating.min_temperature(self.node_id)
+
+    @property
+    def max_temp(self):
+        """Return the maximum temperature."""
+        if self.device_type == "Heating":
+            return self.session.heating.max_temperature(self.node_id)
+
+    @property
+    def operation_list(self):
+        """List of the operation modes."""
+        return self.modes
+
+    @property
+    def current_operation(self):
+        """Return current mode."""
+        if self.device_type == "Heating":
+            currentmode = self.session.heating.get_mode(self.node_id)
+        elif self.device_type == "HotWater":
+            currentmode = self.session.hotwater.get_mode(self.node_id)
+        return HIVE_TO_HASS_STATE.get(currentmode)
+
+    def set_operation_mode(self, operation_mode):
+        """Set new Heating mode."""
+        new_mode = HASS_TO_HIVE_STATE.get(operation_mode)
+        if self.device_type == "Heating":
+            self.session.heating.set_mode(self.node_id, new_mode)
+        elif self.device_type == "HotWater":
+            self.session.hotwater.set_mode(self.node_id, new_mode)
+
+        for entity in self.session.entities:
+            entity.handle_update(self.data_updatesource)
+
+    def set_temperature(self, **kwargs):
+        """Set new target temperature."""
+        new_temperature = kwargs.get(ATTR_TEMPERATURE)
+        if new_temperature is not None:
+            if self.device_type == "Heating":
+                self.session.heating.set_target_temperature(self.node_id,
+                                                            new_temperature)
+
+            for entity in self.session.entities:
+                entity.handle_update(self.data_updatesource)
+
+    def update(self):
+        """Update all Node data frome Hive."""
+        self.session.core.update_data(self.node_id)
@@ -5,9 +5,10 @@ For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/climate.homematic/
 """
 import logging
-from homeassistant.components.climate import ClimateDevice, STATE_AUTO
+from homeassistant.components.climate import (
+    ClimateDevice, STATE_AUTO, SUPPORT_TARGET_TEMPERATURE,
+    SUPPORT_OPERATION_MODE)
 from homeassistant.components.homematic import HMDevice, ATTR_DISCOVER_DEVICES
-from homeassistant.util.temperature import convert
 from homeassistant.const import TEMP_CELSIUS, STATE_UNKNOWN, ATTR_TEMPERATURE

 DEPENDENCIES = ['homematic']
@@ -39,6 +40,8 @@ HM_HUMI_MAP = [

 HM_CONTROL_MODE = 'CONTROL_MODE'

+SUPPORT_FLAGS = SUPPORT_TARGET_TEMPERATURE | SUPPORT_OPERATION_MODE
+

 def setup_platform(hass, config, add_devices, discovery_info=None):
    """Set up the Homematic thermostat platform."""
@@ -56,6 +59,11 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
 class HMThermostat(HMDevice, ClimateDevice):
    """Representation of a Homematic thermostat."""

+    @property
+    def supported_features(self):
+        """Return the list of supported features."""
+        return SUPPORT_FLAGS
+
    @property
    def temperature_unit(self):
        """Return the unit of measurement that is used."""
@@ -121,12 +129,12 @@ class HMThermostat(HMDevice, ClimateDevice):
    @property
    def min_temp(self):
        """Return the minimum temperature - 4.5 means off."""
-        return convert(4.5, TEMP_CELSIUS, self.unit_of_measurement)
+        return 4.5

    @property
    def max_temp(self):
        """Return the maximum temperature - 30.5 means on."""
-        return convert(30.5, TEMP_CELSIUS, self.unit_of_measurement)
+        return 30.5

    def _init_data_struct(self):
        """Generate a data dict (self._data) from the Homematic metadata."""
@@ -11,16 +11,16 @@ import datetime
 import requests
 import voluptuous as vol

+import homeassistant.helpers.config_validation as cv
 from homeassistant.components.climate import (
    ClimateDevice, PLATFORM_SCHEMA, ATTR_FAN_MODE, ATTR_FAN_LIST,
-    ATTR_OPERATION_MODE, ATTR_OPERATION_LIST)
+    ATTR_OPERATION_MODE, ATTR_OPERATION_LIST, SUPPORT_TARGET_TEMPERATURE,
+    SUPPORT_AWAY_MODE, SUPPORT_OPERATION_MODE)
 from homeassistant.const import (
    CONF_PASSWORD, CONF_USERNAME, TEMP_CELSIUS, TEMP_FAHRENHEIT,
-    ATTR_TEMPERATURE)
-import homeassistant.helpers.config_validation as cv
+    ATTR_TEMPERATURE, CONF_REGION)

-REQUIREMENTS = ['evohomeclient==0.2.5',
-                'somecomfort==0.4.1']
+REQUIREMENTS = ['evohomeclient==0.2.5', 'somecomfort==0.5.0']

 _LOGGER = logging.getLogger(__name__)

@@ -31,7 +31,6 @@ ATTR_CURRENT_OPERATION = 'equipment_output_status'
 CONF_AWAY_TEMPERATURE = 'away_temperature'
 CONF_COOL_AWAY_TEMPERATURE = 'away_cool_temperature'
 CONF_HEAT_AWAY_TEMPERATURE = 'away_heat_temperature'
-CONF_REGION = 'region'

 DEFAULT_AWAY_TEMPERATURE = 16
 DEFAULT_COOL_AWAY_TEMPERATURE = 30
@@ -128,6 +127,14 @@ class RoundThermostat(ClimateDevice):
        self._away_temp = away_temp
        self._away = False

+    @property
+    def supported_features(self):
+        """Return the list of supported features."""
+        supported = (SUPPORT_TARGET_TEMPERATURE | SUPPORT_AWAY_MODE)
+        if hasattr(self.client, ATTR_SYSTEM_MODE):
+            supported |= SUPPORT_OPERATION_MODE
+        return supported
+
    @property
    def name(self):
        """Return the name of the honeywell, if any."""
@@ -236,6 +243,14 @@ class HoneywellUSThermostat(ClimateDevice):
        self._username = username
        self._password = password

+    @property
+    def supported_features(self):
+        """Return the list of supported features."""
+        supported = (SUPPORT_TARGET_TEMPERATURE | SUPPORT_AWAY_MODE)
+        if hasattr(self._device, ATTR_SYSTEM_MODE):
+            supported |= SUPPORT_OPERATION_MODE
+        return supported
+
    @property
    def is_fan_on(self):
        """Return true if fan is on."""
@@ -8,14 +8,18 @@ import asyncio
 import voluptuous as vol

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

-CONF_SETPOINT_ADDRESS = 'setpoint_address'
 CONF_SETPOINT_SHIFT_ADDRESS = 'setpoint_shift_address'
 CONF_SETPOINT_SHIFT_STATE_ADDRESS = 'setpoint_shift_state_address'
+CONF_SETPOINT_SHIFT_STEP = 'setpoint_shift_step'
+CONF_SETPOINT_SHIFT_MAX = 'setpoint_shift_max'
+CONF_SETPOINT_SHIFT_MIN = 'setpoint_shift_min'
 CONF_TEMPERATURE_ADDRESS = 'temperature_address'
 CONF_TARGET_TEMPERATURE_ADDRESS = 'target_temperature_address'
 CONF_OPERATION_MODE_ADDRESS = 'operation_mode_address'
@@ -28,15 +32,24 @@ CONF_OPERATION_MODE_NIGHT_ADDRESS = 'operation_mode_night_address'
 CONF_OPERATION_MODE_COMFORT_ADDRESS = 'operation_mode_comfort_address'

 DEFAULT_NAME = 'KNX Climate'
+DEFAULT_SETPOINT_SHIFT_STEP = 0.5
+DEFAULT_SETPOINT_SHIFT_MAX = 6
+DEFAULT_SETPOINT_SHIFT_MIN = -6
 DEPENDENCIES = ['knx']

 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
    vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
-    vol.Required(CONF_SETPOINT_ADDRESS): cv.string,
    vol.Required(CONF_TEMPERATURE_ADDRESS): 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_SETPOINT_SHIFT_STEP,
+                 default=DEFAULT_SETPOINT_SHIFT_STEP): vol.All(
+                     float, vol.Range(min=0, max=2)),
+    vol.Optional(CONF_SETPOINT_SHIFT_MAX, default=DEFAULT_SETPOINT_SHIFT_MAX):
+        vol.All(int, vol.Range(min=-32, max=0)),
+    vol.Optional(CONF_SETPOINT_SHIFT_MIN, default=DEFAULT_SETPOINT_SHIFT_MIN):
+        vol.All(int, vol.Range(min=0, max=32)),
    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,
@@ -77,6 +90,7 @@ def async_add_devices_discovery(hass, discovery_info, async_add_devices):
 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),
@@ -84,12 +98,16 @@ def async_add_devices_config(hass, config, async_add_devices):
            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),
+        setpoint_shift_step=config.get(
+            CONF_SETPOINT_SHIFT_STEP),
+        setpoint_shift_max=config.get(
+            CONF_SETPOINT_SHIFT_MAX),
+        setpoint_shift_min=config.get(
+            CONF_SETPOINT_SHIFT_MIN),
        group_address_operation_mode=config.get(
            CONF_OPERATION_MODE_ADDRESS),
        group_address_operation_mode_state=config.get(
@@ -118,8 +136,14 @@ class KNXClimate(ClimateDevice):
        self.async_register_callbacks()

        self._unit_of_measurement = TEMP_CELSIUS
-        self._away = False  # not yet supported
-        self._is_fan_on = False  # not yet supported
+
+    @property
+    def supported_features(self):
+        """Return the list of supported features."""
+        support = SUPPORT_TARGET_TEMPERATURE
+        if self.device.supports_operation_mode:
+            support |= SUPPORT_OPERATION_MODE
+        return support

    def async_register_callbacks(self):
        """Register callbacks to update hass after device was changed."""
@@ -150,28 +174,25 @@ class KNXClimate(ClimateDevice):
        """Return the current temperature."""
        return self.device.temperature.value

+    @property
+    def target_temperature_step(self):
+        """Return the supported step of target temperature."""
+        return self.device.setpoint_shift_step
+
    @property
    def target_temperature(self):
        """Return the temperature we try to reach."""
-        return self.device.target_temperature_comfort
+        return self.device.target_temperature.value

    @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
+    def min_temp(self):
+        """Return the minimum temperature."""
+        return self.device.target_temperature_min

    @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
+    def max_temp(self):
+        """Return the maximum temperature."""
+        return self.device.target_temperature_max

    @asyncio.coroutine
    def async_set_temperature(self, **kwargs):
@@ -179,7 +200,7 @@ class KNXClimate(ClimateDevice):
        temperature = kwargs.get(ATTR_TEMPERATURE)
        if temperature is None:
            return
-        yield from self.device.set_target_temperature_comfort(temperature)
+        yield from self.device.set_target_temperature(temperature)
        yield from self.async_update_ha_state()

    @property
@@ -7,7 +7,9 @@ https://home-assistant.io/components/maxcube/
 import socket
 import logging

-from homeassistant.components.climate import ClimateDevice, STATE_AUTO
+from homeassistant.components.climate import (
+    ClimateDevice, STATE_AUTO, SUPPORT_TARGET_TEMPERATURE,
+    SUPPORT_OPERATION_MODE)
 from homeassistant.components.maxcube import MAXCUBE_HANDLE
 from homeassistant.const import TEMP_CELSIUS, ATTR_TEMPERATURE

@@ -17,6 +19,8 @@ STATE_MANUAL = 'manual'
 STATE_BOOST = 'boost'
 STATE_VACATION = 'vacation'

+SUPPORT_FLAGS = SUPPORT_TARGET_TEMPERATURE | SUPPORT_OPERATION_MODE
+

 def setup_platform(hass, config, add_devices, discovery_info=None):
    """Iterate through all MAX! Devices and add thermostats."""
@@ -47,6 +51,11 @@ class MaxCubeClimate(ClimateDevice):
        self._rf_address = rf_address
        self._cubehandle = hass.data[MAXCUBE_HANDLE]

+    @property
+    def supported_features(self):
+        """Return the list of supported features."""
+        return SUPPORT_FLAGS
+
    @property
    def should_poll(self):
        """Return the polling state."""
@@ -15,7 +15,9 @@ 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)
+    ATTR_OPERATION_MODE, SUPPORT_TARGET_TEMPERATURE, SUPPORT_OPERATION_MODE,
+    SUPPORT_SWING_MODE, SUPPORT_FAN_MODE, SUPPORT_AWAY_MODE, SUPPORT_HOLD_MODE,
+    SUPPORT_AUX_HEAT)
 from homeassistant.const import (
    STATE_ON, STATE_OFF, ATTR_TEMPERATURE, CONF_NAME)
 from homeassistant.components.mqtt import (CONF_QOS, CONF_RETAIN,
@@ -483,3 +485,38 @@ class MqttClimate(ClimateDevice):
        if self._topic[CONF_AUX_STATE_TOPIC] is None:
            self._aux = False
            self.async_schedule_update_ha_state()
+
+    @property
+    def supported_features(self):
+        """Return the list of supported features."""
+        support = 0
+
+        if (self._topic[CONF_TEMPERATURE_STATE_TOPIC] is not None) or \
+           (self._topic[CONF_TEMPERATURE_COMMAND_TOPIC] is not None):
+            support |= SUPPORT_TARGET_TEMPERATURE
+
+        if (self._topic[CONF_MODE_COMMAND_TOPIC] is not None) or \
+           (self._topic[CONF_MODE_STATE_TOPIC] is not None):
+            support |= SUPPORT_OPERATION_MODE
+
+        if (self._topic[CONF_FAN_MODE_STATE_TOPIC] is not None) or \
+           (self._topic[CONF_FAN_MODE_COMMAND_TOPIC] is not None):
+            support |= SUPPORT_FAN_MODE
+
+        if (self._topic[CONF_SWING_MODE_STATE_TOPIC] is not None) or \
+           (self._topic[CONF_SWING_MODE_COMMAND_TOPIC] is not None):
+            support |= SUPPORT_SWING_MODE
+
+        if (self._topic[CONF_AWAY_MODE_STATE_TOPIC] is not None) or \
+           (self._topic[CONF_AWAY_MODE_COMMAND_TOPIC] is not None):
+            support |= SUPPORT_AWAY_MODE
+
+        if (self._topic[CONF_HOLD_STATE_TOPIC] is not None) or \
+           (self._topic[CONF_HOLD_COMMAND_TOPIC] is not None):
+            support |= SUPPORT_HOLD_MODE
+
+        if (self._topic[CONF_AUX_STATE_TOPIC] is not None) or \
+           (self._topic[CONF_AUX_COMMAND_TOPIC] is not None):
+            support |= SUPPORT_AUX_HEAT
+
+        return support
@@ -7,7 +7,9 @@ https://home-assistant.io/components/climate.mysensors/
 from homeassistant.components import mysensors
 from homeassistant.components.climate import (
    ATTR_TARGET_TEMP_HIGH, ATTR_TARGET_TEMP_LOW, DOMAIN, STATE_AUTO,
-    STATE_COOL, STATE_HEAT, STATE_OFF, ClimateDevice)
+    STATE_COOL, STATE_HEAT, STATE_OFF, ClimateDevice,
+    SUPPORT_TARGET_TEMPERATURE, SUPPORT_TARGET_TEMPERATURE_HIGH,
+    SUPPORT_TARGET_TEMPERATURE_LOW, SUPPORT_FAN_MODE, SUPPORT_OPERATION_MODE)
 from homeassistant.const import ATTR_TEMPERATURE, TEMP_CELSIUS, TEMP_FAHRENHEIT

 DICT_HA_TO_MYS = {
@@ -23,6 +25,10 @@ DICT_MYS_TO_HA = {
    'Off': STATE_OFF,
 }

+SUPPORT_FLAGS = (SUPPORT_TARGET_TEMPERATURE | SUPPORT_TARGET_TEMPERATURE_HIGH |
+                 SUPPORT_TARGET_TEMPERATURE_LOW | SUPPORT_FAN_MODE |
+                 SUPPORT_OPERATION_MODE)
+

 def setup_platform(hass, config, add_devices, discovery_info=None):
    """Setup the mysensors climate."""
@@ -33,6 +39,11 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
 class MySensorsHVAC(mysensors.MySensorsEntity, ClimateDevice):
    """Representation of a MySensors HVAC."""

+    @property
+    def supported_features(self):
+        """Return the list of supported features."""
+        return SUPPORT_FLAGS
+
    @property
    def assumed_state(self):
        """Return True if unable to access real state of entity."""
@@ -12,7 +12,9 @@ from homeassistant.components.nest import DATA_NEST
 from homeassistant.components.climate import (
    STATE_AUTO, STATE_COOL, STATE_HEAT, ClimateDevice,
    PLATFORM_SCHEMA, ATTR_TARGET_TEMP_HIGH, ATTR_TARGET_TEMP_LOW,
-    ATTR_TEMPERATURE)
+    ATTR_TEMPERATURE, SUPPORT_TARGET_TEMPERATURE,
+    SUPPORT_TARGET_TEMPERATURE_HIGH, SUPPORT_TARGET_TEMPERATURE_LOW,
+    SUPPORT_OPERATION_MODE, SUPPORT_AWAY_MODE, SUPPORT_FAN_MODE)
 from homeassistant.const import (
    TEMP_CELSIUS, TEMP_FAHRENHEIT,
    CONF_SCAN_INTERVAL, STATE_ON, STATE_OFF, STATE_UNKNOWN)
@@ -28,6 +30,10 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
 STATE_ECO = 'eco'
 STATE_HEAT_COOL = 'heat-cool'

+SUPPORT_FLAGS = (SUPPORT_TARGET_TEMPERATURE | SUPPORT_TARGET_TEMPERATURE_HIGH |
+                 SUPPORT_TARGET_TEMPERATURE_LOW | SUPPORT_OPERATION_MODE |
+                 SUPPORT_AWAY_MODE | SUPPORT_FAN_MODE)
+

 def setup_platform(hass, config, add_devices, discovery_info=None):
    """Set up the Nest thermostat."""
@@ -87,6 +93,11 @@ class NestThermostat(ClimateDevice):
        self._min_temperature = None
        self._max_temperature = None

+    @property
+    def supported_features(self):
+        """Return the list of supported features."""
+        return SUPPORT_FLAGS
+
    @property
    def name(self):
        """Return the name of the nest, if any."""
@@ -10,7 +10,8 @@ import voluptuous as vol

 from homeassistant.const import TEMP_CELSIUS, ATTR_TEMPERATURE
 from homeassistant.components.climate import (
-    STATE_HEAT, STATE_IDLE, ClimateDevice, PLATFORM_SCHEMA)
+    STATE_HEAT, STATE_IDLE, ClimateDevice, PLATFORM_SCHEMA,
+    SUPPORT_TARGET_TEMPERATURE, SUPPORT_OPERATION_MODE, SUPPORT_AWAY_MODE)
 from homeassistant.util import Throttle
 from homeassistant.loader import get_component
 import homeassistant.helpers.config_validation as cv
@@ -35,6 +36,9 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
        vol.All(cv.ensure_list, [cv.string]),
 })

+SUPPORT_FLAGS = (SUPPORT_TARGET_TEMPERATURE | SUPPORT_OPERATION_MODE |
+                 SUPPORT_AWAY_MODE)
+

 def setup_platform(hass, config, add_devices, discovery_info=None):
    """Set up the NetAtmo Thermostat."""
@@ -65,6 +69,11 @@ class NetatmoThermostat(ClimateDevice):
        self._target_temperature = None
        self._away = None

+    @property
+    def supported_features(self):
+        """Return the list of supported features."""
+        return SUPPORT_FLAGS
+
    @property
    def name(self):
        """Return the name of the sensor."""
@@ -14,7 +14,8 @@ import voluptuous as vol

 # Import the device class from the component that you want to support
 from homeassistant.components.climate import (
-    ClimateDevice, PLATFORM_SCHEMA, STATE_HEAT, STATE_IDLE, ATTR_TEMPERATURE)
+    ClimateDevice, PLATFORM_SCHEMA, STATE_HEAT, STATE_IDLE, ATTR_TEMPERATURE,
+    SUPPORT_TARGET_TEMPERATURE, SUPPORT_AWAY_MODE)
 from homeassistant.const import (CONF_HOST, CONF_USERNAME, CONF_PASSWORD,
                                 CONF_PORT, TEMP_CELSIUS, CONF_NAME)
 import homeassistant.helpers.config_validation as cv
@@ -34,6 +35,8 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
    vol.Optional(CONF_AWAY_TEMP, default=14): vol.Coerce(float)
 })

+SUPPORT_FLAGS = SUPPORT_TARGET_TEMPERATURE | SUPPORT_AWAY_MODE
+

 def setup_platform(hass, config, add_devices, discovery_info=None):
    """Set up the oemthermostat platform."""
@@ -77,6 +80,11 @@ class ThermostatDevice(ClimateDevice):
        self._temperature = None
        self._setpoint = None

+    @property
+    def supported_features(self):
+        """Return the list of supported features."""
+        return SUPPORT_FLAGS
+
    @property
    def name(self):
        """Return the name of this Thermostat."""
@@ -8,7 +8,7 @@ import voluptuous as vol

 from homeassistant.components.climate import (
    PRECISION_TENTHS, STATE_COOL, STATE_HEAT, STATE_IDLE,
-    ClimateDevice, PLATFORM_SCHEMA)
+    ClimateDevice, PLATFORM_SCHEMA, SUPPORT_TARGET_TEMPERATURE)
 from homeassistant.const import (
    CONF_HOST, CONF_PASSWORD, CONF_USERNAME, TEMP_FAHRENHEIT, ATTR_TEMPERATURE)
 import homeassistant.helpers.config_validation as cv
@@ -46,6 +46,11 @@ class ProliphixThermostat(ClimateDevice):
        self._pdp.update()
        self._name = self._pdp.name

+    @property
+    def supported_features(self):
+        """Return the list of supported features."""
+        return SUPPORT_TARGET_TEMPERATURE
+
    @property
    def should_poll(self):
        """Set up polling needed for thermostat."""
@@ -4,15 +4,18 @@ Support for Radio Thermostat wifi-enabled home thermostats.
 For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/climate.radiotherm/
 """
+import asyncio
 import datetime
 import logging

 import voluptuous as vol

 from homeassistant.components.climate import (
-    STATE_AUTO, STATE_COOL, STATE_HEAT, STATE_IDLE, STATE_OFF,
-    ClimateDevice, PLATFORM_SCHEMA)
-from homeassistant.const import CONF_HOST, TEMP_FAHRENHEIT, ATTR_TEMPERATURE
+    STATE_AUTO, STATE_COOL, STATE_HEAT, STATE_IDLE, STATE_ON, STATE_OFF,
+    ClimateDevice, PLATFORM_SCHEMA, SUPPORT_TARGET_TEMPERATURE,
+    SUPPORT_OPERATION_MODE, SUPPORT_FAN_MODE, SUPPORT_AWAY_MODE)
+from homeassistant.const import (
+    CONF_HOST, TEMP_FAHRENHEIT, ATTR_TEMPERATURE, PRECISION_HALVES)
 import homeassistant.helpers.config_validation as cv

 REQUIREMENTS = ['radiotherm==1.3']
@@ -29,15 +32,56 @@ CONF_AWAY_TEMPERATURE_COOL = 'away_temperature_cool'
 DEFAULT_AWAY_TEMPERATURE_HEAT = 60
 DEFAULT_AWAY_TEMPERATURE_COOL = 85

+STATE_CIRCULATE = "circulate"
+
+OPERATION_LIST = [STATE_AUTO, STATE_COOL, STATE_HEAT, STATE_OFF]
+CT30_FAN_OPERATION_LIST = [STATE_ON, STATE_AUTO]
+CT80_FAN_OPERATION_LIST = [STATE_ON, STATE_CIRCULATE, STATE_AUTO]
+
+# Mappings from radiotherm json data codes to and from HASS state
+# flags.  CODE is the thermostat integer code and these map to and
+# from HASS state flags.
+
+# Programmed temperature mode of the thermostat.
+CODE_TO_TEMP_MODE = {0: STATE_OFF, 1: STATE_HEAT, 2: STATE_COOL, 3: STATE_AUTO}
+TEMP_MODE_TO_CODE = {v: k for k, v in CODE_TO_TEMP_MODE.items()}
+
+# Programmed fan mode (circulate is supported by CT80 models)
+CODE_TO_FAN_MODE = {0: STATE_AUTO, 1: STATE_CIRCULATE, 2: STATE_ON}
+FAN_MODE_TO_CODE = {v: k for k, v in CODE_TO_FAN_MODE.items()}
+
+# Active thermostat state (is it heating or cooling?).  In the future
+# this should probably made into heat and cool binary sensors.
+CODE_TO_TEMP_STATE = {0: STATE_IDLE, 1: STATE_HEAT, 2: STATE_COOL}
+
+# Active fan state.  This is if the fan is actually on or not.  In the
+# future this should probably made into a binary sensor for the fan.
+CODE_TO_FAN_STATE = {0: STATE_OFF, 1: STATE_ON}
+
+
+def round_temp(temperature):
+    """Round a temperature to the resolution of the thermostat.
+
+    RadioThermostats can handle 0.5 degree temps so the input
+    temperature is rounded to that value and returned.
+    """
+    return round(temperature * 2.0) / 2.0
+
+
 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
    vol.Optional(CONF_HOST): vol.All(cv.ensure_list, [cv.string]),
    vol.Optional(CONF_HOLD_TEMP, default=False): cv.boolean,
    vol.Optional(CONF_AWAY_TEMPERATURE_HEAT,
-                 default=DEFAULT_AWAY_TEMPERATURE_HEAT): vol.Coerce(float),
+                 default=DEFAULT_AWAY_TEMPERATURE_HEAT):
+    vol.All(vol.Coerce(float), round_temp),
    vol.Optional(CONF_AWAY_TEMPERATURE_COOL,
-                 default=DEFAULT_AWAY_TEMPERATURE_COOL): vol.Coerce(float),
+                 default=DEFAULT_AWAY_TEMPERATURE_COOL):
+    vol.All(vol.Coerce(float), round_temp),
 })

+SUPPORT_FLAGS = (SUPPORT_TARGET_TEMPERATURE | SUPPORT_OPERATION_MODE |
+                 SUPPORT_FAN_MODE | SUPPORT_AWAY_MODE)
+

 def setup_platform(hass, config, add_devices, discovery_info=None):
    """Set up the Radio Thermostat."""
@@ -77,19 +121,39 @@ class RadioThermostat(ClimateDevice):
    def __init__(self, device, hold_temp, away_temps):
        """Initialize the thermostat."""
        self.device = device
-        self.set_time()
        self._target_temperature = None
        self._current_temperature = None
        self._current_operation = STATE_IDLE
        self._name = None
        self._fmode = None
+        self._fstate = None
        self._tmode = None
        self._tstate = None
        self._hold_temp = hold_temp
+        self._hold_set = False
        self._away = False
        self._away_temps = away_temps
        self._prev_temp = None
-        self._operation_list = [STATE_AUTO, STATE_COOL, STATE_HEAT, STATE_OFF]
+
+        # Fan circulate mode is only supported by the CT80 models.
+        import radiotherm
+        self._is_model_ct80 = isinstance(self.device,
+                                         radiotherm.thermostat.CT80)
+
+    @property
+    def supported_features(self):
+        """Return the list of supported features."""
+        return SUPPORT_FLAGS
+
+    @asyncio.coroutine
+    def async_added_to_hass(self):
+        """Register callbacks."""
+        # Set the time on the device.  This shouldn't be in the
+        # constructor because it's a network call.  We can't put it in
+        # update() because calling it will clear any temporary mode or
+        # temperature in the thermostat.  So add it as a future job
+        # for the event loop to run.
+        self.hass.async_add_job(self.set_time)

    @property
    def name(self):
@@ -101,6 +165,11 @@ class RadioThermostat(ClimateDevice):
        """Return the unit of measurement."""
        return TEMP_FAHRENHEIT

+    @property
+    def precision(self):
+        """Return the precision of the system."""
+        return PRECISION_HALVES
+
    @property
    def device_state_attributes(self):
        """Return the device specific state attributes."""
@@ -109,6 +178,25 @@ class RadioThermostat(ClimateDevice):
            ATTR_MODE: self._tmode,
        }

+    @property
+    def fan_list(self):
+        """List of available fan modes."""
+        if self._is_model_ct80:
+            return CT80_FAN_OPERATION_LIST
+        else:
+            return CT30_FAN_OPERATION_LIST
+
+    @property
+    def current_fan_mode(self):
+        """Return whether the fan is on."""
+        return self._fmode
+
+    def set_fan_mode(self, fan):
+        """Turn fan on/off."""
+        code = FAN_MODE_TO_CODE.get(fan, None)
+        if code is not None:
+            self.device.fmode = code
+
    @property
    def current_temperature(self):
        """Return the current temperature."""
@@ -122,7 +210,7 @@ class RadioThermostat(ClimateDevice):
    @property
    def operation_list(self):
        """Return the operation modes list."""
-        return self._operation_list
+        return OPERATION_LIST

    @property
    def target_temperature(self):
@@ -136,53 +224,48 @@ class RadioThermostat(ClimateDevice):

    def update(self):
        """Update and validate the data from the thermostat."""
-        current_temp = self.device.temp['raw']
-        if current_temp == -1:
-            _LOGGER.error("Couldn't get valid temperature reading")
-            return
-        self._current_temperature = current_temp
-        self._name = self.device.name['raw']
-        try:
-            self._fmode = self.device.fmode['human']
-        except AttributeError:
-            _LOGGER.error("Couldn't get valid fan mode reading")
-        try:
-            self._tmode = self.device.tmode['human']
-        except AttributeError:
-            _LOGGER.error("Couldn't get valid thermostat mode reading")
-        try:
-            self._tstate = self.device.tstate['human']
-        except AttributeError:
-            _LOGGER.error("Couldn't get valid thermostat state reading")
+        # Radio thermostats are very slow, and sometimes don't respond
+        # very quickly.  So we need to keep the number of calls to them
+        # to a bare minimum or we'll hit the HASS 10 sec warning.  We
+        # have to make one call to /tstat to get temps but we'll try and
+        # keep the other calls to a minimum.  Even with this, these
+        # thermostats tend to time out sometimes when they're actively
+        # heating or cooling.

-        if self._tmode == 'Cool':
-            target_temp = self.device.t_cool['raw']
-            if target_temp == -1:
-                _LOGGER.error("Couldn't get target reading")
-                return
-            self._target_temperature = target_temp
-            self._current_operation = STATE_COOL
-        elif self._tmode == 'Heat':
-            target_temp = self.device.t_heat['raw']
-            if target_temp == -1:
-                _LOGGER.error("Couldn't get valid target reading")
-                return
-            self._target_temperature = target_temp
-            self._current_operation = STATE_HEAT
-        elif self._tmode == 'Auto':
-            if self._tstate == 'Cool':
-                target_temp = self.device.t_cool['raw']
-                if target_temp == -1:
-                    _LOGGER.error("Couldn't get valid target reading")
-                    return
-                self._target_temperature = target_temp
-            elif self._tstate == 'Heat':
-                target_temp = self.device.t_heat['raw']
-                if target_temp == -1:
-                    _LOGGER.error("Couldn't get valid target reading")
-                    return
-                self._target_temperature = target_temp
-            self._current_operation = STATE_AUTO
+        # First time - get the name from the thermostat.  This is
+        # normally set in the radio thermostat web app.
+        if self._name is None:
+            self._name = self.device.name['raw']
+
+        # Request the current state from the thermostat.
+        data = self.device.tstat['raw']
+
+        current_temp = data['temp']
+        if current_temp == -1:
+            _LOGGER.error('%s (%s) was busy (temp == -1)', self._name,
+                          self.device.host)
+            return
+
+        # Map thermostat values into various STATE_ flags.
+        self._current_temperature = current_temp
+        self._fmode = CODE_TO_FAN_MODE[data['fmode']]
+        self._fstate = CODE_TO_FAN_STATE[data['fstate']]
+        self._tmode = CODE_TO_TEMP_MODE[data['tmode']]
+        self._tstate = CODE_TO_TEMP_STATE[data['tstate']]
+
+        self._current_operation = self._tmode
+        if self._tmode == STATE_COOL:
+            self._target_temperature = data['t_cool']
+        elif self._tmode == STATE_HEAT:
+            self._target_temperature = data['t_heat']
+        elif self._tmode == STATE_AUTO:
+            # This doesn't really work - tstate is only set if the HVAC is
+            # active. If it's idle, we don't know what to do with the target
+            # temperature.
+            if self._tstate == STATE_COOL:
+                self._target_temperature = data['t_cool']
+            elif self._tstate == STATE_HEAT:
+                self._target_temperature = data['t_heat']
        else:
            self._current_operation = STATE_IDLE

@@ -191,23 +274,32 @@ class RadioThermostat(ClimateDevice):
        temperature = kwargs.get(ATTR_TEMPERATURE)
        if temperature is None:
            return
-        if self._current_operation == STATE_COOL:
-            self.device.t_cool = round(temperature * 2.0) / 2.0
-        elif self._current_operation == STATE_HEAT:
-            self.device.t_heat = round(temperature * 2.0) / 2.0
-        elif self._current_operation == STATE_AUTO:
-            if self._tstate == 'Cool':
-                self.device.t_cool = round(temperature * 2.0) / 2.0
-            elif self._tstate == 'Heat':
-                self.device.t_heat = round(temperature * 2.0) / 2.0

-        if self._hold_temp or self._away:
-            self.device.hold = 1
-        else:
-            self.device.hold = 0
+        temperature = round_temp(temperature)
+
+        if self._current_operation == STATE_COOL:
+            self.device.t_cool = temperature
+        elif self._current_operation == STATE_HEAT:
+            self.device.t_heat = temperature
+        elif self._current_operation == STATE_AUTO:
+            if self._tstate == STATE_COOL:
+                self.device.t_cool = temperature
+            elif self._tstate == STATE_HEAT:
+                self.device.t_heat = temperature
+
+        # Only change the hold if requested or if hold mode was turned
+        # on and we haven't set it yet.
+        if kwargs.get('hold_changed', False) or not self._hold_set:
+            if self._hold_temp or self._away:
+                self.device.hold = 1
+                self._hold_set = True
+            else:
+                self.device.hold = 0

    def set_time(self):
        """Set device time."""
+        # Calling this clears any local temperature override and
+        # reverts to the scheduled temperature.
        now = datetime.datetime.now()
        self.device.time = {
            'day': now.weekday(),
@@ -217,14 +309,14 @@ class RadioThermostat(ClimateDevice):

    def set_operation_mode(self, operation_mode):
        """Set operation mode (auto, cool, heat, off)."""
-        if operation_mode == STATE_OFF:
-            self.device.tmode = 0
-        elif operation_mode == STATE_AUTO:
-            self.device.tmode = 3
+        if operation_mode == STATE_OFF or operation_mode == STATE_AUTO:
+            self.device.tmode = TEMP_MODE_TO_CODE[operation_mode]
+
+        # Setting t_cool or t_heat automatically changes tmode.
        elif operation_mode == STATE_COOL:
-            self.device.t_cool = round(self._target_temperature * 2.0) / 2.0
+            self.device.t_cool = self._target_temperature
        elif operation_mode == STATE_HEAT:
-            self.device.t_heat = round(self._target_temperature * 2.0) / 2.0
+            self.device.t_heat = self._target_temperature

    def turn_away_mode_on(self):
        """Turn away on.
@@ -238,10 +330,11 @@ class RadioThermostat(ClimateDevice):
                away_temp = self._away_temps[0]
            elif self._current_operation == STATE_COOL:
                away_temp = self._away_temps[1]
+
        self._away = True
-        self.set_temperature(temperature=away_temp)
+        self.set_temperature(temperature=away_temp, hold_changed=True)

    def turn_away_mode_off(self):
        """Turn away off."""
        self._away = False
-        self.set_temperature(temperature=self._prev_temp)
+        self.set_temperature(temperature=self._prev_temp, hold_changed=True)
@@ -15,7 +15,10 @@ import voluptuous as vol
 from homeassistant.const import (
    ATTR_TEMPERATURE, CONF_API_KEY, CONF_ID, TEMP_CELSIUS, TEMP_FAHRENHEIT)
 from homeassistant.components.climate import (
-    ATTR_CURRENT_HUMIDITY, ClimateDevice, PLATFORM_SCHEMA)
+    ATTR_CURRENT_HUMIDITY, ClimateDevice, PLATFORM_SCHEMA,
+    SUPPORT_TARGET_TEMPERATURE, SUPPORT_OPERATION_MODE,
+    SUPPORT_FAN_MODE, SUPPORT_AWAY_MODE, SUPPORT_SWING_MODE,
+    SUPPORT_AUX_HEAT)
 from homeassistant.exceptions import PlatformNotReady
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
@@ -35,9 +38,13 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({

 _FETCH_FIELDS = ','.join([
    'room{name}', 'measurements', 'remoteCapabilities',
-    'acState', 'connectionStatus{isAlive}'])
+    'acState', 'connectionStatus{isAlive}', 'temperatureUnit'])
 _INITIAL_FETCH_FIELDS = 'id,' + _FETCH_FIELDS

+SUPPORT_FLAGS = (SUPPORT_TARGET_TEMPERATURE | SUPPORT_OPERATION_MODE |
+                 SUPPORT_FAN_MODE | SUPPORT_AWAY_MODE | SUPPORT_SWING_MODE |
+                 SUPPORT_AUX_HEAT)
+

@asyncio.coroutine
 def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
@@ -55,7 +62,7 @@ def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
                devices.append(SensiboClimate(client, dev))
    except (aiohttp.client_exceptions.ClientConnectorError,
            asyncio.TimeoutError):
-        _LOGGER.exception('Failed to connct to Sensibo servers.')
+        _LOGGER.exception('Failed to connect to Sensibo servers.')
        raise PlatformNotReady

    if devices:
@@ -63,7 +70,7 @@ def async_setup_platform(hass, config, async_add_devices, discovery_info=None):


 class SensiboClimate(ClimateDevice):
-    """Representation os a Sensibo device."""
+    """Representation of a Sensibo device."""

    def __init__(self, client, data):
        """Build SensiboClimate.
@@ -75,6 +82,11 @@ class SensiboClimate(ClimateDevice):
        self._id = data['id']
        self._do_update(data)

+    @property
+    def supported_features(self):
+        """Return the list of supported features."""
+        return SUPPORT_FLAGS
+
    def _do_update(self, data):
        self._name = data['room']['name']
        self._measurements = data['measurements']
@@ -84,11 +96,16 @@ class SensiboClimate(ClimateDevice):
        self._operations = sorted(capabilities['modes'].keys())
        self._current_capabilities = capabilities[
            'modes'][self.current_operation]
-        temperature_unit_key = self._ac_states['temperatureUnit']
-        self._temperature_unit = \
-            TEMP_CELSIUS if temperature_unit_key == 'C' else TEMP_FAHRENHEIT
-        self._temperatures_list = self._current_capabilities[
-            'temperatures'][temperature_unit_key]['values']
+        temperature_unit_key = data.get('temperatureUnit') or \
+            self._ac_states.get('temperatureUnit')
+        if temperature_unit_key:
+            self._temperature_unit = TEMP_CELSIUS if \
+                temperature_unit_key == 'C' else TEMP_FAHRENHEIT
+            self._temperatures_list = self._current_capabilities[
+                'temperatures'].get(temperature_unit_key, {}).get('values', [])
+        else:
+            self._temperature_unit = self.unit_of_measurement
+            self._temperatures_list = []

    @property
    def device_state_attributes(self):
@@ -108,7 +125,7 @@ class SensiboClimate(ClimateDevice):
    @property
    def target_temperature(self):
        """Return the temperature we try to reach."""
-        return self._ac_states['targetTemperature']
+        return self._ac_states.get('targetTemperature')

    @property
    def target_temperature_step(self):
@@ -133,10 +150,8 @@ class SensiboClimate(ClimateDevice):
    @property
    def current_temperature(self):
        """Return the current temperature."""
-        # This field is not affected by temperature_unit.
-        # It is always in C / nativeTemperatureUnit
-        if 'nativeTemperatureUnit' not in self._ac_states:
-            return self._measurements['temperature']
+        # This field is not affected by temperatureUnit.
+        # It is always in C
        return convert_temperature(
            self._measurements['temperature'],
            TEMP_CELSIUS,
@@ -180,12 +195,14 @@ class SensiboClimate(ClimateDevice):
    @property
    def min_temp(self):
        """Return the minimum temperature."""
-        return self._temperatures_list[0]
+        return self._temperatures_list[0] \
+            if len(self._temperatures_list) else super.min_temp()

    @property
    def max_temp(self):
        """Return the maximum temperature."""
-        return self._temperatures_list[-1]
+        return self._temperatures_list[-1] \
+            if len(self._temperatures_list) else super.max_temp()

    @asyncio.coroutine
    def async_set_temperature(self, **kwargs):
@@ -1,132 +1,102 @@
+# Describes the format for available climate services
+
 set_aux_heat:
-  description: Turn auxiliary heater on/off for climate device
-
+  description: Turn auxiliary heater on/off for climate device.
  fields:
    entity_id:
-      description: Name(s) of entities to change
+      description: Name(s) of entities to change.
      example: 'climate.kitchen'
-
    aux_heat:
-      description: New value of axillary heater
+      description: New value of axillary heater.
      example: true
-
 set_away_mode:
-  description: Turn away mode on/off for climate device
-
+  description: Turn away mode on/off for climate device.
  fields:
    entity_id:
-      description: Name(s) of entities to change
+      description: Name(s) of entities to change.
      example: 'climate.kitchen'
-
    away_mode:
-      description: New value of away mode
+      description: New value of away mode.
      example: true
-
 set_hold_mode:
-  description: Turn hold mode for climate device
-
+  description: Turn hold mode for climate device.
  fields:
    entity_id:
-      description: Name(s) of entities to change
+      description: Name(s) of entities to change.
      example: 'climate.kitchen'
-
    hold_mode:
      description: New value of hold mode
      example: 'away'
-
 set_temperature:
-  description: Set target temperature of climate device
-
+  description: Set target temperature of climate device.
  fields:
    entity_id:
-      description: Name(s) of entities to change
+      description: Name(s) of entities to change.
      example: 'climate.kitchen'
-
    temperature:
-      description: New target temperature for hvac
+      description: New target temperature for HVAC.
      example: 25
-
    target_temp_high:
-      description: New target high tempereature for hvac
+      description: New target high tempereature for HVAC.
      example: 26
- 
    target_temp_low:
-      description: New target low temperature for hvac
+      description: New target low temperature for HVAC.
      example: 20
-
    operation_mode:
      description: Operation mode to set temperature to. This defaults to current_operation mode if not set, or set incorrectly.
      example: 'Heat'
-
 set_humidity:
-  description: Set target humidity of climate device
-
+  description: Set target humidity of climate device.
  fields:
    entity_id:
-      description: Name(s) of entities to change
+      description: Name(s) of entities to change.
      example: 'climate.kitchen'
-
    humidity:
-      description: New target humidity for climate device
+      description: New target humidity for climate device.
      example: 60
-
 set_fan_mode:
-  description: Set fan operation for climate device
-
+  description: Set fan operation for climate device.
  fields:
    entity_id:
-      description: Name(s) of entities to change
+      description: Name(s) of entities to change.
      example: 'climate.nest'
-
    fan_mode:
-      description: New value of fan mode
+      description: New value of fan mode.
      example: On Low
-
 set_operation_mode:
-  description: Set operation mode for climate device
-
+  description: Set operation mode for climate device.
  fields:
    entity_id:
-      description: Name(s) of entities to change
+      description: Name(s) of entities to change.
      example: 'climate.nest'
-
    operation_mode:
-      description: New value of operation mode
+      description: New value of operation mode.
      example: Heat
-
-
 set_swing_mode:
-  description: Set swing operation for climate device
-
+  description: Set swing operation for climate device.
  fields:
    entity_id:
-      description: Name(s) of entities to change
+      description: Name(s) of entities to change.
      example: 'climate.nest'
-
    swing_mode:
-      description: New value of swing mode
+      description: New value of swing mode.
      example: 1
-
 ecobee_set_fan_min_on_time:
-  description: Set the minimum fan on time
-
+  description: Set the minimum fan on time.
  fields:
    entity_id:
-      description: Name(s) of entities to change
+      description: Name(s) of entities to change.
      example: 'climate.kitchen'
-
    fan_min_on_time:
-      description: New value of fan min on time
+      description: New value of fan min on time.
      example: 5

 ecobee_resume_program:
-  description: Resume the programmed schedule
-
+  description: Resume the programmed schedule.
  fields:
    entity_id:
-      description: Name(s) of entities to change
+      description: Name(s) of entities to change.
      example: 'climate.kitchen'
-
    resume_all:
      description: Resume all events and return to the scheduled program. This default to false which removes only the top event.
      example: true
@@ -7,7 +7,8 @@ https://home-assistant.io/components/climate.tado/
 import logging

 from homeassistant.const import TEMP_CELSIUS
-from homeassistant.components.climate import ClimateDevice
+from homeassistant.components.climate import (
+    ClimateDevice, SUPPORT_TARGET_TEMPERATURE, SUPPORT_OPERATION_MODE)
 from homeassistant.const import ATTR_TEMPERATURE
 from homeassistant.components.tado import DATA_TADO

@@ -43,6 +44,8 @@ OPERATION_LIST = {
    CONST_MODE_OFF: 'Off',
 }

+SUPPORT_FLAGS = SUPPORT_TARGET_TEMPERATURE | SUPPORT_OPERATION_MODE
+

 def setup_platform(hass, config, add_devices, discovery_info=None):
    """Set up the Tado climate platform."""
@@ -127,6 +130,11 @@ class TadoClimate(ClimateDevice):
        self._current_operation = CONST_MODE_SMART_SCHEDULE
        self._overlay_mode = CONST_MODE_SMART_SCHEDULE

+    @property
+    def supported_features(self):
+        """Return the list of supported features."""
+        return SUPPORT_FLAGS
+
    @property
    def name(self):
        """Return the name of the device."""
@@ -7,7 +7,9 @@ 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.climate import (
+    ClimateDevice, ENTITY_ID_FORMAT, SUPPORT_TARGET_TEMPERATURE,
+    SUPPORT_OPERATION_MODE)
 from homeassistant.components.tesla import DOMAIN as TESLA_DOMAIN, TeslaDevice
 from homeassistant.const import (
    TEMP_FAHRENHEIT, TEMP_CELSIUS, ATTR_TEMPERATURE)
@@ -18,6 +20,8 @@ DEPENDENCIES = ['tesla']

 OPERATION_LIST = [STATE_ON, STATE_OFF]

+SUPPORT_FLAGS = SUPPORT_TARGET_TEMPERATURE | SUPPORT_OPERATION_MODE
+

 def setup_platform(hass, config, add_devices, discovery_info=None):
    """Set up the Tesla climate platform."""
@@ -36,6 +40,11 @@ class TeslaThermostat(TeslaDevice, ClimateDevice):
        self._target_temperature = None
        self._temperature = None

+    @property
+    def supported_features(self):
+        """Return the list of supported features."""
+        return SUPPORT_FLAGS
+
    @property
    def current_operation(self):
        """Return current operation ie. On or Off."""
@@ -3,23 +3,22 @@ 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)
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/climate.toon/
+"""
+import homeassistant.components.toon as toon_main
+from homeassistant.components.climate import (
+    ClimateDevice, ATTR_TEMPERATURE, STATE_PERFORMANCE, STATE_HEAT, STATE_ECO,
+    STATE_COOL, SUPPORT_TARGET_TEMPERATURE, SUPPORT_OPERATION_MODE)
 from homeassistant.const import TEMP_CELSIUS

-import homeassistant.components.toon as toon_main
+SUPPORT_FLAGS = SUPPORT_TARGET_TEMPERATURE | SUPPORT_OPERATION_MODE


 def setup_platform(hass, config, add_devices, discovery_info=None):
-    """Setup thermostat."""
-    # Add toon
-    add_devices((ThermostatDevice(hass), ), True)
+    """Set up the Toon thermostat."""
+    add_devices([ThermostatDevice(hass)], True)


 class ThermostatDevice(ClimateDevice):
@@ -31,25 +30,26 @@ class ThermostatDevice(ClimateDevice):
        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]
+        self._operation_list = [
+            STATE_PERFORMANCE,
+            STATE_HEAT,
+            STATE_ECO,
+            STATE_COOL,
+        ]
+
+    @property
+    def supported_features(self):
+        """Return the list of supported features."""
+        return SUPPORT_FLAGS

    @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."""
@@ -83,10 +83,12 @@ class ThermostatDevice(ClimateDevice):

    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'}
+        toonlib_values = {
+            STATE_PERFORMANCE: 'Comfort',
+            STATE_HEAT: 'Home',
+            STATE_ECO: 'Away',
+            STATE_COOL: 'Sleep',
+        }

        self.thermos.set_state(toonlib_values[operation_mode])

@@ -7,7 +7,9 @@ https://home-assistant.io/components/switch.vera/
 import logging

 from homeassistant.util import convert
-from homeassistant.components.climate import ClimateDevice, ENTITY_ID_FORMAT
+from homeassistant.components.climate import (
+    ClimateDevice, ENTITY_ID_FORMAT, SUPPORT_TARGET_TEMPERATURE,
+    SUPPORT_OPERATION_MODE, SUPPORT_FAN_MODE)
 from homeassistant.const import (
    TEMP_FAHRENHEIT,
    TEMP_CELSIUS,
@@ -23,6 +25,9 @@ _LOGGER = logging.getLogger(__name__)
 OPERATION_LIST = ['Heat', 'Cool', 'Auto Changeover', 'Off']
 FAN_OPERATION_LIST = ['On', 'Auto', 'Cycle']

+SUPPORT_FLAGS = (SUPPORT_TARGET_TEMPERATURE | SUPPORT_OPERATION_MODE |
+                 SUPPORT_FAN_MODE)
+

 def setup_platform(hass, config, add_devices_callback, discovery_info=None):
    """Set up of Vera thermostats."""
@@ -39,6 +44,11 @@ class VeraThermostat(VeraDevice, ClimateDevice):
        VeraDevice.__init__(self, vera_device, controller)
        self.entity_id = ENTITY_ID_FORMAT.format(self.vera_id)

+    @property
+    def supported_features(self):
+        """Return the list of supported features."""
+        return SUPPORT_FLAGS
+
    @property
    def current_operation(self):
        """Return current operation ie. heat, cool, idle."""
@@ -4,46 +4,65 @@ 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
+import logging

-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, STATE_FAN_ONLY,
-    ATTR_CURRENT_HUMIDITY, STATE_ECO, STATE_ELECTRIC,
-    STATE_PERFORMANCE, STATE_HIGH_DEMAND,
-    STATE_HEAT_PUMP, STATE_GAS)
+    STATE_ECO, STATE_GAS, STATE_AUTO, STATE_COOL, STATE_HEAT, STATE_ELECTRIC,
+    STATE_FAN_ONLY, STATE_HEAT_PUMP, ATTR_TEMPERATURE, STATE_HIGH_DEMAND,
+    STATE_PERFORMANCE, ATTR_TARGET_TEMP_LOW, ATTR_CURRENT_HUMIDITY,
+    ATTR_TARGET_TEMP_HIGH, ClimateDevice, SUPPORT_TARGET_TEMPERATURE,
+    SUPPORT_TARGET_TEMPERATURE_HIGH, SUPPORT_TARGET_TEMPERATURE_LOW,
+    SUPPORT_OPERATION_MODE, SUPPORT_AWAY_MODE, SUPPORT_FAN_MODE,
+    SUPPORT_AUX_HEAT)
+from homeassistant.components.wink import DOMAIN, WinkDevice
 from homeassistant.const import (
-    TEMP_CELSIUS, STATE_ON,
-    STATE_OFF, STATE_UNKNOWN)
+    STATE_ON, STATE_OFF, TEMP_CELSIUS, STATE_UNKNOWN, PRECISION_TENTHS)
+from homeassistant.helpers.temperature import display_temp as show_temp

 _LOGGER = logging.getLogger(__name__)

+ATTR_ECO_TARGET = 'eco_target'
+ATTR_EXTERNAL_TEMPERATURE = 'external_temperature'
+ATTR_OCCUPIED = 'occupied'
+ATTR_RHEEM_TYPE = 'rheem_type'
+ATTR_SCHEDULE_ENABLED = 'schedule_enabled'
+ATTR_SMART_TEMPERATURE = 'smart_temperature'
+ATTR_TOTAL_CONSUMPTION = 'total_consumption'
+ATTR_VACATION_MODE = 'vacation_mode'
+
 DEPENDENCIES = ['wink']

 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'}
+HA_STATE_TO_WINK = {
+    STATE_AUTO: 'auto',
+    STATE_COOL: 'cool_only',
+    STATE_ECO: 'eco',
+    STATE_ELECTRIC: 'electric_only',
+    STATE_FAN_ONLY: 'fan_only',
+    STATE_GAS: 'gas',
+    STATE_HEAT: 'heat_only',
+    STATE_HEAT_PUMP: 'heat_pump',
+    STATE_HIGH_DEMAND: 'high_demand',
+    STATE_OFF: 'off',
+    STATE_PERFORMANCE: 'performance',
+}
+
 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"
-ATTR_OCCUPIED = "occupied"
+SUPPORT_FLAGS_THERMOSTAT = (
+    SUPPORT_TARGET_TEMPERATURE | SUPPORT_TARGET_TEMPERATURE_HIGH |
+    SUPPORT_TARGET_TEMPERATURE_LOW | SUPPORT_OPERATION_MODE |
+    SUPPORT_AWAY_MODE | SUPPORT_FAN_MODE | SUPPORT_AUX_HEAT)
+
+SUPPORT_FLAGS_AC = (SUPPORT_TARGET_TEMPERATURE | SUPPORT_OPERATION_MODE |
+                    SUPPORT_FAN_MODE)
+
+SUPPORT_FLAGS_HEATER = (SUPPORT_TARGET_TEMPERATURE | SUPPORT_OPERATION_MODE |
+                        SUPPORT_AWAY_MODE)


 def setup_platform(hass, config, add_devices, discovery_info=None):
@@ -67,6 +86,11 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
 class WinkThermostat(WinkDevice, ClimateDevice):
    """Representation of a Wink thermostat."""

+    @property
+    def supported_features(self):
+        """Return the list of supported features."""
+        return SUPPORT_FLAGS_THERMOSTAT
+
    @asyncio.coroutine
    def async_added_to_hass(self):
        """Callback when entity is added to hass."""
@@ -85,15 +109,18 @@ class WinkThermostat(WinkDevice, ClimateDevice):
        target_temp_high = self.target_temperature_high
        target_temp_low = self.target_temperature_low
        if target_temp_high is not None:
-            data[ATTR_TARGET_TEMP_HIGH] = self._convert_for_display(
-                self.target_temperature_high)
+            data[ATTR_TARGET_TEMP_HIGH] = show_temp(
+                self.hass, self.target_temperature_high, self.temperature_unit,
+                PRECISION_TENTHS)
        if target_temp_low is not None:
-            data[ATTR_TARGET_TEMP_LOW] = self._convert_for_display(
-                self.target_temperature_low)
+            data[ATTR_TARGET_TEMP_LOW] = show_temp(
+                self.hass, self.target_temperature_low, self.temperature_unit,
+                PRECISION_TENTHS)

        if self.external_temperature:
-            data[ATTR_EXTERNAL_TEMPERATURE] = self._convert_for_display(
-                self.external_temperature)
+            data[ATTR_EXTERNAL_TEMPERATURE] = show_temp(
+                self.hass, self.external_temperature, self.temperature_unit,
+                PRECISION_TENTHS)

        if self.smart_temperature:
            data[ATTR_SMART_TEMPERATURE] = self.smart_temperature
@@ -139,7 +166,7 @@ class WinkThermostat(WinkDevice, ClimateDevice):

    @property
    def eco_target(self):
-        """Return status of eco target (Is the termostat in eco mode)."""
+        """Return status of eco target (Is the thermostat in eco mode)."""
        return self.wink.eco_target()

    @property
@@ -249,7 +276,7 @@ class WinkThermostat(WinkDevice, ClimateDevice):
            if ha_mode is not None:
                op_list.append(ha_mode)
            else:
-                error = "Invaid operation mode mapping. " + mode + \
+                error = "Invalid operation mode mapping. " + mode + \
                    " doesn't map. Please report this."
                _LOGGER.error(error)
        return op_list
@@ -297,7 +324,6 @@ class WinkThermostat(WinkDevice, ClimateDevice):
        minimum = 7  # Default minimum
        min_min = self.wink.min_min_set_point()
        min_max = self.wink.min_max_set_point()
-        return_value = minimum
        if self.current_operation == STATE_HEAT:
            if min_min:
                return_value = min_min
@@ -323,7 +349,6 @@ class WinkThermostat(WinkDevice, ClimateDevice):
        maximum = 35  # Default maximum
        max_min = self.wink.max_min_set_point()
        max_max = self.wink.max_max_set_point()
-        return_value = maximum
        if self.current_operation == STATE_HEAT:
            if max_min:
                return_value = max_min
@@ -347,6 +372,11 @@ class WinkThermostat(WinkDevice, ClimateDevice):
 class WinkAC(WinkDevice, ClimateDevice):
    """Representation of a Wink air conditioner."""

+    @property
+    def supported_features(self):
+        """Return the list of supported features."""
+        return SUPPORT_FLAGS_AC
+
    @property
    def temperature_unit(self):
        """Return the unit of measurement."""
@@ -360,13 +390,15 @@ class WinkAC(WinkDevice, ClimateDevice):
        target_temp_high = self.target_temperature_high
        target_temp_low = self.target_temperature_low
        if target_temp_high is not None:
-            data[ATTR_TARGET_TEMP_HIGH] = self._convert_for_display(
-                self.target_temperature_high)
+            data[ATTR_TARGET_TEMP_HIGH] = show_temp(
+                self.hass, self.target_temperature_high, self.temperature_unit,
+                PRECISION_TENTHS)
        if target_temp_low is not None:
-            data[ATTR_TARGET_TEMP_LOW] = self._convert_for_display(
-                self.target_temperature_low)
-        data["total_consumption"] = self.wink.total_consumption()
-        data["schedule_enabled"] = self.wink.schedule_enabled()
+            data[ATTR_TARGET_TEMP_LOW] = show_temp(
+                self.hass, self.target_temperature_low, self.temperature_unit,
+                PRECISION_TENTHS)
+        data[ATTR_TOTAL_CONSUMPTION] = self.wink.total_consumption()
+        data[ATTR_SCHEDULE_ENABLED] = self.wink.schedule_enabled()

        return data

@@ -377,11 +409,14 @@ class WinkAC(WinkDevice, ClimateDevice):

    @property
    def current_operation(self):
-        """Return current operation ie. heat, cool, idle."""
+        """Return current operation ie. auto_eco, cool_only, fan_only."""
        if not self.wink.is_on():
            current_op = STATE_OFF
        else:
-            current_op = WINK_STATE_TO_HA.get(self.wink.current_hvac_mode())
+            wink_mode = self.wink.current_mode()
+            if wink_mode == "auto_eco":
+                wink_mode = "eco"
+            current_op = WINK_STATE_TO_HA.get(wink_mode)
            if current_op is None:
                current_op = STATE_UNKNOWN
        return current_op
@@ -392,11 +427,13 @@ class WinkAC(WinkDevice, ClimateDevice):
        op_list = ['off']
        modes = self.wink.modes()
        for mode in modes:
+            if mode == "auto_eco":
+                mode = "eco"
            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 + \
+                error = "Invalid operation mode mapping. " + mode + \
                    " doesn't map. Please report this."
                _LOGGER.error(error)
        return op_list
@@ -420,15 +457,19 @@ class WinkAC(WinkDevice, ClimateDevice):

    @property
    def current_fan_mode(self):
-        """Return the current fan mode."""
+        """
+        Return the current fan mode.
+
+        The official Wink app only supports 3 modes [low, medium, high]
+        which are equal to [0.33, 0.66, 1.0] respectively.
+        """
        speed = self.wink.current_fan_speed()
-        if speed <= 0.4 and speed > 0.3:
+        if speed <= 0.33:
            return SPEED_LOW
-        elif speed <= 0.8 and speed > 0.5:
+        elif speed <= 0.66:
            return SPEED_MEDIUM
-        elif speed <= 1.0 and speed > 0.8:
+        else:
            return SPEED_HIGH
-        return STATE_UNKNOWN

    @property
    def fan_list(self):
@@ -436,11 +477,16 @@ class WinkAC(WinkDevice, ClimateDevice):
        return [SPEED_LOW, SPEED_MEDIUM, SPEED_HIGH]

    def set_fan_mode(self, fan):
-        """Set fan speed."""
+        """
+        Set fan speed.
+
+        The official Wink app only supports 3 modes [low, medium, high]
+        which are equal to [0.33, 0.66, 1.0] respectively.
+        """
        if fan == SPEED_LOW:
-            speed = 0.4
+            speed = 0.33
        elif fan == SPEED_MEDIUM:
-            speed = 0.8
+            speed = 0.66
        elif fan == SPEED_HIGH:
            speed = 1.0
        self.wink.set_ac_fan_speed(speed)
@@ -449,6 +495,11 @@ class WinkAC(WinkDevice, ClimateDevice):
 class WinkWaterHeater(WinkDevice, ClimateDevice):
    """Representation of a Wink water heater."""

+    @property
+    def supported_features(self):
+        """Return the list of supported features."""
+        return SUPPORT_FLAGS_HEATER
+
    @property
    def temperature_unit(self):
        """Return the unit of measurement."""
@@ -459,8 +510,8 @@ class WinkWaterHeater(WinkDevice, ClimateDevice):
    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()
+        data[ATTR_VACATION_MODE] = self.wink.vacation_mode_enabled()
+        data[ATTR_RHEEM_TYPE] = self.wink.rheem_type()

        return data

@@ -492,7 +543,7 @@ class WinkWaterHeater(WinkDevice, ClimateDevice):
            if ha_mode is not None:
                op_list.append(ha_mode)
            else:
-                error = "Invaid operation mode mapping. " + mode + \
+                error = "Invalid operation mode mapping. " + mode + \
                    " doesn't map. Please report this."
                _LOGGER.error(error)
        return op_list
@@ -7,8 +7,9 @@ https://home-assistant.io/components/climate.zwave/
 # Because we do not compile openzwave on CI
 # pylint: disable=import-error
 import logging
-from homeassistant.components.climate import DOMAIN
-from homeassistant.components.climate import ClimateDevice
+from homeassistant.components.climate import (
+    DOMAIN, ClimateDevice, SUPPORT_TARGET_TEMPERATURE, SUPPORT_FAN_MODE,
+    SUPPORT_OPERATION_MODE, SUPPORT_SWING_MODE)
 from homeassistant.components.zwave import ZWaveDeviceEntity
 from homeassistant.components.zwave import async_setup_platform  # noqa # pylint: disable=unused-import
 from homeassistant.const import (
@@ -70,6 +71,18 @@ class ZWaveClimate(ZWaveDeviceEntity, ClimateDevice):
                    self._zxt_120 = 1
        self.update_properties()

+    @property
+    def supported_features(self):
+        """Return the list of supported features."""
+        support = SUPPORT_TARGET_TEMPERATURE
+        if self.values.fan_mode:
+            support |= SUPPORT_FAN_MODE
+        if self.values.mode:
+            support |= SUPPORT_OPERATION_MODE
+        if self._zxt_120 == 1 and self.values.zxt_120_swing_mode:
+            support |= SUPPORT_SWING_MODE
+        return support
+
    def update_properties(self):
        """Handle the data changes for node values."""
        # Operation Mode
@@ -1,27 +1,41 @@
 """Component to integrate the Home Assistant cloud."""
 import asyncio
+from datetime import datetime
 import json
 import logging
 import os

 import voluptuous as vol

-from homeassistant.const import EVENT_HOMEASSISTANT_START
+from homeassistant.const import (
+    EVENT_HOMEASSISTANT_START, CONF_REGION, CONF_MODE)
+from homeassistant.helpers import entityfilter
+from homeassistant.util import dt as dt_util
+from homeassistant.components.alexa import smart_home

 from . import http_api, iot
 from .const import CONFIG_DIR, DOMAIN, SERVERS

-
 REQUIREMENTS = ['warrant==0.5.0']
-DEPENDENCIES = ['http']
-CONF_MODE = 'mode'
+
+_LOGGER = logging.getLogger(__name__)
+
+CONF_ALEXA = 'alexa'
+CONF_ALEXA_FILTER = 'filter'
 CONF_COGNITO_CLIENT_ID = 'cognito_client_id'
-CONF_USER_POOL_ID = 'user_pool_id'
-CONF_REGION = 'region'
 CONF_RELAYER = 'relayer'
+CONF_USER_POOL_ID = 'user_pool_id'
+
 MODE_DEV = 'development'
 DEFAULT_MODE = MODE_DEV
-_LOGGER = logging.getLogger(__name__)
+DEPENDENCIES = ['http']
+
+ALEXA_SCHEMA = vol.Schema({
+    vol.Optional(
+        CONF_ALEXA_FILTER,
+        default=lambda: entityfilter.generate_filter([], [], [], [])
+    ): entityfilter.FILTER_SCHEMA,
+})

 CONFIG_SCHEMA = vol.Schema({
    DOMAIN: vol.Schema({
@@ -32,6 +46,7 @@ CONFIG_SCHEMA = vol.Schema({
        vol.Required(CONF_USER_POOL_ID): str,
        vol.Required(CONF_REGION): str,
        vol.Required(CONF_RELAYER): str,
+        vol.Optional(CONF_ALEXA): ALEXA_SCHEMA
    }),
 }, extra=vol.ALLOW_EXTRA)

@@ -44,6 +59,10 @@ def async_setup(hass, config):
    else:
        kwargs = {CONF_MODE: DEFAULT_MODE}

+    if CONF_ALEXA not in kwargs:
+        kwargs[CONF_ALEXA] = ALEXA_SCHEMA({})
+
+    kwargs[CONF_ALEXA] = smart_home.Config(**kwargs[CONF_ALEXA])
    cloud = hass.data[DOMAIN] = Cloud(hass, **kwargs)

    @asyncio.coroutine
@@ -61,11 +80,11 @@ 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):
+                 region=None, relayer=None, alexa=None):
        """Create an instance of Cloud."""
        self.hass = hass
        self.mode = mode
-        self.email = None
+        self.alexa_config = alexa
        self.id_token = None
        self.access_token = None
        self.refresh_token = None
@@ -85,10 +104,37 @@ class Cloud:
            self.region = info['region']
            self.relayer = info['relayer']

+    @property
+    def cognito_email_based(self):
+        """Return if cognito is email based."""
+        return not self.user_pool_id.endswith('GmV')
+
    @property
    def is_logged_in(self):
        """Get if cloud is logged in."""
-        return self.email is not None
+        return self.id_token is not None
+
+    @property
+    def subscription_expired(self):
+        """Return a boolen if the subscription has expired."""
+        # For now, don't enforce subscriptions to exist
+        if 'custom:sub-exp' not in self.claims:
+            return False
+
+        return dt_util.utcnow() > self.expiration_date
+
+    @property
+    def expiration_date(self):
+        """Return the subscription expiration as a UTC datetime object."""
+        return datetime.combine(
+            dt_util.parse_date(self.claims['custom:sub-exp']),
+            datetime.min.time()).replace(tzinfo=dt_util.UTC)
+
+    @property
+    def claims(self):
+        """Get the claims from the id token."""
+        from jose import jwt
+        return jwt.get_unverified_claims(self.id_token)

    @property
    def user_info_path(self):
@@ -109,18 +155,20 @@ class Cloud:
            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:
+        if self.id_token is not None:
            yield from self.iot.connect()

    def path(self, *parts):
-        """Get config path inside cloud dir."""
+        """Get config path inside cloud dir.
+
+        Async friendly.
+        """
        return self.hass.config.path(CONFIG_DIR, *parts)

    @asyncio.coroutine
@@ -128,7 +176,6 @@ class Cloud:
        """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
@@ -140,7 +187,6 @@ class Cloud:
        """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,
@@ -69,7 +69,10 @@ def register(cloud, email, password):

    cognito = _cognito(cloud)
    try:
-        cognito.register(_generate_username(email), password, email=email)
+        if cloud.cognito_email_based:
+            cognito.register(email, password, email=email)
+        else:
+            cognito.register(_generate_username(email), password, email=email)
    except ClientError as err:
        raise _map_aws_exception(err)

@@ -80,7 +83,11 @@ def confirm_register(cloud, confirmation_code, email):

    cognito = _cognito(cloud)
    try:
-        cognito.confirm_sign_up(confirmation_code, _generate_username(email))
+        if cloud.cognito_email_based:
+            cognito.confirm_sign_up(confirmation_code, email)
+        else:
+            cognito.confirm_sign_up(confirmation_code,
+                                    _generate_username(email))
    except ClientError as err:
        raise _map_aws_exception(err)

@@ -89,7 +96,11 @@ def forgot_password(cloud, email):
    """Initiate forgotten password flow."""
    from botocore.exceptions import ClientError

-    cognito = _cognito(cloud, username=_generate_username(email))
+    if cloud.cognito_email_based:
+        cognito = _cognito(cloud, username=email)
+    else:
+        cognito = _cognito(cloud, username=_generate_username(email))
+
    try:
        cognito.initiate_forgot_password()
    except ClientError as err:
@@ -100,7 +111,11 @@ 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))
+    if cloud.cognito_email_based:
+        cognito = _cognito(cloud, username=email)
+    else:
+        cognito = _cognito(cloud, username=_generate_username(email))
+
    try:
        cognito.confirm_forgot_password(confirmation_code, new_password)
    except ClientError as err:
@@ -113,7 +128,6 @@ def login(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()


@@ -12,3 +12,8 @@ SERVERS = {
    #     'relayer': ''
    # }
 }
+
+MESSAGE_EXPIRATION = """
+It looks like your Home Assistant Cloud subscription has expired. Please check
+your [account page](/config/cloud/account) to continue using the service.
+"""
@@ -65,12 +65,12 @@ class CloudLoginView(HomeAssistantView):
    url = '/api/cloud/login'
    name = 'api:cloud:login'

-    @asyncio.coroutine
    @_handle_cloud_errors
    @RequestDataValidator(vol.Schema({
        vol.Required('email'): str,
        vol.Required('password'): str,
    }))
+    @asyncio.coroutine
    def post(self, request, data):
        """Handle login request."""
        hass = request.app['hass']
@@ -79,8 +79,10 @@ class CloudLoginView(HomeAssistantView):
        with async_timeout.timeout(REQUEST_TIMEOUT, loop=hass.loop):
            yield from hass.async_add_job(auth_api.login, cloud, data['email'],
                                          data['password'])
-            hass.async_add_job(cloud.iot.connect)

+        hass.async_add_job(cloud.iot.connect)
+        # Allow cloud to start connecting.
+        yield from asyncio.sleep(0, loop=hass.loop)
        return self.json(_account_data(cloud))


@@ -90,8 +92,8 @@ class CloudLogoutView(HomeAssistantView):
    url = '/api/cloud/logout'
    name = 'api:cloud:logout'

-    @asyncio.coroutine
    @_handle_cloud_errors
+    @asyncio.coroutine
    def post(self, request):
        """Handle logout request."""
        hass = request.app['hass']
@@ -127,12 +129,12 @@ class CloudRegisterView(HomeAssistantView):
    url = '/api/cloud/register'
    name = 'api:cloud:register'

-    @asyncio.coroutine
    @_handle_cloud_errors
    @RequestDataValidator(vol.Schema({
        vol.Required('email'): str,
        vol.Required('password'): vol.All(str, vol.Length(min=6)),
    }))
+    @asyncio.coroutine
    def post(self, request, data):
        """Handle registration request."""
        hass = request.app['hass']
@@ -151,12 +153,12 @@ class CloudConfirmRegisterView(HomeAssistantView):
    url = '/api/cloud/confirm_register'
    name = 'api:cloud:confirm_register'

-    @asyncio.coroutine
    @_handle_cloud_errors
    @RequestDataValidator(vol.Schema({
        vol.Required('confirmation_code'): str,
        vol.Required('email'): str,
    }))
+    @asyncio.coroutine
    def post(self, request, data):
        """Handle registration confirmation request."""
        hass = request.app['hass']
@@ -176,11 +178,11 @@ class CloudForgotPasswordView(HomeAssistantView):
    url = '/api/cloud/forgot_password'
    name = 'api:cloud:forgot_password'

-    @asyncio.coroutine
    @_handle_cloud_errors
    @RequestDataValidator(vol.Schema({
        vol.Required('email'): str,
    }))
+    @asyncio.coroutine
    def post(self, request, data):
        """Handle forgot password request."""
        hass = request.app['hass']
@@ -199,13 +201,13 @@ class CloudConfirmForgotPasswordView(HomeAssistantView):
    url = '/api/cloud/confirm_forgot_password'
    name = 'api:cloud:confirm_forgot_password'

-    @asyncio.coroutine
    @_handle_cloud_errors
    @RequestDataValidator(vol.Schema({
        vol.Required('confirmation_code'): str,
        vol.Required('email'): str,
        vol.Required('new_password'): vol.All(str, vol.Length(min=6))
    }))
+    @asyncio.coroutine
    def post(self, request, data):
        """Handle forgot password confirm request."""
        hass = request.app['hass']
@@ -222,6 +224,10 @@ class CloudConfirmForgotPasswordView(HomeAssistantView):

 def _account_data(cloud):
    """Generate the auth data JSON response."""
+    claims = cloud.claims
+
    return {
-        'email': cloud.email
+        'email': claims['email'],
+        'sub_exp': claims.get('custom:sub-exp'),
+        'cloud': cloud.iot.state,
    }
@@ -9,11 +9,16 @@ from homeassistant.components.alexa import smart_home
 from homeassistant.util.decorator import Registry
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from . import auth_api
+from .const import MESSAGE_EXPIRATION


 HANDLERS = Registry()
 _LOGGER = logging.getLogger(__name__)

+STATE_CONNECTING = 'connecting'
+STATE_CONNECTED = 'connected'
+STATE_DISCONNECTED = 'disconnected'
+

 class UnknownHandler(Exception):
    """Exception raised when trying to handle unknown handler."""
@@ -25,27 +30,34 @@ class CloudIoT:
    def __init__(self, cloud):
        """Initialize the CloudIoT class."""
        self.cloud = cloud
+        # The WebSocket client
        self.client = None
+        # Scheduled sleep task till next connection retry
+        self.retry_task = None
+        # Boolean to indicate if we wanted the connection to close
        self.close_requested = False
+        # The current number of attempts to connect, impacts wait time
        self.tries = 0
-
-    @property
-    def is_connected(self):
-        """Return if connected to the cloud."""
-        return self.client is not None
+        # Current state of the connection
+        self.state = STATE_DISCONNECTED

    @asyncio.coroutine
    def connect(self):
        """Connect to the IoT broker."""
-        if self.client is not None:
-            raise RuntimeError('Cannot connect while already connected')
-
-        self.close_requested = False
-
        hass = self.cloud.hass
-        remove_hass_stop_listener = None
+        if self.cloud.subscription_expired:
+            # Try refreshing the token to see if it is still expired.
+            yield from hass.async_add_job(auth_api.check_token, self.cloud)

-        session = async_get_clientsession(self.cloud.hass)
+            if self.cloud.subscription_expired:
+                hass.components.persistent_notification.async_create(
+                    MESSAGE_EXPIRATION, 'Subscription expired',
+                    'cloud_subscription_expired')
+                self.state = STATE_DISCONNECTED
+                return
+
+        if self.state == STATE_CONNECTED:
+            raise RuntimeError('Already connected')

        @asyncio.coroutine
        def _handle_hass_stop(event):
@@ -54,29 +66,33 @@ class CloudIoT:
            remove_hass_stop_listener = None
            yield from self.disconnect()

+        self.state = STATE_CONNECTING
+        self.close_requested = False
+        remove_hass_stop_listener = hass.bus.async_listen_once(
+            EVENT_HOMEASSISTANT_STOP, _handle_hass_stop)
+        session = async_get_clientsession(self.cloud.hass)
        client = None
        disconnect_warn = None
+
        try:
            yield from hass.async_add_job(auth_api.check_token, self.cloud)

            self.client = client = yield from session.ws_connect(
                self.cloud.relayer, headers={
                    hdrs.AUTHORIZATION:
-                        'Bearer {}'.format(self.cloud.access_token)
+                        'Bearer {}'.format(self.cloud.id_token)
                })
            self.tries = 0

-            remove_hass_stop_listener = hass.bus.async_listen_once(
-                EVENT_HOMEASSISTANT_STOP, _handle_hass_stop)
-
            _LOGGER.info('Connected')
+            self.state = STATE_CONNECTED

            while not client.closed:
                msg = yield from client.receive()

                if msg.type in (WSMsgType.ERROR, WSMsgType.CLOSED,
                                WSMsgType.CLOSING):
-                    disconnect_warn = 'Closed by server'
+                    disconnect_warn = 'Connection cancelled.'
                    break

                elif msg.type != WSMsgType.TEXT:
@@ -144,20 +160,33 @@ class CloudIoT:
                self.client = None
                yield from client.close()

-            if not self.close_requested:
+            if self.close_requested:
+                self.state = STATE_DISCONNECTED
+
+            else:
+                self.state = STATE_CONNECTING
                self.tries += 1

-                # Sleep 0, 5, 10, 15 … up to 30 seconds between retries
-                yield from asyncio.sleep(
-                    min(30, (self.tries - 1) * 5), loop=hass.loop)
-
-                hass.async_add_job(self.connect())
+                try:
+                    # Sleep 0, 5, 10, 15 … up to 30 seconds between retries
+                    self.retry_task = hass.async_add_job(asyncio.sleep(
+                        min(30, (self.tries - 1) * 5), loop=hass.loop))
+                    yield from self.retry_task
+                    self.retry_task = None
+                    hass.async_add_job(self.connect())
+                except asyncio.CancelledError:
+                    # Happens if disconnect called
+                    pass

    @asyncio.coroutine
    def disconnect(self):
        """Disconnect the client."""
        self.close_requested = True
-        yield from self.client.close()
+
+        if self.client is not None:
+            yield from self.client.close()
+        elif self.retry_task is not None:
+            self.retry_task.cancel()


@asyncio.coroutine
@@ -175,7 +204,9 @@ def async_handle_message(hass, cloud, handler_name, payload):
@asyncio.coroutine
 def async_handle_alexa(hass, cloud, payload):
    """Handle an incoming IoT message for Alexa."""
-    return (yield from smart_home.async_handle_message(hass, payload))
+    return (yield from smart_home.async_handle_message(hass,
+                                                       cloud.alexa_config,
+                                                       payload))


@HANDLERS.register('cloud')
@@ -8,7 +8,6 @@ from homeassistant.core import callback
 from homeassistant.const import EVENT_COMPONENT_LOADED, CONF_ID
 from homeassistant.setup import (
    async_prepare_setup_platform, ATTR_COMPONENT)
-from homeassistant.components.frontend import register_built_in_panel
 from homeassistant.components.http import HomeAssistantView
 from homeassistant.util.yaml import load_yaml, dump

@@ -21,7 +20,8 @@ ON_DEMAND = ('zwave')
@asyncio.coroutine
 def async_setup(hass, config):
    """Set up the config component."""
-    register_built_in_panel(hass, 'config', 'Configuration', 'mdi:settings')
+    yield from hass.components.frontend.async_register_built_in_panel(
+        'config', 'config', 'mdi:settings')

    @asyncio.coroutine
    def setup_panel(panel_name):
@@ -1,8 +1,8 @@
 """Provide configuration end points for Groups."""
 import asyncio
-
+from homeassistant.const import SERVICE_RELOAD
 from homeassistant.components.config import EditKeyBasedConfigView
-from homeassistant.components.group import GROUP_SCHEMA
+from homeassistant.components.group import DOMAIN, GROUP_SCHEMA
 import homeassistant.helpers.config_validation as cv


@@ -12,7 +12,13 @@ CONFIG_PATH = 'groups.yaml'
@asyncio.coroutine
 def async_setup(hass):
    """Set up the Group config API."""
+    @asyncio.coroutine
+    def hook(hass):
+        """post_write_hook for Config View that reloads groups."""
+        yield from hass.services.async_call(DOMAIN, SERVICE_RELOAD)
+
    hass.http.register_view(EditKeyBasedConfigView(
-        'group', 'config', CONFIG_PATH, cv.slug, GROUP_SCHEMA
+        'group', 'config', CONFIG_PATH, cv.slug, GROUP_SCHEMA,
+        post_write_hook=hook
    ))
    return True
@@ -1,17 +1,19 @@
 """Provide configuration end points for Z-Wave."""
 import asyncio
+import logging

+from collections import deque
+from aiohttp.web import Response
 import homeassistant.core as ha
-from homeassistant.const import HTTP_NOT_FOUND
+from homeassistant.const import HTTP_NOT_FOUND, HTTP_OK
 from homeassistant.components.http import HomeAssistantView
 from homeassistant.components.config import EditKeyBasedConfigView
 from homeassistant.components.zwave import const, DEVICE_CONFIG_SCHEMA_ENTRY
 import homeassistant.helpers.config_validation as cv

-
+_LOGGER = logging.getLogger(__name__)
 CONFIG_PATH = 'zwave_device_config.yaml'
 OZW_LOG_FILENAME = 'OZW_Log.txt'
-URL_API_OZW_LOG = '/api/zwave/ozwlog'


@asyncio.coroutine
@@ -25,12 +27,64 @@ def async_setup(hass):
    hass.http.register_view(ZWaveNodeGroupView)
    hass.http.register_view(ZWaveNodeConfigView)
    hass.http.register_view(ZWaveUserCodeView)
-    hass.http.register_static_path(
-        URL_API_OZW_LOG, hass.config.path(OZW_LOG_FILENAME), False)
+    hass.http.register_view(ZWaveLogView)
+    hass.http.register_view(ZWaveConfigWriteView)

    return True


+class ZWaveLogView(HomeAssistantView):
+    """View to read the ZWave log file."""
+
+    url = "/api/zwave/ozwlog"
+    name = "api:zwave:ozwlog"
+
+# pylint: disable=no-self-use
+    @asyncio.coroutine
+    def get(self, request):
+        """Retrieve the lines from ZWave log."""
+        try:
+            lines = int(request.query.get('lines', 0))
+        except ValueError:
+            return Response(text='Invalid datetime', status=400)
+
+        hass = request.app['hass']
+        response = yield from hass.async_add_job(self._get_log, hass, lines)
+
+        return Response(text='\n'.join(response))
+
+    def _get_log(self, hass, lines):
+        """Retrieve the logfile content."""
+        logfilepath = hass.config.path(OZW_LOG_FILENAME)
+        with open(logfilepath, 'r') as logfile:
+            data = (line.rstrip() for line in logfile)
+            if lines == 0:
+                loglines = list(data)
+            else:
+                loglines = deque(data, lines)
+        return loglines
+
+
+class ZWaveConfigWriteView(HomeAssistantView):
+    """View to save the ZWave configuration to zwcfg_xxxxx.xml."""
+
+    url = "/api/zwave/saveconfig"
+    name = "api:zwave:saveconfig"
+
+    @ha.callback
+    def post(self, request):
+        """Save cache configuration to zwcfg_xxxxx.xml."""
+        hass = request.app['hass']
+        network = hass.data.get(const.DATA_NETWORK)
+        if network is None:
+            return self.json_message('No Z-Wave network data found',
+                                     HTTP_NOT_FOUND)
+        _LOGGER.info("Z-Wave configuration written to file.")
+        network.write_config()
+        return self.json_message('Z-Wave configuration saved to file.',
+                                 HTTP_OK)
+
+
 class ZWaveNodeValueView(HomeAssistantView):
    """View to return the node values."""

@@ -50,15 +50,19 @@ def async_request_config(

    Will return an ID to be used for sequent calls.
    """
+    if link_name is not None and link_url is not None:
+        description += '\n\n[{}]({})'.format(link_name, link_url)
+
+    if description_image is not None:
+        description += '\n\n![Description image]({})'.format(description_image)
+
    instance = hass.data.get(_KEY_INSTANCE)

    if instance is None:
        instance = hass.data[_KEY_INSTANCE] = Configurator(hass)

    request_id = instance.async_request_config(
-        name, callback,
-        description, description_image, submit_caption,
-        fields, link_name, link_url, entity_picture)
+        name, callback, description, submit_caption, fields, entity_picture)

    if DATA_REQUESTS not in hass.data:
        hass.data[DATA_REQUESTS] = {}
@@ -137,9 +141,8 @@ class Configurator(object):

    @async_callback
    def async_request_config(
-            self, name, callback,
-            description, description_image, submit_caption,
-            fields, link_name, link_url, entity_picture):
+            self, name, callback, description, submit_caption, fields,
+            entity_picture):
        """Set up a request for configuration."""
        entity_id = async_generate_entity_id(
            ENTITY_ID_FORMAT, name, hass=self.hass)
@@ -161,10 +164,7 @@ class Configurator(object):
        data.update({
            key: value for key, value in [
                (ATTR_DESCRIPTION, description),
-                (ATTR_DESCRIPTION_IMAGE, description_image),
                (ATTR_SUBMIT_CAPTION, submit_caption),
-                (ATTR_LINK_NAME, link_name),
-                (ATTR_LINK_URL, link_url),
            ] if value is not None
        })

@@ -207,7 +207,7 @@ class Configurator(object):

        self.hass.bus.async_listen_once(EVENT_TIME_CHANGED, deferred_remove)

-    @async_callback
+    @asyncio.coroutine
    def async_handle_service_call(self, call):
        """Handle a configure service call."""
        request_id = call.data.get(ATTR_CONFIGURE_ID)
@@ -220,7 +220,8 @@ class Configurator(object):

        # field validation goes here?
        if callback:
-            self.hass.async_add_job(callback, call.data.get(ATTR_FIELDS, {}))
+            yield from self.hass.async_add_job(callback,
+                                               call.data.get(ATTR_FIELDS, {}))

    def _generate_unique_id(self):
        """Generate a unique configurator ID."""
@@ -14,7 +14,7 @@ import voluptuous as vol
 from homeassistant import core
 from homeassistant.loader import bind_hass
 from homeassistant.const import (
-    ATTR_ENTITY_ID, SERVICE_TURN_OFF, SERVICE_TURN_ON, HTTP_BAD_REQUEST)
+    ATTR_ENTITY_ID, SERVICE_TURN_OFF, SERVICE_TURN_ON)
 from homeassistant.helpers import intent, config_validation as cv
 from homeassistant.components import http

@@ -39,6 +39,10 @@ CONFIG_SCHEMA = vol.Schema({DOMAIN: vol.Schema({
    })
 })}, extra=vol.ALLOW_EXTRA)

+INTENT_TURN_ON = 'HassTurnOn'
+INTENT_TURN_OFF = 'HassTurnOff'
+REGEX_TYPE = type(re.compile(''))
+
 _LOGGER = logging.getLogger(__name__)


@@ -60,7 +64,11 @@ def async_register(hass, intent_type, utterances):
    if conf is None:
        conf = intents[intent_type] = []

-    conf.extend(_create_matcher(utterance) for utterance in utterances)
+    for utterance in utterances:
+        if isinstance(utterance, REGEX_TYPE):
+            conf.append(utterance)
+        else:
+            conf.append(_create_matcher(utterance))


@asyncio.coroutine
@@ -93,6 +101,13 @@ def async_setup(hass, config):

    hass.http.register_view(ConversationProcessView)

+    hass.helpers.intent.async_register(TurnOnIntent())
+    hass.helpers.intent.async_register(TurnOffIntent())
+    async_register(hass, INTENT_TURN_ON,
+                   ['Turn {name} on', 'Turn on {name}'])
+    async_register(hass, INTENT_TURN_OFF, [
+        'Turn {name} off', 'Turn off {name}'])
+
    return True


@@ -128,48 +143,84 @@ def _process(hass, text):
            if not match:
                continue

-            response = yield from intent.async_handle(
-                hass, DOMAIN, intent_type,
+            response = yield from hass.helpers.intent.async_handle(
+                DOMAIN, intent_type,
                {key: {'value': value} for key, value
                 in match.groupdict().items()}, text)
            return response

+
+@core.callback
+def _match_entity(hass, name):
+    """Match a name to an entity."""
    from fuzzywuzzy import process as fuzzyExtract
-    text = text.lower()
-    match = REGEX_TURN_COMMAND.match(text)
-
-    if not match:
-        _LOGGER.error("Unable to process: %s", text)
-        return None
-
-    name, command = match.groups()
    entities = {state.entity_id: state.name for state
                in hass.states.async_all()}
-    entity_ids = fuzzyExtract.extractOne(
+    entity_id = fuzzyExtract.extractOne(
        name, entities, score_cutoff=65)[2]
+    return hass.states.get(entity_id) if entity_id else None

-    if not entity_ids:
-        _LOGGER.error(
-            "Could not find entity id %s from text %s", name, text)
-        return None

-    if command == 'on':
+class TurnOnIntent(intent.IntentHandler):
+    """Handle turning item on intents."""
+
+    intent_type = INTENT_TURN_ON
+    slot_schema = {
+        'name': cv.string,
+    }
+
+    @asyncio.coroutine
+    def async_handle(self, intent_obj):
+        """Handle turn on intent."""
+        hass = intent_obj.hass
+        slots = self.async_validate_slots(intent_obj.slots)
+        name = slots['name']['value']
+        entity = _match_entity(hass, name)
+
+        if not entity:
+            _LOGGER.error("Could not find entity id for %s", name)
+            return None
+
        yield from hass.services.async_call(
            core.DOMAIN, SERVICE_TURN_ON, {
-                ATTR_ENTITY_ID: entity_ids,
+                ATTR_ENTITY_ID: entity.entity_id,
            }, blocking=True)

-    elif command == 'off':
+        response = intent_obj.create_response()
+        response.async_set_speech(
+            'Turned on {}'.format(entity.name))
+        return response
+
+
+class TurnOffIntent(intent.IntentHandler):
+    """Handle turning item off intents."""
+
+    intent_type = INTENT_TURN_OFF
+    slot_schema = {
+        'name': cv.string,
+    }
+
+    @asyncio.coroutine
+    def async_handle(self, intent_obj):
+        """Handle turn off intent."""
+        hass = intent_obj.hass
+        slots = self.async_validate_slots(intent_obj.slots)
+        name = slots['name']['value']
+        entity = _match_entity(hass, name)
+
+        if not entity:
+            _LOGGER.error("Could not find entity id for %s", name)
+            return None
+
        yield from hass.services.async_call(
            core.DOMAIN, SERVICE_TURN_OFF, {
-                ATTR_ENTITY_ID: entity_ids,
+                ATTR_ENTITY_ID: entity.entity_id,
            }, blocking=True)

-    else:
-        _LOGGER.error('Got unsupported command %s from text %s',
-                      command, text)
-
-    return None
+        response = intent_obj.create_response()
+        response.async_set_speech(
+            'Turned off {}'.format(entity.name))
+        return response


 class ConversationProcessView(http.HomeAssistantView):
@@ -178,23 +229,15 @@ class ConversationProcessView(http.HomeAssistantView):
    url = '/api/conversation/process'
    name = "api:conversation:process"

+    @http.RequestDataValidator(vol.Schema({
+        vol.Required('text'): str,
+    }))
    @asyncio.coroutine
-    def post(self, request):
+    def post(self, request, data):
        """Send a request for processing."""
        hass = request.app['hass']
-        try:
-            data = yield from request.json()
-        except ValueError:
-            return self.json_message('Invalid JSON specified',
-                                     HTTP_BAD_REQUEST)

-        text = data.get('text')
-
-        if text is None:
-            return self.json_message('Missing "text" key in JSON.',
-                                     HTTP_BAD_REQUEST)
-
-        intent_result = yield from _process(hass, text)
+        intent_result = yield from _process(hass, data['text'])

        if intent_result is None:
            intent_result = intent.IntentResponse()
@@ -140,13 +140,13 @@ def async_setup(hass, config):

    hass.services.async_register(
        DOMAIN, SERVICE_INCREMENT, async_handler_service,
-        descriptions[DOMAIN][SERVICE_INCREMENT], SERVICE_SCHEMA)
+        descriptions[SERVICE_INCREMENT], SERVICE_SCHEMA)
    hass.services.async_register(
        DOMAIN, SERVICE_DECREMENT, async_handler_service,
-        descriptions[DOMAIN][SERVICE_DECREMENT], SERVICE_SCHEMA)
+        descriptions[SERVICE_DECREMENT], SERVICE_SCHEMA)
    hass.services.async_register(
        DOMAIN, SERVICE_RESET, async_handler_service,
-        descriptions[DOMAIN][SERVICE_RESET], SERVICE_SCHEMA)
+        descriptions[SERVICE_RESET], SERVICE_SCHEMA)

    yield from component.async_add_entities(entities)
    return True
--- a/Show More
+++ b/Show More