Merge pull request #5530 from home-assistant/dev

0.37
Version bump to 0.37
2017-01-28 15:13:43 -08:00 · 2017-01-28 15:13:17 -08:00 · 2017-01-28 23:52:30 +01:00 · 2017-01-28 13:57:18 -08:00 · 2017-01-28 12:46:34 -08:00 · 2017-01-28 12:45:52 -08:00
495 changed files with 22191 additions and 4298 deletions
@@ -13,6 +13,9 @@ omit =
    homeassistant/components/arduino.py
    homeassistant/components/*/arduino.py

+    homeassistant/components/bbb_gpio.py
+    homeassistant/components/*/bbb_gpio.py
+
    homeassistant/components/bloomsky.py
    homeassistant/components/*/bloomsky.py

@@ -34,12 +37,18 @@ omit =
    homeassistant/components/insteon_hub.py
    homeassistant/components/*/insteon_hub.py

+    homeassistant/components/insteon_local.py
+    homeassistant/components/*/insteon_local.py
+
    homeassistant/components/ios.py
    homeassistant/components/*/ios.py

    homeassistant/components/isy994.py
    homeassistant/components/*/isy994.py

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

@@ -116,6 +125,9 @@ omit =
    homeassistant/components/mochad.py
    homeassistant/components/*/mochad.py

+    homeassistant/components/zabbix.py
+    homeassistant/components/*/zabbix.py
+
    homeassistant/components/alarm_control_panel/alarmdotcom.py
    homeassistant/components/alarm_control_panel/concord232.py
    homeassistant/components/alarm_control_panel/nx584.py
@@ -124,6 +136,7 @@ omit =
    homeassistant/components/binary_sensor/concord232.py
    homeassistant/components/binary_sensor/flic.py
    homeassistant/components/binary_sensor/hikvision.py
+    homeassistant/components/binary_sensor/iss.py
    homeassistant/components/binary_sensor/rest.py
    homeassistant/components/browser.py
    homeassistant/components/camera/amcrest.py
@@ -154,16 +167,22 @@ omit =
    homeassistant/components/device_tracker/fritz.py
    homeassistant/components/device_tracker/gpslogger.py
    homeassistant/components/device_tracker/icloud.py
+    homeassistant/components/device_tracker/linksys_ap.py
    homeassistant/components/device_tracker/luci.py
    homeassistant/components/device_tracker/netgear.py
    homeassistant/components/device_tracker/nmap_tracker.py
+    homeassistant/components/device_tracker/ping.py
+    homeassistant/components/device_tracker/sky_hub.py
    homeassistant/components/device_tracker/snmp.py
    homeassistant/components/device_tracker/swisscom.py
    homeassistant/components/device_tracker/thomson.py
    homeassistant/components/device_tracker/tomato.py
+    homeassistant/components/device_tracker/tado.py
    homeassistant/components/device_tracker/tplink.py
+    homeassistant/components/device_tracker/trackr.py
    homeassistant/components/device_tracker/ubus.py
    homeassistant/components/device_tracker/volvooncall.py
+    homeassistant/components/device_tracker/xiaomi.py
    homeassistant/components/discovery.py
    homeassistant/components/downloader.py
    homeassistant/components/emoncms_history.py
@@ -176,16 +195,22 @@ omit =
    homeassistant/components/joaoapps_join.py
    homeassistant/components/keyboard.py
    homeassistant/components/keyboard_remote.py
+    homeassistant/components/light/avion.py
    homeassistant/components/light/blinksticklight.py
+    homeassistant/components/light/decora.py
    homeassistant/components/light/flux_led.py
    homeassistant/components/light/hue.py
    homeassistant/components/light/hyperion.py
    homeassistant/components/light/lifx.py
    homeassistant/components/light/limitlessled.py
    homeassistant/components/light/osramlightify.py
+    homeassistant/components/light/tikteck.py
    homeassistant/components/light/x10.py
    homeassistant/components/light/yeelight.py
+    homeassistant/components/light/piglow.py
+    homeassistant/components/light/zengge.py
    homeassistant/components/lirc.py
+    homeassistant/components/media_player/anthemav.py
    homeassistant/components/media_player/aquostv.py
    homeassistant/components/media_player/braviatv.py
    homeassistant/components/media_player/cast.py
@@ -197,11 +222,13 @@ omit =
    homeassistant/components/media_player/emby.py
    homeassistant/components/media_player/firetv.py
    homeassistant/components/media_player/gpmdp.py
+    homeassistant/components/media_player/hdmi_cec.py
    homeassistant/components/media_player/itunes.py
    homeassistant/components/media_player/kodi.py
    homeassistant/components/media_player/lg_netcast.py
    homeassistant/components/media_player/mpchc.py
    homeassistant/components/media_player/mpd.py
+    homeassistant/components/media_player/nad.py
    homeassistant/components/media_player/onkyo.py
    homeassistant/components/media_player/panasonic_viera.py
    homeassistant/components/media_player/pandora.py
@@ -219,12 +246,15 @@ omit =
    homeassistant/components/notify/aws_lambda.py
    homeassistant/components/notify/aws_sns.py
    homeassistant/components/notify/aws_sqs.py
+    homeassistant/components/notify/discord.py
+    homeassistant/components/notify/facebook.py
    homeassistant/components/notify/free_mobile.py
    homeassistant/components/notify/gntp.py
    homeassistant/components/notify/group.py
    homeassistant/components/notify/instapush.py
    homeassistant/components/notify/joaoapps_join.py
    homeassistant/components/notify/kodi.py
+    homeassistant/components/notify/lannouncer.py
    homeassistant/components/notify/llamalab_automate.py
    homeassistant/components/notify/matrix.py
    homeassistant/components/notify/message_bird.py
@@ -242,18 +272,20 @@ omit =
    homeassistant/components/notify/telegram.py
    homeassistant/components/notify/telstra.py
    homeassistant/components/notify/twilio_sms.py
+    homeassistant/components/notify/twilio_call.py
    homeassistant/components/notify/twitter.py
    homeassistant/components/notify/xmpp.py
    homeassistant/components/nuimo_controller.py
-    homeassistant/components/openalpr.py
    homeassistant/components/remote/harmony.py
    homeassistant/components/scene/hunterdouglas_powerview.py
+    homeassistant/components/sensor/amcrest.py
    homeassistant/components/sensor/arest.py
    homeassistant/components/sensor/arwn.py
    homeassistant/components/sensor/bbox.py
    homeassistant/components/sensor/bitcoin.py
    homeassistant/components/sensor/bom.py
    homeassistant/components/sensor/broadlink.py
+    homeassistant/components/sensor/dublin_bus_transport.py
    homeassistant/components/sensor/coinmarketcap.py
    homeassistant/components/sensor/cpuspeed.py
    homeassistant/components/sensor/cups.py
@@ -277,6 +309,7 @@ omit =
    homeassistant/components/sensor/haveibeenpwned.py
    homeassistant/components/sensor/hddtemp.py
    homeassistant/components/sensor/hp_ilo.py
+    homeassistant/components/sensor/hydroquebec.py
    homeassistant/components/sensor/imap.py
    homeassistant/components/sensor/imap_email_content.py
    homeassistant/components/sensor/influxdb.py
@@ -301,6 +334,8 @@ omit =
    homeassistant/components/sensor/scrape.py
    homeassistant/components/sensor/sensehat.py
    homeassistant/components/sensor/serial_pm.py
+    homeassistant/components/sensor/skybeacon.py
+    homeassistant/components/sensor/sma.py
    homeassistant/components/sensor/snmp.py
    homeassistant/components/sensor/sonarr.py
    homeassistant/components/sensor/speedtest.py
@@ -317,6 +352,7 @@ omit =
    homeassistant/components/sensor/transmission.py
    homeassistant/components/sensor/twitch.py
    homeassistant/components/sensor/uber.py
+    homeassistant/components/sensor/usps.py
    homeassistant/components/sensor/vasttrafik.py
    homeassistant/components/sensor/waqi.py
    homeassistant/components/sensor/xbox_live.py
@@ -329,8 +365,10 @@ omit =
    homeassistant/components/switch/digitalloggers.py
    homeassistant/components/switch/dlink.py
    homeassistant/components/switch/edimax.py
+    homeassistant/components/switch/hdmi_cec.py
    homeassistant/components/switch/hikvisioncam.py
    homeassistant/components/switch/hook.py
+    homeassistant/components/switch/kankun.py
    homeassistant/components/switch/mystrom.py
    homeassistant/components/switch/netio.py
    homeassistant/components/switch/orvibo.py
@@ -342,7 +380,10 @@ omit =
    homeassistant/components/switch/transmission.py
    homeassistant/components/switch/wake_on_lan.py
    homeassistant/components/thingspeak.py
+    homeassistant/components/tts/amazon_polly.py
+    homeassistant/components/tts/picotts.py
    homeassistant/components/upnp.py
+    homeassistant/components/weather/bom.py
    homeassistant/components/weather/openweathermap.py
    homeassistant/components/zeroconf.py

@@ -0,0 +1,6 @@
+# Patterns matched in this file will be ignored by supported search utilities
+
+# Ignore generated html and javascript files
+/homeassistant/components/frontend/www_static/*.html
+/homeassistant/components/frontend/www_static/*.js
+/homeassistant/components/frontend/www_static/panels/*.html
@@ -8,13 +8,16 @@ matrix:
      env: TOXENV=requirements
    - python: "3.4.2"
      env: TOXENV=lint
-    - python: "3.5"
-      env: TOXENV=typing
+    # - python: "3.5"
+    #   env: TOXENV=typing
    - python: "3.5"
      env: TOXENV=py35
-  allow_failures:
-    - python: "3.5"
-      env: TOXENV=typing
+    - python: "3.6"
+      env: TOXENV=py36
+  # allow_failures:
+  #   - python: "3.5"
+  #     env: TOXENV=typing
+
 cache:
  directories:
    - $HOME/.cache/pip
@@ -0,0 +1,39 @@
+# Contributor License Agreement
+
+```
+By making a contribution to this project, I certify that:
+
+(a) The contribution was created in whole or in part by me and I
+    have the right to submit it under the Apache 2.0 license; or
+
+(b) The contribution is based upon previous work that, to the best
+    of my knowledge, is covered under an appropriate open source
+    license and I have the right under that license to submit that
+    work with modifications, whether created in whole or in part
+    by me, under the Apache 2.0 license; or
+
+(c) The contribution was provided directly to me by some other
+    person who certified (a), (b) or (c) and I have not modified
+    it.
+
+(d) I understand and agree that this project and the contribution
+    are public and that a record of the contribution (including all
+    personal information I submit with it) is maintained indefinitely
+    and may be redistributed consistent with this project or the open
+    source license(s) involved.
+```
+
+## Attribution
+
+The text of this license is available under the [Creative Commons Attribution-ShareAlike 3.0 Unported License](http://creativecommons.org/licenses/by-sa/3.0/).  It is based on the Linux [Developer Certificate Of Origin](http://elinux.org/Developer_Certificate_Of_Origin), but is modified to explicitly use the Apache 2.0 license
+and not mention sign-off.
+
+## Signing
+
+To sign this CLA you must first submit a pull request to a repository under the Home Assistant organization.
+
+## Adoption
+
+This Contributor License Agreement (CLA) was first announced on January 21st, 2017 in [this][cla-blog] blog post and adopted January 28th, 2017.
+
+[cla-blog]: https://home-assistant.io/blog/2017/01/21/home-assistant-governance/
@@ -0,0 +1,80 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at [safety@home-assistant.io][email]. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available [here][version].
+
+## Adoption
+
+This Code of Conduct was first adopted January 21st, 2017 and announced in [this][coc-blog] blog post.
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/
+[email]: mailto:safety@home-assistant.io
+[coc-blog]: https://home-assistant.io/blog/2017/01/21/home-assistant-governance/
@@ -4,7 +4,7 @@ Everybody is invited and welcome to contribute to Home Assistant. There is a lot

 The process is straight-forward.

- - Read [How to get faster PR reviews](https://github.com/kubernetes/kubernetes/blob/master/docs/devel/faster_reviews.md) by Kubernetes (but skip step 0)
+ - Read [How to get faster PR reviews](https://github.com/kubernetes/community/blob/master/contributors/devel/faster_reviews.md) by Kubernetes (but skip step 0)
 - Fork the Home Assistant [git repository](https://github.com/home-assistant/home-assistant).
 - Write the code for your device, notification service, sensor, or IoT thing.
 - Ensure tests work.
@@ -6,24 +6,14 @@ VOLUME /config
 RUN mkdir -p /usr/src/app
 WORKDIR /usr/src/app

-RUN pip3 install --no-cache-dir colorlog cython
-
-# For the nmap tracker, bluetooth tracker, Z-Wave, tellstick
-RUN echo "deb http://download.telldus.com/debian/ stable main" >> /etc/apt/sources.list.d/telldus.list && \
-    wget -qO - http://download.telldus.se/debian/telldus-public.key | apt-key add - && \
-    apt-get update && \
-    apt-get install -y --no-install-recommends nmap net-tools cython3 libudev-dev sudo libglib2.0-dev bluetooth libbluetooth-dev \
-            libtelldus-core2 && \
-    apt-get clean && rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*
-
-COPY script/build_python_openzwave script/build_python_openzwave
-RUN script/build_python_openzwave && \
-  mkdir -p /usr/local/share/python-openzwave && \
-  ln -sf /usr/src/app/build/python-openzwave/openzwave/config /usr/local/share/python-openzwave/config
+# Copy build scripts
+COPY script/setup_docker_prereqs script/build_python_openzwave script/build_libcec script/install_phantomjs script/
+RUN script/setup_docker_prereqs

+# Install hass component dependencies
 COPY requirements_all.txt requirements_all.txt
 RUN pip3 install --no-cache-dir -r requirements_all.txt && \
-    pip3 install mysqlclient psycopg2 uvloop
+    pip3 install --no-cache-dir mysqlclient psycopg2 uvloop

 # Copy source
 COPY . .
@@ -1,20 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2016 Paulus Schoutsen
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of
-this software and associated documentation files (the "Software"), to deal in
-the Software without restriction, including without limitation the rights to
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software is furnished to do so,
-subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
-FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
-COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
-IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
@@ -0,0 +1,194 @@
+Apache License
+==============
+
+_Version 2.0, January 2004_
+_&lt;<http://www.apache.org/licenses/>&gt;_
+
+### Terms and Conditions for use, reproduction, and distribution
+
+#### 1. Definitions
+
+“License” shall mean the terms and conditions for use, reproduction, and
+distribution as defined by Sections 1 through 9 of this document.
+
+“Licensor” shall mean the copyright owner or entity authorized by the copyright
+owner that is granting the License.
+
+“Legal Entity” shall mean the union of the acting entity and all other entities
+that control, are controlled by, or are under common control with that entity.
+For the purposes of this definition, “control” means **(i)** the power, direct or
+indirect, to cause the direction or management of such entity, whether by
+contract or otherwise, or **(ii)** ownership of fifty percent (50%) or more of the
+outstanding shares, or **(iii)** beneficial ownership of such entity.
+
+“You” (or “Your”) shall mean an individual or Legal Entity exercising
+permissions granted by this License.
+
+“Source” form shall mean the preferred form for making modifications, including
+but not limited to software source code, documentation source, and configuration
+files.
+
+“Object” form shall mean any form resulting from mechanical transformation or
+translation of a Source form, including but not limited to compiled object code,
+generated documentation, and conversions to other media types.
+
+“Work” shall mean the work of authorship, whether in Source or Object form, made
+available under the License, as indicated by a copyright notice that is included
+in or attached to the work (an example is provided in the Appendix below).
+
+“Derivative Works” shall mean any work, whether in Source or Object form, that
+is based on (or derived from) the Work and for which the editorial revisions,
+annotations, elaborations, or other modifications represent, as a whole, an
+original work of authorship. For the purposes of this License, Derivative Works
+shall not include works that remain separable from, or merely link (or bind by
+name) to the interfaces of, the Work and Derivative Works thereof.
+
+“Contribution” shall mean any work of authorship, including the original version
+of the Work and any modifications or additions to that Work or Derivative Works
+thereof, that is intentionally submitted to Licensor for inclusion in the Work
+by the copyright owner or by an individual or Legal Entity authorized to submit
+on behalf of the copyright owner. For the purposes of this definition,
+“submitted” means any form of electronic, verbal, or written communication sent
+to the Licensor or its representatives, including but not limited to
+communication on electronic mailing lists, source code control systems, and
+issue tracking systems that are managed by, or on behalf of, the Licensor for
+the purpose of discussing and improving the Work, but excluding communication
+that is conspicuously marked or otherwise designated in writing by the copyright
+owner as “Not a Contribution.”
+
+“Contributor” shall mean Licensor and any individual or Legal Entity on behalf
+of whom a Contribution has been received by Licensor and subsequently
+incorporated within the Work.
+
+#### 2. Grant of Copyright License
+
+Subject to the terms and conditions of this License, each Contributor hereby
+grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free,
+irrevocable copyright license to reproduce, prepare Derivative Works of,
+publicly display, publicly perform, sublicense, and distribute the Work and such
+Derivative Works in Source or Object form.
+
+#### 3. Grant of Patent License
+
+Subject to the terms and conditions of this License, each Contributor hereby
+grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free,
+irrevocable (except as stated in this section) patent license to make, have
+made, use, offer to sell, sell, import, and otherwise transfer the Work, where
+such license applies only to those patent claims licensable by such Contributor
+that are necessarily infringed by their Contribution(s) alone or by combination
+of their Contribution(s) with the Work to which such Contribution(s) was
+submitted. If You institute patent litigation against any entity (including a
+cross-claim or counterclaim in a lawsuit) alleging that the Work or a
+Contribution incorporated within the Work constitutes direct or contributory
+patent infringement, then any patent licenses granted to You under this License
+for that Work shall terminate as of the date such litigation is filed.
+
+#### 4. Redistribution
+
+You may reproduce and distribute copies of the Work or Derivative Works thereof
+in any medium, with or without modifications, and in Source or Object form,
+provided that You meet the following conditions:
+
+* **(a)** You must give any other recipients of the Work or Derivative Works a copy of
+this License; and
+* **(b)** You must cause any modified files to carry prominent notices stating that You
+changed the files; and
+* **(c)** You must retain, in the Source form of any Derivative Works that You distribute,
+all copyright, patent, trademark, and attribution notices from the Source form
+of the Work, excluding those notices that do not pertain to any part of the
+Derivative Works; and
+* **(d)** If the Work includes a “NOTICE” text file as part of its distribution, then any
+Derivative Works that You distribute must include a readable copy of the
+attribution notices contained within such NOTICE file, excluding those notices
+that do not pertain to any part of the Derivative Works, in at least one of the
+following places: within a NOTICE text file distributed as part of the
+Derivative Works; within the Source form or documentation, if provided along
+with the Derivative Works; or, within a display generated by the Derivative
+Works, if and wherever such third-party notices normally appear. The contents of
+the NOTICE file are for informational purposes only and do not modify the
+License. You may add Your own attribution notices within Derivative Works that
+You distribute, alongside or as an addendum to the NOTICE text from the Work,
+provided that such additional attribution notices cannot be construed as
+modifying the License.
+
+You may add Your own copyright statement to Your modifications and may provide
+additional or different license terms and conditions for use, reproduction, or
+distribution of Your modifications, or for any such Derivative Works as a whole,
+provided Your use, reproduction, and distribution of the Work otherwise complies
+with the conditions stated in this License.
+
+#### 5. Submission of Contributions
+
+Unless You explicitly state otherwise, any Contribution intentionally submitted
+for inclusion in the Work by You to the Licensor shall be under the terms and
+conditions of this License, without any additional terms or conditions.
+Notwithstanding the above, nothing herein shall supersede or modify the terms of
+any separate license agreement you may have executed with Licensor regarding
+such Contributions.
+
+#### 6. Trademarks
+
+This License does not grant permission to use the trade names, trademarks,
+service marks, or product names of the Licensor, except as required for
+reasonable and customary use in describing the origin of the Work and
+reproducing the content of the NOTICE file.
+
+#### 7. Disclaimer of Warranty
+
+Unless required by applicable law or agreed to in writing, Licensor provides the
+Work (and each Contributor provides its Contributions) on an “AS IS” BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied,
+including, without limitation, any warranties or conditions of TITLE,
+NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are
+solely responsible for determining the appropriateness of using or
+redistributing the Work and assume any risks associated with Your exercise of
+permissions under this License.
+
+#### 8. Limitation of Liability
+
+In no event and under no legal theory, whether in tort (including negligence),
+contract, or otherwise, unless required by applicable law (such as deliberate
+and grossly negligent acts) or agreed to in writing, shall any Contributor be
+liable to You for damages, including any direct, indirect, special, incidental,
+or consequential damages of any character arising as a result of this License or
+out of the use or inability to use the Work (including but not limited to
+damages for loss of goodwill, work stoppage, computer failure or malfunction, or
+any and all other commercial damages or losses), even if such Contributor has
+been advised of the possibility of such damages.
+
+#### 9. Accepting Warranty or Additional Liability
+
+While redistributing the Work or Derivative Works thereof, You may choose to
+offer, and charge a fee for, acceptance of support, warranty, indemnity, or
+other liability obligations and/or rights consistent with this License. However,
+in accepting such obligations, You may act only on Your own behalf and on Your
+sole responsibility, not on behalf of any other Contributor, and only if You
+agree to indemnify, defend, and hold each Contributor harmless for any liability
+incurred by, or claims asserted against, such Contributor by reason of your
+accepting any such warranty or additional liability.
+
+_END OF TERMS AND CONDITIONS_
+
+### APPENDIX: How to apply the Apache License to your work
+
+To apply the Apache License to your work, attach the following boilerplate
+notice, with the fields enclosed by brackets `[]` replaced with your own
+identifying information. (Don't include the brackets!) The text should be
+enclosed in the appropriate comment syntax for the file format. We also
+recommend that a file or class name and description of purpose be included on
+the same “printed page” as the copyright notice for easier identification within
+third-party archives.
+
+    Copyright [yyyy] [name of copyright owner]
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
@@ -26,7 +26,8 @@ Examples of devices Home Assistant can interface with:
   `Netgear <http://netgear.com>`__,
   `DD-WRT <http://www.dd-wrt.com/site/index>`__,
   `TPLink <http://www.tp-link.us/>`__,
-   `ASUSWRT <http://event.asus.com/2013/nw/ASUSWRT/>`__ and any SNMP
+   `ASUSWRT <http://event.asus.com/2013/nw/ASUSWRT/>`__,
+   `Xiaomi <http://miwifi.com/>`__ and any SNMP
   capable Linksys WAP/WRT
 -  `Philips Hue <http://meethue.com>`__ lights,
   `WeMo <http://www.belkin.com/us/Products/home-automation/c/wemo-home-automation/>`__
@@ -86,7 +87,7 @@ components <https://home-assistant.io/developers/creating_components/>`__.

 If you run into issues while using Home Assistant or during development
 of a component, check the `Home Assistant help
-section <https://home-assistant.io/help/>`__ how to reach us.
+section <https://home-assistant.io/help/>`__ of our website for further help and information.

 .. |Build Status| image:: https://travis-ci.org/home-assistant/home-assistant.svg?branch=master
   :target: https://travis-ci.org/home-assistant/home-assistant
@@ -356,7 +356,8 @@ def try_to_restart() -> None:

 def main() -> int:
    """Start Home Assistant."""
-    monkey_patch_asyncio()
+    if sys.version_info[:3] < (3, 5, 3):
+        monkey_patch_asyncio()

    validate_python()

@@ -395,6 +395,10 @@ def async_from_config_dict(config: Dict[str, Any],
    if not loader.PREPARED:
        yield from hass.loop.run_in_executor(None, loader.prepare, hass)

+    # Merge packages
+    conf_util.merge_packages_config(
+        config, core_config.get(conf_util.CONF_PACKAGES, {}))
+
    # Make a copy because we are mutating it.
    # Use OrderedDict in case original one was one.
    # Convert values to dictionaries if they are None
@@ -504,8 +508,10 @@ def enable_logging(hass: core.HomeAssistant, verbose: bool=False,
    Async friendly.
    """
    logging.basicConfig(level=logging.INFO)
-    fmt = ("%(log_color)s%(asctime)s %(levelname)s (%(threadName)s) "
-           "[%(name)s] %(message)s%(reset)s")
+    fmt = ("%(asctime)s %(levelname)s (%(threadName)s) "
+           "[%(name)s] %(message)s")
+    colorfmt = "%(log_color)s{}%(reset)s".format(fmt)
+    datefmt = '%y-%m-%d %H:%M:%S'

    # suppress overly verbose logs from libraries that aren't helpful
    logging.getLogger("requests").setLevel(logging.WARNING)
@@ -515,8 +521,8 @@ def enable_logging(hass: core.HomeAssistant, verbose: bool=False,
    try:
        from colorlog import ColoredFormatter
        logging.getLogger().handlers[0].setFormatter(ColoredFormatter(
-            fmt,
-            datefmt='%y-%m-%d %H:%M:%S',
+            colorfmt,
+            datefmt=datefmt,
            reset=True,
            log_colors={
                'DEBUG': 'cyan',
@@ -550,9 +556,7 @@ def enable_logging(hass: core.HomeAssistant, verbose: bool=False,
                err_log_path, mode='w', delay=True)

        err_handler.setLevel(logging.INFO if verbose else logging.WARNING)
-        err_handler.setFormatter(
-            logging.Formatter('%(asctime)s %(name)s: %(message)s',
-                              datefmt='%y-%m-%d %H:%M:%S'))
+        err_handler.setFormatter(logging.Formatter(fmt, datefmt=datefmt))

        async_handler = AsyncHandler(hass.loop, err_handler)
        hass.data[core.DATA_ASYNCHANDLER] = async_handler
@@ -606,7 +610,7 @@ def async_log_exception(ex, domain, config, hass):
        message += '{}.'.format(humanize_error(config, ex))

    domain_config = config.get(domain, config)
-    message += " (See {}:{}). ".format(
+    message += " (See {}, line {}). ".format(
        getattr(domain_config, '__config_file__', '?'),
        getattr(domain_config, '__line__', '?'))

@@ -5,6 +5,7 @@ For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/alarm_control_panel/
 """
 import asyncio
+from datetime import timedelta
 import logging
 import os

@@ -20,7 +21,7 @@ from homeassistant.helpers.entity import Entity
 from homeassistant.helpers.entity_component import EntityComponent

 DOMAIN = 'alarm_control_panel'
-SCAN_INTERVAL = 30
+SCAN_INTERVAL = timedelta(seconds=30)
 ATTR_CHANGED_BY = 'changed_by'

 ENTITY_ID_FORMAT = DOMAIN + '.{}'
@@ -115,7 +116,7 @@ def async_setup(hass, config):
            update_coro = hass.loop.create_task(
                alarm.async_update_ha_state(True))
            if hasattr(alarm, 'async_update'):
-                update_tasks.append(hass.loop.create_task(update_coro))
+                update_tasks.append(update_coro)
            else:
                yield from update_coro

@@ -152,40 +153,48 @@ class AlarmControlPanel(Entity):
        """Send disarm command."""
        raise NotImplementedError()

-    @asyncio.coroutine
    def async_alarm_disarm(self, code=None):
-        """Send disarm command."""
-        yield from self.hass.loop.run_in_executor(
+        """Send disarm command.
+
+        This method must be run in the event loop and returns a coroutine.
+        """
+        return self.hass.loop.run_in_executor(
            None, self.alarm_disarm, code)

    def alarm_arm_home(self, code=None):
        """Send arm home command."""
        raise NotImplementedError()

-    @asyncio.coroutine
    def async_alarm_arm_home(self, code=None):
-        """Send arm home command."""
-        yield from self.hass.loop.run_in_executor(
+        """Send arm home command.
+
+        This method must be run in the event loop and returns a coroutine.
+        """
+        return self.hass.loop.run_in_executor(
            None, self.alarm_arm_home, code)

    def alarm_arm_away(self, code=None):
        """Send arm away command."""
        raise NotImplementedError()

-    @asyncio.coroutine
    def async_alarm_arm_away(self, code=None):
-        """Send arm away command."""
-        yield from self.hass.loop.run_in_executor(
+        """Send arm away command.
+
+        This method must be run in the event loop and returns a coroutine.
+        """
+        return self.hass.loop.run_in_executor(
            None, self.alarm_arm_away, code)

    def alarm_trigger(self, code=None):
        """Send alarm trigger command."""
        raise NotImplementedError()

-    @asyncio.coroutine
    def async_alarm_trigger(self, code=None):
-        """Send alarm trigger command."""
-        yield from self.hass.loop.run_in_executor(
+        """Send alarm trigger command.
+
+        This method must be run in the event loop and returns a coroutine.
+        """
+        return self.hass.loop.run_in_executor(
            None, self.alarm_trigger, code)

    @property
@@ -5,6 +5,7 @@ For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/alarm_control_panel.concord232/
 """
 import datetime
+from datetime import timedelta
 import logging

 import requests
@@ -25,7 +26,7 @@ DEFAULT_HOST = 'localhost'
 DEFAULT_NAME = 'CONCORD232'
 DEFAULT_PORT = 5007

-SCAN_INTERVAL = 1
+SCAN_INTERVAL = timedelta(seconds=1)

 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
    vol.Optional(CONF_PORT, default=DEFAULT_PORT): cv.port,
@@ -16,7 +16,7 @@ from homeassistant.const import (
    STATE_UNKNOWN, CONF_NAME, CONF_HOST, CONF_PORT)
 import homeassistant.helpers.config_validation as cv

-REQUIREMENTS = ['pynx584==0.2']
+REQUIREMENTS = ['pynx584==0.4']

 _LOGGER = logging.getLogger(__name__)

@@ -86,9 +86,11 @@ class NX584Alarm(alarm.AlarmControlPanel):
            _LOGGER.error('Unable to connect to %(host)s: %(reason)s',
                          dict(host=self._url, reason=ex))
            self._state = STATE_UNKNOWN
+            zones = []
        except IndexError:
            _LOGGER.error('nx584 reports no partitions')
            self._state = STATE_UNKNOWN
+            zones = []

        bypassed = False
        for zone in zones:
@@ -0,0 +1,68 @@
+"""
+Interfaces with Wink Cameras.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/alarm_control_panel.wink/
+"""
+import logging
+
+import homeassistant.components.alarm_control_panel as alarm
+from homeassistant.const import (STATE_UNKNOWN,
+                                 STATE_ALARM_DISARMED,
+                                 STATE_ALARM_ARMED_HOME,
+                                 STATE_ALARM_ARMED_AWAY)
+from homeassistant.components.wink import WinkDevice
+
+_LOGGER = logging.getLogger(__name__)
+
+DEPENDENCIES = ['wink']
+STATE_ALARM_PRIVACY = 'Private'
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Setup the Wink platform."""
+    import pywink
+
+    for camera in pywink.get_cameras():
+        add_devices([WinkCameraDevice(camera, hass)])
+
+
+class WinkCameraDevice(WinkDevice, alarm.AlarmControlPanel):
+    """Representation a Wink camera alarm."""
+
+    def __init__(self, wink, hass):
+        """Initialize the Wink alarm."""
+        WinkDevice.__init__(self, wink, hass)
+
+    @property
+    def state(self):
+        """Return the state of the device."""
+        wink_state = self.wink.state()
+        if wink_state == "away":
+            state = STATE_ALARM_ARMED_AWAY
+        elif wink_state == "home":
+            state = STATE_ALARM_DISARMED
+        elif wink_state == "night":
+            state = STATE_ALARM_ARMED_HOME
+        else:
+            state = STATE_UNKNOWN
+        return state
+
+    def alarm_disarm(self, code=None):
+        """Send disarm command."""
+        self.wink.set_mode("home")
+
+    def alarm_arm_home(self, code=None):
+        """Send arm home command."""
+        self.wink.set_mode("night")
+
+    def alarm_arm_away(self, code=None):
+        """Send arm away command."""
+        self.wink.set_mode("away")
+
+    @property
+    def device_state_attributes(self):
+        """Return the state attributes."""
+        return {
+            'private': self.wink.private()
+        }
@@ -203,11 +203,12 @@ class AlexaResponse(object):
        self.reprompt = None
        self.session_attributes = {}
        self.should_end_session = True
+        self.variables = {}
        if intent is not None and 'slots' in intent:
-            self.variables = {key: value['value'] for key, value
-                              in intent['slots'].items() if 'value' in value}
-        else:
-            self.variables = {}
+            for key, value in intent['slots'].items():
+                if 'value' in value:
+                    underscored_key = key.replace('.', '_')
+                    self.variables[underscored_key] = value['value']

    def add_card(self, card_type, title, content):
        """Add a card to the response."""
@@ -133,6 +133,9 @@ class APIEventStream(HomeAssistantView):
                except asyncio.TimeoutError:
                    yield from to_write.put(STREAM_PING_PAYLOAD)

+        except asyncio.CancelledError:
+            _LOGGER.debug('STREAM %s ABORT', id(stop_obj))
+
        finally:
            _LOGGER.debug('STREAM %s RESPONSE CLOSED', id(stop_obj))
            unsub_stream()
@@ -0,0 +1,74 @@
+"""
+Support for controlling GPIO pins of a Beaglebone Black.
+
+For more details about this component, please refer to the documentation at
+https://home-assistant.io/components/bbb_gpio/
+"""
+import logging
+
+from homeassistant.const import (
+    EVENT_HOMEASSISTANT_START, EVENT_HOMEASSISTANT_STOP)
+
+REQUIREMENTS = ['Adafruit_BBIO==1.0.0']
+
+_LOGGER = logging.getLogger(__name__)
+
+DOMAIN = 'bbb_gpio'
+
+
+# pylint: disable=no-member
+def setup(hass, config):
+    """Set up the BeagleBone Black GPIO component."""
+    # pylint: disable=import-error
+    import Adafruit_BBIO.GPIO as GPIO
+
+    def cleanup_gpio(event):
+        """Stuff to do before stopping."""
+        GPIO.cleanup()
+
+    def prepare_gpio(event):
+        """Stuff to do when home assistant starts."""
+        hass.bus.listen_once(EVENT_HOMEASSISTANT_STOP, cleanup_gpio)
+
+    hass.bus.listen_once(EVENT_HOMEASSISTANT_START, prepare_gpio)
+    return True
+
+
+# noqa: F821
+
+def setup_output(pin):
+    """Setup a GPIO as output."""
+    # pylint: disable=import-error,undefined-variable
+    import Adafruit_BBIO.GPIO as GPIO
+    GPIO.setup(pin, GPIO.OUT)
+
+
+def setup_input(pin, pull_mode):
+    """Setup a GPIO as input."""
+    # pylint: disable=import-error,undefined-variable
+    import Adafruit_BBIO.GPIO as GPIO
+    GPIO.setup(pin, GPIO.IN,                            # noqa: F821
+               GPIO.PUD_DOWN if pull_mode == 'DOWN'     # noqa: F821
+               else GPIO.PUD_UP)                        # noqa: F821
+
+
+def write_output(pin, value):
+    """Write a value to a GPIO."""
+    # pylint: disable=import-error,undefined-variable
+    import Adafruit_BBIO.GPIO as GPIO
+    GPIO.output(pin, value)
+
+
+def read_input(pin):
+    """Read a value from a GPIO."""
+    # pylint: disable=import-error,undefined-variable
+    import Adafruit_BBIO.GPIO as GPIO
+    return GPIO.input(pin) is GPIO.HIGH
+
+
+def edge_detect(pin, event_callback, bounce):
+    """Add detection for RISING and FALLING events."""
+    # pylint: disable=import-error,undefined-variable
+    import Adafruit_BBIO.GPIO as GPIO
+    GPIO.add_event_detect(
+        pin, GPIO.BOTH, callback=event_callback, bouncetime=bounce)
@@ -5,6 +5,7 @@ For more details about this component, please refer to the documentation at
 https://home-assistant.io/components/binary_sensor/
 """
 import asyncio
+from datetime import timedelta
 import logging

 import voluptuous as vol
@@ -15,7 +16,7 @@ from homeassistant.const import (STATE_ON, STATE_OFF)
 from homeassistant.helpers.config_validation import PLATFORM_SCHEMA  # noqa

 DOMAIN = 'binary_sensor'
-SCAN_INTERVAL = 30
+SCAN_INTERVAL = timedelta(seconds=30)

 ENTITY_ID_FORMAT = DOMAIN + '.{}'
 SENSOR_CLASSES = [
@@ -30,7 +30,7 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({


 def setup_platform(hass, config, add_devices, discovery_info=None):
-    """Setup the aREST binary sensor."""
+    """Set up the aREST binary sensor."""
    resource = config.get(CONF_RESOURCE)
    pin = config.get(CONF_PIN)
    sensor_class = config.get(CONF_SENSOR_CLASS)
@@ -38,13 +38,11 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
    try:
        response = requests.get(resource, timeout=10).json()
    except requests.exceptions.MissingSchema:
-        _LOGGER.error('Missing resource or schema in configuration. '
-                      'Add http:// to your URL.')
+        _LOGGER.error("Missing resource or schema in configuration. "
+                      "Add http:// to your URL")
        return False
    except requests.exceptions.ConnectionError:
-        _LOGGER.error('No route to device at %s. '
-                      'Please check the IP address in the configuration file.',
-                      resource)
+        _LOGGER.error("No route to device at %s", resource)
        return False

    arest = ArestData(resource, pin)
@@ -67,10 +65,10 @@ class ArestBinarySensor(BinarySensorDevice):
        self.update()

        if self._pin is not None:
-            request = requests.get('{}/mode/{}/i'.format
-                                   (self._resource, self._pin), timeout=10)
+            request = requests.get(
+                '{}/mode/{}/i'.format(self._resource, self._pin), timeout=10)
            if request.status_code is not 200:
-                _LOGGER.error("Can't set mode. Is device offline?")
+                _LOGGER.error("Can't set mode of %s", self._resource)

    @property
    def name(self):
@@ -109,5 +107,4 @@ class ArestData(object):
                self._resource, self._pin), timeout=10)
            self.data = {'state': response.json()['return_value']}
        except requests.exceptions.ConnectionError:
-            _LOGGER.error("No route to device '%s'. Is device offline?",
-                          self._resource)
+            _LOGGER.error("No route to device '%s'", self._resource)
@@ -0,0 +1,89 @@
+"""
+Support for binary sensor using Beaglebone Black GPIO.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/binary_sensor.bbb_gpio/
+"""
+import logging
+
+import voluptuous as vol
+
+import homeassistant.components.bbb_gpio as bbb_gpio
+from homeassistant.components.binary_sensor import (
+    BinarySensorDevice, PLATFORM_SCHEMA)
+from homeassistant.const import (DEVICE_DEFAULT_NAME, CONF_NAME)
+import homeassistant.helpers.config_validation as cv
+
+_LOGGER = logging.getLogger(__name__)
+
+DEPENDENCIES = ['bbb_gpio']
+
+CONF_PINS = 'pins'
+CONF_BOUNCETIME = 'bouncetime'
+CONF_INVERT_LOGIC = 'invert_logic'
+CONF_PULL_MODE = 'pull_mode'
+
+DEFAULT_BOUNCETIME = 50
+DEFAULT_INVERT_LOGIC = False
+DEFAULT_PULL_MODE = 'UP'
+
+PIN_SCHEMA = vol.Schema({
+    vol.Required(CONF_NAME): cv.string,
+    vol.Optional(CONF_BOUNCETIME, default=DEFAULT_BOUNCETIME): cv.positive_int,
+    vol.Optional(CONF_INVERT_LOGIC, default=DEFAULT_INVERT_LOGIC): cv.boolean,
+    vol.Optional(CONF_PULL_MODE, default=DEFAULT_PULL_MODE):
+        vol.In(['UP', 'DOWN'])
+})
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Required(CONF_PINS, default={}):
+        vol.Schema({cv.string: PIN_SCHEMA}),
+})
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Setup the Beaglebone Black GPIO devices."""
+    pins = config.get(CONF_PINS)
+
+    binary_sensors = []
+
+    for pin, params in pins.items():
+        binary_sensors.append(BBBGPIOBinarySensor(pin, params))
+    add_devices(binary_sensors)
+
+
+class BBBGPIOBinarySensor(BinarySensorDevice):
+    """Represent a binary sensor that uses Beaglebone Black GPIO."""
+
+    def __init__(self, pin, params):
+        """Initialize the Beaglebone Black binary sensor."""
+        self._pin = pin
+        self._name = params.get(CONF_NAME) or DEVICE_DEFAULT_NAME
+        self._bouncetime = params.get(CONF_BOUNCETIME)
+        self._pull_mode = params.get(CONF_PULL_MODE)
+        self._invert_logic = params.get(CONF_INVERT_LOGIC)
+
+        bbb_gpio.setup_input(self._pin, self._pull_mode)
+        self._state = bbb_gpio.read_input(self._pin)
+
+        def read_gpio(pin):
+            """Read state from GPIO."""
+            self._state = bbb_gpio.read_input(self._pin)
+            self.schedule_update_ha_state()
+
+        bbb_gpio.edge_detect(self._pin, read_gpio, self._bouncetime)
+
+    @property
+    def should_poll(self):
+        """No polling needed."""
+        return False
+
+    @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 != self._invert_logic
@@ -4,6 +4,7 @@ Support for custom shell commands to retrieve values.
 For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/binary_sensor.command_line/
 """
+from datetime import timedelta
 import logging

 import voluptuous as vol
@@ -22,7 +23,7 @@ DEFAULT_NAME = 'Binary Command Sensor'
 DEFAULT_PAYLOAD_ON = 'ON'
 DEFAULT_PAYLOAD_OFF = 'OFF'

-SCAN_INTERVAL = 60
+SCAN_INTERVAL = timedelta(seconds=60)

 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
    vol.Required(CONF_COMMAND): cv.string,
@@ -27,7 +27,7 @@ DEFAULT_NAME = 'Alarm'
 DEFAULT_PORT = '5007'
 DEFAULT_SSL = False

-SCAN_INTERVAL = 1
+SCAN_INTERVAL = datetime.timedelta(seconds=1)

 ZONE_TYPES_SCHEMA = vol.Schema({
    cv.positive_int: vol.In(SENSOR_CLASSES),
@@ -29,7 +29,7 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({


 def setup_platform(hass, config, add_devices, discovery_info=None):
-    """Setup the Digital Ocean droplet sensor."""
+    """Set up the Digital Ocean droplet sensor."""
    digital_ocean = get_component('digital_ocean')
    droplets = config.get(CONF_DROPLETS)

@@ -68,7 +68,7 @@ class DigitalOceanBinarySensor(BinarySensorDevice):
        return DEFAULT_SENSOR_CLASS

    @property
-    def state_attributes(self):
+    def device_state_attributes(self):
        """Return the state attributes of the Digital Ocean droplet."""
        return {
            ATTR_CREATED_AT: self.data.created_at,
@@ -4,8 +4,9 @@ Provides a binary sensor which is a collection of ffmpeg tools.
 For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/binary_sensor.ffmpeg/
 """
+import asyncio
 import logging
-from os import path
+import os

 import voluptuous as vol

@@ -13,17 +14,22 @@ import homeassistant.helpers.config_validation as cv
 from homeassistant.components.binary_sensor import (
    BinarySensorDevice, PLATFORM_SCHEMA, DOMAIN)
 from homeassistant.components.ffmpeg import (
-    get_binary, run_test, CONF_INPUT, CONF_OUTPUT, CONF_EXTRA_ARGUMENTS)
+    DATA_FFMPEG, CONF_INPUT, CONF_OUTPUT, CONF_EXTRA_ARGUMENTS)
 from homeassistant.config import load_yaml_config_file
-from homeassistant.const import (EVENT_HOMEASSISTANT_STOP, CONF_NAME,
-                                 ATTR_ENTITY_ID)
+from homeassistant.const import (
+    EVENT_HOMEASSISTANT_STOP, EVENT_HOMEASSISTANT_START, CONF_NAME,
+    ATTR_ENTITY_ID)

 DEPENDENCIES = ['ffmpeg']

 _LOGGER = logging.getLogger(__name__)

+SERVICE_START = 'ffmpeg_start'
+SERVICE_STOP = 'ffmpeg_stop'
 SERVICE_RESTART = 'ffmpeg_restart'

+DATA_FFMPEG_DEVICE = 'ffmpeg_binary_sensor'
+
 FFMPEG_SENSOR_NOISE = 'noise'
 FFMPEG_SENSOR_MOTION = 'motion'

@@ -32,6 +38,7 @@ MAP_FFMPEG_BIN = [
    FFMPEG_SENSOR_MOTION
 ]

+CONF_INITIAL_STATE = 'initial_state'
 CONF_TOOL = 'tool'
 CONF_PEAK = 'peak'
 CONF_DURATION = 'duration'
@@ -41,10 +48,12 @@ CONF_REPEAT = 'repeat'
 CONF_REPEAT_TIME = 'repeat_time'

 DEFAULT_NAME = 'FFmpeg'
+DEFAULT_INIT_STATE = True

 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
    vol.Required(CONF_TOOL): vol.In(MAP_FFMPEG_BIN),
    vol.Required(CONF_INPUT): cv.string,
+    vol.Optional(CONF_INITIAL_STATE, default=DEFAULT_INIT_STATE): cv.boolean,
    vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
    vol.Optional(CONF_EXTRA_ARGUMENTS): cv.string,
    vol.Optional(CONF_OUTPUT): cv.string,
@@ -61,7 +70,7 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
        vol.All(vol.Coerce(int), vol.Range(min=0)),
 })

-SERVICE_RESTART_SCHEMA = vol.Schema({
+SERVICE_FFMPEG_SCHEMA = vol.Schema({
    vol.Optional(ATTR_ENTITY_ID): cv.entity_ids,
 })

@@ -72,86 +81,126 @@ def restart(hass, entity_id=None):
    hass.services.call(DOMAIN, SERVICE_RESTART, data)


-# list of all ffmpeg sensors
-DEVICES = []
-
-
-def setup_platform(hass, config, add_entities, discovery_info=None):
+@asyncio.coroutine
+def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
    """Create the binary sensor."""
    from haffmpeg import SensorNoise, SensorMotion

    # check source
-    if not run_test(hass, config.get(CONF_INPUT)):
+    if not hass.data[DATA_FFMPEG].async_run_test(config.get(CONF_INPUT)):
        return

    # generate sensor object
    if config.get(CONF_TOOL) == FFMPEG_SENSOR_NOISE:
-        entity = FFmpegNoise(SensorNoise, config)
+        entity = FFmpegNoise(hass, SensorNoise, config)
    else:
-        entity = FFmpegMotion(SensorMotion, config)
+        entity = FFmpegMotion(hass, SensorMotion, config)

-    hass.bus.listen_once(EVENT_HOMEASSISTANT_STOP, entity.shutdown_ffmpeg)
+    @asyncio.coroutine
+    def async_shutdown(event):
+        """Stop ffmpeg."""
+        yield from entity.async_shutdown_ffmpeg()
+
+    hass.bus.async_listen_once(
+        EVENT_HOMEASSISTANT_STOP, async_shutdown)
+
+    # start on startup
+    if config.get(CONF_INITIAL_STATE):
+        @asyncio.coroutine
+        def async_start(event):
+            """Start ffmpeg."""
+            yield from entity.async_start_ffmpeg()
+            yield from entity.async_update_ha_state()
+
+        hass.bus.async_listen_once(
+            EVENT_HOMEASSISTANT_START, async_start)

    # add to system
-    add_entities([entity])
-    DEVICES.append(entity)
+    yield from async_add_devices([entity])

    # exists service?
    if hass.services.has_service(DOMAIN, SERVICE_RESTART):
+        hass.data[DATA_FFMPEG_DEVICE].append(entity)
        return
+    hass.data[DATA_FFMPEG_DEVICE] = [entity]

-    descriptions = load_yaml_config_file(
-        path.join(path.dirname(__file__), 'services.yaml'))
+    descriptions = yield from hass.loop.run_in_executor(
+        None, load_yaml_config_file,
+        os.path.join(os.path.dirname(__file__), 'services.yaml'))

    # register service
-    def _service_handle_restart(service):
+    @asyncio.coroutine
+    def async_service_handle(service):
        """Handle service binary_sensor.ffmpeg_restart."""
        entity_ids = service.data.get('entity_id')

        if entity_ids:
-            _devices = [device for device in DEVICES
+            _devices = [device for device in hass.data[DATA_FFMPEG_DEVICE]
                        if device.entity_id in entity_ids]
        else:
-            _devices = DEVICES
+            _devices = hass.data[DATA_FFMPEG_DEVICE]

+        tasks = []
        for device in _devices:
-            device.restart_ffmpeg()
+            if service.service == SERVICE_START:
+                tasks.append(device.async_start_ffmpeg())
+            elif service.service == SERVICE_STOP:
+                tasks.append(device.async_shutdown_ffmpeg())
+            else:
+                tasks.append(device.async_restart_ffmpeg())

-    hass.services.register(DOMAIN, SERVICE_RESTART,
-                           _service_handle_restart,
-                           descriptions.get(SERVICE_RESTART),
-                           schema=SERVICE_RESTART_SCHEMA)
+        if tasks:
+            yield from asyncio.wait(tasks, loop=hass.loop)
+
+    hass.services.async_register(
+        DOMAIN, SERVICE_START, async_service_handle,
+        descriptions.get(SERVICE_START), schema=SERVICE_FFMPEG_SCHEMA)
+
+    hass.services.async_register(
+        DOMAIN, SERVICE_STOP, async_service_handle,
+        descriptions.get(SERVICE_STOP), schema=SERVICE_FFMPEG_SCHEMA)
+
+    hass.services.async_register(
+        DOMAIN, SERVICE_RESTART, async_service_handle,
+        descriptions.get(SERVICE_RESTART), schema=SERVICE_FFMPEG_SCHEMA)


 class FFmpegBinarySensor(BinarySensorDevice):
    """A binary sensor which use ffmpeg for noise detection."""

-    def __init__(self, ffobj, config):
+    def __init__(self, hass, ffobj, config):
        """Constructor for binary sensor noise detection."""
+        self._manager = hass.data[DATA_FFMPEG]
        self._state = False
        self._config = config
        self._name = config.get(CONF_NAME)
-        self._ffmpeg = ffobj(get_binary(), self._callback)
+        self._ffmpeg = ffobj(
+            self._manager.binary, hass.loop, self._async_callback)

-        self._start_ffmpeg(config)
-
-    def _callback(self, state):
+    def _async_callback(self, state):
        """HA-FFmpeg callback for noise detection."""
        self._state = state
-        self.schedule_update_ha_state()
+        self.hass.async_add_job(self.async_update_ha_state())

-    def _start_ffmpeg(self, config):
-        """Start a FFmpeg instance."""
-        raise NotImplementedError
+    def async_start_ffmpeg(self):
+        """Start a FFmpeg instance.

-    def shutdown_ffmpeg(self, event):
-        """For STOP event to shutdown ffmpeg."""
-        self._ffmpeg.close()
+        This method must be run in the event loop and returns a coroutine.
+        """
+        raise NotImplementedError()

-    def restart_ffmpeg(self):
-        """Restart ffmpeg with new config."""
-        self._ffmpeg.close()
-        self._start_ffmpeg(self._config)
+    def async_shutdown_ffmpeg(self):
+        """For STOP event to shutdown ffmpeg.
+
+        This method must be run in the event loop and returns a coroutine.
+        """
+        return self._ffmpeg.close()
+
+    @asyncio.coroutine
+    def async_restart_ffmpeg(self):
+        """Restart processing."""
+        yield from self.async_shutdown_ffmpeg()
+        yield from self.async_start_ffmpeg()

    @property
    def is_on(self):
@@ -177,20 +226,23 @@ class FFmpegBinarySensor(BinarySensorDevice):
 class FFmpegNoise(FFmpegBinarySensor):
    """A binary sensor which use ffmpeg for noise detection."""

-    def _start_ffmpeg(self, config):
-        """Start a FFmpeg instance."""
+    def async_start_ffmpeg(self):
+        """Start a FFmpeg instance.
+
+        This method must be run in the event loop and returns a coroutine.
+        """
        # init config
        self._ffmpeg.set_options(
-            time_duration=config.get(CONF_DURATION),
-            time_reset=config.get(CONF_RESET),
-            peak=config.get(CONF_PEAK),
+            time_duration=self._config.get(CONF_DURATION),
+            time_reset=self._config.get(CONF_RESET),
+            peak=self._config.get(CONF_PEAK),
        )

        # run
-        self._ffmpeg.open_sensor(
-            input_source=config.get(CONF_INPUT),
-            output_dest=config.get(CONF_OUTPUT),
-            extra_cmd=config.get(CONF_EXTRA_ARGUMENTS),
+        return self._ffmpeg.open_sensor(
+            input_source=self._config.get(CONF_INPUT),
+            output_dest=self._config.get(CONF_OUTPUT),
+            extra_cmd=self._config.get(CONF_EXTRA_ARGUMENTS),
        )

    @property
@@ -202,20 +254,23 @@ class FFmpegNoise(FFmpegBinarySensor):
 class FFmpegMotion(FFmpegBinarySensor):
    """A binary sensor which use ffmpeg for noise detection."""

-    def _start_ffmpeg(self, config):
-        """Start a FFmpeg instance."""
+    def async_start_ffmpeg(self):
+        """Start a FFmpeg instance.
+
+        This method must be run in the event loop and returns a coroutine.
+        """
        # init config
        self._ffmpeg.set_options(
-            time_reset=config.get(CONF_RESET),
-            time_repeat=config.get(CONF_REPEAT_TIME),
-            repeat=config.get(CONF_REPEAT),
-            changes=config.get(CONF_CHANGES),
+            time_reset=self._config.get(CONF_RESET),
+            time_repeat=self._config.get(CONF_REPEAT_TIME),
+            repeat=self._config.get(CONF_REPEAT),
+            changes=self._config.get(CONF_CHANGES),
        )

        # run
-        self._ffmpeg.open_sensor(
-            input_source=config.get(CONF_INPUT),
-            extra_cmd=config.get(CONF_EXTRA_ARGUMENTS),
+        return self._ffmpeg.open_sensor(
+            input_source=self._config.get(CONF_INPUT),
+            extra_cmd=self._config.get(CONF_EXTRA_ARGUMENTS),
        )

    @property
@@ -1,6 +1,6 @@
 """Contains functionality to use flic buttons as a binary sensor."""
-import asyncio
 import logging
+import threading

 import voluptuous as vol

@@ -10,7 +10,6 @@ from homeassistant.const import (
    EVENT_HOMEASSISTANT_STOP)
 from homeassistant.components.binary_sensor import (
    BinarySensorDevice, PLATFORM_SCHEMA)
-from homeassistant.util.async import run_callback_threadsafe


 REQUIREMENTS = ['https://github.com/soldag/pyflic/archive/0.4.zip#pyflic==0.4']
@@ -43,9 +42,7 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
 })


-@asyncio.coroutine
-def async_setup_platform(hass, config, async_add_entities,
-                         discovery_info=None):
+def setup_platform(hass, config, add_entities, discovery_info=None):
    """Setup the flic platform."""
    import pyflic

@@ -63,26 +60,29 @@ def async_setup_platform(hass, config, async_add_entities,

    def new_button_callback(address):
        """Setup newly verified button as device in home assistant."""
-        hass.add_job(async_setup_button(hass, config, async_add_entities,
-                                        client, address))
+        setup_button(hass, config, add_entities, client, address)

    client.on_new_verified_button = new_button_callback
    if discovery:
-        start_scanning(hass, config, async_add_entities, client)
+        start_scanning(config, add_entities, client)

-    hass.bus.async_listen_once(EVENT_HOMEASSISTANT_STOP,
-                               lambda event: client.close())
-    hass.loop.run_in_executor(None, client.handle_events)
+    hass.bus.listen_once(EVENT_HOMEASSISTANT_STOP,
+                         lambda event: client.close())
+
+    # Start the pyflic event handling thread
+    threading.Thread(target=client.handle_events).start()
+
+    def get_info_callback(items):
+        """Add entities for already verified buttons."""
+        addresses = items["bd_addr_of_verified_buttons"] or []
+        for address in addresses:
+            setup_button(hass, config, add_entities, client, address)

    # Get addresses of already verified buttons
-    addresses = yield from async_get_verified_addresses(client)
-    if addresses:
-        for address in addresses:
-            yield from async_setup_button(hass, config, async_add_entities,
-                                          client, address)
+    client.get_info(get_info_callback)


-def start_scanning(hass, config, async_add_entities, client):
+def start_scanning(config, add_entities, client):
    """Start a new flic client for scanning & connceting to new buttons."""
    import pyflic

@@ -97,36 +97,20 @@ def start_scanning(hass, config, async_add_entities, client):
                            address, result)

        # Restart scan wizard
-        start_scanning(hass, config, async_add_entities, client)
+        start_scanning(config, add_entities, client)

    scan_wizard.on_completed = scan_completed_callback
    client.add_scan_wizard(scan_wizard)


-@asyncio.coroutine
-def async_setup_button(hass, config, async_add_entities, client, address):
+def setup_button(hass, config, add_entities, client, address):
    """Setup single button device."""
    timeout = config.get(CONF_TIMEOUT)
    ignored_click_types = config.get(CONF_IGNORED_CLICK_TYPES)
    button = FlicButton(hass, client, address, timeout, ignored_click_types)
    _LOGGER.info("Connected to button (%s)", address)

-    yield from async_add_entities([button])
-
-
-@asyncio.coroutine
-def async_get_verified_addresses(client):
-    """Retrieve addresses of verified buttons."""
-    future = asyncio.Future()
-    loop = asyncio.get_event_loop()
-
-    def get_info_callback(items):
-        """Set the addressed of connected buttons as result of the future."""
-        addresses = items["bd_addr_of_verified_buttons"]
-        run_callback_threadsafe(loop, future.set_result, addresses)
-    client.get_info(get_info_callback)
-
-    return future
+    add_entities([button])


 class FlicButton(BinarySensorDevice):
@@ -17,7 +17,7 @@ from homeassistant.const import (
    CONF_HOST, CONF_PORT, CONF_NAME, CONF_USERNAME, CONF_PASSWORD,
    CONF_SSL, EVENT_HOMEASSISTANT_STOP, ATTR_LAST_TRIP_TIME, CONF_CUSTOMIZE)

-REQUIREMENTS = ['pyhik==0.0.6', 'pydispatcher==2.0.5']
+REQUIREMENTS = ['pyhik==0.0.7', 'pydispatcher==2.0.5']
 _LOGGER = logging.getLogger(__name__)

 CONF_IGNORED = 'ignored'
@@ -17,6 +17,7 @@ DEPENDENCIES = ['homematic']
 SENSOR_TYPES_CLASS = {
    "Remote": None,
    "ShutterContact": "opening",
+    "MaxShutterContact": "opening",
    "IPShutterContact": "opening",
    "Smoke": "smoke",
    "SmokeV2": "smoke",
@@ -0,0 +1,131 @@
+"""
+Support for International Space Station data sensor.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/sensor.iss/
+"""
+import logging
+from datetime import timedelta
+
+import requests
+import voluptuous as vol
+
+import homeassistant.helpers.config_validation as cv
+from homeassistant.components.binary_sensor import (
+    BinarySensorDevice, PLATFORM_SCHEMA)
+from homeassistant.const import (CONF_NAME, ATTR_LONGITUDE, ATTR_LATITUDE)
+from homeassistant.util import Throttle
+
+REQUIREMENTS = ['pyiss==1.0.1']
+
+_LOGGER = logging.getLogger(__name__)
+
+ATTR_ISS_NEXT_RISE = 'next_rise'
+ATTR_ISS_NUMBER_PEOPLE_SPACE = 'number_of_people_in_space'
+
+CONF_SHOW_ON_MAP = 'show_on_map'
+
+DEFAULT_NAME = 'ISS'
+DEFAULT_SENSOR_CLASS = 'visible'
+
+MIN_TIME_BETWEEN_UPDATES = timedelta(seconds=60)
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
+    vol.Optional(CONF_SHOW_ON_MAP, default=False): cv.boolean,
+})
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Set up the ISS sensor."""
+    if None in (hass.config.latitude, hass.config.longitude):
+        _LOGGER.error("Latitude or longitude not set in Home Assistant config")
+        return False
+
+    try:
+        iss_data = IssData(hass.config.latitude, hass.config.longitude)
+        iss_data.update()
+    except requests.exceptions.HTTPError as error:
+        _LOGGER.error(error)
+        return False
+
+    name = config.get(CONF_NAME)
+    show_on_map = config.get(CONF_SHOW_ON_MAP)
+
+    add_devices([IssBinarySensor(iss_data, name, show_on_map)], True)
+
+
+class IssBinarySensor(BinarySensorDevice):
+    """Implementation of the ISS binary sensor."""
+
+    def __init__(self, iss_data, name, show):
+        """Initialize the sensor."""
+        self.iss_data = iss_data
+        self._state = None
+        self._name = name
+        self._show_on_map = show
+        self.update()
+
+    @property
+    def name(self):
+        """Return the name of the sensor."""
+        return self._name
+
+    @property
+    def is_on(self):
+        """Return true if the binary sensor is on."""
+        return self.iss_data.is_above if self.iss_data else False
+
+    @property
+    def sensor_class(self):
+        """Return the class of this sensor."""
+        return DEFAULT_SENSOR_CLASS
+
+    @property
+    def device_state_attributes(self):
+        """Return the state attributes."""
+        if self.iss_data:
+            attrs = {
+                ATTR_ISS_NUMBER_PEOPLE_SPACE:
+                    self.iss_data.number_of_people_in_space,
+                ATTR_ISS_NEXT_RISE: self.iss_data.next_rise,
+            }
+            if self._show_on_map:
+                attrs[ATTR_LONGITUDE] = self.iss_data.position.get('longitude')
+                attrs[ATTR_LATITUDE] = self.iss_data.position.get('latitude')
+            else:
+                attrs['long'] = self.iss_data.position.get('longitude')
+                attrs['lat'] = self.iss_data.position.get('latitude')
+            return attrs
+
+    def update(self):
+        """Get the latest data from ISS API and updates the states."""
+        self.iss_data.update()
+
+
+class IssData(object):
+    """Get data from the ISS API."""
+
+    def __init__(self, latitude, longitude):
+        """Initialize the data object."""
+        self.is_above = None
+        self.next_rise = None
+        self.number_of_people_in_space = None
+        self.position = None
+        self.latitude = latitude
+        self.longitude = longitude
+
+    @Throttle(MIN_TIME_BETWEEN_UPDATES)
+    def update(self):
+        """Get the latest data from the ISS API."""
+        import pyiss
+
+        try:
+            iss = pyiss.ISS()
+            self.is_above = iss.is_ISS_above(self.latitude, self.longitude)
+            self.next_rise = iss.next_rise(self.latitude, self.longitude)
+            self.number_of_people_in_space = iss.number_of_people_in_space()
+            self.position = iss.current_location()
+        except requests.exceptions.HTTPError as error:
+            _LOGGER.error(error)
+            return False
@@ -47,7 +47,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):

        devices = {}
        gateway.platform_callbacks.append(mysensors.pf_callback_factory(
-            map_sv_types, devices, add_devices, MySensorsBinarySensor))
+            map_sv_types, devices, MySensorsBinarySensor, add_devices))


 class MySensorsBinarySensor(
@@ -7,15 +7,10 @@ https://home-assistant.io/components/binary_sensor.nest/
 from itertools import chain
 import logging

-import voluptuous as vol
-
-from homeassistant.components.binary_sensor import (
-    BinarySensorDevice, PLATFORM_SCHEMA)
+from homeassistant.components.binary_sensor import (BinarySensorDevice)
 from homeassistant.components.sensor.nest import NestSensor
-from homeassistant.const import (CONF_SCAN_INTERVAL, CONF_MONITORED_CONDITIONS)
-from homeassistant.components.nest import (
-    DATA_NEST, is_thermostat, is_camera)
-import homeassistant.helpers.config_validation as cv
+from homeassistant.const import CONF_MONITORED_CONDITIONS
+from homeassistant.components.nest import DATA_NEST

 DEPENDENCIES = ['nest']

@@ -43,17 +38,6 @@ _BINARY_TYPES_DEPRECATED = [

 _VALID_BINARY_SENSOR_TYPES = BINARY_TYPES + CLIMATE_BINARY_TYPES \
    + CAMERA_BINARY_TYPES
-_VALID_BINARY_SENSOR_TYPES_WITH_DEPRECATED = _VALID_BINARY_SENSOR_TYPES \
-    + _BINARY_TYPES_DEPRECATED
-
-
-PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
-    vol.Optional(CONF_SCAN_INTERVAL):
-        vol.All(vol.Coerce(int), vol.Range(min=1)),
-    vol.Required(CONF_MONITORED_CONDITIONS):
-        vol.All(cv.ensure_list,
-                [vol.In(_VALID_BINARY_SENSOR_TYPES_WITH_DEPRECATED)])
-})

 _LOGGER = logging.getLogger(__name__)

@@ -64,33 +48,37 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
        return

    nest = hass.data[DATA_NEST]
-    conf = config.get(CONF_MONITORED_CONDITIONS, _VALID_BINARY_SENSOR_TYPES)

-    for variable in conf:
+    # Add all available binary sensors if no Nest binary sensor config is set
+    if discovery_info == {}:
+        conditions = _VALID_BINARY_SENSOR_TYPES
+    else:
+        conditions = discovery_info.get(CONF_MONITORED_CONDITIONS, {})
+
+    for variable in conditions:
        if variable in _BINARY_TYPES_DEPRECATED:
            wstr = (variable + " is no a longer supported "
                    "monitored_conditions. See "
                    "https://home-assistant.io/components/binary_sensor.nest/ "
-                    "for valid options, or remove monitored_conditions "
-                    "entirely to get a reasonable default")
+                    "for valid options.")
            _LOGGER.error(wstr)

    sensors = []
-    device_chain = chain(nest.devices(),
-                         nest.protect_devices(),
-                         nest.camera_devices())
+    device_chain = chain(nest.thermostats(),
+                         nest.smoke_co_alarms(),
+                         nest.cameras())
    for structure, device in device_chain:
        sensors += [NestBinarySensor(structure, device, variable)
-                    for variable in conf
+                    for variable in conditions
                    if variable in BINARY_TYPES]
        sensors += [NestBinarySensor(structure, device, variable)
-                    for variable in conf
+                    for variable in conditions
                    if variable in CLIMATE_BINARY_TYPES
-                    and is_thermostat(device)]
+                    and device.is_thermostat]

-        if is_camera(device):
+        if device.is_camera:
            sensors += [NestBinarySensor(structure, device, variable)
-                        for variable in conf
+                        for variable in conditions
                        if variable in CAMERA_BINARY_TYPES]
            for activity_zone in device.activity_zones:
                sensors += [NestActivityZoneSensor(structure,
@@ -118,13 +106,14 @@ class NestActivityZoneSensor(NestBinarySensor):

    def __init__(self, structure, device, zone):
        """Initialize the sensor."""
-        super(NestActivityZoneSensor, self).__init__(structure, device, None)
+        super(NestActivityZoneSensor, self).__init__(structure, device, "")
        self.zone = zone
+        self._name = "{} {} activity".format(self._name, self.zone.name)

    @property
    def name(self):
        """Return the name of the nest, if any."""
-        return "{} {} activity".format(self._name, self.zone.name)
+        return self._name

    def update(self):
        """Retrieve latest state."""
@@ -1,19 +1,19 @@
 """
 Support for the Netatmo binary sensors.

-The binary sensors based on events seen by the NetatmoCamera
+The binary sensors based on events seen by the Netatmo cameras.

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

 from homeassistant.components.binary_sensor import (
    BinarySensorDevice, PLATFORM_SCHEMA)
-from homeassistant.components.netatmo import WelcomeData
+from homeassistant.components.netatmo import CameraData
 from homeassistant.loader import get_component
-from homeassistant.const import CONF_MONITORED_CONDITIONS, CONF_TIMEOUT
+from homeassistant.const import CONF_TIMEOUT, CONF_OFFSET
 from homeassistant.helpers import config_validation as cv

 DEPENDENCIES = ["netatmo"]
@@ -22,24 +22,37 @@ _LOGGER = logging.getLogger(__name__)


 # These are the available sensors mapped to binary_sensor class
-SENSOR_TYPES = {
-    "Someone known": 'occupancy',
-    "Someone unknown": 'motion',
-    "Motion": 'motion',
+WELCOME_SENSOR_TYPES = {
+    "Someone known": "motion",
+    "Someone unknown": "motion",
+    "Motion": "motion",
    "Tag Vibration": 'vibration',
-    "Tag Open": 'opening',
+    "Tag Open": 'opening'
+}
+PRESENCE_SENSOR_TYPES = {
+    "Outdoor motion": "motion",
+    "Outdoor human": "motion",
+    "Outdoor animal": "motion",
+    "Outdoor vehicle": "motion"
 }

 CONF_HOME = 'home'
 CONF_CAMERAS = 'cameras'
+CONF_WELCOME_SENSORS = 'welcome_sensors'
+CONF_PRESENCE_SENSORS = 'presence_sensors'

 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
    vol.Optional(CONF_HOME): cv.string,
    vol.Optional(CONF_TIMEOUT): cv.positive_int,
+    vol.Optional(CONF_OFFSET): cv.positive_int,
    vol.Optional(CONF_CAMERAS, default=[]):
        vol.All(cv.ensure_list, [cv.string]),
-    vol.Optional(CONF_MONITORED_CONDITIONS, default=SENSOR_TYPES.keys()):
-        vol.All(cv.ensure_list, [vol.In(SENSOR_TYPES)]),
+    vol.Optional(
+        CONF_WELCOME_SENSORS, default=WELCOME_SENSOR_TYPES.keys()):
+        vol.All(cv.ensure_list, [vol.In(WELCOME_SENSOR_TYPES)]),
+    vol.Optional(
+        CONF_PRESENCE_SENSORS, default=PRESENCE_SENSOR_TYPES.keys()):
+        vol.All(cv.ensure_list, [vol.In(PRESENCE_SENSOR_TYPES)]),
 })


@@ -49,48 +62,68 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
    netatmo = get_component('netatmo')
    home = config.get(CONF_HOME, None)
    timeout = config.get(CONF_TIMEOUT, 15)
+    offset = config.get(CONF_OFFSET, 90)

    module_name = None

    import lnetatmo
    try:
-        data = WelcomeData(netatmo.NETATMO_AUTH, home)
+        data = CameraData(netatmo.NETATMO_AUTH, home)
        if data.get_camera_names() == []:
            return None
    except lnetatmo.NoDevice:
        return None

-    sensors = config.get(CONF_MONITORED_CONDITIONS, SENSOR_TYPES)
+    welcome_sensors = config.get(
+        CONF_WELCOME_SENSORS, WELCOME_SENSOR_TYPES)
+    presence_sensors = config.get(
+        CONF_PRESENCE_SENSORS, PRESENCE_SENSOR_TYPES)

    for camera_name in data.get_camera_names():
-        if CONF_CAMERAS in config:
-            if config[CONF_CAMERAS] != [] and \
-               camera_name not in config[CONF_CAMERAS]:
-                continue
-        for variable in sensors:
-            if variable in ('Tag Vibration', 'Tag Open'):
-                continue
-            add_devices([WelcomeBinarySensor(data, camera_name, module_name,
-                                             home, timeout, variable)])
+        camera_type = data.get_camera_type(camera=camera_name, home=home)
+        if camera_type == "NACamera":
+            if CONF_CAMERAS in config:
+                if config[CONF_CAMERAS] != [] and \
+                   camera_name not in config[CONF_CAMERAS]:
+                    continue
+            for variable in welcome_sensors:
+                add_devices([NetatmoBinarySensor(data, camera_name,
+                                                 module_name, home, timeout,
+                                                 offset, camera_type,
+                                                 variable)])
+        if camera_type == "NOC":
+            if CONF_CAMERAS in config:
+                if config[CONF_CAMERAS] != [] and \
+                   camera_name not in config[CONF_CAMERAS]:
+                    continue
+            for variable in presence_sensors:
+                add_devices([NetatmoBinarySensor(data, camera_name,
+                                                 module_name, home, timeout,
+                                                 offset, camera_type,
+                                                 variable)])

        for module_name in data.get_module_names(camera_name):
-            for variable in sensors:
+            for variable in welcome_sensors:
                if variable in ('Tag Vibration', 'Tag Open'):
-                    add_devices([WelcomeBinarySensor(data, camera_name,
+                    add_devices([NetatmoBinarySensor(data, camera_name,
                                                     module_name, home,
-                                                     timeout, variable)])
+                                                     timeout, offset,
+                                                     camera_type,
+                                                     variable)])


-class WelcomeBinarySensor(BinarySensorDevice):
-    """Represent a single binary sensor in a Netatmo Welcome device."""
+class NetatmoBinarySensor(BinarySensorDevice):
+    """Represent a single binary sensor in a Netatmo Camera device."""

-    def __init__(self, data, camera_name, module_name, home, timeout, sensor):
+    def __init__(self, data, camera_name, module_name, home,
+                 timeout, offset, camera_type, sensor):
        """Setup for access to the Netatmo camera events."""
        self._data = data
        self._camera_name = camera_name
        self._module_name = module_name
        self._home = home
        self._timeout = timeout
+        self._offset = offset
        if home:
            self._name = home + ' / ' + camera_name
        else:
@@ -99,10 +132,11 @@ class WelcomeBinarySensor(BinarySensorDevice):
            self._name += ' / ' + module_name
        self._sensor_name = sensor
        self._name += ' ' + sensor
-        camera_id = data.welcomedata.cameraByName(camera=camera_name,
+        camera_id = data.camera_data.cameraByName(camera=camera_name,
                                                  home=home)['id']
-        self._unique_id = "Welcome_binary_sensor {0} - {1}".format(self._name,
+        self._unique_id = "Netatmo_binary_sensor {0} - {1}".format(self._name,
                                                                   camera_id)
+        self._cameratype = camera_type
        self.update()

    @property
@@ -118,7 +152,12 @@ class WelcomeBinarySensor(BinarySensorDevice):
    @property
    def sensor_class(self):
        """Return the class of this sensor, from SENSOR_CLASSES."""
-        return SENSOR_TYPES.get(self._sensor_name)
+        if self._cameratype == "NACamera":
+            return WELCOME_SENSOR_TYPES.get(self._sensor_name)
+        elif self._cameratype == "NOC":
+            return PRESENCE_SENSOR_TYPES.get(self._sensor_name)
+        else:
+            return None

    @property
    def is_on(self):
@@ -130,30 +169,54 @@ class WelcomeBinarySensor(BinarySensorDevice):
        self._data.update()
        self._data.update_event()

-        if self._sensor_name == "Someone known":
-            self._state =\
-                    self._data.welcomedata.someoneKnownSeen(self._home,
+        if self._cameratype == "NACamera":
+            if self._sensor_name == "Someone known":
+                self._state =\
+                    self._data.camera_data.someoneKnownSeen(self._home,
                                                            self._camera_name,
                                                            self._timeout*60)
-        elif self._sensor_name == "Someone unknown":
-            self._state =\
-                self._data.welcomedata.someoneUnknownSeen(self._home,
+            elif self._sensor_name == "Someone unknown":
+                self._state =\
+                    self._data.camera_data.someoneUnknownSeen(
+                        self._home, self._camera_name, self._timeout*60)
+            elif self._sensor_name == "Motion":
+                self._state =\
+                    self._data.camera_data.motionDetected(self._home,
                                                          self._camera_name,
                                                          self._timeout*60)
-        elif self._sensor_name == "Motion":
-            self._state =\
-                self._data.welcomedata.motionDetected(self._home,
-                                                      self._camera_name,
-                                                      self._timeout*60)
+            else:
+                return None
+        elif self._cameratype == "NOC":
+            if self._sensor_name == "Outdoor motion":
+                self._state =\
+                    self._data.camera_data.outdoormotionDetected(
+                        self._home, self._camera_name, self._offset)
+            elif self._sensor_name == "Outdoor human":
+                self._state =\
+                    self._data.camera_data.humanDetected(self._home,
+                                                         self._camera_name,
+                                                         self._offset)
+            elif self._sensor_name == "Outdoor animal":
+                self._state =\
+                    self._data.camera_data.animalDetected(self._home,
+                                                          self._camera_name,
+                                                          self._offset)
+            elif self._sensor_name == "Outdoor vehicle":
+                self._state =\
+                    self._data.camera_data.carDetected(self._home,
+                                                       self._camera_name,
+                                                       self._offset)
+            else:
+                return None
        elif self._sensor_name == "Tag Vibration":
            self._state =\
-                self._data.welcomedata.moduleMotionDetected(self._home,
+                self._data.camera_data.moduleMotionDetected(self._home,
                                                            self._module_name,
                                                            self._camera_name,
                                                            self._timeout*60)
        elif self._sensor_name == "Tag Open":
            self._state =\
-                self._data.welcomedata.moduleOpened(self._home,
+                self._data.camera_data.moduleOpened(self._home,
                                                    self._module_name,
                                                    self._camera_name)
        else:
@@ -16,7 +16,7 @@ from homeassistant.components.binary_sensor import (
 from homeassistant.const import (CONF_HOST, CONF_PORT)
 import homeassistant.helpers.config_validation as cv

-REQUIREMENTS = ['pynx584==0.2']
+REQUIREMENTS = ['pynx584==0.4']

 _LOGGER = logging.getLogger(__name__)

@@ -51,7 +51,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
    for port_num, port_name in ports.items():
        binary_sensors.append(RPiGPIOBinarySensor(
            port_name, port_num, pull_mode, bouncetime, invert_logic))
-    add_devices(binary_sensors)
+    add_devices(binary_sensors, True)


 class RPiGPIOBinarySensor(BinarySensorDevice):
@@ -65,9 +65,9 @@ class RPiGPIOBinarySensor(BinarySensorDevice):
        self._pull_mode = pull_mode
        self._bouncetime = bouncetime
        self._invert_logic = invert_logic
+        self._state = None

        rpi_gpio.setup_input(self._port, self._pull_mode)
-        self._state = rpi_gpio.read_input(self._port)

        def read_gpio(port):
            """Read state from GPIO."""
@@ -90,3 +90,7 @@ class RPiGPIOBinarySensor(BinarySensorDevice):
    def is_on(self):
        """Return the state of the entity."""
        return self._state != self._invert_logic
+
+    def update(self):
+        """Update the GPIO state."""
+        self._state = rpi_gpio.read_input(self._port)
@@ -1,7 +1,23 @@
 # Describes the format for available binary_sensor services

+ffmpeg_start:
+  description: Send a start command to a ffmpeg based sensor.
+
+  fields:
+    entity_id:
+      description: Name(s) of entites that will start. Platform dependent.
+      example: 'binary_sensor.ffmpeg_noise'
+
+ffmpeg_stop:
+  description: Send a stop command to a ffmpeg based sensor.
+
+  fields:
+    entity_id:
+      description: Name(s) of entites that will stop. Platform dependent.
+      example: 'binary_sensor.ffmpeg_noise'
+
 ffmpeg_restart:
-  description: Send a restart command to a ffmpeg based sensor (party mode).
+  description: Send a restart command to a ffmpeg based sensor.

  fields:
    entity_id:
@@ -110,7 +110,7 @@ class ThresholdSensor(BinarySensorDevice):
        return self._sensor_class

    @property
-    def state_attributes(self):
+    def device_state_attributes(self):
        """Return the state attributes of the sensor."""
        return {
            ATTR_ENTITY_ID: self._entity_id,
@@ -8,7 +8,6 @@ at https://home-assistant.io/components/binary_sensor.wink/
 from homeassistant.components.binary_sensor import BinarySensorDevice
 from homeassistant.components.sensor.wink import WinkDevice
 from homeassistant.helpers.entity import Entity
-from homeassistant.loader import get_component

 DEPENDENCIES = ['wink']

@@ -43,6 +42,15 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
    for hub in pywink.get_hubs():
        add_devices([WinkHub(hub, hass)])

+    for remote in pywink.get_remotes():
+        add_devices([WinkRemote(remote, hass)])
+
+    for button in pywink.get_buttons():
+        add_devices([WinkButton(button, hass)])
+
+    for gang in pywink.get_gangs():
+        add_devices([WinkGang(gang, hass)])
+

 class WinkBinarySensorDevice(WinkDevice, BinarySensorDevice, Entity):
    """Representation of a Wink binary sensor."""
@@ -50,33 +58,13 @@ class WinkBinarySensorDevice(WinkDevice, BinarySensorDevice, Entity):
    def __init__(self, wink, hass):
        """Initialize the Wink binary sensor."""
        super().__init__(wink, hass)
-        wink = get_component('wink')
-        self._unit_of_measurement = self.wink.UNIT
+        self._unit_of_measurement = self.wink.unit()
        self.capability = self.wink.capability()

    @property
    def is_on(self):
        """Return true if the binary sensor is on."""
-        if self.capability == "loudness":
-            state = self.wink.loudness_boolean()
-        elif self.capability == "vibration":
-            state = self.wink.vibration_boolean()
-        elif self.capability == "brightness":
-            state = self.wink.brightness_boolean()
-        elif self.capability == "liquid_detected":
-            state = self.wink.liquid_boolean()
-        elif self.capability == "motion":
-            state = self.wink.motion_boolean()
-        elif self.capability == "presence":
-            state = self.wink.presence_boolean()
-        elif self.capability == "co_detected":
-            state = self.wink.co_detected_boolean()
-        elif self.capability == "smoke_detected":
-            state = self.wink.smoke_detected_boolean()
-        else:
-            state = self.wink.state()
-
-        return state
+        return self.wink.state()

    @property
    def sensor_class(self):
@@ -91,6 +79,11 @@ class WinkHub(WinkDevice, BinarySensorDevice, Entity):
        """Initialize the hub sensor."""
        WinkDevice.__init__(self, wink, hass)

+    @property
+    def is_on(self):
+        """Return true if the binary sensor is on."""
+        return self.wink.state()
+
    @property
    def device_state_attributes(self):
        """Return the state attributes."""
@@ -99,7 +92,59 @@ class WinkHub(WinkDevice, BinarySensorDevice, Entity):
            'firmware version': self.wink.firmware_version()
        }

+
+class WinkRemote(WinkDevice, BinarySensorDevice, Entity):
+    """Representation of a Wink Lutron Connected bulb remote."""
+
+    def __init(self, wink, hass):
+        """Initialize the hub sensor."""
+        WinkDevice.__init__(self, wink, hass)
+
    @property
    def is_on(self):
        """Return true if the binary sensor is on."""
        return self.wink.state()
+
+    @property
+    def device_state_attributes(self):
+        """Return the state attributes."""
+        return {
+            'button_on_pressed': self.wink.button_on_pressed(),
+            'button_off_pressed': self.wink.button_off_pressed(),
+            'button_up_pressed': self.wink.button_up_pressed(),
+            'button_down_pressed': self.wink.button_down_pressed()
+        }
+
+
+class WinkButton(WinkDevice, BinarySensorDevice, Entity):
+    """Representation of a Wink Relay button."""
+
+    def __init(self, wink, hass):
+        """Initialize the hub sensor."""
+        WinkDevice.__init__(self, wink, hass)
+
+    @property
+    def is_on(self):
+        """Return true if the binary sensor is on."""
+        return self.wink.state()
+
+    @property
+    def device_state_attributes(self):
+        """Return the state attributes."""
+        return {
+            'pressed': self.wink.pressed(),
+            'long_pressed': self.wink.long_pressed()
+        }
+
+
+class WinkGang(WinkDevice, BinarySensorDevice, Entity):
+    """Representation of a Wink Relay gang."""
+
+    def __init(self, wink, hass):
+        """Initialize the gang sensor."""
+        WinkDevice.__init__(self, wink, hass)
+
+    @property
+    def is_on(self):
+        """Return true if the gang is connected."""
+        return self.wink.state()
@@ -8,7 +8,6 @@ import logging
 import datetime
 import homeassistant.util.dt as dt_util
 from homeassistant.helpers.event import track_point_in_time
-from homeassistant.helpers.entity import Entity
 from homeassistant.components import zwave
 from homeassistant.components.binary_sensor import (
    DOMAIN,
@@ -20,6 +19,8 @@ DEPENDENCIES = []
 PHILIO = 0x013c
 PHILIO_SLIM_SENSOR = 0x0002
 PHILIO_SLIM_SENSOR_MOTION = (PHILIO, PHILIO_SLIM_SENSOR, 0)
+PHILIO_3_IN_1_SENSOR_GEN_4 = 0x000d
+PHILIO_3_IN_1_SENSOR_GEN_4_MOTION = (PHILIO, PHILIO_3_IN_1_SENSOR_GEN_4, 0)
 WENZHOU = 0x0118
 WENZHOU_SLIM_SENSOR_MOTION = (WENZHOU, PHILIO_SLIM_SENSOR, 0)

@@ -27,6 +28,7 @@ WORKAROUND_NO_OFF_EVENT = 'trigger_no_off_event'

 DEVICE_MAPPINGS = {
    PHILIO_SLIM_SENSOR_MOTION: WORKAROUND_NO_OFF_EVENT,
+    PHILIO_3_IN_1_SENSOR_GEN_4_MOTION: WORKAROUND_NO_OFF_EVENT,
    WENZHOU_SLIM_SENSOR_MOTION: WORKAROUND_NO_OFF_EVENT,
 }

@@ -62,21 +64,14 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
        add_devices([ZWaveBinarySensor(value, None)])


-class ZWaveBinarySensor(BinarySensorDevice, zwave.ZWaveDeviceEntity, Entity):
+class ZWaveBinarySensor(BinarySensorDevice, zwave.ZWaveDeviceEntity):
    """Representation of a binary sensor within Z-Wave."""

    def __init__(self, value, sensor_class):
        """Initialize the sensor."""
        self._sensor_type = sensor_class
-        # pylint: disable=import-error
-        from openzwave.network import ZWaveNetwork
-        from pydispatch import dispatcher
-
        zwave.ZWaveDeviceEntity.__init__(self, value, DOMAIN)

-        dispatcher.connect(
-            self.value_changed, ZWaveNetwork.SIGNAL_VALUE_CHANGED)
-
    @property
    def is_on(self):
        """Return True if the binary sensor is on."""
@@ -92,31 +87,25 @@ class ZWaveBinarySensor(BinarySensorDevice, zwave.ZWaveDeviceEntity, Entity):
        """No polling needed."""
        return False

-    def value_changed(self, value):
-        """Called when a value has changed on the network."""
-        if self._value.value_id == value.value_id or \
-           self._value.node == value.node:
-            self.schedule_update_ha_state()

-
-class ZWaveTriggerSensor(ZWaveBinarySensor, Entity):
+class ZWaveTriggerSensor(ZWaveBinarySensor):
    """Representation of a stateless sensor within Z-Wave."""

-    def __init__(self, sensor_value, sensor_class, hass, re_arm_sec=60):
+    def __init__(self, value, sensor_class, hass, re_arm_sec=60):
        """Initialize the sensor."""
-        super(ZWaveTriggerSensor, self).__init__(sensor_value, sensor_class)
+        super(ZWaveTriggerSensor, self).__init__(value, sensor_class)
        self._hass = hass
        self.re_arm_sec = re_arm_sec
        self.invalidate_after = dt_util.utcnow() + datetime.timedelta(
            seconds=self.re_arm_sec)
        # If it's active make sure that we set the timeout tracker
-        if sensor_value.data:
+        if value.data:
            track_point_in_time(
                self._hass, self.async_update_ha_state,
                self.invalidate_after)

    def value_changed(self, value):
-        """Called when a value has changed on the network."""
+        """Called when a value for this entity's node has changed."""
        if self._value.value_id == value.value_id:
            self.schedule_update_ha_state()
            if value.data:
@@ -6,6 +6,8 @@ https://home-assistant.io/components/calendar/

 """
 import logging
+from datetime import timedelta
+
 import re

 from homeassistant.components.google import (CONF_OFFSET,
@@ -20,6 +22,7 @@ from homeassistant.util import dt

 _LOGGER = logging.getLogger(__name__)

+SCAN_INTERVAL = timedelta(seconds=60)
 DOMAIN = 'calendar'
 ENTITY_ID_FORMAT = DOMAIN + '.{}'

@@ -27,7 +30,7 @@ ENTITY_ID_FORMAT = DOMAIN + '.{}'
 def setup(hass, config):
    """Track states and offer events for calendars."""
    component = EntityComponent(
-        logging.getLogger(__name__), DOMAIN, hass, 60, DOMAIN)
+        logging.getLogger(__name__), DOMAIN, hass, SCAN_INTERVAL, DOMAIN)

    component.setup(config)

@@ -144,10 +147,10 @@ class CalendarEventDevice(Entity):
        def _get_date(date):
            """Get the dateTime from date or dateTime as a local."""
            if 'date' in date:
-                return dt.as_utc(dt.dt.datetime.combine(
-                    dt.parse_date(date['date']), dt.dt.time()))
+                return dt.start_of_local_day(dt.dt.datetime.combine(
+                    dt.parse_date(date['date']), dt.dt.time.min))
            else:
-                return dt.parse_datetime(date['dateTime'])
+                return dt.as_local(dt.parse_datetime(date['dateTime']))

        start = _get_date(self.data.event['start'])
        end = _get_date(self.data.event['end'])
@@ -66,7 +66,7 @@ class GoogleCalendarData(object):
        """Get the latest data."""
        service = self.calendar_service.get()
        params = dict(DEFAULT_GOOGLE_SEARCH_PARAMS)
-        params['timeMin'] = dt.utcnow().isoformat('T')
+        params['timeMin'] = dt.start_of_local_day().isoformat('T')
        params['calendarId'] = self.calendar_id
        if self.search:
            params['q'] = self.search
@@ -6,18 +6,31 @@ For more details about this component, please refer to the documentation at
 https://home-assistant.io/components/camera/
 """
 import asyncio
+import collections
+from datetime import timedelta
 import logging
+import hashlib
+from random import SystemRandom

+import aiohttp
 from aiohttp import web
+import async_timeout

+from homeassistant.core import callback
+from homeassistant.const import ATTR_ENTITY_PICTURE
+from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
 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
+
+_LOGGER = logging.getLogger(__name__)

 DOMAIN = 'camera'
 DEPENDENCIES = ['http']
-SCAN_INTERVAL = 30
+SCAN_INTERVAL = timedelta(seconds=30)
 ENTITY_ID_FORMAT = DOMAIN + '.{}'

 STATE_RECORDING = 'recording'
@@ -26,17 +39,63 @@ STATE_IDLE = 'idle'

 ENTITY_IMAGE_URL = '/api/camera_proxy/{0}?token={1}'

+TOKEN_CHANGE_INTERVAL = timedelta(minutes=5)
+_RND = SystemRandom()
+
+
+@asyncio.coroutine
+def async_get_image(hass, entity_id, timeout=10):
+    """Fetch a image from a camera entity."""
+    websession = async_get_clientsession(hass)
+    state = hass.states.get(entity_id)
+
+    if state is None:
+        raise HomeAssistantError(
+            "No entity '{0}' for grab a image".format(entity_id))
+
+    url = "{0}{1}".format(
+        hass.config.api.base_url,
+        state.attributes.get(ATTR_ENTITY_PICTURE)
+    )
+
+    response = None
+    try:
+        with async_timeout.timeout(timeout, loop=hass.loop):
+            response = yield from websession.get(url)
+
+            if response.status != 200:
+                raise HomeAssistantError("Error {0} on {1}".format(
+                    response.status, url))
+
+            image = yield from response.read()
+            return image
+
+    except (asyncio.TimeoutError, aiohttp.errors.ClientError):
+        raise HomeAssistantError("Can't connect to {0}".format(url))
+
+    finally:
+        if response is not None:
+            yield from response.release()
+

@asyncio.coroutine
 def async_setup(hass, config):
    """Setup the camera component."""
-    component = EntityComponent(
-        logging.getLogger(__name__), DOMAIN, hass, SCAN_INTERVAL)
+    component = EntityComponent(_LOGGER, DOMAIN, hass, SCAN_INTERVAL)

    hass.http.register_view(CameraImageView(component.entities))
    hass.http.register_view(CameraMjpegStream(component.entities))

    yield from component.async_setup(config)
+
+    @callback
+    def update_tokens(time):
+        """Update tokens of the entities."""
+        for entity in component.entities.values():
+            entity.async_update_token()
+            hass.async_add_job(entity.async_update_ha_state())
+
+    async_track_time_interval(hass, update_tokens, TOKEN_CHANGE_INTERVAL)
    return True


@@ -46,11 +105,8 @@ class Camera(Entity):
    def __init__(self):
        """Initialize a camera."""
        self.is_streaming = False
-
-    @property
-    def access_token(self):
-        """Access token for this camera."""
-        return str(id(self))
+        self.access_tokens = collections.deque([], 2)
+        self.async_update_token()

    @property
    def should_poll(self):
@@ -60,7 +116,7 @@ class Camera(Entity):
    @property
    def entity_picture(self):
        """Return a link to the camera feed as entity picture."""
-        return ENTITY_IMAGE_URL.format(self.entity_id, self.access_token)
+        return ENTITY_IMAGE_URL.format(self.entity_id, self.access_tokens[-1])

    @property
    def is_recording(self):
@@ -81,15 +137,12 @@ class Camera(Entity):
        """Return bytes of camera image."""
        raise NotImplementedError()

-    @asyncio.coroutine
    def async_camera_image(self):
        """Return bytes of camera image.

-        This method must be run in the event loop.
+        This method must be run in the event loop and returns a coroutine.
        """
-        image = yield from self.hass.loop.run_in_executor(
-            None, self.camera_image)
-        return image
+        return self.hass.loop.run_in_executor(None, self.camera_image)

    @asyncio.coroutine
    def handle_async_mjpeg_stream(self, request):
@@ -131,8 +184,14 @@ class Camera(Entity):
                    yield from response.drain()

                yield from asyncio.sleep(.5)
+
+        except (asyncio.CancelledError, ConnectionResetError):
+            _LOGGER.debug("Close stream by frontend.")
+            response = None
+
        finally:
-            yield from response.write_eof()
+            if response is not None:
+                yield from response.write_eof()

    @property
    def state(self):
@@ -148,7 +207,7 @@ class Camera(Entity):
    def state_attributes(self):
        """Camera state attributes."""
        attr = {
-            'access_token': self.access_token,
+            'access_token': self.access_tokens[-1],
        }

        if self.model:
@@ -159,6 +218,13 @@ class Camera(Entity):

        return attr

+    @callback
+    def async_update_token(self):
+        """Update the used token."""
+        self.access_tokens.append(
+            hashlib.sha256(
+                _RND.getrandbits(256).to_bytes(32, 'little')).hexdigest())
+

 class CameraView(HomeAssistantView):
    """Base CameraView."""
@@ -175,10 +241,11 @@ class CameraView(HomeAssistantView):
        camera = self.entities.get(entity_id)

        if camera is None:
-            return web.Response(status=404)
+            status = 404 if request[KEY_AUTHENTICATED] else 401
+            return web.Response(status=status)

        authenticated = (request[KEY_AUTHENTICATED] or
-                         request.GET.get('token') == camera.access_token)
+                         request.GET.get('token') in camera.access_tokens)

        if not authenticated:
            return web.Response(status=401)
@@ -201,12 +268,16 @@ class CameraImageView(CameraView):
    @asyncio.coroutine
    def handle(self, request, camera):
        """Serve camera image."""
-        image = yield from camera.async_camera_image()
+        try:
+            image = yield from camera.async_camera_image()

-        if image is None:
-            return web.Response(status=500)
+            if image is None:
+                return web.Response(status=500)

-        return web.Response(body=image)
+            return web.Response(body=image)
+
+        except asyncio.CancelledError:
+            _LOGGER.debug("Close stream by frontend.")


 class CameraMjpegStream(CameraView):
@@ -4,8 +4,10 @@ This component provides basic support for Amcrest IP cameras.
 For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/camera.amcrest/
 """
+import asyncio
 import logging

+import aiohttp
 import voluptuous as vol

 import homeassistant.loader as loader
@@ -13,16 +15,20 @@ from homeassistant.components.camera import (Camera, PLATFORM_SCHEMA)
 from homeassistant.const import (
    CONF_HOST, CONF_NAME, CONF_USERNAME, CONF_PASSWORD, CONF_PORT)
 from homeassistant.helpers import config_validation as cv
+from homeassistant.helpers.aiohttp_client import (
+    async_get_clientsession, async_aiohttp_proxy_stream)

-REQUIREMENTS = ['amcrest==1.0.0']
+REQUIREMENTS = ['amcrest==1.1.3']

 _LOGGER = logging.getLogger(__name__)

 CONF_RESOLUTION = 'resolution'
+CONF_STREAM_SOURCE = 'stream_source'

 DEFAULT_NAME = 'Amcrest Camera'
 DEFAULT_PORT = 80
 DEFAULT_RESOLUTION = 'high'
+DEFAULT_STREAM_SOURCE = 'mjpeg'

 NOTIFICATION_ID = 'amcrest_notification'
 NOTIFICATION_TITLE = 'Amcrest Camera Setup'
@@ -32,6 +38,14 @@ RESOLUTION_LIST = {
    'low': 1,
 }

+STREAM_SOURCE_LIST = {
+    'mjpeg': 0,
+    'snapshot': 1
+}
+
+CONTENT_TYPE_HEADER = 'Content-Type'
+TIMEOUT = 5
+
 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
    vol.Required(CONF_HOST): cv.string,
    vol.Required(CONF_USERNAME): cv.string,
@@ -40,19 +54,21 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
        vol.All(vol.In(RESOLUTION_LIST)),
    vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
    vol.Optional(CONF_PORT, default=DEFAULT_PORT): cv.port,
+    vol.Optional(CONF_STREAM_SOURCE, default=DEFAULT_STREAM_SOURCE):
+        vol.All(vol.In(STREAM_SOURCE_LIST)),
 })


 def setup_platform(hass, config, add_devices, discovery_info=None):
    """Set up an Amcrest IP Camera."""
    from amcrest import AmcrestCamera
-    data = AmcrestCamera(
+    camera = AmcrestCamera(
        config.get(CONF_HOST), config.get(CONF_PORT),
-        config.get(CONF_USERNAME), config.get(CONF_PASSWORD))
+        config.get(CONF_USERNAME), config.get(CONF_PASSWORD)).camera

    persistent_notification = loader.get_component('persistent_notification')
    try:
-        data.camera.current_time
+        camera.current_time
    # pylint: disable=broad-except
    except Exception as ex:
        _LOGGER.error("Unable to connect to Amcrest camera: %s", str(ex))
@@ -64,26 +80,53 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
            notification_id=NOTIFICATION_ID)
        return False

-    add_devices([AmcrestCam(config, data)])
+    add_devices([AmcrestCam(hass, config, camera)])
    return True


 class AmcrestCam(Camera):
    """An implementation of an Amcrest IP camera."""

-    def __init__(self, device_info, data):
+    def __init__(self, hass, device_info, camera):
        """Initialize an Amcrest camera."""
        super(AmcrestCam, self).__init__()
-        self._data = data
+        self._camera = camera
+        self._base_url = self._camera.get_base_url()
+        self._hass = hass
        self._name = device_info.get(CONF_NAME)
        self._resolution = RESOLUTION_LIST[device_info.get(CONF_RESOLUTION)]
+        self._stream_source = STREAM_SOURCE_LIST[
+            device_info.get(CONF_STREAM_SOURCE)
+        ]
+        self._token = self._auth = aiohttp.BasicAuth(
+            device_info.get(CONF_USERNAME),
+            password=device_info.get(CONF_PASSWORD)
+        )

    def camera_image(self):
        """Return a still image reponse from the camera."""
        # Send the request to snap a picture and return raw jpg data
-        response = self._data.camera.snapshot(channel=self._resolution)
+        response = self._camera.snapshot(channel=self._resolution)
        return response.data

+    @asyncio.coroutine
+    def handle_async_mjpeg_stream(self, request):
+        """Return an MJPEG stream."""
+        # The snapshot implementation is handled by the parent class
+        if self._stream_source == STREAM_SOURCE_LIST['snapshot']:
+            yield from super().handle_async_mjpeg_stream(request)
+            return
+
+        # Otherwise, stream an MJPEG image stream directly from the camera
+        websession = async_get_clientsession(self.hass)
+        streaming_url = '{0}mjpg/video.cgi?channel=0&subtype={1}'.format(
+            self._base_url, self._resolution)
+
+        stream_coro = websession.get(
+            streaming_url, auth=self._token, timeout=TIMEOUT)
+
+        yield from async_aiohttp_proxy_stream(self.hass, request, stream_coro)
+
    @property
    def name(self):
        """Return the name of this camera."""
@@ -12,10 +12,9 @@ from aiohttp import web

 from homeassistant.components.camera import Camera, PLATFORM_SCHEMA
 from homeassistant.components.ffmpeg import (
-    async_run_test, get_binary, CONF_INPUT, CONF_EXTRA_ARGUMENTS)
+    DATA_FFMPEG, CONF_INPUT, CONF_EXTRA_ARGUMENTS)
 import homeassistant.helpers.config_validation as cv
 from homeassistant.const import CONF_NAME
-from homeassistant.util.async import run_coroutine_threadsafe

 DEPENDENCIES = ['ffmpeg']

@@ -33,7 +32,7 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
@asyncio.coroutine
 def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
    """Setup a FFmpeg Camera."""
-    if not async_run_test(hass, config.get(CONF_INPUT)):
+    if not hass.data[DATA_FFMPEG].async_run_test(config.get(CONF_INPUT)):
        return
    yield from async_add_devices([FFmpegCamera(hass, config)])

@@ -44,20 +43,17 @@ class FFmpegCamera(Camera):
    def __init__(self, hass, config):
        """Initialize a FFmpeg camera."""
        super().__init__()
+
+        self._manager = hass.data[DATA_FFMPEG]
        self._name = config.get(CONF_NAME)
        self._input = config.get(CONF_INPUT)
        self._extra_arguments = config.get(CONF_EXTRA_ARGUMENTS)

-    def camera_image(self):
-        """Return bytes of camera image."""
-        return run_coroutine_threadsafe(
-            self.async_camera_image(), self.hass.loop).result()
-
    @asyncio.coroutine
    def async_camera_image(self):
        """Return a still image response from the camera."""
-        from haffmpeg import ImageSingleAsync, IMAGE_JPEG
-        ffmpeg = ImageSingleAsync(get_binary(), loop=self.hass.loop)
+        from haffmpeg import ImageFrame, IMAGE_JPEG
+        ffmpeg = ImageFrame(self._manager.binary, loop=self.hass.loop)

        image = yield from ffmpeg.get_image(
            self._input, output_format=IMAGE_JPEG,
@@ -67,9 +63,9 @@ class FFmpegCamera(Camera):
    @asyncio.coroutine
    def handle_async_mjpeg_stream(self, request):
        """Generate an HTTP MJPEG stream from the camera."""
-        from haffmpeg import CameraMjpegAsync
+        from haffmpeg import CameraMjpeg

-        stream = CameraMjpegAsync(get_binary(), loop=self.hass.loop)
+        stream = CameraMjpeg(self._manager.binary, loop=self.hass.loop)
        yield from stream.open_camera(
            self._input, extra_cmd=self._extra_arguments)

@@ -84,9 +80,15 @@ class FFmpegCamera(Camera):
                if not data:
                    break
                response.write(data)
+
+        except asyncio.CancelledError:
+            _LOGGER.debug("Close stream by frontend.")
+            response = None
+
        finally:
-            self.hass.async_add_job(stream.close())
-            yield from response.write_eof()
+            yield from stream.close()
+            if response is not None:
+                yield from response.write_eof()

    @property
    def name(self):
@@ -9,8 +9,6 @@ import logging
 from contextlib import closing

 import aiohttp
-from aiohttp import web
-from aiohttp.web_exceptions import HTTPGatewayTimeout
 import async_timeout
 import requests
 from requests.auth import HTTPBasicAuth, HTTPDigestAuth
@@ -20,18 +18,21 @@ from homeassistant.const import (
    CONF_NAME, CONF_USERNAME, CONF_PASSWORD, CONF_AUTHENTICATION,
    HTTP_BASIC_AUTHENTICATION, HTTP_DIGEST_AUTHENTICATION)
 from homeassistant.components.camera import (PLATFORM_SCHEMA, Camera)
-from homeassistant.helpers.aiohttp_client import async_get_clientsession
+from homeassistant.helpers.aiohttp_client import (
+    async_get_clientsession, async_aiohttp_proxy_stream)
 from homeassistant.helpers import config_validation as cv

 _LOGGER = logging.getLogger(__name__)

 CONF_MJPEG_URL = 'mjpeg_url'
+CONF_STILL_IMAGE_URL = 'still_image_url'
 CONTENT_TYPE_HEADER = 'Content-Type'

 DEFAULT_NAME = 'Mjpeg Camera'

 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
    vol.Required(CONF_MJPEG_URL): cv.url,
+    vol.Optional(CONF_STILL_IMAGE_URL): cv.url,
    vol.Optional(CONF_AUTHENTICATION, default=HTTP_BASIC_AUTHENTICATION):
        vol.In([HTTP_BASIC_AUTHENTICATION, HTTP_DIGEST_AUTHENTICATION]),
    vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
@@ -70,6 +71,7 @@ class MjpegCamera(Camera):
        self._username = device_info.get(CONF_USERNAME)
        self._password = device_info.get(CONF_PASSWORD)
        self._mjpeg_url = device_info[CONF_MJPEG_URL]
+        self._still_image_url = device_info.get(CONF_STILL_IMAGE_URL)

        self._auth = None
        if self._username and self._password:
@@ -78,6 +80,37 @@ class MjpegCamera(Camera):
                    self._username, password=self._password
                )

+    @asyncio.coroutine
+    def async_camera_image(self):
+        """Return a still image response from the camera."""
+        # DigestAuth is not supported
+        if self._authentication == HTTP_DIGEST_AUTHENTICATION or \
+           self._still_image_url is None:
+            image = yield from self.hass.loop.run_in_executor(
+                None, self.camera_image)
+            return image
+
+        websession = async_get_clientsession(self.hass)
+        response = None
+        try:
+            with async_timeout.timeout(10, loop=self.hass.loop):
+                response = yield from websession.get(
+                    self._still_image_url, auth=self._auth)
+
+                image = yield from response.read()
+                return image
+
+        except asyncio.TimeoutError:
+            _LOGGER.error('Timeout getting camera image')
+
+        except (aiohttp.errors.ClientError,
+                aiohttp.errors.ClientDisconnectedError) as err:
+            _LOGGER.error('Error getting new camera image: %s', err)
+
+        finally:
+            if response is not None:
+                yield from response.release()
+
    def camera_image(self):
        """Return a still image response from the camera."""
        if self._username and self._password:
@@ -103,32 +136,9 @@ class MjpegCamera(Camera):

        # connect to stream
        websession = async_get_clientsession(self.hass)
-        stream = None
-        response = None
-        try:
-            with async_timeout.timeout(10, loop=self.hass.loop):
-                stream = yield from websession.get(self._mjpeg_url,
-                                                   auth=self._auth)
+        stream_coro = websession.get(self._mjpeg_url, auth=self._auth)

-            response = web.StreamResponse()
-            response.content_type = stream.headers.get(CONTENT_TYPE_HEADER)
-
-            yield from response.prepare(request)
-
-            while True:
-                data = yield from stream.content.read(102400)
-                if not data:
-                    break
-                response.write(data)
-
-        except asyncio.TimeoutError:
-            raise HTTPGatewayTimeout()
-
-        finally:
-            if stream is not None:
-                self.hass.async_add_job(stream.release())
-            if response is not None:
-                yield from response.write_eof()
+        yield from async_aiohttp_proxy_stream(self.hass, request, stream_coro)

    @property
    def name(self):
@@ -27,7 +27,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
    if discovery_info is None:
        return

-    camera_devices = hass.data[nest.DATA_NEST].camera_devices()
+    camera_devices = hass.data[nest.DATA_NEST].cameras()
    cameras = [NestCamera(structure, device)
               for structure, device in camera_devices]
    add_devices(cameras, True)
@@ -43,7 +43,7 @@ class NestCamera(Camera):
        self.device = device
        self._location = None
        self._name = None
-        self._is_online = None
+        self._online = None
        self._is_streaming = None
        self._is_video_history_enabled = False
        # Default to non-NestAware subscribed, but will be fixed during update
@@ -76,7 +76,7 @@ class NestCamera(Camera):
        """Cache value from Python-nest."""
        self._location = self.device.where
        self._name = self.device.name
-        self._is_online = self.device.is_online
+        self._online = self.device.online
        self._is_streaming = self.device.is_streaming
        self._is_video_history_enabled = self.device.is_video_history_enabled

@@ -1,15 +1,15 @@
 """
-Support for the Netatmo Welcome camera.
+Support for the Netatmo cameras.

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

 import requests
 import voluptuous as vol

-from homeassistant.components.netatmo import WelcomeData
+from homeassistant.components.netatmo import CameraData
 from homeassistant.components.camera import (Camera, PLATFORM_SCHEMA)
 from homeassistant.loader import get_component
 from homeassistant.helpers import config_validation as cv
@@ -30,41 +30,43 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({

 # pylint: disable=unused-argument
 def setup_platform(hass, config, add_devices, discovery_info=None):
-    """Setup access to Netatmo Welcome cameras."""
+    """Setup access to Netatmo cameras."""
    netatmo = get_component('netatmo')
    home = config.get(CONF_HOME)
    import lnetatmo
    try:
-        data = WelcomeData(netatmo.NETATMO_AUTH, home)
+        data = CameraData(netatmo.NETATMO_AUTH, home)
        for camera_name in data.get_camera_names():
+            camera_type = data.get_camera_type(camera=camera_name, home=home)
            if CONF_CAMERAS in config:
                if config[CONF_CAMERAS] != [] and \
                   camera_name not in config[CONF_CAMERAS]:
                    continue
-            add_devices([WelcomeCamera(data, camera_name, home)])
+            add_devices([NetatmoCamera(data, camera_name, home, camera_type)])
    except lnetatmo.NoDevice:
        return None


-class WelcomeCamera(Camera):
-    """Representation of the images published from Welcome camera."""
+class NetatmoCamera(Camera):
+    """Representation of the images published from a Netatmo camera."""

-    def __init__(self, data, camera_name, home):
+    def __init__(self, data, camera_name, home, camera_type):
        """Setup for access to the Netatmo camera images."""
-        super(WelcomeCamera, self).__init__()
+        super(NetatmoCamera, self).__init__()
        self._data = data
        self._camera_name = camera_name
        if home:
            self._name = home + ' / ' + camera_name
        else:
            self._name = camera_name
-        camera_id = data.welcomedata.cameraByName(camera=camera_name,
+        camera_id = data.camera_data.cameraByName(camera=camera_name,
                                                  home=home)['id']
        self._unique_id = "Welcome_camera {0} - {1}".format(self._name,
                                                            camera_id)
-        self._vpnurl, self._localurl = self._data.welcomedata.cameraUrls(
+        self._vpnurl, self._localurl = self._data.camera_data.cameraUrls(
            camera=camera_name
            )
+        self._cameratype = camera_type

    def camera_image(self):
        """Return a still image response from the camera."""
@@ -79,15 +81,30 @@ class WelcomeCamera(Camera):
            _LOGGER.error('Welcome VPN url changed: %s', error)
            self._data.update()
            (self._vpnurl, self._localurl) = \
-                self._data.welcomedata.cameraUrls(camera=self._camera_name)
+                self._data.camera_data.cameraUrls(camera=self._camera_name)
            return None
        return response.content

    @property
    def name(self):
-        """Return the name of this Netatmo Welcome device."""
+        """Return the name of this Netatmo camera device."""
        return self._name

+    @property
+    def brand(self):
+        """Camera brand."""
+        return "Netatmo"
+
+    @property
+    def model(self):
+        """Camera model."""
+        if self._cameratype == "NOC":
+            return "Presence"
+        elif self._cameratype == "NACamera":
+            return "Welcome"
+        else:
+            return None
+
    @property
    def unique_id(self):
        """Return the unique ID for this sensor."""
@@ -10,8 +10,6 @@ import logging
 import voluptuous as vol

 import aiohttp
-from aiohttp import web
-from aiohttp.web_exceptions import HTTPGatewayTimeout
 import async_timeout

 from homeassistant.const import (
@@ -20,7 +18,8 @@ from homeassistant.const import (
 from homeassistant.components.camera import (
    Camera, PLATFORM_SCHEMA)
 from homeassistant.helpers.aiohttp_client import (
-    async_get_clientsession, async_create_clientsession)
+    async_get_clientsession, async_create_clientsession,
+    async_aiohttp_proxy_stream)
 import homeassistant.helpers.config_validation as cv
 from homeassistant.util.async import run_coroutine_threadsafe

@@ -253,34 +252,10 @@ class SynologyCamera(Camera):
            'cameraId': self._camera_id,
            'format': 'mjpeg'
        }
-        stream = None
-        response = None
-        try:
-            with async_timeout.timeout(TIMEOUT, loop=self.hass.loop):
-                stream = yield from self._websession.get(
-                    streaming_url,
-                    params=streaming_payload
-                )
-            response = web.StreamResponse()
-            response.content_type = stream.headers.get(CONTENT_TYPE_HEADER)
+        stream_coro = self._websession.get(
+            streaming_url, params=streaming_payload)

-            yield from response.prepare(request)
-
-            while True:
-                data = yield from stream.content.read(102400)
-                if not data:
-                    break
-                response.write(data)
-
-        except (asyncio.TimeoutError, aiohttp.errors.ClientError):
-            _LOGGER.exception("Error on %s", streaming_url)
-            raise HTTPGatewayTimeout()
-
-        finally:
-            if stream is not None:
-                self.hass.async_add_job(stream.release())
-            if response is not None:
-                yield from response.write_eof()
+        yield from async_aiohttp_proxy_stream(self.hass, request, stream_coro)

    @property
    def name(self):
@@ -14,7 +14,7 @@ from homeassistant.const import CONF_PORT
 from homeassistant.components.camera import Camera, PLATFORM_SCHEMA
 import homeassistant.helpers.config_validation as cv

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

 _LOGGER = logging.getLogger(__name__)

@@ -4,15 +4,18 @@ Provides functionality to interact with climate devices.
 For more details about this component, please refer to the documentation at
 https://home-assistant.io/components/climate/
 """
+import asyncio
+from datetime import timedelta
 import logging
 import os
+import functools as ft
 from numbers import Number
-import voluptuous as vol

-from homeassistant.helpers.entity_component import EntityComponent
+import voluptuous as vol

 from homeassistant.config import load_yaml_config_file
 from homeassistant.util.temperature import convert as convert_temperature
+from homeassistant.helpers.entity_component import EntityComponent
 from homeassistant.helpers.entity import Entity
 from homeassistant.helpers.config_validation import PLATFORM_SCHEMA  # noqa
 import homeassistant.helpers.config_validation as cv
@@ -23,12 +26,13 @@ from homeassistant.const import (
 DOMAIN = "climate"

 ENTITY_ID_FORMAT = DOMAIN + ".{}"
-SCAN_INTERVAL = 60
+SCAN_INTERVAL = timedelta(seconds=60)

 SERVICE_SET_AWAY_MODE = "set_away_mode"
 SERVICE_SET_AUX_HEAT = "set_aux_heat"
 SERVICE_SET_TEMPERATURE = "set_temperature"
 SERVICE_SET_FAN_MODE = "set_fan_mode"
+SERVICE_SET_HOLD_MODE = "set_hold_mode"
 SERVICE_SET_OPERATION_MODE = "set_operation_mode"
 SERVICE_SET_SWING_MODE = "set_swing_mode"
 SERVICE_SET_HUMIDITY = "set_humidity"
@@ -53,6 +57,7 @@ ATTR_CURRENT_HUMIDITY = "current_humidity"
 ATTR_HUMIDITY = "humidity"
 ATTR_MAX_HUMIDITY = "max_humidity"
 ATTR_MIN_HUMIDITY = "min_humidity"
+ATTR_HOLD_MODE = "hold_mode"
 ATTR_OPERATION_MODE = "operation_mode"
 ATTR_OPERATION_LIST = "operation_list"
 ATTR_SWING_MODE = "swing_mode"
@@ -90,6 +95,10 @@ SET_FAN_MODE_SCHEMA = vol.Schema({
    vol.Optional(ATTR_ENTITY_ID): cv.entity_ids,
    vol.Required(ATTR_FAN_MODE): cv.string,
 })
+SET_HOLD_MODE_SCHEMA = vol.Schema({
+    vol.Optional(ATTR_ENTITY_ID): cv.entity_ids,
+    vol.Required(ATTR_HOLD_MODE): cv.string,
+})
 SET_OPERATION_MODE_SCHEMA = vol.Schema({
    vol.Optional(ATTR_ENTITY_ID): cv.entity_ids,
    vol.Required(ATTR_OPERATION_MODE): cv.string,
@@ -113,9 +122,23 @@ def set_away_mode(hass, away_mode, entity_id=None):
    if entity_id:
        data[ATTR_ENTITY_ID] = entity_id

+    _LOGGER.warning(
+        'This service has been deprecated; use climate.set_hold_mode')
    hass.services.call(DOMAIN, SERVICE_SET_AWAY_MODE, data)


+def set_hold_mode(hass, hold_mode, entity_id=None):
+    """Set new hold mode."""
+    data = {
+        ATTR_HOLD_MODE: hold_mode
+    }
+
+    if entity_id:
+        data[ATTR_ENTITY_ID] = entity_id
+
+    hass.services.call(DOMAIN, SERVICE_SET_HOLD_MODE, data)
+
+
 def set_aux_heat(hass, aux_heat, entity_id=None):
    """Turn all or specified climate devices auxillary heater on."""
    data = {
@@ -185,17 +208,38 @@ def set_swing_mode(hass, swing_mode, entity_id=None):
    hass.services.call(DOMAIN, SERVICE_SET_SWING_MODE, data)


-def setup(hass, config):
+@asyncio.coroutine
+def async_setup(hass, config):
    """Setup climate devices."""
    component = EntityComponent(_LOGGER, DOMAIN, hass, SCAN_INTERVAL)
-    component.setup(config)
+    yield from component.async_setup(config)

-    descriptions = load_yaml_config_file(
+    descriptions = yield from hass.loop.run_in_executor(
+        None, load_yaml_config_file,
        os.path.join(os.path.dirname(__file__), 'services.yaml'))

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

        away_mode = service.data.get(ATTR_AWAY_MODE)

@@ -205,23 +249,42 @@ def setup(hass, config):
                SERVICE_SET_AWAY_MODE, ATTR_AWAY_MODE)
            return

+        _LOGGER.warning(
+            'This service has been deprecated; use climate.set_hold_mode')
        for climate in target_climate:
            if away_mode:
-                climate.turn_away_mode_on()
+                yield from climate.async_turn_away_mode_on()
            else:
-                climate.turn_away_mode_off()
+                yield from climate.async_turn_away_mode_off()

-            if climate.should_poll:
-                climate.update_ha_state(True)
+        yield from _async_update_climate(target_climate)

-    hass.services.register(
-        DOMAIN, SERVICE_SET_AWAY_MODE, away_mode_set_service,
+    hass.services.async_register(
+        DOMAIN, SERVICE_SET_AWAY_MODE, async_away_mode_set_service,
        descriptions.get(SERVICE_SET_AWAY_MODE),
        schema=SET_AWAY_MODE_SCHEMA)

-    def aux_heat_set_service(service):
+    @asyncio.coroutine
+    def async_hold_mode_set_service(service):
+        """Set hold mode on target climate devices."""
+        target_climate = component.async_extract_from_service(service)
+
+        hold_mode = service.data.get(ATTR_HOLD_MODE)
+
+        for climate in target_climate:
+            yield from climate.async_set_hold_mode(hold_mode)
+
+        yield from _async_update_climate(target_climate)
+
+    hass.services.async_register(
+        DOMAIN, SERVICE_SET_HOLD_MODE, async_hold_mode_set_service,
+        descriptions.get(SERVICE_SET_HOLD_MODE),
+        schema=SET_HOLD_MODE_SCHEMA)
+
+    @asyncio.coroutine
+    def async_aux_heat_set_service(service):
        """Set auxillary heater on target climate devices."""
-        target_climate = component.extract_from_service(service)
+        target_climate = component.async_extract_from_service(service)

        aux_heat = service.data.get(ATTR_AUX_HEAT)

@@ -233,21 +296,21 @@ def setup(hass, config):

        for climate in target_climate:
            if aux_heat:
-                climate.turn_aux_heat_on()
+                yield from climate.async_turn_aux_heat_on()
            else:
-                climate.turn_aux_heat_off()
+                yield from climate.async_turn_aux_heat_off()

-            if climate.should_poll:
-                climate.update_ha_state(True)
+        yield from _async_update_climate(target_climate)

-    hass.services.register(
-        DOMAIN, SERVICE_SET_AUX_HEAT, aux_heat_set_service,
+    hass.services.async_register(
+        DOMAIN, SERVICE_SET_AUX_HEAT, async_aux_heat_set_service,
        descriptions.get(SERVICE_SET_AUX_HEAT),
        schema=SET_AUX_HEAT_SCHEMA)

-    def temperature_set_service(service):
+    @asyncio.coroutine
+    def async_temperature_set_service(service):
        """Set temperature on the target climate devices."""
-        target_climate = component.extract_from_service(service)
+        target_climate = component.async_extract_from_service(service)

        for climate in target_climate:
            kwargs = {}
@@ -261,18 +324,19 @@ def setup(hass, config):
                else:
                    kwargs[value] = temp

-            climate.set_temperature(**kwargs)
-            if climate.should_poll:
-                climate.update_ha_state(True)
+            yield from climate.async_set_temperature(**kwargs)

-    hass.services.register(
-        DOMAIN, SERVICE_SET_TEMPERATURE, temperature_set_service,
+        yield from _async_update_climate(target_climate)
+
+    hass.services.async_register(
+        DOMAIN, SERVICE_SET_TEMPERATURE, async_temperature_set_service,
        descriptions.get(SERVICE_SET_TEMPERATURE),
        schema=SET_TEMPERATURE_SCHEMA)

-    def humidity_set_service(service):
+    @asyncio.coroutine
+    def async_humidity_set_service(service):
        """Set humidity on the target climate devices."""
-        target_climate = component.extract_from_service(service)
+        target_climate = component.async_extract_from_service(service)

        humidity = service.data.get(ATTR_HUMIDITY)

@@ -283,19 +347,19 @@ def setup(hass, config):
            return

        for climate in target_climate:
-            climate.set_humidity(humidity)
+            yield from climate.async_set_humidity(humidity)

-            if climate.should_poll:
-                climate.update_ha_state(True)
+        yield from _async_update_climate(target_climate)

-    hass.services.register(
-        DOMAIN, SERVICE_SET_HUMIDITY, humidity_set_service,
+    hass.services.async_register(
+        DOMAIN, SERVICE_SET_HUMIDITY, async_humidity_set_service,
        descriptions.get(SERVICE_SET_HUMIDITY),
        schema=SET_HUMIDITY_SCHEMA)

-    def fan_mode_set_service(service):
+    @asyncio.coroutine
+    def async_fan_mode_set_service(service):
        """Set fan mode on target climate devices."""
-        target_climate = component.extract_from_service(service)
+        target_climate = component.async_extract_from_service(service)

        fan = service.data.get(ATTR_FAN_MODE)

@@ -306,19 +370,19 @@ def setup(hass, config):
            return

        for climate in target_climate:
-            climate.set_fan_mode(fan)
+            yield from climate.async_set_fan_mode(fan)

-            if climate.should_poll:
-                climate.update_ha_state(True)
+        yield from _async_update_climate(target_climate)

-    hass.services.register(
-        DOMAIN, SERVICE_SET_FAN_MODE, fan_mode_set_service,
+    hass.services.async_register(
+        DOMAIN, SERVICE_SET_FAN_MODE, async_fan_mode_set_service,
        descriptions.get(SERVICE_SET_FAN_MODE),
        schema=SET_FAN_MODE_SCHEMA)

-    def operation_set_service(service):
+    @asyncio.coroutine
+    def async_operation_set_service(service):
        """Set operating mode on the target climate devices."""
-        target_climate = component.extract_from_service(service)
+        target_climate = component.async_extract_from_service(service)

        operation_mode = service.data.get(ATTR_OPERATION_MODE)

@@ -329,19 +393,19 @@ def setup(hass, config):
            return

        for climate in target_climate:
-            climate.set_operation_mode(operation_mode)
+            yield from climate.async_set_operation_mode(operation_mode)

-            if climate.should_poll:
-                climate.update_ha_state(True)
+        yield from _async_update_climate(target_climate)

-    hass.services.register(
-        DOMAIN, SERVICE_SET_OPERATION_MODE, operation_set_service,
+    hass.services.async_register(
+        DOMAIN, SERVICE_SET_OPERATION_MODE, async_operation_set_service,
        descriptions.get(SERVICE_SET_OPERATION_MODE),
        schema=SET_OPERATION_MODE_SCHEMA)

-    def swing_set_service(service):
+    @asyncio.coroutine
+    def async_swing_set_service(service):
        """Set swing mode on the target climate devices."""
-        target_climate = component.extract_from_service(service)
+        target_climate = component.async_extract_from_service(service)

        swing_mode = service.data.get(ATTR_SWING_MODE)

@@ -352,15 +416,15 @@ def setup(hass, config):
            return

        for climate in target_climate:
-            climate.set_swing_mode(swing_mode)
+            yield from climate.async_set_swing_mode(swing_mode)

-            if climate.should_poll:
-                climate.update_ha_state(True)
+        yield from _async_update_climate(target_climate)

-    hass.services.register(
-        DOMAIN, SERVICE_SET_SWING_MODE, swing_set_service,
+    hass.services.async_register(
+        DOMAIN, SERVICE_SET_SWING_MODE, async_swing_set_service,
        descriptions.get(SERVICE_SET_SWING_MODE),
        schema=SET_SWING_MODE_SCHEMA)
+
    return True


@@ -421,6 +485,10 @@ class ClimateDevice(Entity):
            if self.operation_list:
                data[ATTR_OPERATION_LIST] = self.operation_list

+        is_hold = self.current_hold_mode
+        if is_hold is not None:
+            data[ATTR_HOLD_MODE] = is_hold
+
        swing_mode = self.current_swing_mode
        if swing_mode is not None:
            data[ATTR_SWING_MODE] = swing_mode
@@ -492,6 +560,11 @@ class ClimateDevice(Entity):
        """Return true if away mode is on."""
        return None

+    @property
+    def current_hold_mode(self):
+        """Return the current hold mode, e.g., home, away, temp."""
+        return None
+
    @property
    def is_aux_heat_on(self):
        """Return true if aux heater."""
@@ -521,38 +594,122 @@ class ClimateDevice(Entity):
        """Set new target temperature."""
        raise NotImplementedError()

+    def async_set_temperature(self, **kwargs):
+        """Set new target temperature.
+
+        This method must be run in the event loop and returns a coroutine.
+        """
+        return self.hass.loop.run_in_executor(
+            None, ft.partial(self.set_temperature, **kwargs))
+
    def set_humidity(self, humidity):
        """Set new target humidity."""
        raise NotImplementedError()

+    def async_set_humidity(self, humidity):
+        """Set new target humidity.
+
+        This method must be run in the event loop and returns a coroutine.
+        """
+        return self.hass.loop.run_in_executor(
+            None, self.set_humidity, humidity)
+
    def set_fan_mode(self, fan):
        """Set new target fan mode."""
        raise NotImplementedError()

+    def async_set_fan_mode(self, fan):
+        """Set new target fan mode.
+
+        This method must be run in the event loop and returns a coroutine.
+        """
+        return self.hass.loop.run_in_executor(
+            None, self.set_fan_mode, fan)
+
    def set_operation_mode(self, operation_mode):
        """Set new target operation mode."""
        raise NotImplementedError()

+    def async_set_operation_mode(self, operation_mode):
+        """Set new target operation mode.
+
+        This method must be run in the event loop and returns a coroutine.
+        """
+        return self.hass.loop.run_in_executor(
+            None, self.set_operation_mode, operation_mode)
+
    def set_swing_mode(self, swing_mode):
        """Set new target swing operation."""
        raise NotImplementedError()

+    def async_set_swing_mode(self, swing_mode):
+        """Set new target swing operation.
+
+        This method must be run in the event loop and returns a coroutine.
+        """
+        return self.hass.loop.run_in_executor(
+            None, self.set_swing_mode, swing_mode)
+
    def turn_away_mode_on(self):
        """Turn away mode on."""
        raise NotImplementedError()

+    def async_turn_away_mode_on(self):
+        """Turn away mode on.
+
+        This method must be run in the event loop and returns a coroutine.
+        """
+        return self.hass.loop.run_in_executor(
+            None, self.turn_away_mode_on)
+
    def turn_away_mode_off(self):
        """Turn away mode off."""
        raise NotImplementedError()

+    def async_turn_away_mode_off(self):
+        """Turn away mode off.
+
+        This method must be run in the event loop and returns a coroutine.
+        """
+        return self.hass.loop.run_in_executor(
+            None, self.turn_away_mode_off)
+
+    def set_hold_mode(self, hold_mode):
+        """Set new target hold mode."""
+        raise NotImplementedError()
+
+    def async_set_hold_mode(self, hold_mode):
+        """Set new target hold mode.
+
+        This method must be run in the event loop and returns a coroutine.
+        """
+        return self.hass.loop.run_in_executor(
+            None, self.set_hold_mode, hold_mode)
+
    def turn_aux_heat_on(self):
        """Turn auxillary heater on."""
        raise NotImplementedError()

+    def async_turn_aux_heat_on(self):
+        """Turn auxillary heater on.
+
+        This method must be run in the event loop and returns a coroutine.
+        """
+        return self.hass.loop.run_in_executor(
+            None, self.turn_aux_heat_on)
+
    def turn_aux_heat_off(self):
        """Turn auxillary heater off."""
        raise NotImplementedError()

+    def async_turn_aux_heat_off(self):
+        """Turn auxillary heater off.
+
+        This method must be run in the event loop and returns a coroutine.
+        """
+        return self.hass.loop.run_in_executor(
+            None, self.turn_aux_heat_off)
+
    @property
    def min_temp(self):
        """Return the minimum temperature."""
@@ -12,11 +12,11 @@ from homeassistant.const import TEMP_CELSIUS, TEMP_FAHRENHEIT, ATTR_TEMPERATURE
 def setup_platform(hass, config, add_devices, discovery_info=None):
    """Setup the Demo climate devices."""
    add_devices([
-        DemoClimate("HeatPump", 68, TEMP_FAHRENHEIT, None, 77, "Auto Low",
-                    None, None, "Auto", "heat", None, None, None),
-        DemoClimate("Hvac", 21, TEMP_CELSIUS, True, 22, "On High",
+        DemoClimate("HeatPump", 68, TEMP_FAHRENHEIT, None, None, 77,
+                    "Auto Low", None, None, "Auto", "heat", None, None, None),
+        DemoClimate("Hvac", 21, TEMP_CELSIUS, True, None, 22, "On High",
                    67, 54, "Off", "cool", False, None, None),
-        DemoClimate("Ecobee", None, TEMP_CELSIUS, None, 23, "Auto Low",
+        DemoClimate("Ecobee", None, TEMP_CELSIUS, None, None, 23, "Auto Low",
                    None, None, "Auto", "auto", None, 24, 21)
    ])

@@ -25,7 +25,7 @@ class DemoClimate(ClimateDevice):
    """Representation of a demo climate device."""

    def __init__(self, name, target_temperature, unit_of_measurement,
-                 away, current_temperature, current_fan_mode,
+                 away, hold, current_temperature, current_fan_mode,
                 target_humidity, current_humidity, current_swing_mode,
                 current_operation, aux, target_temp_high, target_temp_low):
        """Initialize the climate device."""
@@ -34,6 +34,7 @@ class DemoClimate(ClimateDevice):
        self._target_humidity = target_humidity
        self._unit_of_measurement = unit_of_measurement
        self._away = away
+        self._hold = hold
        self._current_temperature = current_temperature
        self._current_humidity = current_humidity
        self._current_fan_mode = current_fan_mode
@@ -106,6 +107,11 @@ class DemoClimate(ClimateDevice):
        """Return if away mode is on."""
        return self._away

+    @property
+    def current_hold_mode(self):
+        """Return hold mode setting."""
+        return self._hold
+
    @property
    def is_aux_heat_on(self):
        """Return true if away mode is on."""
@@ -171,6 +177,11 @@ class DemoClimate(ClimateDevice):
        self._away = False
        self.update_ha_state()

+    def set_hold_mode(self, hold):
+        """Update hold mode on."""
+        self._hold = hold
+        self.update_ha_state()
+
    def turn_aux_heat_on(self):
        """Turn away auxillary heater on."""
        self._aux = True
@@ -11,10 +11,10 @@ import voluptuous as vol

 from homeassistant.components import ecobee
 from homeassistant.components.climate import (
-    DOMAIN, STATE_COOL, STATE_HEAT, STATE_IDLE, ClimateDevice,
+    DOMAIN, STATE_COOL, STATE_HEAT, STATE_AUTO, STATE_IDLE, ClimateDevice,
    ATTR_TARGET_TEMP_LOW, ATTR_TARGET_TEMP_HIGH)
 from homeassistant.const import (
-    ATTR_ENTITY_ID, STATE_OFF, STATE_ON, TEMP_FAHRENHEIT)
+    ATTR_ENTITY_ID, STATE_OFF, STATE_ON, ATTR_TEMPERATURE, TEMP_FAHRENHEIT)
 from homeassistant.config import load_yaml_config_file
 import homeassistant.helpers.config_validation as cv

@@ -22,16 +22,25 @@ _CONFIGURING = {}
 _LOGGER = logging.getLogger(__name__)

 ATTR_FAN_MIN_ON_TIME = 'fan_min_on_time'
+ATTR_RESUME_ALL = 'resume_all'
+
+DEFAULT_RESUME_ALL = False

 DEPENDENCIES = ['ecobee']

 SERVICE_SET_FAN_MIN_ON_TIME = 'ecobee_set_fan_min_on_time'
+SERVICE_RESUME_PROGRAM = 'ecobee_resume_program'

 SET_FAN_MIN_ON_TIME_SCHEMA = vol.Schema({
    vol.Optional(ATTR_ENTITY_ID): cv.entity_ids,
    vol.Required(ATTR_FAN_MIN_ON_TIME): vol.Coerce(int),
 })

+RESUME_PROGRAM_SCHEMA = vol.Schema({
+    vol.Optional(ATTR_ENTITY_ID): cv.entity_ids,
+    vol.Optional(ATTR_RESUME_ALL, default=DEFAULT_RESUME_ALL): cv.boolean,
+})
+

 def setup_platform(hass, config, add_devices, discovery_info=None):
    """Setup the Ecobee Thermostat Platform."""
@@ -48,21 +57,36 @@ def setup_platform(hass, config, add_devices, discovery_info=None):

    def fan_min_on_time_set_service(service):
        """Set the minimum fan on time on the target thermostats."""
-        entity_id = service.data.get('entity_id')
+        entity_id = service.data.get(ATTR_ENTITY_ID)
+        fan_min_on_time = service.data[ATTR_FAN_MIN_ON_TIME]

        if entity_id:
            target_thermostats = [device for device in devices
-                                  if device.entity_id == entity_id]
+                                  if device.entity_id in entity_id]
        else:
            target_thermostats = devices

-        fan_min_on_time = service.data[ATTR_FAN_MIN_ON_TIME]
-
        for thermostat in target_thermostats:
            thermostat.set_fan_min_on_time(str(fan_min_on_time))

            thermostat.update_ha_state(True)

+    def resume_program_set_service(service):
+        """Resume the program on the target thermostats."""
+        entity_id = service.data.get(ATTR_ENTITY_ID)
+        resume_all = service.data.get(ATTR_RESUME_ALL)
+
+        if entity_id:
+            target_thermostats = [device for device in devices
+                                  if device.entity_id in entity_id]
+        else:
+            target_thermostats = devices
+
+        for thermostat in target_thermostats:
+            thermostat.resume_program(resume_all)
+
+            thermostat.update_ha_state(True)
+
    descriptions = load_yaml_config_file(
        path.join(path.dirname(__file__), 'services.yaml'))

@@ -71,6 +95,11 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
        descriptions.get(SERVICE_SET_FAN_MIN_ON_TIME),
        schema=SET_FAN_MIN_ON_TIME_SCHEMA)

+    hass.services.register(
+        DOMAIN, SERVICE_RESUME_PROGRAM, resume_program_set_service,
+        descriptions.get(SERVICE_RESUME_PROGRAM),
+        schema=RESUME_PROGRAM_SCHEMA)
+

 class Thermostat(ClimateDevice):
    """A thermostat class for Ecobee."""
@@ -116,12 +145,30 @@ class Thermostat(ClimateDevice):
    @property
    def target_temperature_low(self):
        """Return the lower bound temperature we try to reach."""
-        return int(self.thermostat['runtime']['desiredHeat'] / 10)
+        if self.current_operation == STATE_AUTO:
+            return int(self.thermostat['runtime']['desiredHeat'] / 10)
+        else:
+            return None

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

    @property
    def desired_fan_mode(self):
@@ -136,6 +183,19 @@ class Thermostat(ClimateDevice):
        else:
            return STATE_OFF

+    @property
+    def current_hold_mode(self):
+        """Return current hold mode."""
+        if self.is_away_mode_on:
+            hold = 'away'
+        elif self.is_home_mode_on:
+            hold = 'home'
+        elif self.is_temp_hold_on():
+            hold = 'temp'
+        else:
+            hold = None
+        return hold
+
    @property
    def current_operation(self):
        """Return current operation."""
@@ -189,54 +249,110 @@ class Thermostat(ClimateDevice):
            "fan_min_on_time": self.fan_min_on_time
        }

+    def is_vacation_on(self):
+        """Return true if vacation mode is on."""
+        events = self.thermostat['events']
+        return any(event['type'] == 'vacation' and event['running']
+                   for event in events)
+
+    def is_temp_hold_on(self):
+        """Return true if temperature hold is on."""
+        events = self.thermostat['events']
+        return any(event['type'] == 'hold' and event['running']
+                   for event in events)
+
    @property
    def is_away_mode_on(self):
        """Return true if away mode is on."""
-        mode = self.mode
        events = self.thermostat['events']
-        for event in events:
-            if event['holdClimateRef'] == 'away' or \
-               event['type'] == 'autoAway':
-                mode = "away"
-                break
-        return 'away' in mode
+        return any(event['holdClimateRef'] == 'away' or
+                   event['type'] == 'autoAway'
+                   for event in events)

    def turn_away_mode_on(self):
        """Turn away on."""
-        if self.hold_temp:
-            self.data.ecobee.set_climate_hold(self.thermostat_index,
-                                              "away", "indefinite")
-        else:
-            self.data.ecobee.set_climate_hold(self.thermostat_index, "away")
+        self.data.ecobee.set_climate_hold(self.thermostat_index,
+                                          "away", self.hold_preference())
        self.update_without_throttle = True

    def turn_away_mode_off(self):
        """Turn away off."""
-        self.data.ecobee.resume_program(self.thermostat_index)
+        self.set_hold_mode(None)
+
+    @property
+    def is_home_mode_on(self):
+        """Return true if home mode is on."""
+        events = self.thermostat['events']
+        return any(event['holdClimateRef'] == 'home' or
+                   event['type'] == 'autoHome'
+                   for event in events)
+
+    def turn_home_mode_on(self):
+        """Turn home on."""
+        self.data.ecobee.set_climate_hold(self.thermostat_index,
+                                          "home", self.hold_preference())
+        self.update_without_throttle = True
+
+    def set_hold_mode(self, hold_mode):
+        """Set hold mode (away, home, temp)."""
+        hold = self.current_hold_mode
+
+        if hold == hold_mode:
+            return
+        elif hold_mode == 'away':
+            self.turn_away_mode_on()
+        elif hold_mode == 'home':
+            self.turn_home_mode_on()
+        elif hold_mode == 'temp':
+            self.set_temp_hold(int(self.current_temperature))
+        else:
+            self.data.ecobee.resume_program(self.thermostat_index)
+            self.update_without_throttle = True
+
+    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())
+        _LOGGER.debug("Setting ecobee hold_temp to: heat=%s, is=%s, "
+                      "cool=%s, is=%s", heat_temp, isinstance(
+                          heat_temp, (int, float)), cool_temp,
+                      isinstance(cool_temp, (int, float)))
+
+        self.update_without_throttle = True
+
+    def set_temp_hold(self, temp):
+        """Set temperature hold in modes other than auto."""
+        # Set arbitrary range when not in auto mode
+        if self.current_operation == STATE_HEAT:
+            heat_temp = temp
+            cool_temp = temp + 20
+        elif self.current_operation == STATE_COOL:
+            heat_temp = temp - 20
+            cool_temp = temp
+
+        self.data.ecobee.set_hold_temp(self.thermostat_index, cool_temp,
+                                       heat_temp, self.hold_preference())
+        _LOGGER.debug("Setting ecobee hold_temp to: low=%s, is=%s, "
+                      "cool=%s, is=%s", heat_temp, isinstance(
+                          heat_temp, (int, float)), cool_temp,
+                      isinstance(cool_temp, (int, float)))
+
        self.update_without_throttle = True

    def set_temperature(self, **kwargs):
        """Set new target temperature."""
-        if kwargs.get(ATTR_TARGET_TEMP_LOW) is not None and \
-           kwargs.get(ATTR_TARGET_TEMP_HIGH) is not None:
-            high_temp = int(kwargs.get(ATTR_TARGET_TEMP_LOW))
-            low_temp = int(kwargs.get(ATTR_TARGET_TEMP_HIGH))
+        low_temp = kwargs.get(ATTR_TARGET_TEMP_LOW)
+        high_temp = kwargs.get(ATTR_TARGET_TEMP_HIGH)
+        temp = kwargs.get(ATTR_TEMPERATURE)

-        if self.hold_temp:
-            self.data.ecobee.set_hold_temp(self.thermostat_index, low_temp,
-                                           high_temp, "indefinite")
-            _LOGGER.debug("Setting ecobee hold_temp to: low=%s, is=%s, "
-                          "high=%s, is=%s", low_temp, isinstance(
-                              low_temp, (int, float)), high_temp,
-                          isinstance(high_temp, (int, float)))
+        if self.current_operation == STATE_AUTO and low_temp is not None \
+           and high_temp is not None:
+            self.set_auto_temp_hold(int(low_temp), int(high_temp))
+        elif temp is not None:
+            self.set_temp_hold(int(temp))
        else:
-            self.data.ecobee.set_hold_temp(self.thermostat_index, low_temp,
-                                           high_temp)
-            _LOGGER.debug("Setting ecobee temp to: low=%s, is=%s, "
-                          "high=%s, is=%s", low_temp, isinstance(
-                              low_temp, (int, float)), high_temp,
-                          isinstance(high_temp, (int, float)))
-        self.update_without_throttle = True
+            _LOGGER.error(
+                'Missing valid arguments for set_temperature in %s', kwargs)

    def set_operation_mode(self, operation_mode):
        """Set HVAC mode (auto, auxHeatOnly, cool, heat, off)."""
@@ -249,15 +365,25 @@ class Thermostat(ClimateDevice):
                                             fan_min_on_time)
        self.update_without_throttle = True

-    # Home and Sleep mode aren't used in UI yet:
+    def resume_program(self, resume_all):
+        """Resume the thermostat schedule program."""
+        self.data.ecobee.resume_program(self.thermostat_index,
+                                        str(resume_all).lower())
+        self.update_without_throttle = True

-    # def turn_home_mode_on(self):
-    #     """ Turns home mode on. """
-    #     self.data.ecobee.set_climate_hold(self.thermostat_index, "home")
+    def hold_preference(self):
+        """Return user preference setting for hold time."""
+        # Values returned from thermostat are 'useEndTime4hour',
+        # 'useEndTime2hour', 'nextTransition', 'indefinite', 'askMe'
+        default = self.thermostat['settings']['holdAction']
+        if default == 'nextTransition':
+            return default
+        elif default == 'indefinite':
+            return default
+        else:
+            return 'nextTransition'

-    # def turn_home_mode_off(self):
-    #     """ Turns home mode off. """
-    #     self.data.ecobee.resume_program(self.thermostat_index)
+    # Sleep mode isn't used in UI yet:

    # def turn_sleep_mode_on(self):
    #     """ Turns sleep mode on. """
@@ -8,18 +8,28 @@ import logging

 import voluptuous as vol

-from homeassistant.components.climate import ClimateDevice, PLATFORM_SCHEMA
+from homeassistant.components.climate import (
+    ClimateDevice, PLATFORM_SCHEMA, PRECISION_HALVES,
+    STATE_UNKNOWN, STATE_AUTO, STATE_ON, STATE_OFF,
+)
 from homeassistant.const import (
    CONF_MAC, TEMP_CELSIUS, CONF_DEVICES, ATTR_TEMPERATURE)
-from homeassistant.util.temperature import convert
+
 import homeassistant.helpers.config_validation as cv

-REQUIREMENTS = ['bluepy_devices==0.2.0']
+REQUIREMENTS = ['python-eq3bt==0.1.4']

 _LOGGER = logging.getLogger(__name__)

-ATTR_MODE = 'mode'
-ATTR_MODE_READABLE = 'mode_readable'
+STATE_BOOST = "boost"
+STATE_AWAY = "away"
+STATE_MANUAL = "manual"
+
+ATTR_STATE_WINDOW_OPEN = "window_open"
+ATTR_STATE_VALVE = "valve"
+ATTR_STATE_LOCKED = "is_locked"
+ATTR_STATE_LOW_BAT = "low_battery"
+ATTR_STATE_AWAY_END = "away_end"

 DEVICE_SCHEMA = vol.Schema({
    vol.Required(CONF_MAC): cv.string,
@@ -48,10 +58,28 @@ class EQ3BTSmartThermostat(ClimateDevice):

    def __init__(self, _mac, _name):
        """Initialize the thermostat."""
-        from bluepy_devices.devices import eq3btsmart
+        # we want to avoid name clash with this module..
+        import eq3bt as eq3
+
+        self.modes = {None: STATE_UNKNOWN,  # When not yet connected.
+                      eq3.Mode.Unknown: STATE_UNKNOWN,
+                      eq3.Mode.Auto: STATE_AUTO,
+                      # away handled separately, here just for reverse mapping
+                      eq3.Mode.Away: STATE_AWAY,
+                      eq3.Mode.Closed: STATE_OFF,
+                      eq3.Mode.Open: STATE_ON,
+                      eq3.Mode.Manual: STATE_MANUAL,
+                      eq3.Mode.Boost: STATE_BOOST}
+
+        self.reverse_modes = {v: k for k, v in self.modes.items()}

        self._name = _name
-        self._thermostat = eq3btsmart.EQ3BTSmartThermostat(_mac)
+        self._thermostat = eq3.Thermostat(_mac)
+
+    @property
+    def available(self) -> bool:
+        """Return if thermostat is available."""
+        return self.current_operation != STATE_UNKNOWN

    @property
    def name(self):
@@ -63,6 +91,11 @@ class EQ3BTSmartThermostat(ClimateDevice):
        """Return the unit of measurement that is used."""
        return TEMP_CELSIUS

+    @property
+    def precision(self):
+        """Return eq3bt's precision 0.5."""
+        return PRECISION_HALVES
+
    @property
    def current_temperature(self):
        """Can not report temperature, so return target_temperature."""
@@ -81,24 +114,54 @@ class EQ3BTSmartThermostat(ClimateDevice):
        self._thermostat.target_temperature = temperature

    @property
-    def device_state_attributes(self):
-        """Return the device specific state attributes."""
-        return {
-            ATTR_MODE: self._thermostat.mode,
-            ATTR_MODE_READABLE: self._thermostat.mode_readable,
-        }
+    def current_operation(self):
+        """Current mode."""
+        return self.modes[self._thermostat.mode]
+
+    @property
+    def operation_list(self):
+        """List of available operation modes."""
+        return [x for x in self.modes.values()]
+
+    def set_operation_mode(self, operation_mode):
+        """Set operation mode."""
+        self._thermostat.mode = self.reverse_modes[operation_mode]
+
+    def turn_away_mode_off(self):
+        """Away mode off turns to AUTO mode."""
+        self.set_operation_mode(STATE_AUTO)
+
+    def turn_away_mode_on(self):
+        """Set away mode on."""
+        self.set_operation_mode(STATE_AWAY)
+
+    @property
+    def is_away_mode_on(self):
+        """Return if we are away."""
+        return self.current_operation == STATE_AWAY

    @property
    def min_temp(self):
        """Return the minimum temperature."""
-        return convert(self._thermostat.min_temp, TEMP_CELSIUS,
-                       self.unit_of_measurement)
+        return self._thermostat.min_temp

    @property
    def max_temp(self):
        """Return the maximum temperature."""
-        return convert(self._thermostat.max_temp, TEMP_CELSIUS,
-                       self.unit_of_measurement)
+        return self._thermostat.max_temp
+
+    @property
+    def device_state_attributes(self):
+        """Return the device specific state attributes."""
+        dev_specific = {
+            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

    def update(self):
        """Update the data from the thermostat."""
@@ -87,6 +87,7 @@ class GenericThermostat(ClimateDevice):
        self._unit = hass.config.units.temperature_unit

        track_state_change(hass, sensor_entity_id, self._sensor_changed)
+        track_state_change(hass, heater_entity_id, self._switch_changed)

        sensor_state = hass.states.get(sensor_entity_id)
        if sensor_state:
@@ -134,7 +135,7 @@ class GenericThermostat(ClimateDevice):
            return
        self._target_temp = temperature
        self._control_heating()
-        self.update_ha_state()
+        self.schedule_update_ha_state()

    @property
    def min_temp(self):
@@ -165,6 +166,12 @@ class GenericThermostat(ClimateDevice):
        self._control_heating()
        self.schedule_update_ha_state()

+    def _switch_changed(self, entity_id, old_state, new_state):
+        """Called when heater switch changes state."""
+        if new_state is None:
+            return
+        self.schedule_update_ha_state()
+
    def _update_temp(self, state):
        """Update thermostat with latest state from sensor."""
        unit = state.attributes.get(ATTR_UNIT_OF_MEASUREMENT)
@@ -16,7 +16,7 @@ from homeassistant.const import (
 import homeassistant.helpers.config_validation as cv

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

 _LOGGER = logging.getLogger(__name__)

@@ -39,7 +39,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
        }
        devices = {}
        gateway.platform_callbacks.append(mysensors.pf_callback_factory(
-            map_sv_types, devices, add_devices, MySensorsHVAC))
+            map_sv_types, devices, MySensorsHVAC, add_devices))


 class MySensorsHVAC(mysensors.MySensorsDeviceEntity, ClimateDevice):
@@ -40,7 +40,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):

    add_devices(
        [NestThermostat(structure, device, temp_unit)
-         for structure, device in hass.data[DATA_NEST].devices()],
+         for structure, device in hass.data[DATA_NEST].thermostats()],
        True
    )

@@ -22,6 +22,18 @@ set_away_mode:
      description: New value of away mode
      example: true

+set_hold_mode:
+  description: Turn hold mode for climate device
+
+  fields:
+    entity_id:
+      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

@@ -76,7 +88,7 @@ set_operation_mode:
  fields:
    entity_id:
      description: Name(s) of entities to change
-      example: 'climet.nest'
+      example: 'climate.nest'

    operation_mode:
      description: New value of operation mode
@@ -94,3 +106,27 @@ set_swing_mode:
    swing_mode:
    description: New value of swing mode
    example: 1
+
+ecobee_set_fan_min_on_time:
+  description: Set the minimum fan on time
+
+  fields:
+    entity_id:
+      description: Name(s) of entities to change
+      example: 'climate.kitchen'
+
+    fan_min_on_time:
+      description: New value of fan min on time
+      example: 5
+
+ecobee_resume_program:
+  description: Resume the programmed schedule
+
+  fields:
+    entity_id:
+      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
@@ -52,8 +52,6 @@ class ZWaveClimate(ZWaveDeviceEntity, ClimateDevice):

    def __init__(self, value, temp_unit):
        """Initialize the Z-Wave climate device."""
-        from openzwave.network import ZWaveNetwork
-        from pydispatch import dispatcher
        ZWaveDeviceEntity.__init__(self, value, DOMAIN)
        self._index = value.index
        self._node = value.node
@@ -71,9 +69,6 @@ class ZWaveClimate(ZWaveDeviceEntity, ClimateDevice):
        _LOGGER.debug("temp_unit is %s", self._unit)
        self._zxt_120 = None
        self.update_properties()
-        # register listener
-        dispatcher.connect(
-            self.value_changed, ZWaveNetwork.SIGNAL_VALUE_CHANGED)
        # Make sure that we have values for the key before converting to int
        if (value.node.manufacturer_id.strip() and
                value.node.product_id.strip()):
@@ -85,16 +80,8 @@ class ZWaveClimate(ZWaveDeviceEntity, ClimateDevice):
                                  " workaround")
                    self._zxt_120 = 1

-    def value_changed(self, value):
-        """Called when a value has changed on the network."""
-        if self._value.value_id == value.value_id or \
-           self._value.node == value.node:
-            self.update_properties()
-            self.schedule_update_ha_state()
-            _LOGGER.debug("Value changed on network %s", value)
-
    def update_properties(self):
-        """Callback on data change for the registered node/value pair."""
+        """Callback on data changes for node values."""
        # Operation Mode
        for value in self._node.get_values(
                class_id=zwave.const.COMMAND_CLASS_THERMOSTAT_MODE).values():
@@ -5,6 +5,7 @@ For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/cover/
 """
 import os
+from datetime import timedelta
 import logging

 import voluptuous as vol
@@ -23,7 +24,7 @@ from homeassistant.const import (


 DOMAIN = 'cover'
-SCAN_INTERVAL = 15
+SCAN_INTERVAL = timedelta(seconds=15)

 GROUP_NAME_ALL_COVERS = 'all covers'
 ENTITY_ID_ALL_COVERS = group.ENTITY_ID_FORMAT.format('all_covers')
@@ -35,7 +35,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
            })
        devices = {}
        gateway.platform_callbacks.append(mysensors.pf_callback_factory(
-            map_sv_types, devices, add_devices, MySensorsCover))
+            map_sv_types, devices, MySensorsCover, add_devices))


 class MySensorsCover(mysensors.MySensorsDeviceEntity, CoverDevice):
@@ -53,8 +53,6 @@ class ZwaveRollershutter(zwave.ZWaveDeviceEntity, CoverDevice):
    def __init__(self, value):
        """Initialize the zwave rollershutter."""
        import libopenzwave
-        from openzwave.network import ZWaveNetwork
-        from pydispatch import dispatcher
        ZWaveDeviceEntity.__init__(self, value, DOMAIN)
        # pylint: disable=no-member
        self._lozwmgr = libopenzwave.PyManager()
@@ -62,8 +60,6 @@ class ZwaveRollershutter(zwave.ZWaveDeviceEntity, CoverDevice):
        self._node = value.node
        self._current_position = None
        self._workaround = None
-        dispatcher.connect(
-            self.value_changed, ZWaveNetwork.SIGNAL_VALUE_CHANGED)
        if (value.node.manufacturer_id.strip() and
                value.node.product_id.strip()):
            specific_sensor_key = (int(value.node.manufacturer_id, 16),
@@ -74,16 +70,8 @@ class ZwaveRollershutter(zwave.ZWaveDeviceEntity, CoverDevice):
                    _LOGGER.debug("Controller without positioning feedback")
                    self._workaround = 1

-    def value_changed(self, value):
-        """Called when a value has changed on the network."""
-        if self._value.value_id == value.value_id or \
-           self._value.node == value.node:
-            self.update_properties()
-            self.update_ha_state()
-            _LOGGER.debug("Value changed on network %s", value)
-
    def update_properties(self):
-        """Callback on data change for the registered node/value pair."""
+        """Callback on data changes for node values."""
        # Position value
        for value in self._node.get_values(
                class_id=zwave.const.COMMAND_CLASS_SWITCH_MULTILEVEL).values():
@@ -160,24 +148,12 @@ class ZwaveGarageDoor(zwave.ZWaveDeviceEntity, CoverDevice):

    def __init__(self, value):
        """Initialize the zwave garage door."""
-        from openzwave.network import ZWaveNetwork
-        from pydispatch import dispatcher
        ZWaveDeviceEntity.__init__(self, value, DOMAIN)
-        self._state = value.data
-        dispatcher.connect(
-            self.value_changed, ZWaveNetwork.SIGNAL_VALUE_CHANGED)
-
-    def value_changed(self, value):
-        """Called when a value has changed on the network."""
-        if self._value.value_id == value.value_id:
-            self._state = value.data
-            self.update_ha_state()
-            _LOGGER.debug("Value changed on network %s", value)

    @property
    def is_closed(self):
        """Return the current position of Zwave garage door."""
-        return not self._state
+        return not self._value.data

    def close_cover(self):
        """Close the garage door."""
@@ -23,12 +23,14 @@ COMPONENTS_WITH_DEMO_PLATFORM = [
    'cover',
    'device_tracker',
    'fan',
+    'image_processing',
    'light',
    'lock',
    'media_player',
    'notify',
    'sensor',
    'switch',
+    'tts',
 ]


@@ -8,7 +8,7 @@ import asyncio
 from datetime import timedelta
 import logging
 import os
-from typing import Any, Sequence, Callable
+from typing import Any, List, Sequence, Callable

 import aiohttp
 import async_timeout
@@ -24,6 +24,7 @@ from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.helpers import config_per_platform, discovery
 from homeassistant.helpers.entity import Entity
+from homeassistant.helpers.event import async_track_time_interval
 from homeassistant.helpers.typing import GPSType, ConfigType, HomeAssistantType
 import homeassistant.helpers.config_validation as cv
 import homeassistant.util as util
@@ -50,10 +51,10 @@ CONF_TRACK_NEW = 'track_new_devices'
 DEFAULT_TRACK_NEW = True

 CONF_CONSIDER_HOME = 'consider_home'
-DEFAULT_CONSIDER_HOME = 180
+DEFAULT_CONSIDER_HOME = timedelta(seconds=180)

 CONF_SCAN_INTERVAL = 'interval_seconds'
-DEFAULT_SCAN_INTERVAL = 12
+DEFAULT_SCAN_INTERVAL = timedelta(seconds=12)

 CONF_AWAY_HIDE = 'hide_if_away'
 DEFAULT_AWAY_HIDE = False
@@ -69,12 +70,16 @@ ATTR_LOCATION_NAME = 'location_name'
 ATTR_GPS = 'gps'
 ATTR_BATTERY = 'battery'
 ATTR_ATTRIBUTES = 'attributes'
+ATTR_SOURCE_TYPE = 'source_type'
+
+SOURCE_TYPE_GPS = 'gps'
+SOURCE_TYPE_ROUTER = 'router'

 PLATFORM_SCHEMA = cv.PLATFORM_SCHEMA.extend({
-    vol.Optional(CONF_SCAN_INTERVAL): cv.positive_int,  # seconds
+    vol.Optional(CONF_SCAN_INTERVAL): cv.time_period,
    vol.Optional(CONF_TRACK_NEW, default=DEFAULT_TRACK_NEW): cv.boolean,
    vol.Optional(CONF_CONSIDER_HOME,
-                 default=timedelta(seconds=DEFAULT_CONSIDER_HOME)): vol.All(
+                 default=DEFAULT_CONSIDER_HOME): vol.All(
                     cv.time_period, cv.positive_timedelta)
 })

@@ -121,8 +126,7 @@ def async_setup(hass: HomeAssistantType, config: ConfigType):
        return False
    else:
        conf = conf[0] if len(conf) > 0 else {}
-        consider_home = conf.get(CONF_CONSIDER_HOME,
-                                 timedelta(seconds=DEFAULT_CONSIDER_HOME))
+        consider_home = conf.get(CONF_CONSIDER_HOME, DEFAULT_CONSIDER_HOME)
        track_new = conf.get(CONF_TRACK_NEW, DEFAULT_TRACK_NEW)

    devices = yield from async_load_config(yaml_path, hass, consider_home)
@@ -142,23 +146,34 @@ def async_setup(hass: HomeAssistantType, config: ConfigType):
        if platform is None:
            return

+        _LOGGER.info("Setting up %s.%s", DOMAIN, p_type)
        try:
-            if hasattr(platform, 'get_scanner'):
+            scanner = None
+            setup = None
+            if hasattr(platform, 'async_get_scanner'):
+                scanner = yield from platform.async_get_scanner(
+                    hass, {DOMAIN: p_config})
+            elif hasattr(platform, 'get_scanner'):
                scanner = yield from hass.loop.run_in_executor(
                    None, platform.get_scanner, hass, {DOMAIN: p_config})
+            elif hasattr(platform, 'async_setup_scanner'):
+                setup = yield from platform.async_setup_scanner(
+                    hass, p_config, tracker.async_see)
+            elif hasattr(platform, 'setup_scanner'):
+                setup = yield from hass.loop.run_in_executor(
+                    None, platform.setup_scanner, hass, p_config, tracker.see)
+            else:
+                raise HomeAssistantError("Invalid device_tracker platform.")

-                if scanner is None:
-                    _LOGGER.error('Error setting up platform %s', p_type)
-                    return
-
+            if scanner:
                yield from async_setup_scanner_platform(
                    hass, p_config, scanner, tracker.async_see)
                return

-            ret = yield from hass.loop.run_in_executor(
-                None, platform.setup_scanner, hass, p_config, tracker.see)
-            if not ret:
+            if not setup:
                _LOGGER.error('Error setting up platform %s', p_type)
+                return
+
        except Exception:  # pylint: disable=broad-except
            _LOGGER.exception('Error setting up platform %s', p_type)

@@ -223,17 +238,19 @@ class DeviceTracker(object):

    def see(self, mac: str=None, dev_id: str=None, host_name: str=None,
            location_name: str=None, gps: GPSType=None, gps_accuracy=None,
-            battery: str=None, attributes: dict=None):
+            battery: str=None, attributes: dict=None,
+            source_type: str=SOURCE_TYPE_GPS):
        """Notify the device tracker that you see a device."""
        self.hass.add_job(
            self.async_see(mac, dev_id, host_name, location_name, gps,
-                           gps_accuracy, battery, attributes)
+                           gps_accuracy, battery, attributes, source_type)
        )

    @asyncio.coroutine
    def async_see(self, mac: str=None, dev_id: str=None, host_name: str=None,
                  location_name: str=None, gps: GPSType=None,
-                  gps_accuracy=None, battery: str=None, attributes: dict=None):
+                  gps_accuracy=None, battery: str=None, attributes: dict=None,
+                  source_type: str=SOURCE_TYPE_GPS):
        """Notify the device tracker that you see a device.

        This method is a coroutine.
@@ -251,7 +268,8 @@ class DeviceTracker(object):

        if device:
            yield from device.async_seen(host_name, location_name, gps,
-                                         gps_accuracy, battery, attributes)
+                                         gps_accuracy, battery, attributes,
+                                         source_type)
            if device.track:
                yield from device.async_update_ha_state()
            return
@@ -266,7 +284,8 @@ class DeviceTracker(object):
            self.mac_to_dev[mac] = device

        yield from device.async_seen(host_name, location_name, gps,
-                                     gps_accuracy, battery, attributes)
+                                     gps_accuracy, battery, attributes,
+                                     source_type)

        if device.track:
            yield from device.async_update_ha_state()
@@ -370,6 +389,9 @@ class Device(Entity):

        self.away_hide = hide_if_away
        self.vendor = vendor
+
+        self.source_type = None
+
        self._attributes = {}

    @property
@@ -390,7 +412,9 @@ class Device(Entity):
    @property
    def state_attributes(self):
        """Return the device state attributes."""
-        attr = {}
+        attr = {
+            ATTR_SOURCE_TYPE: self.source_type
+        }

        if self.gps:
            attr[ATTR_LATITUDE] = self.gps[0]
@@ -415,12 +439,13 @@ class Device(Entity):
    @asyncio.coroutine
    def async_seen(self, host_name: str=None, location_name: str=None,
                   gps: GPSType=None, gps_accuracy=0, battery: str=None,
-                   attributes: dict=None):
+                   attributes: dict=None, source_type: str=SOURCE_TYPE_GPS):
        """Mark the device as seen."""
+        self.source_type = source_type
        self.last_seen = dt_util.utcnow()
        self.host_name = host_name
        self.location_name = location_name
-        self.gps_accuracy = gps_accuracy or 0
+
        if battery:
            self.battery = battery
        if attributes:
@@ -431,7 +456,10 @@ class Device(Entity):
        if gps is not None:
            try:
                self.gps = float(gps[0]), float(gps[1])
+                self.gps_accuracy = gps_accuracy or 0
            except (ValueError, TypeError, IndexError):
+                self.gps = None
+                self.gps_accuracy = 0
                _LOGGER.warning('Could not parse gps value for %s: %s',
                                self.dev_id, gps)

@@ -456,7 +484,7 @@ class Device(Entity):
            return
        elif self.location_name:
            self._state = self.location_name
-        elif self.gps is not None:
+        elif self.gps is not None and self.source_type == SOURCE_TYPE_GPS:
            zone_state = zone.async_active_zone(
                self.hass, self.gps[0], self.gps[1], self.gps_accuracy)
            if zone_state is None:
@@ -465,9 +493,9 @@ class Device(Entity):
                self._state = STATE_HOME
            else:
                self._state = zone_state.name
-
        elif self.stale():
            self._state = STATE_NOT_HOME
+            self.gps = None
            self.last_update_home = False
        else:
            self._state = STATE_HOME
@@ -485,13 +513,18 @@ class Device(Entity):
        if not self.mac:
            return None

+        if '_' in self.mac:
+            _, mac = self.mac.split('_', 1)
+        else:
+            mac = self.mac
+
        # prevent lookup of invalid macs
-        if not len(self.mac.split(':')) == 6:
+        if not len(mac.split(':')) == 6:
            return 'unknown'

        # we only need the first 3 bytes of the mac for a lookup
        # this improves somewhat on privacy
-        oui_bytes = self.mac.split(':')[0:3]
+        oui_bytes = mac.split(':')[0:3]
        # bytes like 00 get truncates to 0, API needs full bytes
        oui = '{:02x}:{:02x}:{:02x}'.format(*[int(b, 16) for b in oui_bytes])
        url = 'http://api.macvendors.com/' + oui
@@ -521,6 +554,34 @@ class Device(Entity):
                yield from resp.release()


+class DeviceScanner(object):
+    """Device scanner object."""
+
+    hass = None  # type: HomeAssistantType
+
+    def scan_devices(self) -> List[str]:
+        """Scan for devices."""
+        raise NotImplementedError()
+
+    def async_scan_devices(self) -> Any:
+        """Scan for devices.
+
+        This method must be run in the event loop and returns a coroutine.
+        """
+        return self.hass.loop.run_in_executor(None, self.scan_devices)
+
+    def get_device_name(self, mac: str) -> str:
+        """Get device name from mac."""
+        raise NotImplementedError()
+
+    def async_get_device_name(self, mac: str) -> Any:
+        """Get device name from mac.
+
+        This method must be run in the event loop and returns a coroutine.
+        """
+        return self.hass.loop.run_in_executor(None, self.get_device_name, mac)
+
+
 def load_config(path: str, hass: HomeAssistantType, consider_home: timedelta):
    """Load devices from YAML configuration file."""
    return run_coroutine_threadsafe(
@@ -577,26 +638,39 @@ def async_setup_scanner_platform(hass: HomeAssistantType, config: ConfigType,
    This method is a coroutine.
    """
    interval = config.get(CONF_SCAN_INTERVAL, DEFAULT_SCAN_INTERVAL)
+    scanner.hass = hass

    # Initial scan of each mac we also tell about host name for config
    seen = set()  # type: Any

-    def device_tracker_scan(now: dt_util.dt.datetime):
+    @asyncio.coroutine
+    def async_device_tracker_scan(now: dt_util.dt.datetime):
        """Called when interval matches."""
-        found_devices = scanner.scan_devices()
+        found_devices = yield from scanner.async_scan_devices()

        for mac in found_devices:
            if mac in seen:
                host_name = None
            else:
-                host_name = scanner.get_device_name(mac)
+                host_name = yield from scanner.async_get_device_name(mac)
                seen.add(mac)
-            hass.add_job(async_see_device(mac=mac, host_name=host_name))

-    async_track_utc_time_change(
-        hass, device_tracker_scan, second=range(0, 60, interval))
+            kwargs = {
+                'mac': mac,
+                'host_name': host_name,
+                'source_type': SOURCE_TYPE_ROUTER
+            }

-    hass.async_add_job(device_tracker_scan, None)
+            zone_home = hass.states.get(zone.ENTITY_ID_HOME)
+            if zone_home:
+                kwargs['gps'] = [zone_home.attributes[ATTR_LATITUDE],
+                                 zone_home.attributes[ATTR_LONGITUDE]]
+                kwargs['gps_accuracy'] = 0
+
+            hass.async_add_job(async_see_device(**kwargs))
+
+    async_track_time_interval(hass, async_device_tracker_scan, interval)
+    hass.async_add_job(async_device_tracker_scan, None)


 def update_config(path: str, dev_id: str, device: Device):
@@ -14,7 +14,8 @@ import voluptuous as vol

 import homeassistant.helpers.config_validation as cv
 import homeassistant.util.dt as dt_util
-from homeassistant.components.device_tracker import (DOMAIN, PLATFORM_SCHEMA)
+from homeassistant.components.device_tracker import (
+    DOMAIN, PLATFORM_SCHEMA, DeviceScanner)
 from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_USERNAME
 from homeassistant.util import Throttle

@@ -46,7 +47,7 @@ def get_scanner(hass, config):
 Device = namedtuple("Device", ["mac", "ip", "last_update"])


-class ActiontecDeviceScanner(object):
+class ActiontecDeviceScanner(DeviceScanner):
    """This class queries a an actiontec router for connected devices."""

    def __init__(self, config):
@@ -12,7 +12,8 @@ from datetime import timedelta
 import voluptuous as vol

 import homeassistant.helpers.config_validation as cv
-from homeassistant.components.device_tracker import DOMAIN, PLATFORM_SCHEMA
+from homeassistant.components.device_tracker import (
+    DOMAIN, PLATFORM_SCHEMA, DeviceScanner)
 from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_USERNAME
 from homeassistant.util import Throttle

@@ -42,7 +43,7 @@ def get_scanner(hass, config):
    return scanner if scanner.success_init else None


-class ArubaDeviceScanner(object):
+class ArubaDeviceScanner(DeviceScanner):
    """This class queries a Aruba Access Point for connected devices."""

    def __init__(self, config):
@@ -14,7 +14,8 @@ from datetime import timedelta

 import voluptuous as vol

-from homeassistant.components.device_tracker import DOMAIN, PLATFORM_SCHEMA
+from homeassistant.components.device_tracker import (
+    DOMAIN, PLATFORM_SCHEMA, DeviceScanner)
 from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_USERNAME
 from homeassistant.util import Throttle
 import homeassistant.helpers.config_validation as cv
@@ -70,10 +71,11 @@ _ARP_REGEX = re.compile(

 _IP_NEIGH_CMD = 'ip neigh'
 _IP_NEIGH_REGEX = re.compile(
-    r'(?P<ip>([0-9]{1,3}[\.]){3}[0-9]{1,3})\s' +
-    r'\w+\s' +
-    r'\w+\s' +
-    r'(\w+\s(?P<mac>(([0-9a-f]{2}[:-]){5}([0-9a-f]{2}))))?\s' +
+    r'(?P<ip>([0-9]{1,3}[\.]){3}[0-9]{1,3}|'
+    r'([0-9a-fA-F]{1,4}:){1,7}[0-9a-fA-F]{0,4}(:[0-9a-fA-F]{1,4}){1,7})\s'
+    r'\w+\s'
+    r'\w+\s'
+    r'(\w+\s(?P<mac>(([0-9a-f]{2}[:-]){5}([0-9a-f]{2}))))?\s'
    r'(?P<status>(\w+))')

 _NVRAM_CMD = 'nvram get client_info_tmp'
@@ -97,7 +99,7 @@ def get_scanner(hass, config):
 AsusWrtResult = namedtuple('AsusWrtResult', 'neighbors leases arp nvram')


-class AsusWrtDeviceScanner(object):
+class AsusWrtDeviceScanner(DeviceScanner):
    """This class queries a router running ASUSWRT firmware."""

    # Eighth attribute needed for mode (AP mode vs router mode)
@@ -322,6 +324,8 @@ class AsusWrtDeviceScanner(object):

        else:
            for lease in result.leases:
+                if lease.startswith(b'duid '):
+                    continue
                match = _LEASES_REGEX.search(lease.decode('utf-8'))

                if not match:
@@ -11,8 +11,8 @@ import requests

 import voluptuous as vol

-from homeassistant.components.device_tracker import (PLATFORM_SCHEMA,
-                                                     ATTR_ATTRIBUTES)
+from homeassistant.components.device_tracker import (
+    PLATFORM_SCHEMA, ATTR_ATTRIBUTES)
 from homeassistant.const import CONF_USERNAME, CONF_PASSWORD
 import homeassistant.helpers.config_validation as cv
 from homeassistant.helpers.event import track_utc_time_change
@@ -9,7 +9,7 @@ import logging
 from datetime import timedelta

 import homeassistant.util.dt as dt_util
-from homeassistant.components.device_tracker import DOMAIN
+from homeassistant.components.device_tracker import DOMAIN, DeviceScanner
 from homeassistant.util import Throttle

 REQUIREMENTS = ['pybbox==0.0.5-alpha']
@@ -29,7 +29,7 @@ def get_scanner(hass, config):
 Device = namedtuple('Device', ['mac', 'name', 'ip', 'last_update'])


-class BboxDeviceScanner(object):
+class BboxDeviceScanner(DeviceScanner):
    """This class scans for devices connected to the bbox."""

    def __init__(self, config):
@@ -1,19 +1,12 @@
 """Tracking for bluetooth low energy devices."""
 import logging
-from datetime import timedelta

 import voluptuous as vol
 from homeassistant.helpers.event import track_point_in_utc_time
 from homeassistant.components.device_tracker import (
-    YAML_DEVICES,
-    CONF_TRACK_NEW,
-    CONF_SCAN_INTERVAL,
-    DEFAULT_SCAN_INTERVAL,
-    PLATFORM_SCHEMA,
-    load_config,
-    DEFAULT_TRACK_NEW
+    YAML_DEVICES, CONF_TRACK_NEW, CONF_SCAN_INTERVAL, DEFAULT_SCAN_INTERVAL,
+    PLATFORM_SCHEMA, load_config
 )
-import homeassistant.util as util
 import homeassistant.util.dt as dt_util
 import homeassistant.helpers.config_validation as cv

@@ -24,9 +17,11 @@ REQUIREMENTS = ['gattlib==0.20150805']
 BLE_PREFIX = 'BLE_'
 MIN_SEEN_NEW = 5
 CONF_SCAN_DURATION = "scan_duration"
+CONF_BLUETOOTH_DEVICE = "device_id"

 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
-    vol.Optional(CONF_SCAN_DURATION, default=10): cv.positive_int
+    vol.Optional(CONF_SCAN_DURATION, default=10): cv.positive_int,
+    vol.Optional(CONF_BLUETOOTH_DEVICE, default="hci0"): cv.string
 })


@@ -60,7 +55,7 @@ def setup_scanner(hass, config, see):
        """Discover Bluetooth LE devices."""
        _LOGGER.debug("Discovering Bluetooth LE devices")
        try:
-            service = DiscoveryService()
+            service = DiscoveryService(ble_dev_id)
            devices = service.discover(duration)
            _LOGGER.debug("Bluetooth LE devices discovered = %s", devices)
        except RuntimeError as error:
@@ -70,6 +65,7 @@ def setup_scanner(hass, config, see):

    yaml_path = hass.config.path(YAML_DEVICES)
    duration = config.get(CONF_SCAN_DURATION)
+    ble_dev_id = config.get(CONF_BLUETOOTH_DEVICE)
    devs_to_track = []
    devs_donot_track = []

@@ -88,14 +84,13 @@ def setup_scanner(hass, config, see):

    # if track new devices is true discover new devices
    # on every scan.
-    track_new = util.convert(config.get(CONF_TRACK_NEW), bool,
-                             DEFAULT_TRACK_NEW)
+    track_new = config.get(CONF_TRACK_NEW)
+
    if not devs_to_track and not track_new:
        _LOGGER.warning("No Bluetooth LE devices to track!")
        return False

-    interval = util.convert(config.get(CONF_SCAN_INTERVAL), int,
-                            DEFAULT_SCAN_INTERVAL)
+    interval = config.get(CONF_SCAN_INTERVAL, DEFAULT_SCAN_INTERVAL)

    def update_ble(now):
        """Lookup Bluetooth LE devices and update status."""
@@ -115,8 +110,7 @@ def setup_scanner(hass, config, see):
                    _LOGGER.info("Discovered Bluetooth LE device %s", address)
                    see_device(address, devs[address], new_device=True)

-        track_point_in_utc_time(hass, update_ble,
-                                now + timedelta(seconds=interval))
+        track_point_in_utc_time(hass, update_ble, now + interval)

    update_ble(dt_util.utcnow())

@@ -1,6 +1,5 @@
 """Tracking for bluetooth devices."""
 import logging
-from datetime import timedelta

 import voluptuous as vol

@@ -83,8 +82,7 @@ def setup_scanner(hass, config, see):
                see_device((mac, result))
        except bluetooth.BluetoothError:
            _LOGGER.exception('Error looking up bluetooth device!')
-        track_point_in_utc_time(hass, update_bluetooth,
-                                now + timedelta(seconds=interval))
+        track_point_in_utc_time(hass, update_bluetooth, now + interval)

    update_bluetooth(dt_util.utcnow())

@@ -16,7 +16,8 @@ import requests
 import voluptuous as vol

 import homeassistant.helpers.config_validation as cv
-from homeassistant.components.device_tracker import DOMAIN, PLATFORM_SCHEMA
+from homeassistant.components.device_tracker import (
+    DOMAIN, PLATFORM_SCHEMA, DeviceScanner)
 from homeassistant.const import CONF_HOST
 from homeassistant.util import Throttle

@@ -40,7 +41,7 @@ def get_scanner(hass, config):
    return scanner if scanner.success_init else None


-class BTHomeHub5DeviceScanner(object):
+class BTHomeHub5DeviceScanner(DeviceScanner):
    """This class queries a BT Home Hub 5."""

    def __init__(self, config):
@@ -10,7 +10,8 @@ from datetime import timedelta
 import voluptuous as vol

 import homeassistant.helpers.config_validation as cv
-from homeassistant.components.device_tracker import DOMAIN, PLATFORM_SCHEMA
+from homeassistant.components.device_tracker import (
+    DOMAIN, PLATFORM_SCHEMA, DeviceScanner)
 from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_USERNAME, \
    CONF_PORT
 from homeassistant.util import Throttle
@@ -39,7 +40,7 @@ def get_scanner(hass, config):
    return scanner if scanner.success_init else None


-class CiscoDeviceScanner(object):
+class CiscoDeviceScanner(DeviceScanner):
    """This class queries a wireless router running Cisco IOS firmware."""

    def __init__(self, config):
@@ -13,7 +13,8 @@ import requests
 import voluptuous as vol

 import homeassistant.helpers.config_validation as cv
-from homeassistant.components.device_tracker import DOMAIN, PLATFORM_SCHEMA
+from homeassistant.components.device_tracker import (
+    DOMAIN, PLATFORM_SCHEMA, DeviceScanner)
 from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_USERNAME
 from homeassistant.util import Throttle

@@ -41,7 +42,7 @@ def get_scanner(hass, config):
        return None


-class DdWrtDeviceScanner(object):
+class DdWrtDeviceScanner(DeviceScanner):
    """This class queries a wireless router running DD-WRT firmware."""

    def __init__(self, config):
@@ -10,13 +10,12 @@ from datetime import timedelta
 import voluptuous as vol

 import homeassistant.helpers.config_validation as cv
-from homeassistant.components.device_tracker import DOMAIN, PLATFORM_SCHEMA
+from homeassistant.components.device_tracker import (
+    DOMAIN, PLATFORM_SCHEMA, DeviceScanner)
 from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_USERNAME
 from homeassistant.util import Throttle

-REQUIREMENTS = ['https://github.com/deisi/fritzconnection/archive/'
-                'b5c14515e1c8e2652b06b6316a7f3913df942841.zip'
-                '#fritzconnection==0.4.6']
+REQUIREMENTS = ['fritzconnection==0.6']

 # Return cached results if last scan was less then this time ago.
 MIN_TIME_BETWEEN_SCANS = timedelta(seconds=5)
@@ -38,7 +37,7 @@ def get_scanner(hass, config):
    return scanner if scanner.success_init else None


-class FritzBoxScanner(object):
+class FritzBoxScanner(DeviceScanner):
    """This class queries a FRITZ!Box router."""

    def __init__(self, config):
@@ -12,7 +12,7 @@ import voluptuous as vol

 from homeassistant.const import CONF_USERNAME, CONF_PASSWORD
 from homeassistant.components.device_tracker import (
-    PLATFORM_SCHEMA, DOMAIN, ATTR_ATTRIBUTES, ENTITY_ID_FORMAT)
+    PLATFORM_SCHEMA, DOMAIN, ATTR_ATTRIBUTES, ENTITY_ID_FORMAT, DeviceScanner)
 from homeassistant.components.zone import active_zone
 from homeassistant.helpers.event import track_utc_time_change
 import homeassistant.helpers.config_validation as cv
@@ -131,7 +131,7 @@ def setup_scanner(hass, config: dict, see):
    return True


-class Icloud(object):
+class Icloud(DeviceScanner):
    """Represent an icloud account in Home Assistant."""

    def __init__(self, hass, username, password, name, see):
@@ -0,0 +1,107 @@
+"""
+Support for Linksys Access Points.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/device_tracker.linksys_ap/
+"""
+import base64
+import logging
+import threading
+from datetime import timedelta
+
+import requests
+import voluptuous as vol
+
+import homeassistant.helpers.config_validation as cv
+from homeassistant.components.device_tracker import DOMAIN, PLATFORM_SCHEMA
+from homeassistant.const import (
+    CONF_HOST, CONF_PASSWORD, CONF_USERNAME, CONF_VERIFY_SSL)
+from homeassistant.util import Throttle
+
+MIN_TIME_BETWEEN_SCANS = timedelta(seconds=5)
+INTERFACES = 2
+DEFAULT_TIMEOUT = 10
+
+REQUIREMENTS = ['beautifulsoup4==4.5.3']
+
+_LOGGER = logging.getLogger(__name__)
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Required(CONF_HOST): cv.string,
+    vol.Required(CONF_PASSWORD): cv.string,
+    vol.Required(CONF_USERNAME): cv.string,
+    vol.Optional(CONF_VERIFY_SSL, default=True): cv.boolean,
+})
+
+
+def get_scanner(hass, config):
+    """Validate the configuration and return a Linksys AP scanner."""
+    try:
+        return LinksysAPDeviceScanner(config[DOMAIN])
+    except ConnectionError:
+        return None
+
+
+class LinksysAPDeviceScanner(object):
+    """This class queries a Linksys Access Point."""
+
+    def __init__(self, config):
+        """Initialize the scanner."""
+        self.host = config[CONF_HOST]
+        self.username = config[CONF_USERNAME]
+        self.password = config[CONF_PASSWORD]
+        self.verify_ssl = config[CONF_VERIFY_SSL]
+
+        self.lock = threading.Lock()
+        self.last_results = []
+
+        # Check if the access point is accessible
+        response = self._make_request()
+        if not response.status_code == 200:
+            raise ConnectionError("Cannot connect to Linksys Access Point")
+
+    def scan_devices(self):
+        """Scan for new devices and return a list with found device IDs."""
+        self._update_info()
+
+        return self.last_results
+
+    # pylint: disable=no-self-use
+    def get_device_name(self, mac):
+        """
+        Return the name (if known) of the device.
+
+        Linksys does not provide an API to get a name for a device,
+        so we just return None
+        """
+        return None
+
+    @Throttle(MIN_TIME_BETWEEN_SCANS)
+    def _update_info(self):
+        """Check for connected devices."""
+        from bs4 import BeautifulSoup as BS
+
+        with self.lock:
+            _LOGGER.info("Checking Linksys AP")
+
+            self.last_results = []
+            for interface in range(INTERFACES):
+                request = self._make_request(interface)
+                self.last_results.extend(
+                    [x.find_all('td')[1].text
+                     for x in BS(request.content, "html.parser")
+                     .find_all(class_='section-row')]
+                )
+
+            return True
+
+    def _make_request(self, unit=0):
+        # No, the '&&' is not a typo - this is expected by the web interface.
+        login = base64.b64encode(bytes(self.username, 'utf8')).decode('ascii')
+        pwd = base64.b64encode(bytes(self.password, 'utf8')).decode('ascii')
+        return requests.get(
+            'https://%s/StatusClients.htm&&unit=%s&vap=0' % (self.host, unit),
+            timeout=DEFAULT_TIMEOUT,
+            verify=self.verify_ssl,
+            cookies={'LoginName': login,
+                     'LoginPWD': pwd})
@@ -8,9 +8,8 @@ import asyncio
 from functools import partial
 import logging

-from homeassistant.const import (ATTR_LATITUDE, ATTR_LONGITUDE,
-                                 STATE_NOT_HOME,
-                                 HTTP_UNPROCESSABLE_ENTITY)
+from homeassistant.const import (
+    ATTR_LATITUDE, ATTR_LONGITUDE, STATE_NOT_HOME, HTTP_UNPROCESSABLE_ENTITY)
 from homeassistant.components.http import HomeAssistantView
 # pylint: disable=unused-import
 from homeassistant.components.device_tracker import (  # NOQA
@@ -64,18 +63,18 @@ class LocativeView(HomeAssistantView):
            return ('Device id not specified.',
                    HTTP_UNPROCESSABLE_ENTITY)

-        if 'id' not in data:
-            _LOGGER.error('Location id not specified.')
-            return ('Location id not specified.',
-                    HTTP_UNPROCESSABLE_ENTITY)
-
        if 'trigger' not in data:
            _LOGGER.error('Trigger is not specified.')
            return ('Trigger is not specified.',
                    HTTP_UNPROCESSABLE_ENTITY)

+        if 'id' not in data and data['trigger'] != 'test':
+            _LOGGER.error('Location id not specified.')
+            return ('Location id not specified.',
+                    HTTP_UNPROCESSABLE_ENTITY)
+
        device = data['device'].replace('-', '')
-        location_name = data['id'].lower()
+        location_name = data.get('id', data['trigger']).lower()
        direction = data['trigger']
        gps_location = (data[ATTR_LATITUDE], data[ATTR_LONGITUDE])

@@ -14,7 +14,8 @@ import requests
 import voluptuous as vol

 import homeassistant.helpers.config_validation as cv
-from homeassistant.components.device_tracker import DOMAIN, PLATFORM_SCHEMA
+from homeassistant.components.device_tracker import (
+    DOMAIN, PLATFORM_SCHEMA, DeviceScanner)
 from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_USERNAME
 from homeassistant.util import Throttle

@@ -37,7 +38,7 @@ def get_scanner(hass, config):
    return scanner if scanner.success_init else None


-class LuciDeviceScanner(object):
+class LuciDeviceScanner(DeviceScanner):
    """This class queries a wireless router running OpenWrt firmware.

    Adapted from Tomato scanner.
@@ -11,7 +11,8 @@ from datetime import timedelta
 import voluptuous as vol

 import homeassistant.helpers.config_validation as cv
-from homeassistant.components.device_tracker import DOMAIN, PLATFORM_SCHEMA
+from homeassistant.components.device_tracker import (
+    DOMAIN, PLATFORM_SCHEMA, DeviceScanner)
 from homeassistant.const import (
    CONF_HOST, CONF_PASSWORD, CONF_USERNAME, CONF_PORT)
 from homeassistant.util import Throttle
@@ -47,7 +48,7 @@ def get_scanner(hass, config):
    return scanner if scanner.success_init else None


-class NetgearDeviceScanner(object):
+class NetgearDeviceScanner(DeviceScanner):
    """Queries a Netgear wireless router using the SOAP-API."""

    def __init__(self, host, username, password, port):
@@ -14,7 +14,8 @@ import voluptuous as vol

 import homeassistant.helpers.config_validation as cv
 import homeassistant.util.dt as dt_util
-from homeassistant.components.device_tracker import DOMAIN, PLATFORM_SCHEMA
+from homeassistant.components.device_tracker import (
+    DOMAIN, PLATFORM_SCHEMA, DeviceScanner)
 from homeassistant.const import CONF_HOSTS
 from homeassistant.util import Throttle

@@ -63,7 +64,7 @@ def _arp(ip_address):
    return None


-class NmapDeviceScanner(object):
+class NmapDeviceScanner(DeviceScanner):
    """This class scans for devices using nmap."""

    exclude = []
@@ -0,0 +1,92 @@
+"""
+Tracks devices by sending a ICMP ping.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/device_tracker.ping/
+
+device_tracker:
+  - platform: ping
+    count: 2
+    hosts:
+      host_one: pc.local
+      host_two: 192.168.2.25
+"""
+import logging
+import subprocess
+import sys
+from datetime import timedelta
+
+import voluptuous as vol
+
+from homeassistant.components.device_tracker import (
+    PLATFORM_SCHEMA, DEFAULT_SCAN_INTERVAL)
+from homeassistant.helpers.event import track_point_in_utc_time
+from homeassistant import util
+from homeassistant import const
+import homeassistant.helpers.config_validation as cv
+
+DEPENDENCIES = []
+
+_LOGGER = logging.getLogger(__name__)
+
+CONF_PING_COUNT = 'count'
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Required(const.CONF_HOSTS): {cv.string: cv.string},
+    vol.Optional(CONF_PING_COUNT, default=1): cv.positive_int,
+})
+
+
+class Host:
+    """Host object with ping detection."""
+
+    def __init__(self, ip_address, dev_id, hass, config):
+        """Initialize the Host pinger."""
+        self.hass = hass
+        self.ip_address = ip_address
+        self.dev_id = dev_id
+        self._count = config[CONF_PING_COUNT]
+        if sys.platform == "win32":
+            self._ping_cmd = ['ping', '-n 1', '-w 1000', self.ip_address]
+        else:
+            self._ping_cmd = ['ping', '-n', '-q', '-c1', '-W1',
+                              self.ip_address]
+
+    def ping(self):
+        """Send ICMP ping and return True if success."""
+        pinger = subprocess.Popen(self._ping_cmd, stdout=subprocess.PIPE)
+        try:
+            pinger.communicate()
+            return pinger.returncode == 0
+        except subprocess.CalledProcessError:
+            return False
+
+    def update(self, see):
+        """Update device state by sending one or more ping messages."""
+        failed = 0
+        while failed < self._count:  # check more times if host in unreachable
+            if self.ping():
+                see(dev_id=self.dev_id)
+                return True
+            failed += 1
+
+        _LOGGER.debug("ping KO on ip=%s failed=%d", self.ip_address, failed)
+
+
+def setup_scanner(hass, config, see):
+    """Setup the Host objects and return the update function."""
+    hosts = [Host(ip, dev_id, hass, config) for (dev_id, ip) in
+             config[const.CONF_HOSTS].items()]
+    interval = timedelta(seconds=len(hosts) * config[CONF_PING_COUNT]) + \
+        DEFAULT_SCAN_INTERVAL
+    _LOGGER.info("Started ping tracker with interval=%s on hosts: %s",
+                 interval, ",".join([host.ip_address for host in hosts]))
+
+    def update(now):
+        """Update all the hosts on every interval time."""
+        for host in hosts:
+            host.update(see)
+        track_point_in_utc_time(hass, update, now + interval)
+        return True
+
+    return update(util.dt.utcnow())
@@ -0,0 +1,126 @@
+"""
+Support for Sky Hub.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/device_tracker.sky_hub/
+"""
+import logging
+import re
+import threading
+from datetime import timedelta
+
+import requests
+import voluptuous as vol
+
+import homeassistant.helpers.config_validation as cv
+from homeassistant.components.device_tracker import (
+    DOMAIN, PLATFORM_SCHEMA, DeviceScanner)
+from homeassistant.const import CONF_HOST
+from homeassistant.util import Throttle
+
+_LOGGER = logging.getLogger(__name__)
+_MAC_REGEX = re.compile(r'(([0-9A-Fa-f]{1,2}\:){5}[0-9A-Fa-f]{1,2})')
+
+MIN_TIME_BETWEEN_SCANS = timedelta(seconds=10)
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Required(CONF_HOST): cv.string
+})
+
+
+# pylint: disable=unused-argument
+def get_scanner(hass, config):
+    """Return a Sky Hub 5 scanner if successful."""
+    scanner = SkyHubDeviceScanner(config[DOMAIN])
+
+    return scanner if scanner.success_init else None
+
+
+class SkyHubDeviceScanner(DeviceScanner):
+    """This class queries a Sky Hub router."""
+
+    def __init__(self, config):
+        """Initialise the scanner."""
+        _LOGGER.info("Initialising Sky Hub")
+        self.host = config.get(CONF_HOST, '192.168.1.254')
+
+        self.lock = threading.Lock()
+
+        self.last_results = {}
+
+        self.url = 'http://{}/'.format(self.host)
+
+        # Test the router is accessible
+        data = _get_skyhub_data(self.url)
+        self.success_init = data is not None
+
+    def scan_devices(self):
+        """Scan for new devices and return a list with found device IDs."""
+        self._update_info()
+
+        return (device for device in self.last_results)
+
+    def get_device_name(self, device):
+        """Return the name of the given device or None if we don't know."""
+        with self.lock:
+            # If not initialised and not already scanned and not found.
+            if device not in self.last_results:
+                self._update_info()
+
+                if not self.last_results:
+                    return None
+
+            return self.last_results.get(device)
+
+    @Throttle(MIN_TIME_BETWEEN_SCANS)
+    def _update_info(self):
+        """Ensure the information from the Sky Hub is up to date.
+
+        Return boolean if scanning successful.
+        """
+        if not self.success_init:
+            return False
+
+        with self.lock:
+            _LOGGER.info("Scanning")
+
+            data = _get_skyhub_data(self.url)
+
+            if not data:
+                _LOGGER.warning('Error scanning devices')
+                return False
+
+            self.last_results = data
+
+            return True
+
+
+def _get_skyhub_data(url):
+    """Retrieve data from Sky Hub and return parsed result."""
+    try:
+        response = requests.get(url, timeout=5)
+    except requests.exceptions.Timeout:
+        _LOGGER.exception("Connection to the router timed out")
+        return
+    if response.status_code == 200:
+        return _parse_skyhub_response(response.text)
+    else:
+        _LOGGER.error("Invalid response from Sky Hub: %s", response)
+
+
+def _parse_skyhub_response(data_str):
+    """Parse the Sky Hub data format."""
+    pattmatch = re.search('attach_dev = \'(.*)\'', data_str)
+    patt = pattmatch.group(1)
+
+    dev = [patt1.split(',') for patt1 in patt.split('<lf>')]
+
+    devices = {}
+    for dvc in dev:
+        if _MAC_REGEX.match(dvc[1]):
+            devices[dvc[1]] = dvc[0]
+        else:
+            raise RuntimeError('Error: MAC address ' + dvc[1] +
+                               ' not in correct format.')
+
+    return devices
@@ -12,7 +12,8 @@ from datetime import timedelta
 import voluptuous as vol

 import homeassistant.helpers.config_validation as cv
-from homeassistant.components.device_tracker import DOMAIN, PLATFORM_SCHEMA
+from homeassistant.components.device_tracker import (
+    DOMAIN, PLATFORM_SCHEMA, DeviceScanner)
 from homeassistant.const import CONF_HOST
 from homeassistant.util import Throttle

@@ -46,7 +47,7 @@ def get_scanner(hass, config):
    return scanner if scanner.success_init else None


-class SnmpScanner(object):
+class SnmpScanner(DeviceScanner):
    """Queries any SNMP capable Access Point for connected devices."""

    def __init__(self, config):
@@ -12,7 +12,8 @@ import requests
 import voluptuous as vol

 import homeassistant.helpers.config_validation as cv
-from homeassistant.components.device_tracker import DOMAIN, PLATFORM_SCHEMA
+from homeassistant.components.device_tracker import (
+    DOMAIN, PLATFORM_SCHEMA, DeviceScanner)
 from homeassistant.const import CONF_HOST
 from homeassistant.util import Throttle

@@ -35,7 +36,7 @@ def get_scanner(hass, config):
    return scanner if scanner.success_init else None


-class SwisscomDeviceScanner(object):
+class SwisscomDeviceScanner(DeviceScanner):
    """This class queries a router running Swisscom Internet-Box firmware."""

    def __init__(self, config):
@@ -0,0 +1,129 @@
+"""
+Support for Tado Smart Thermostat.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/device_tracker.tado/
+"""
+import logging
+from datetime import timedelta
+from collections import namedtuple
+
+import asyncio
+import aiohttp
+import async_timeout
+
+import voluptuous as vol
+
+from homeassistant.const import CONF_USERNAME, CONF_PASSWORD
+import homeassistant.helpers.config_validation as cv
+from homeassistant.util import Throttle
+from homeassistant.components.device_tracker import (
+    DOMAIN, PLATFORM_SCHEMA, DeviceScanner)
+from homeassistant.helpers.aiohttp_client import async_create_clientsession
+
+_LOGGER = logging.getLogger(__name__)
+
+MIN_TIME_BETWEEN_SCANS = timedelta(seconds=30)
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Required(CONF_PASSWORD): cv.string,
+    vol.Required(CONF_USERNAME): cv.string
+})
+
+
+def get_scanner(hass, config):
+    """Return a Tado scanner."""
+    scanner = TadoDeviceScanner(hass, config[DOMAIN])
+
+    return scanner if scanner.success_init else None
+
+
+Device = namedtuple("Device", ["mac", "name"])
+
+
+class TadoDeviceScanner(DeviceScanner):
+    """This class gets geofenced devices from Tado."""
+
+    def __init__(self, hass, config):
+        """Initialize the scanner."""
+        self.last_results = []
+
+        self.username = config[CONF_USERNAME]
+        self.password = config[CONF_PASSWORD]
+        self.tadoapiurl = 'https://my.tado.com/api/v2/me' \
+                          '?username={}&password={}'
+
+        self.websession = async_create_clientsession(
+            hass, cookie_jar=aiohttp.CookieJar(unsafe=True, loop=hass.loop))
+
+        self.success_init = self._update_info()
+        _LOGGER.info("Tado scanner initialized")
+
+    @asyncio.coroutine
+    def async_scan_devices(self):
+        """Scan for devices and return a list containing found device ids."""
+        yield from self._update_info()
+
+        return [device.mac for device in self.last_results]
+
+    @asyncio.coroutine
+    def async_get_device_name(self, mac):
+        """Return the name of the given device or None if we don't know."""
+        filter_named = [device.name for device in self.last_results
+                        if device.mac == mac]
+
+        if filter_named:
+            return filter_named[0]
+        else:
+            return None
+
+    @Throttle(MIN_TIME_BETWEEN_SCANS)
+    def _update_info(self):
+        """
+        Query Tado for device marked as at home.
+
+        Returns boolean if scanning successful.
+        """
+        _LOGGER.debug("Requesting Tado")
+
+        last_results = []
+
+        response = None
+        tadojson = None
+        try:
+            # get first token
+            with async_timeout.timeout(10, loop=self.hass.loop):
+                url = self.tadoapiurl.format(self.username, self.password)
+                response = yield from self.websession.get(
+                    url
+                )
+
+                # error on Tado webservice
+                if response.status != 200:
+                    _LOGGER.warning(
+                        "Error %d on %s.", response.status, self.tadoapiurl)
+                    self.token = None
+                    return
+
+                tadojson = yield from response.json()
+
+        except (asyncio.TimeoutError, aiohttp.errors.ClientError):
+            _LOGGER.error("Can not load Tado data")
+            return False
+
+        finally:
+            if response is not None:
+                yield from response.release()
+
+        # Find devices that have geofencing enabled, and are currently at home
+        for mobiledevice in tadojson['mobileDevices']:
+            if 'location' in mobiledevice:
+                if mobiledevice['location']['atHome']:
+                    deviceid = mobiledevice['id']
+                    devicename = mobiledevice['name']
+                    last_results.append(Device(deviceid, devicename))
+
+        self.last_results = last_results
+
+        _LOGGER.info("Tado presence query successful")
+        return True
@@ -13,7 +13,8 @@ from datetime import timedelta
 import voluptuous as vol

 import homeassistant.helpers.config_validation as cv
-from homeassistant.components.device_tracker import DOMAIN, PLATFORM_SCHEMA
+from homeassistant.components.device_tracker import (
+    DOMAIN, PLATFORM_SCHEMA, DeviceScanner)
 from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_USERNAME
 from homeassistant.util import Throttle

@@ -46,7 +47,7 @@ def get_scanner(hass, config):
    return scanner if scanner.success_init else None


-class ThomsonDeviceScanner(object):
+class ThomsonDeviceScanner(DeviceScanner):
    """This class queries a router running THOMSON firmware."""

    def __init__(self, config):
@@ -14,7 +14,8 @@ import requests
 import voluptuous as vol

 import homeassistant.helpers.config_validation as cv
-from homeassistant.components.device_tracker import DOMAIN, PLATFORM_SCHEMA
+from homeassistant.components.device_tracker import (
+    DOMAIN, PLATFORM_SCHEMA, DeviceScanner)
 from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_USERNAME
 from homeassistant.util import Throttle

@@ -38,7 +39,7 @@ def get_scanner(hass, config):
    return TomatoDeviceScanner(config[DOMAIN])


-class TomatoDeviceScanner(object):
+class TomatoDeviceScanner(DeviceScanner):
    """This class queries a wireless router running Tomato firmware."""

    def __init__(self, config):
@@ -15,7 +15,8 @@ import requests
 import voluptuous as vol

 import homeassistant.helpers.config_validation as cv
-from homeassistant.components.device_tracker import DOMAIN, PLATFORM_SCHEMA
+from homeassistant.components.device_tracker import (
+    DOMAIN, PLATFORM_SCHEMA, DeviceScanner)
 from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_USERNAME
 from homeassistant.util import Throttle

@@ -42,7 +43,7 @@ def get_scanner(hass, config):
    return None


-class TplinkDeviceScanner(object):
+class TplinkDeviceScanner(DeviceScanner):
    """This class queries a wireless router running TP-Link firmware."""

    def __init__(self, config):
@@ -0,0 +1,79 @@
+"""
+Support for the TrackR platform.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/device_tracker.trackr/
+"""
+import logging
+
+import voluptuous as vol
+
+from homeassistant.components.device_tracker import PLATFORM_SCHEMA
+from homeassistant.const import CONF_USERNAME, CONF_PASSWORD
+import homeassistant.helpers.config_validation as cv
+from homeassistant.helpers.event import track_utc_time_change
+
+_LOGGER = logging.getLogger(__name__)
+
+REQUIREMENTS = ['pytrackr==0.0.5']
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Required(CONF_USERNAME): cv.string,
+    vol.Required(CONF_PASSWORD): cv.string
+})
+
+
+def setup_scanner(hass, config: dict, see):
+    """Validate the configuration and return a TrackR scanner."""
+    TrackRDeviceScanner(hass, config, see)
+    return True
+
+
+class TrackRDeviceScanner(object):
+    """A class representing a TrackR device."""
+
+    def __init__(self, hass, config: dict, see) -> None:
+        """Initialize the TrackR device scanner."""
+        from pytrackr.api import trackrApiInterface
+        self.hass = hass
+        self.api = trackrApiInterface(config.get(CONF_USERNAME),
+                                      config.get(CONF_PASSWORD))
+        self.see = see
+        self.devices = self.api.get_trackrs()
+        self._update_info()
+
+        track_utc_time_change(self.hass, self._update_info,
+                              second=range(0, 60, 30))
+
+    def _update_info(self, now=None) -> None:
+        """Update the device info."""
+        _LOGGER.debug('Updating devices %s', now)
+
+        # Update self.devices to collect new devices added
+        # to the users account.
+        self.devices = self.api.get_trackrs()
+
+        for trackr in self.devices:
+            trackr.update_state()
+            trackr_id = trackr.tracker_id()
+            trackr_device_id = trackr.id()
+            lost = trackr.lost()
+            dev_id = trackr.name().replace(" ", "_")
+            if dev_id is None:
+                dev_id = trackr_id
+            location = trackr.last_known_location()
+            lat = location['latitude']
+            lon = location['longitude']
+
+            attrs = {
+                'last_updated': trackr.last_updated(),
+                'last_seen': trackr.last_time_seen(),
+                'trackr_id': trackr_id,
+                'id': trackr_device_id,
+                'lost': lost,
+                'battery_level': trackr.battery_level()
+            }
+
+            self.see(
+                dev_id=dev_id, gps=(lat, lon), attributes=attrs
+            )
@@ -14,7 +14,8 @@ import requests
 import voluptuous as vol

 import homeassistant.helpers.config_validation as cv
-from homeassistant.components.device_tracker import DOMAIN, PLATFORM_SCHEMA
+from homeassistant.components.device_tracker import (
+    DOMAIN, PLATFORM_SCHEMA, DeviceScanner)
 from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_USERNAME
 from homeassistant.util import Throttle

@@ -37,7 +38,7 @@ def get_scanner(hass, config):
    return scanner if scanner.success_init else None


-class UbusDeviceScanner(object):
+class UbusDeviceScanner(DeviceScanner):
    """
    This class queries a wireless router running OpenWrt firmware.

@@ -10,7 +10,8 @@ import voluptuous as vol

 import homeassistant.helpers.config_validation as cv
 import homeassistant.loader as loader
-from homeassistant.components.device_tracker import DOMAIN, PLATFORM_SCHEMA
+from homeassistant.components.device_tracker import (
+    DOMAIN, PLATFORM_SCHEMA, DeviceScanner)
 from homeassistant.const import CONF_HOST, CONF_USERNAME, CONF_PASSWORD

 # Unifi package doesn't list urllib3 as a requirement
@@ -59,7 +60,7 @@ def get_scanner(hass, config):
    return UnifiScanner(ctrl)


-class UnifiScanner(object):
+class UnifiScanner(DeviceScanner):
    """Provide device_tracker support from Unifi WAP client data."""

    def __init__(self, controller):
@@ -0,0 +1,180 @@
+"""
+Support for UPC ConnectBox router.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/device_tracker.upc_connect/
+"""
+import asyncio
+import logging
+import xml.etree.ElementTree as ET
+
+import aiohttp
+import async_timeout
+import voluptuous as vol
+
+from homeassistant.const import EVENT_HOMEASSISTANT_STOP
+import homeassistant.helpers.config_validation as cv
+from homeassistant.components.device_tracker import (
+    DOMAIN, PLATFORM_SCHEMA, DeviceScanner)
+from homeassistant.const import CONF_HOST, CONF_PASSWORD
+from homeassistant.helpers.aiohttp_client import async_create_clientsession
+
+
+_LOGGER = logging.getLogger(__name__)
+
+DEFAULT_IP = '192.168.0.1'
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Required(CONF_PASSWORD): cv.string,
+    vol.Optional(CONF_HOST, default=DEFAULT_IP): cv.string,
+})
+
+CMD_LOGIN = 15
+CMD_LOGOUT = 16
+CMD_DEVICES = 123
+
+
+@asyncio.coroutine
+def async_get_scanner(hass, config):
+    """Return the UPC device scanner."""
+    scanner = UPCDeviceScanner(hass, config[DOMAIN])
+    success_init = yield from scanner.async_login()
+
+    return scanner if success_init else None
+
+
+class UPCDeviceScanner(DeviceScanner):
+    """This class queries a router running UPC ConnectBox firmware."""
+
+    def __init__(self, hass, config):
+        """Initialize the scanner."""
+        self.hass = hass
+        self.host = config[CONF_HOST]
+        self.password = config[CONF_PASSWORD]
+
+        self.data = {}
+        self.token = None
+
+        self.headers = {
+            'X-Requested-With': 'XMLHttpRequest',
+            'Referer': "http://{}/index.html".format(self.host),
+            'User-Agent': ("Mozilla/5.0 (Windows NT 10.0; WOW64) "
+                           "AppleWebKit/537.36 (KHTML, like Gecko) "
+                           "Chrome/47.0.2526.106 Safari/537.36")
+        }
+
+        self.websession = async_create_clientsession(
+            hass, auto_cleanup=False,
+            cookie_jar=aiohttp.CookieJar(unsafe=True, loop=hass.loop)
+        )
+
+        @asyncio.coroutine
+        def async_logout(event):
+            """Logout from upc connect box."""
+            try:
+                yield from self._async_ws_function(CMD_LOGOUT)
+                self.token = None
+            finally:
+                self.websession.detach()
+
+        hass.bus.async_listen_once(
+            EVENT_HOMEASSISTANT_STOP, async_logout)
+
+    @asyncio.coroutine
+    def async_scan_devices(self):
+        """Scan for new devices and return a list with found device IDs."""
+        if self.token is None:
+            reconnect = yield from self.async_login()
+            if not reconnect:
+                _LOGGER.error("Not connected to %s", self.host)
+                return []
+
+        raw = yield from self._async_ws_function(CMD_DEVICES)
+
+        try:
+            xml_root = ET.fromstring(raw)
+            return [mac.text for mac in xml_root.iter('MACAddr')]
+        except (ET.ParseError, TypeError):
+            _LOGGER.warning("Can't read device from %s", self.host)
+            self.token = None
+            return []
+
+    @asyncio.coroutine
+    def async_get_device_name(self, device):
+        """The firmware doesn't save the name of the wireless device."""
+        return None
+
+    @asyncio.coroutine
+    def async_login(self):
+        """Login into firmware and get first token."""
+        response = None
+        try:
+            # get first token
+            self.websession.cookie_jar.clear()
+            with async_timeout.timeout(10, loop=self.hass.loop):
+                response = yield from self.websession.get(
+                    "http://{}/common_page/login.html".format(self.host)
+                )
+
+            yield from response.text()
+            self.token = response.cookies['sessionToken'].value
+
+            # login
+            data = yield from self._async_ws_function(CMD_LOGIN, {
+                'Username': 'NULL',
+                'Password': self.password,
+            })
+
+            # successfull?
+            if data is not None:
+                return True
+            return False
+
+        except (asyncio.TimeoutError, aiohttp.errors.ClientError):
+            _LOGGER.error("Can not load login page from %s", self.host)
+            return False
+
+        finally:
+            if response is not None:
+                yield from response.release()
+
+    @asyncio.coroutine
+    def _async_ws_function(self, function, additional_form=None):
+        """Execute a command on UPC firmware webservice."""
+        form_data = {
+            'token': self.token,
+            'fun': function
+        }
+
+        if additional_form:
+            form_data.update(additional_form)
+
+        response = None
+        try:
+            with async_timeout.timeout(10, loop=self.hass.loop):
+                response = yield from self.websession.post(
+                    "http://{}/xml/getter.xml".format(self.host),
+                    data=form_data,
+                    headers=self.headers
+                )
+
+                # error on UPC webservice
+                if response.status != 200:
+                    _LOGGER.warning(
+                        "Error %d on %s.", response.status, function)
+                    self.token = None
+                    return
+
+                # load data, store token for next request
+                raw = yield from response.text()
+                self.token = response.cookies['sessionToken'].value
+
+                return raw
+
+        except (asyncio.TimeoutError, aiohttp.errors.ClientError):
+            _LOGGER.error("Error on %s", function)
+            self.token = None
+
+        finally:
+            if response is not None:
+                yield from response.release()
@@ -14,12 +14,9 @@ from homeassistant.helpers.event import track_point_in_utc_time
 from homeassistant.util.dt import utcnow
 from homeassistant.util import slugify
 from homeassistant.const import (
-    CONF_PASSWORD,
-    CONF_SCAN_INTERVAL,
-    CONF_USERNAME)
+    CONF_PASSWORD, CONF_SCAN_INTERVAL, CONF_USERNAME)
 from homeassistant.components.device_tracker import (
-    DEFAULT_SCAN_INTERVAL,
-    PLATFORM_SCHEMA)
+    DEFAULT_SCAN_INTERVAL, PLATFORM_SCHEMA)

 MIN_TIME_BETWEEN_SCANS = timedelta(minutes=1)

@@ -40,7 +37,7 @@ def setup_scanner(hass, config, see):
        config.get(CONF_USERNAME),
        config.get(CONF_PASSWORD))

-    interval = max(MIN_TIME_BETWEEN_SCANS.seconds,
+    interval = max(MIN_TIME_BETWEEN_SCANS,
                   config.get(CONF_SCAN_INTERVAL, DEFAULT_SCAN_INTERVAL))

    def _see_vehicle(vehicle):
@@ -94,8 +91,7 @@ def setup_scanner(hass, config, see):

            return True
        finally:
-            track_point_in_utc_time(hass, update,
-                                    now + timedelta(seconds=interval))
+            track_point_in_utc_time(hass, update, now + interval)

    _LOGGER.info('Logging in to service')
    return update(utcnow())
@@ -0,0 +1,183 @@
+"""
+Support for Xiaomi Mi routers.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/device_tracker.xiaomi/
+"""
+import logging
+import threading
+from datetime import timedelta
+
+import requests
+import voluptuous as vol
+
+import homeassistant.helpers.config_validation as cv
+from homeassistant.components.device_tracker import (
+    DOMAIN, PLATFORM_SCHEMA, DeviceScanner)
+from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_USERNAME
+from homeassistant.util import Throttle
+
+# Return cached results if last scan was less then this time ago.
+MIN_TIME_BETWEEN_SCANS = timedelta(seconds=5)
+
+_LOGGER = logging.getLogger(__name__)
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Required(CONF_HOST): cv.string,
+    vol.Required(CONF_USERNAME, default='admin'): cv.string,
+    vol.Required(CONF_PASSWORD): cv.string
+})
+
+
+def get_scanner(hass, config):
+    """Validate the configuration and return a Xiaomi Device Scanner."""
+    scanner = XiaomiDeviceScanner(config[DOMAIN])
+
+    return scanner if scanner.success_init else None
+
+
+class XiaomiDeviceScanner(DeviceScanner):
+    """This class queries a Xiaomi Mi router.
+
+    Adapted from Luci scanner.
+    """
+
+    def __init__(self, config):
+        """Initialize the scanner."""
+        self.host = config[CONF_HOST]
+        self.username = config[CONF_USERNAME]
+        self.password = config[CONF_PASSWORD]
+
+        self.lock = threading.Lock()
+
+        self.last_results = {}
+        self.token = _get_token(self.host, self.username, self.password)
+
+        self.mac2name = None
+        self.success_init = self.token is not None
+
+    def scan_devices(self):
+        """Scan for new devices and return a list with found device IDs."""
+        self._update_info()
+        return self.last_results
+
+    def get_device_name(self, device):
+        """Return the name of the given device or None if we don't know."""
+        with self.lock:
+            if self.mac2name is None:
+                result = self._retrieve_list_with_retry()
+                if result:
+                    hosts = [x for x in result
+                             if 'mac' in x and 'name' in x]
+                    mac2name_list = [
+                        (x['mac'].upper(), x['name']) for x in hosts]
+                    self.mac2name = dict(mac2name_list)
+                else:
+                    # Error, handled in the _retrieve_list_with_retry
+                    return
+            return self.mac2name.get(device.upper(), None)
+
+    @Throttle(MIN_TIME_BETWEEN_SCANS)
+    def _update_info(self):
+        """Ensure the informations from the router are up to date.
+
+        Returns true if scanning successful.
+        """
+        if not self.success_init:
+            return False
+
+        with self.lock:
+            result = self._retrieve_list_with_retry()
+            if result:
+                self._store_result(result)
+                return True
+            return False
+
+    def _retrieve_list_with_retry(self):
+        """Retrieve the device list with a retry if token is invalid.
+
+        Return the list if successful.
+        """
+        _LOGGER.info('Refreshing device list')
+        result = _retrieve_list(self.host, self.token)
+        if result:
+            return result
+        else:
+            _LOGGER.info('Refreshing token and retrying device list refresh')
+            self.token = _get_token(self.host, self.username, self.password)
+            return _retrieve_list(self.host, self.token)
+
+    def _store_result(self, result):
+        """Extract and store the device list in self.last_results."""
+        self.last_results = []
+        for device_entry in result:
+            # Check if the device is marked as connected
+            if int(device_entry['online']) == 1:
+                self.last_results.append(device_entry['mac'])
+
+
+def _retrieve_list(host, token, **kwargs):
+    """"Get device list for the given host."""
+    url = "http://{}/cgi-bin/luci/;stok={}/api/misystem/devicelist"
+    url = url.format(host, token)
+    try:
+        res = requests.get(url, timeout=5, **kwargs)
+    except requests.exceptions.Timeout:
+        _LOGGER.exception('Connection to the router timed out at URL [%s]',
+                          url)
+        return
+    if res.status_code != 200:
+        _LOGGER.exception('Connection failed with http code [%s]',
+                          res.status_code)
+        return
+    try:
+        result = res.json()
+    except ValueError:
+        # If json decoder could not parse the response
+        _LOGGER.exception('Failed to parse response from mi router')
+        return
+    try:
+        xiaomi_code = result['code']
+    except KeyError:
+        _LOGGER.exception('No field code in response from mi router. %s',
+                          result)
+        return
+    if xiaomi_code == 0:
+        try:
+            return result['list']
+        except KeyError:
+            _LOGGER.exception('No list in response from mi router. %s', result)
+            return
+    else:
+        _LOGGER.info(
+            'Receive wrong Xiaomi code [%s], expected [0] in response [%s]',
+            xiaomi_code, result)
+        return
+
+
+def _get_token(host, username, password):
+    """Get authentication token for the given host+username+password."""
+    url = 'http://{}/cgi-bin/luci/api/xqsystem/login'.format(host)
+    data = {'username': username, 'password': password}
+    try:
+        res = requests.post(url, data=data, timeout=5)
+    except requests.exceptions.Timeout:
+        _LOGGER.exception('Connection to the router timed out')
+        return
+    if res.status_code == 200:
+        try:
+            result = res.json()
+        except ValueError:
+            # If json decoder could not parse the response
+            _LOGGER.exception('Failed to parse response from mi router')
+            return
+        try:
+            return result['token']
+        except KeyError:
+            error_message = "Xiaomi token cannot be refreshed, response from "\
+                            + "url: [%s] \nwith parameter: [%s] \nwas: [%s]"
+            _LOGGER.exception(error_message, url, data, result)
+            return
+    else:
+        _LOGGER.error('Invalid response: [%s] at url: [%s] with data [%s]',
+                      res, url, data)
@@ -38,6 +38,7 @@ SERVICE_HANDLERS = {
    'directv': ('media_player', 'directv'),
    'denonavr': ('media_player', 'denonavr'),
    'samsung_tv': ('media_player', 'samsungtv'),
+    'yeelight': ('light', 'yeelight'),
 }

 CONFIG_SCHEMA = vol.Schema({
@@ -5,6 +5,7 @@ For more details about this component, please refer to the documentation at
 https://home-assistant.io/components/emulated_hue/
 """
 import asyncio
+import json
 import logging

 import voluptuous as vol
@@ -13,6 +14,7 @@ from homeassistant import util
 from homeassistant.const import (
    EVENT_HOMEASSISTANT_START, EVENT_HOMEASSISTANT_STOP,
 )
+from homeassistant.components.http import REQUIREMENTS  # NOQA
 from homeassistant.components.http import HomeAssistantWSGI
 import homeassistant.helpers.config_validation as cv
 from .hue_api import (
@@ -24,8 +26,13 @@ DOMAIN = 'emulated_hue'

 _LOGGER = logging.getLogger(__name__)

+NUMBERS_FILE = 'emulated_hue_ids.json'
+
 CONF_HOST_IP = 'host_ip'
 CONF_LISTEN_PORT = 'listen_port'
+CONF_ADVERTISE_IP = 'advertise_ip'
+CONF_ADVERTISE_PORT = 'advertise_port'
+CONF_UPNP_BIND_MULTICAST = 'upnp_bind_multicast'
 CONF_OFF_MAPS_TO_ON_DOMAINS = 'off_maps_to_on_domains'
 CONF_EXPOSE_BY_DEFAULT = 'expose_by_default'
 CONF_EXPOSED_DOMAINS = 'exposed_domains'
@@ -35,18 +42,23 @@ TYPE_ALEXA = 'alexa'
 TYPE_GOOGLE = 'google_home'

 DEFAULT_LISTEN_PORT = 8300
+DEFAULT_UPNP_BIND_MULTICAST = True
 DEFAULT_OFF_MAPS_TO_ON_DOMAINS = ['script', 'scene']
 DEFAULT_EXPOSE_BY_DEFAULT = True
 DEFAULT_EXPOSED_DOMAINS = [
    'switch', 'light', 'group', 'input_boolean', 'media_player', 'fan'
 ]
-DEFAULT_TYPE = TYPE_ALEXA
+DEFAULT_TYPE = TYPE_GOOGLE

 CONFIG_SCHEMA = vol.Schema({
    DOMAIN: vol.Schema({
        vol.Optional(CONF_HOST_IP): cv.string,
        vol.Optional(CONF_LISTEN_PORT, default=DEFAULT_LISTEN_PORT):
            vol.All(vol.Coerce(int), vol.Range(min=1, max=65535)),
+        vol.Optional(CONF_ADVERTISE_IP): cv.string,
+        vol.Optional(CONF_ADVERTISE_PORT):
+            vol.All(vol.Coerce(int), vol.Range(min=1, max=65535)),
+        vol.Optional(CONF_UPNP_BIND_MULTICAST): cv.boolean,
        vol.Optional(CONF_OFF_MAPS_TO_ON_DOMAINS): cv.ensure_list,
        vol.Optional(CONF_EXPOSE_BY_DEFAULT): cv.boolean,
        vol.Optional(CONF_EXPOSED_DOMAINS): cv.ensure_list,
@@ -60,7 +72,7 @@ ATTR_EMULATED_HUE = 'emulated_hue'

 def setup(hass, yaml_config):
    """Activate the emulated_hue component."""
-    config = Config(yaml_config.get(DOMAIN, {}))
+    config = Config(hass, yaml_config.get(DOMAIN, {}))

    server = HomeAssistantWSGI(
        hass,
@@ -84,7 +96,9 @@ def setup(hass, yaml_config):
    server.register_view(HueOneLightChangeView(config))

    upnp_listener = UPNPResponderThread(
-        config.host_ip_addr, config.listen_port)
+        config.host_ip_addr, config.listen_port,
+        config.upnp_bind_multicast, config.advertise_ip,
+        config.advertise_port)

    @asyncio.coroutine
    def stop_emulated_hue_bridge(event):
@@ -108,12 +122,17 @@ def setup(hass, yaml_config):
 class Config(object):
    """Holds configuration variables for the emulated hue bridge."""

-    def __init__(self, conf):
+    def __init__(self, hass, conf):
        """Initialize the instance."""
+        self.hass = hass
        self.type = conf.get(CONF_TYPE)
-        self.numbers = {}
+        self.numbers = None
        self.cached_states = {}

+        if self.type == TYPE_ALEXA:
+            _LOGGER.warning('Alexa type is deprecated and will be removed in a'
+                            ' future version')
+
        # Get the IP address that will be passed to the Echo during discovery
        self.host_ip_addr = conf.get(CONF_HOST_IP)
        if self.host_ip_addr is None:
@@ -134,6 +153,11 @@ class Config(object):
            _LOGGER.warning('When targetting Google Home, listening port has '
                            'to be port 80')

+        # Get whether or not UPNP binds to multicast address (239.255.255.250)
+        # or to the unicast address (host_ip_addr)
+        self.upnp_bind_multicast = conf.get(
+            CONF_UPNP_BIND_MULTICAST, DEFAULT_UPNP_BIND_MULTICAST)
+
        # Get domains that cause both "on" and "off" commands to map to "on"
        # This is primarily useful for things like scenes or scripts, which
        # don't really have a concept of being off
@@ -151,11 +175,21 @@ class Config(object):
        self.exposed_domains = conf.get(
            CONF_EXPOSED_DOMAINS, DEFAULT_EXPOSED_DOMAINS)

+        # Calculated effective advertised IP and port for network isolation
+        self.advertise_ip = conf.get(
+            CONF_ADVERTISE_IP) or self.host_ip_addr
+
+        self.advertise_port = conf.get(
+            CONF_ADVERTISE_PORT) or self.listen_port
+
    def entity_id_to_number(self, entity_id):
        """Get a unique number for the entity id."""
        if self.type == TYPE_ALEXA:
            return entity_id

+        if self.numbers is None:
+            self.numbers = self._load_numbers_json()
+
        # Google Home
        for number, ent_id in self.numbers.items():
            if entity_id == ent_id:
@@ -163,6 +197,7 @@ class Config(object):

        number = str(len(self.numbers) + 1)
        self.numbers[number] = entity_id
+        self._save_numbers_json()
        return number

    def number_to_entity_id(self, number):
@@ -170,6 +205,9 @@ class Config(object):
        if self.type == TYPE_ALEXA:
            return number

+        if self.numbers is None:
+            self.numbers = self._load_numbers_json()
+
        # Google Home
        assert isinstance(number, str)
        return self.numbers.get(number)
@@ -196,3 +234,26 @@ class Config(object):
            domain_exposed_by_default and explicit_expose is not False

        return is_default_exposed or explicit_expose
+
+    def _load_numbers_json(self):
+        """Helper method to load numbers json."""
+        try:
+            with open(self.hass.config.path(NUMBERS_FILE),
+                      encoding='utf-8') as fil:
+                return json.loads(fil.read())
+        except (OSError, ValueError) as err:
+            # OSError if file not found or unaccessible/no permissions
+            # ValueError if could not parse JSON
+            if not isinstance(err, FileNotFoundError):
+                _LOGGER.warning('Failed to open %s: %s', NUMBERS_FILE, err)
+            return {}
+
+    def _save_numbers_json(self):
+        """Helper method to save numbers json."""
+        try:
+            with open(self.hass.config.path(NUMBERS_FILE), 'w',
+                      encoding='utf-8') as fil:
+                fil.write(json.dumps(self.numbers))
+        except OSError as err:
+            # OSError if file write permissions
+            _LOGGER.warning('Failed to write %s: %s', NUMBERS_FILE, err)
@@ -7,7 +7,8 @@ from aiohttp import web
 from homeassistant import core
 from homeassistant.const import (
    ATTR_ENTITY_ID, SERVICE_TURN_OFF, SERVICE_TURN_ON, SERVICE_VOLUME_SET,
-    STATE_ON, STATE_OFF, HTTP_BAD_REQUEST, HTTP_NOT_FOUND,
+    SERVICE_OPEN_COVER, SERVICE_CLOSE_COVER, STATE_ON, STATE_OFF,
+    HTTP_BAD_REQUEST, HTTP_NOT_FOUND,
 )
 from homeassistant.components.light import (
    ATTR_BRIGHTNESS, ATTR_SUPPORTED_FEATURES, SUPPORT_BRIGHTNESS
@@ -16,6 +17,10 @@ from homeassistant.components.media_player import (
    ATTR_MEDIA_VOLUME_LEVEL, ATTR_SUPPORTED_MEDIA_COMMANDS,
    SUPPORT_VOLUME_SET,
 )
+from homeassistant.components.fan import (
+    ATTR_SPEED, SUPPORT_SET_SPEED, SPEED_OFF, SPEED_LOW,
+    SPEED_MEDIUM, SPEED_HIGH
+)
 from homeassistant.components.http import HomeAssistantView

 _LOGGER = logging.getLogger(__name__)
@@ -90,7 +95,7 @@ class HueOneLightStateView(HomeAssistantView):
        self.config = config

    @core.callback
-    def get(self, request, username, entity_id=None):
+    def get(self, request, username, entity_id):
        """Process a request to get the state of an individual light."""
        hass = request.app['hass']
        entity_id = self.config.number_to_entity_id(entity_id)
@@ -161,6 +166,9 @@ class HueOneLightChangeView(HomeAssistantView):
        # Choose general HA domain
        domain = core.DOMAIN

+        # Entity needs separate call to turn on
+        turn_on_needed = False
+
        # Convert the resulting "on" status into the service we need to call
        service = SERVICE_TURN_ON if result else SERVICE_TURN_OFF

@@ -170,7 +178,9 @@ class HueOneLightChangeView(HomeAssistantView):
        # Make sure the entity actually supports brightness
        entity_features = entity.attributes.get(ATTR_SUPPORTED_FEATURES, 0)

-        if (entity_features & SUPPORT_BRIGHTNESS) == SUPPORT_BRIGHTNESS:
+        if (entity_features &
+                SUPPORT_BRIGHTNESS &
+                (entity.domain == "light")) == SUPPORT_BRIGHTNESS:
            if brightness is not None:
                data[ATTR_BRIGHTNESS] = brightness

@@ -189,11 +199,37 @@ class HueOneLightChangeView(HomeAssistantView):
                ATTR_SUPPORTED_MEDIA_COMMANDS, 0)
            if media_commands & SUPPORT_VOLUME_SET == SUPPORT_VOLUME_SET:
                if brightness is not None:
+                    turn_on_needed = True
                    domain = entity.domain
                    service = SERVICE_VOLUME_SET
                    # Convert 0-100 to 0.0-1.0
                    data[ATTR_MEDIA_VOLUME_LEVEL] = brightness / 100.0

+        # If the requested entity is a cover, convert to open_cover/close_cover
+        elif entity.domain == "cover":
+            domain = entity.domain
+            if service == SERVICE_TURN_ON:
+                service = SERVICE_OPEN_COVER
+            else:
+                service = SERVICE_CLOSE_COVER
+
+        # If the requested entity is a fan, convert to speed
+        elif entity.domain == "fan":
+            functions = entity.attributes.get(
+                ATTR_SUPPORTED_FEATURES, 0)
+            if (functions & SUPPORT_SET_SPEED) == SUPPORT_SET_SPEED:
+                if brightness is not None:
+                    domain = entity.domain
+                    # Convert 0-100 to a fan speed
+                    if brightness == 0:
+                        data[ATTR_SPEED] = SPEED_OFF
+                    elif brightness <= 33.3 and brightness > 0:
+                        data[ATTR_SPEED] = SPEED_LOW
+                    elif brightness <= 66.6 and brightness > 33.3:
+                        data[ATTR_SPEED] = SPEED_MEDIUM
+                    elif brightness <= 100 and brightness > 66.6:
+                        data[ATTR_SPEED] = SPEED_HIGH
+
        if entity.domain in config.off_maps_to_on_domains:
            # Map the off command to on
            service = SERVICE_TURN_ON
@@ -206,7 +242,7 @@ class HueOneLightChangeView(HomeAssistantView):
            config.cached_states[entity_id] = (result, brightness)

        # Separate call to turn on needed
-        if domain != core.DOMAIN:
+        if turn_on_needed:
            hass.async_add_job(hass.services.async_call(
                core.DOMAIN, SERVICE_TURN_ON, {ATTR_ENTITY_ID: entity_id},
                blocking=True))
@@ -256,7 +292,9 @@ def parse_hue_api_put_light_body(request_json, entity):
            report_brightness = True
            result = (brightness > 0)

-        elif entity.domain == "script" or entity.domain == "media_player":
+        elif (entity.domain == "script" or
+              entity.domain == "media_player" or
+              entity.domain == "fan"):
            # Convert 0-255 to 0-100
            level = brightness / 255 * 100
            brightness = round(level)
@@ -286,8 +324,21 @@ def get_entity_state(config, entity):
                ATTR_MEDIA_VOLUME_LEVEL, 1.0 if final_state else 0.0)
            # Convert 0.0-1.0 to 0-255
            final_brightness = round(min(1.0, level) * 255)
+        elif entity.domain == "fan":
+            speed = entity.attributes.get(ATTR_SPEED, 0)
+            # Convert 0.0-1.0 to 0-255
+            final_brightness = 0
+            if speed == SPEED_LOW:
+                final_brightness = 85
+            elif speed == SPEED_MEDIUM:
+                final_brightness = 170
+            elif speed == SPEED_HIGH:
+                final_brightness = 255
    else:
        final_state, final_brightness = cached_state
+        # Make sure brightness is valid
+        if final_brightness is None:
+            final_brightness = 255 if final_state else 0

    return (final_state, final_brightness)

@@ -50,7 +50,7 @@ class DescriptionXmlView(HomeAssistantView):
 """

        resp_text = xml_template.format(
-            self.config.host_ip_addr, self.config.listen_port)
+            self.config.advertise_ip, self.config.advertise_port)

        return web.Response(text=resp_text, content_type='text/xml')

@@ -60,12 +60,14 @@ class UPNPResponderThread(threading.Thread):

    _interrupted = False

-    def __init__(self, host_ip_addr, listen_port):
+    def __init__(self, host_ip_addr, listen_port, upnp_bind_multicast,
+                 advertise_ip, advertise_port):
        """Initialize the class."""
        threading.Thread.__init__(self)

        self.host_ip_addr = host_ip_addr
        self.listen_port = listen_port
+        self.upnp_bind_multicast = upnp_bind_multicast

        # Note that the double newline at the end of
        # this string is required per the SSDP spec
@@ -80,9 +82,9 @@ USN: uuid:Socket-1_0-221438K0100073::urn:schemas-upnp-org:device:basic:1

 """

-        self.upnp_response = resp_template.format(host_ip_addr, listen_port) \
-                                          .replace("\n", "\r\n") \
-                                          .encode('utf-8')
+        self.upnp_response = resp_template.format(
+            advertise_ip, advertise_port).replace("\n", "\r\n") \
+                                         .encode('utf-8')

        # Set up a pipe for signaling to the receiver that it's time to
        # shutdown. Essentially, we place the SSDP socket into nonblocking
@@ -116,7 +118,10 @@ USN: uuid:Socket-1_0-221438K0100073::urn:schemas-upnp-org:device:basic:1
            socket.inet_aton("239.255.255.250") +
            socket.inet_aton(self.host_ip_addr))

-        ssdp_socket.bind(("239.255.255.250", 1900))
+        if self.upnp_bind_multicast:
+            ssdp_socket.bind(("239.255.255.250", 1900))
+        else:
+            ssdp_socket.bind((self.host_ip_addr, 1900))

        while True:
            if self._interrupted:
@@ -12,7 +12,7 @@ from homeassistant.const import EVENT_HOMEASSISTANT_STOP
 from homeassistant.helpers.entity import Entity
 from homeassistant.components.discovery import load_platform

-REQUIREMENTS = ['pyenvisalink==1.9', 'pydispatcher==2.0.5']
+REQUIREMENTS = ['pyenvisalink==2.0', 'pydispatcher==2.0.5']

 _LOGGER = logging.getLogger(__name__)
 DOMAIN = 'envisalink'
--- a/Show More
+++ b/Show More