0.6.5

History tweaks

.gitignore

@@ -11,3 +11,5 @@ build/
 .idea/
 
 key.properties
+premium_features_manager.class.dart
+pubspec.lock

CODE_OF_CONDUCT.md

@@ -0,0 +1,76 @@
+# 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, sex characteristics, gender identity and expression,
+level of experience, education, socio-economic status, 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 vyalov.egor@gmail.com. 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 at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html
+
+[homepage]: https://www.contributor-covenant.org
+
+For answers to common questions about this code of conduct, see
+https://www.contributor-covenant.org/faq

LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   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.

README.md

@@ -1,3 +1,9 @@
-# Android client for Home Assistant
+# HA Client
+## Native Android client for Home Assistant
+### With Lovelace UI support
 
-Home Assistant Android client using Flutter and Dart.
+Visit [homemade.systems](http://ha-client.homemade.systems/) for more info.
+
+Download the app from [Google Play](https://play.google.com/apps/testing/com.keyboardcrumbs.haclient)
+
+Discuss it in [Home Assistant community](https://community.home-assistant.io/t/alpha-testing-ha-client-native-android-client-for-home-assistant/69912) or on [Discord server](https://discord.gg/AUzEvwn)

android/app/build.gradle

@@ -29,7 +29,12 @@ def keystoreProperties = new Properties()
 keystoreProperties.load(new FileInputStream(keystorePropertiesFile))
 
 android {
-    compileSdkVersion 27
+    compileSdkVersion 28
+
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_1_8
+        targetCompatibility JavaVersion.VERSION_1_8
+    }
 
     lintOptions {
         disable 'InvalidPackage'
@@ -38,7 +43,7 @@ android {
     defaultConfig {
         applicationId "com.keyboardcrumbs.haclient"
         minSdkVersion 21
-        targetSdkVersion 27
+        targetSdkVersion 28
         versionCode flutterVersionCode.toInteger()
         versionName flutterVersionName
         testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
@@ -65,7 +70,10 @@ flutter {
 }
 
 dependencies {
+    implementation 'com.google.firebase:firebase-core:16.0.8'
     testImplementation 'junit:junit:4.12'
     androidTestImplementation 'com.android.support.test:runner:1.0.2'
     androidTestImplementation 'com.android.support.test.espresso:espresso-core:3.0.2'
 }
+
+apply plugin: 'com.google.gms.google-services'

android/app/google-services.json

@@ -0,0 +1,42 @@
+{
+  "project_info": {
+    "project_number": "441874387819",
+    "firebase_url": "https://ha-client-c73c4.firebaseio.com",
+    "project_id": "ha-client-c73c4",
+    "storage_bucket": "ha-client-c73c4.appspot.com"
+  },
+  "client": [
+    {
+      "client_info": {
+        "mobilesdk_app_id": "1:441874387819:android:92c7efc892dc3d45",
+        "android_client_info": {
+          "package_name": "com.keyboardcrumbs.haclient"
+        }
+      },
+      "oauth_client": [
+        {
+          "client_id": "441874387819-id0hqsfprj3b5kc312faqv3lmdfpm7l8.apps.googleusercontent.com",
+          "client_type": 3
+        }
+      ],
+      "api_key": [
+        {
+          "current_key": "AIzaSyBsl9cjBY633IrdrTyCsLFlO9lfsYJ0OJU"
+        }
+      ],
+      "services": {
+        "analytics_service": {
+          "status": 1
+        },
+        "appinvite_service": {
+          "status": 1,
+          "other_platform_oauth_client": []
+        },
+        "ads_service": {
+          "status": 2
+        }
+      }
+    }
+  ],
+  "configuration_version": "1"
+}

android/app/src/main/AndroidManifest.xml

@@ -6,6 +6,11 @@
          to allow setting breakpoints, to provide hot reload, etc.
     -->
     <uses-permission android:name="android.permission.INTERNET"/>
+    <uses-permission android:name="android.permission.VIBRATE" />
+    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
+    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
+    <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED"/>
+    <uses-permission android:name="android.permission.WAKE_LOCK"/>
 
     <!-- io.flutter.app.FlutterApplication is an android.app.Application that
          calls FlutterMain.startInitialization(this); in its onCreate method.
@@ -13,9 +18,15 @@
          additional functionality it is fine to subclass or reimplement
          FlutterApplication and put your custom class here. -->
     <application
-        android:name="io.flutter.app.FlutterApplication"
+        android:name=".Application"
         android:label="HA Client"
-        android:icon="@mipmap/ic_launcher">
+        android:icon="@mipmap/ic_launcher"
+        android:usesCleartextTraffic="true">
+
+        <meta-data
+            android:name="com.google.firebase.messaging.default_notification_channel_id"
+            android:value="ha_notify" />
+
         <activity
             android:name=".MainActivity"
             android:launchMode="singleTop"
@@ -26,14 +37,33 @@
             <!-- This keeps the window background of the activity showing
                  until Flutter renders its first frame. It can be removed if
                  there is no splash screen (such as the default splash screen
-                 defined in @style/LaunchTheme). -->
+                 defined in @style/LaunchTheme).
             <meta-data
                 android:name="io.flutter.app.android.SplashScreenUntilFirstFrame"
-                android:value="true" />
+                android:value="true" />-->
+            <intent-filter>
+                <action android:name="FLUTTER_NOTIFICATION_CLICK" />
+                <category android:name="android.intent.category.DEFAULT" />
+            </intent-filter>
             <intent-filter>
                 <action android:name="android.intent.action.MAIN"/>
                 <category android:name="android.intent.category.LAUNCHER"/>
             </intent-filter>
         </activity>
+
+        <service
+            android:name="io.flutter.plugins.androidalarmmanager.AlarmService"
+            android:permission="android.permission.BIND_JOB_SERVICE"
+            android:exported="false"/>
+        <receiver
+            android:name="io.flutter.plugins.androidalarmmanager.AlarmBroadcastReceiver"
+            android:exported="false"/>
+        <receiver
+            android:name="io.flutter.plugins.androidalarmmanager.RebootBroadcastReceiver"
+            android:enabled="false">
+            <intent-filter>
+                <action android:name="android.intent.action.BOOT_COMPLETED"></action>
+            </intent-filter>
+        </receiver>
     </application>
 </manifest>

android/app/src/main/java/com/keyboardcrumbs/hassclient/Application.java

@@ -0,0 +1,18 @@
+package com.keyboardcrumbs.hassclient;
+
+import io.flutter.app.FlutterApplication;
+import io.flutter.plugin.common.PluginRegistry;
+import io.flutter.plugin.common.PluginRegistry.PluginRegistrantCallback;
+import io.flutter.plugins.GeneratedPluginRegistrant;
+
+public class Application extends FlutterApplication implements PluginRegistrantCallback {
+    @Override
+    public void onCreate() {
+        super.onCreate();
+    }
+
+    @Override
+    public void registerWith(PluginRegistry registry) {
+        GeneratedPluginRegistrant.registerWith(registry);
+    }
+}

android/build.gradle

@@ -5,7 +5,8 @@ buildscript {
     }
 
     dependencies {
-        classpath 'com.android.tools.build:gradle:3.1.2'
+        classpath 'com.android.tools.build:gradle:3.3.2'
+        classpath 'com.google.gms:google-services:4.2.0'
     }
 }
 

android/gradle.properties

@@ -1 +1,5 @@
-org.gradle.jvmargs=-Xmx1536M
+org.gradle.jvmargs=-Xmx2g
+org.gradle.daemon=true
+org.gradle.caching=true
+android.useAndroidX=true
+android.enableJetifier=true

android/gradle/wrapper/gradle-wrapper.properties

@@ -3,4 +3,4 @@ distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-4.4-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-4.10.1-all.zip

assets/js/externalAuth.js

@@ -0,0 +1,16 @@
+window.externalApp = {};
+window.externalApp.getExternalAuth = function(options) {
+    console.log("Starting external auth");
+    var options = JSON.parse(options);
+    if (options && options.callback) {
+        var responseData = {
+            access_token: "[token]",
+            expires_in: 1800
+        };
+        console.log("Waiting for callback to be added");
+        setTimeout(function(){
+            console.log("Calling a callback");
+            window[options.callback](true, responseData);
+        }, 500);
+    }
+};

docs/empty

@@ -0,0 +1 @@
+

flutter_01.log

@@ -0,0 +1,41 @@
+Flutter crash report; please file at https://github.com/flutter/flutter/issues.
+
+## command
+
+flutter --no-color run --machine --track-widget-creation --device-id=89AY052S4 lib/main.dart
+
+## exception
+
+_InternalLinkedHashMap<String, dynamic>: {code: 105, message: Isolate must be runnable, data: {request: {method: _reloadSources, params: {pause: true, rootLibUri: file:///data/user/0/com.keyboardcrumbs.haclient/code_cache/ha_clientSYJJZI/ha_client/lib/main.dart.incremental.dill, packagesUri: file:///data/user/0/com.keyboardcrumbs.haclient/code_cache/ha_clientSYJJZI/ha_client/.packages, isolateId: isolates/68989666}}, details: Isolate must be runnable before this request is made.}}
+
+```
+null```
+
+## flutter doctor
+
+```
+[✓] Flutter (Channel stable, v1.7.8+hotfix.4, on Linux, locale en_US.UTF-8)
+    • Flutter version 1.7.8+hotfix.4 at /home/estevez/sdk/flutter
+    • Framework revision 20e59316b8 (6 weeks ago), 2019-07-18 20:04:33 -0700
+    • Engine revision fee001c93f
+    • Dart version 2.4.0
+
+[✓] Android toolchain - develop for Android devices (Android SDK version 29.0.2)
+    • Android SDK at /home/estevez/Android/Sdk
+    • Android NDK location not configured (optional; useful for native profiling support)
+    • Platform android-29, build-tools 29.0.2
+    • Java binary at: /home/estevez/bin/android-studio/jre/bin/java
+    • Java version OpenJDK Runtime Environment (build 1.8.0_202-release-1483-b49-5587405)
+    • All Android licenses accepted.
+
+[✓] Android Studio (version 3.5)
+    • Android Studio at /home/estevez/bin/android-studio
+    • Flutter plugin version 38.2.3
+    • Dart plugin version 191.8423
+    • Java version OpenJDK Runtime Environment (build 1.8.0_202-release-1483-b49-5587405)
+
+[✓] Connected device (1 available)
+    • Pixel 3 XL • 89AY052S4 • android-arm64 • Android 9 (API 28)
+
+• No issues found!
+```

flutter_02.log

@@ -0,0 +1,41 @@
+Flutter crash report; please file at https://github.com/flutter/flutter/issues.
+
+## command
+
+flutter --no-color run --machine --track-widget-creation --device-id=89AY052S4 lib/main.dart
+
+## exception
+
+_InternalLinkedHashMap<String, dynamic>: {code: 105, message: Isolate must be runnable, data: {request: {method: _reloadSources, params: {pause: true, rootLibUri: file:///data/user/0/com.keyboardcrumbs.haclient/code_cache/ha_clientWYMXDL/ha_client/lib/main.dart.incremental.dill, packagesUri: file:///data/user/0/com.keyboardcrumbs.haclient/code_cache/ha_clientWYMXDL/ha_client/.packages, isolateId: isolates/289688365}}, details: Isolate must be runnable before this request is made.}}
+
+```
+null```
+
+## flutter doctor
+
+```
+[✓] Flutter (Channel stable, v1.7.8+hotfix.4, on Linux, locale en_US.UTF-8)
+    • Flutter version 1.7.8+hotfix.4 at /home/estevez/sdk/flutter
+    • Framework revision 20e59316b8 (6 weeks ago), 2019-07-18 20:04:33 -0700
+    • Engine revision fee001c93f
+    • Dart version 2.4.0
+
+[✓] Android toolchain - develop for Android devices (Android SDK version 29.0.2)
+    • Android SDK at /home/estevez/Android/Sdk
+    • Android NDK location not configured (optional; useful for native profiling support)
+    • Platform android-29, build-tools 29.0.2
+    • Java binary at: /home/estevez/bin/android-studio/jre/bin/java
+    • Java version OpenJDK Runtime Environment (build 1.8.0_202-release-1483-b49-5587405)
+    • All Android licenses accepted.
+
+[✓] Android Studio (version 3.5)
+    • Android Studio at /home/estevez/bin/android-studio
+    • Flutter plugin version 38.2.3
+    • Dart plugin version 191.8423
+    • Java version OpenJDK Runtime Environment (build 1.8.0_202-release-1483-b49-5587405)
+
+[✓] Connected device (1 available)
+    • Pixel 3 XL • 89AY052S4 • android-arm64 • Android 9 (API 28)
+
+• No issues found!
+```

flutter_03.log

@@ -0,0 +1,41 @@
+Flutter crash report; please file at https://github.com/flutter/flutter/issues.
+
+## command
+
+flutter --no-color run --machine --track-widget-creation --device-id=89AY052S4 lib/main.dart
+
+## exception
+
+_InternalLinkedHashMap<String, dynamic>: {code: 105, message: Isolate must be runnable, data: {request: {method: _reloadSources, params: {pause: true, rootLibUri: file:///data/user/0/com.keyboardcrumbs.haclient/code_cache/ha_clientLNSJAH/ha_client/lib/main.dart.incremental.dill, packagesUri: file:///data/user/0/com.keyboardcrumbs.haclient/code_cache/ha_clientLNSJAH/ha_client/.packages, isolateId: isolates/866521062}}, details: Isolate must be runnable before this request is made.}}
+
+```
+null```
+
+## flutter doctor
+
+```
+[✓] Flutter (Channel stable, v1.7.8+hotfix.4, on Linux, locale en_US.UTF-8)
+    • Flutter version 1.7.8+hotfix.4 at /home/estevez/sdk/flutter
+    • Framework revision 20e59316b8 (6 weeks ago), 2019-07-18 20:04:33 -0700
+    • Engine revision fee001c93f
+    • Dart version 2.4.0
+
+[✓] Android toolchain - develop for Android devices (Android SDK version 29.0.2)
+    • Android SDK at /home/estevez/Android/Sdk
+    • Android NDK location not configured (optional; useful for native profiling support)
+    • Platform android-29, build-tools 29.0.2
+    • Java binary at: /home/estevez/bin/android-studio/jre/bin/java
+    • Java version OpenJDK Runtime Environment (build 1.8.0_202-release-1483-b49-5587405)
+    • All Android licenses accepted.
+
+[✓] Android Studio (version 3.5)
+    • Android Studio at /home/estevez/bin/android-studio
+    • Flutter plugin version 38.2.3
+    • Dart plugin version 191.8423
+    • Java version OpenJDK Runtime Environment (build 1.8.0_202-release-1483-b49-5587405)
+
+[✓] Connected device (1 available)
+    • Pixel 3 XL • 89AY052S4 • android-arm64 • Android 9 (API 28)
+
+• No issues found!
+```

lib/const.dart

@@ -0,0 +1,99 @@
+part of 'main.dart';
+
+class EntityState {
+  static const on = 'on';
+  static const off = 'off';
+  static const home = 'home';
+  static const not_home = 'not_home';
+  static const unknown = 'unknown';
+  static const open = 'open';
+  static const opening = 'opening';
+  static const closed = 'closed';
+  static const closing = 'closing';
+  static const playing = 'playing';
+  static const paused = 'paused';
+  static const idle = 'idle';
+  static const standby = 'standby';
+  static const alarm_disarmed = 'disarmed';
+  static const alarm_armed_home = 'armed_home';
+  static const alarm_armed_away = 'armed_away';
+  static const alarm_armed_night = 'armed_night';
+  static const alarm_armed_custom_bypass = 'armed_custom_bypass';
+  static const alarm_pending = 'pending';
+  static const alarm_arming = 'arming';
+  static const alarm_disarming = 'disarming';
+  static const alarm_triggered = 'triggered';
+  static const locked = 'locked';
+  static const unlocked = 'unlocked';
+  static const unavailable = 'unavailable';
+  static const ok = 'ok';
+  static const problem = 'problem';
+  static const active = 'active';
+}
+
+class EntityUIAction {
+  static const moreInfo = 'more-info';
+  static const toggle = 'toggle';
+  static const callService = 'call-service';
+  static const navigate = 'navigate';
+  static const none = 'none';
+
+  String tapAction = EntityUIAction.moreInfo;
+  String tapNavigationPath;
+  String tapService;
+  Map<String, dynamic> tapServiceData;
+  String holdAction = EntityUIAction.none;
+  String holdNavigationPath;
+  String holdService;
+  Map<String, dynamic> holdServiceData;
+
+  EntityUIAction({rawEntityData}) {
+    if (rawEntityData != null) {
+      if (rawEntityData["tap_action"] != null) {
+        if (rawEntityData["tap_action"] is String) {
+          tapAction = rawEntityData["tap_action"];
+        } else {
+          tapAction =
+              rawEntityData["tap_action"]["action"] ?? EntityUIAction.moreInfo;
+          tapNavigationPath = rawEntityData["tap_action"]["navigation_path"];
+          tapService = rawEntityData["tap_action"]["service"];
+          tapServiceData = rawEntityData["tap_action"]["service_data"];
+        }
+      }
+      if (rawEntityData["hold_action"] != null) {
+        if (rawEntityData["hold_action"] is String) {
+          holdAction = rawEntityData["hold_action"];
+        } else {
+          holdAction =
+              rawEntityData["hold_action"]["action"] ?? EntityUIAction.none;
+          holdNavigationPath = rawEntityData["hold_action"]["navigation_path"];
+          holdService = rawEntityData["hold_action"]["service"];
+          holdServiceData = rawEntityData["hold_action"]["service_data"];
+        }
+      }
+    }
+  }
+
+}
+
+class CardType {
+  static const horizontalStack = "horizontal-stack";
+  static const verticalStack = "vertical-stack";
+  static const entities = "entities";
+  static const glance = "glance";
+  static const mediaControl = "media-control";
+  static const weatherForecast = "weather-forecast";
+  static const thermostat = "thermostat";
+  static const sensor = "sensor";
+  static const plantStatus = "plant-status";
+  static const pictureEntity = "picture-entity";
+  static const pictureElements = "picture-elements";
+  static const picture = "picture";
+  static const map = "map";
+  static const iframe = "iframe";
+  static const gauge = "gauge";
+  static const entityButton = "entity-button";
+  static const conditional = "conditional";
+  static const alarmPanel = "alarm-panel";
+  static const markdown = "markdown";
+}

lib/entities/alarm_control_panel/alarm_control_panel_entity.class.dart

@@ -0,0 +1,13 @@
+part of '../../main.dart';
+
+class AlarmControlPanelEntity extends Entity {
+  AlarmControlPanelEntity(Map rawData, String webHost) : super(rawData, webHost);
+
+
+  @override
+  Widget _buildAdditionalControlsForPage(BuildContext context) {
+    return AlarmControlPanelControlsWidget(
+      extended: false,
+    );
+  }
+}

lib/entities/alarm_control_panel/widgets/alarm_control_panel_controls.widget.dart

@@ -0,0 +1,262 @@
+part of '../../../main.dart';
+
+class AlarmControlPanelControlsWidget extends StatefulWidget {
+
+  final bool extended;
+  final List states;
+
+  const AlarmControlPanelControlsWidget({Key key, @required this.extended, this.states}) : super(key: key);
+
+  @override
+  _AlarmControlPanelControlsWidgetWidgetState createState() => _AlarmControlPanelControlsWidgetWidgetState();
+
+}
+
+class _AlarmControlPanelControlsWidgetWidgetState extends State<AlarmControlPanelControlsWidget> {
+
+  String code = "";
+  List supportedStates;
+
+  @override
+  void initState() {
+    super.initState();
+    supportedStates = widget.states ?? ["arm_home", "arm_away"];
+  }
+
+
+  void _callService(AlarmControlPanelEntity entity, String service) {
+    eventBus.fire(new ServiceCallEvent(
+          entity.domain, service, entity.entityId,
+          {"code": "$code"}));
+    setState(() {
+      code = "";
+    });
+  }
+
+  void _pinPadHandler(value) {
+    setState(() {
+      code += "$value";
+    });
+  }
+
+  void _pinPadClear() {
+    setState(() {
+      code = "";
+    });
+  }
+
+  void _askToTrigger(AlarmControlPanelEntity entity) {
+    // flutter defined function
+    showDialog(
+      context: context,
+      builder: (BuildContext context) {
+        // return object of type Dialog
+        return AlertDialog(
+          title: new Text("Are you sure?"),
+          content: new Text("Are you sure want to trigger alarm ${entity.displayName}?"),
+          actions: <Widget>[
+            FlatButton(
+              child: new Text("Yes"),
+              onPressed: () {
+                eventBus.fire(new ServiceCallEvent(entity.domain, "alarm_trigger", entity.entityId, null));
+                Navigator.of(context).pop();
+              },
+            ),
+            FlatButton(
+              child: new Text("No"),
+              onPressed: () {
+                Navigator.of(context).pop();
+              },
+            ),
+          ],
+        );
+      },
+    );
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    final entityModel = EntityModel.of(context);
+    final AlarmControlPanelEntity entity = entityModel.entityWrapper.entity;
+    List<Widget> buttons = [];
+    if (entity.state == EntityState.alarm_disarmed) {
+      if (supportedStates.contains("arm_home")) {
+        buttons.add(
+          RaisedButton(
+            onPressed: () => _callService(entity, "alarm_arm_home"),
+            child: Text("ARM HOME"),
+          )
+        );
+      }
+      if (supportedStates.contains("arm_away")) {
+        buttons.add(
+            RaisedButton(
+              onPressed: () => _callService(entity, "alarm_arm_away"),
+              child: Text("ARM AWAY"),
+            )
+        );
+      }
+      if (widget.extended) {
+        if (supportedStates.contains("arm_night")) {
+          buttons.add(
+              RaisedButton(
+                onPressed: () => _callService(entity, "alarm_arm_night"),
+                child: Text("ARM NIGHT"),
+              )
+          );
+        }
+        if (supportedStates.contains("arm_custom_bypass")) {
+          buttons.add(
+              RaisedButton(
+                onPressed: () =>
+                    _callService(entity, "alarm_arm_custom_bypass"),
+                child: Text("ARM CUSTOM BYPASS"),
+              )
+          );
+        }
+      }
+    } else {
+      buttons.add(
+        RaisedButton(
+          onPressed: () => _callService(entity, "alarm_disarm"),
+          child: Text("DISARM"),
+        )
+      );
+    }
+    Widget pinPad;
+    if (entity.attributes["code_format"] == null) {
+      pinPad = Container(width: 0.0, height: 0.0,);
+    } else {
+      pinPad = Padding(
+          padding: EdgeInsets.only(bottom: Sizes.rowPadding),
+          child: Column(
+            mainAxisSize: MainAxisSize.min,
+            children: <Widget>[
+              Wrap(
+                spacing: 5.0,
+                children: <Widget>[
+                  RaisedButton(
+                    onPressed: () => _pinPadHandler("1"),
+                    child: Text("1"),
+                  ),
+                  RaisedButton(
+                    onPressed: () => _pinPadHandler("2"),
+                    child: Text("2"),
+                  ),
+                  RaisedButton(
+                    onPressed: () => _pinPadHandler("3"),
+                    child: Text("3"),
+                  )
+                ],
+              ),
+              Wrap(
+                spacing: 5.0,
+                children: <Widget>[
+                  RaisedButton(
+                    onPressed: () => _pinPadHandler("4"),
+                    child: Text("4"),
+                  ),
+                  RaisedButton(
+                    onPressed: () => _pinPadHandler("5"),
+                    child: Text("5"),
+                  ),
+                  RaisedButton(
+                    onPressed: () => _pinPadHandler("6"),
+                    child: Text("6"),
+                  )
+                ],
+              ),
+              Wrap(
+                spacing: 5.0,
+                children: <Widget>[
+                  RaisedButton(
+                    onPressed: () => _pinPadHandler("7"),
+                    child: Text("7"),
+                  ),
+                  RaisedButton(
+                    onPressed: () => _pinPadHandler("8"),
+                    child: Text("8"),
+                  ),
+                  RaisedButton(
+                    onPressed: () => _pinPadHandler("9"),
+                    child: Text("9"),
+                  )
+                ],
+              ),
+              Wrap(
+                spacing: 5.0,
+                alignment: WrapAlignment.end,
+                children: <Widget>[
+                  RaisedButton(
+                    onPressed: () => _pinPadHandler("0"),
+                    child: Text("0"),
+                  ),
+                  RaisedButton(
+                    onPressed: () => _pinPadClear(),
+                    child: Text("CLEAR"),
+                  )
+                ],
+              )
+            ],
+          )
+      );
+    }
+    Widget inputWrapper;
+    if (entity.attributes["code_format"] == null) {
+      inputWrapper = Container(width: 0.0, height: 0.0,);
+    } else {
+      inputWrapper = Container(
+          width: 150.0,
+          child: TextField(
+              decoration: InputDecoration(
+                  labelText: "Alarm Code"
+              ),
+              //focusNode: _focusNode,
+              obscureText: true,
+              controller: new TextEditingController.fromValue(
+                  new TextEditingValue(
+                      text: code,
+                      selection:
+                      new TextSelection.collapsed(offset: code.length)
+                  )
+              ),
+              onChanged: (value) {
+                code = value;
+              }
+          )
+      );
+    }
+    Widget buttonsWrapper = Padding(
+        padding: EdgeInsets.symmetric(vertical: Sizes.rowPadding),
+        child: Wrap(
+            alignment: WrapAlignment.center,
+            spacing: 15.0,
+            runSpacing: Sizes.rowPadding,
+            children: buttons
+        )
+    );
+    Widget triggerButton = Row(
+      mainAxisAlignment: MainAxisAlignment.end,
+      children: [
+        FlatButton(
+          child: Text(
+            "TRIGGER",
+            style: TextStyle(color: Colors.redAccent)
+          ),
+          onPressed: () => _askToTrigger(entity),
+        )
+      ]
+    );
+    return Column(
+      crossAxisAlignment: CrossAxisAlignment.center,
+      children: <Widget>[
+        widget.extended ? buttonsWrapper : inputWrapper,
+        widget.extended ? inputWrapper : buttonsWrapper,
+        widget.extended ? pinPad : triggerButton
+      ]
+
+    );
+  }
+
+
+}

lib/entities/automation/automation_entity.class.dart

@@ -0,0 +1,27 @@
+part of '../../main.dart';
+
+class AutomationEntity extends Entity {
+  AutomationEntity(Map rawData, String webHost) : super(rawData, webHost);
+
+
+  @override
+  Widget _buildStatePart(BuildContext context) {
+    return SwitchStateWidget();
+  }
+
+  @override
+  Widget _buildAdditionalControlsForPage(BuildContext context) {
+    return Row(
+      mainAxisAlignment: MainAxisAlignment.center,
+      mainAxisSize: MainAxisSize.max,
+      children: <Widget>[
+        FlatServiceButton(
+          serviceDomain: domain,
+          entityId: entityId,
+          text: "TRIGGER",
+          serviceName: "trigger",
+        )
+      ],
+    );
+  }
+}

lib/entities/button/button_entity.class.dart

@@ -0,0 +1,16 @@
+part of '../../main.dart';
+
+class ButtonEntity extends Entity {
+  ButtonEntity(Map rawData, String webHost) : super(rawData, webHost);
+
+
+  @override
+  Widget _buildStatePart(BuildContext context) {
+    return FlatServiceButton(
+      entityId: entityId,
+      serviceDomain: domain,
+      serviceName: 'turn_on',
+      text: domain == "scene" ? "ACTIVATE" : "EXECUTE",
+    );
+  }
+}

lib/entities/camera/camera_entity.class.dart

@@ -0,0 +1,17 @@
+part of '../../main.dart';
+
+class CameraEntity extends Entity {
+
+  static const SUPPORT_ON_OFF = 1;
+
+  CameraEntity(Map rawData, String webHost) : super(rawData, webHost);
+
+  bool get supportOnOff => ((supportedFeatures &
+  CameraEntity.SUPPORT_ON_OFF) ==
+      CameraEntity.SUPPORT_ON_OFF);
+
+  @override
+  Widget _buildAdditionalControlsForPage(BuildContext context) {
+    return CameraStreamView();
+  }
+}

lib/entities/climate/climate_entity.class.dart

@@ -0,0 +1,114 @@
+part of '../../main.dart';
+
+class ClimateEntity extends Entity {
+
+  @override
+  EntityHistoryConfig historyConfig = EntityHistoryConfig(
+    chartType: EntityHistoryWidgetType.numericAttributes,
+    numericState: false,
+    numericAttributesToShow: ["current_temperature"]
+  );
+
+  static const SUPPORT_TARGET_TEMPERATURE = 1;
+  static const SUPPORT_TARGET_TEMPERATURE_RANGE = 2;
+  static const SUPPORT_TARGET_HUMIDITY = 4;
+  static const SUPPORT_FAN_MODE = 8;
+  static const SUPPORT_PRESET_MODE = 16;
+  static const SUPPORT_SWING_MODE = 32;
+  static const SUPPORT_AUX_HEAT = 64;
+
+
+  //static const SUPPORT_OPERATION_MODE = 16;
+  //static const SUPPORT_HOLD_MODE = 256;
+  //static const SUPPORT_AWAY_MODE = 1024;
+  //static const SUPPORT_ON_OFF = 4096;
+
+  ClimateEntity(Map rawData, String webHost) : super(rawData, webHost);
+
+  bool get supportTargetTemperature => ((supportedFeatures &
+  ClimateEntity.SUPPORT_TARGET_TEMPERATURE) ==
+      ClimateEntity.SUPPORT_TARGET_TEMPERATURE);
+  bool get supportTargetTemperatureRange => ((supportedFeatures &
+  ClimateEntity.SUPPORT_TARGET_TEMPERATURE_RANGE) ==
+      ClimateEntity.SUPPORT_TARGET_TEMPERATURE_RANGE);
+  bool get supportTargetHumidity => ((supportedFeatures &
+  ClimateEntity.SUPPORT_TARGET_HUMIDITY) ==
+      ClimateEntity.SUPPORT_TARGET_HUMIDITY);
+  bool get supportFanMode =>
+      ((supportedFeatures & ClimateEntity.SUPPORT_FAN_MODE) ==
+          ClimateEntity.SUPPORT_FAN_MODE);
+  bool get supportSwingMode =>
+      ((supportedFeatures & ClimateEntity.SUPPORT_SWING_MODE) ==
+          ClimateEntity.SUPPORT_SWING_MODE);
+  bool get supportPresetMode =>
+      ((supportedFeatures & ClimateEntity.SUPPORT_PRESET_MODE) ==
+          ClimateEntity.SUPPORT_PRESET_MODE);
+  bool get supportAuxHeat =>
+      ((supportedFeatures & ClimateEntity.SUPPORT_AUX_HEAT) ==
+          ClimateEntity.SUPPORT_AUX_HEAT);
+
+  List<String> get hvacModes => attributes["hvac_modes"] != null
+      ? (attributes["hvac_modes"] as List).cast<String>()
+      : null;
+  List<String> get fanModes => attributes["fan_modes"] != null
+      ? (attributes["fan_modes"] as List).cast<String>()
+      : null;
+  List<String> get presetModes => attributes["preset_modes"] != null
+      ? (attributes["preset_modes"] as List).cast<String>()
+      : null;
+  List<String> get swingModes => attributes["swing_modes"] != null
+      ? (attributes["swing_modes"] as List).cast<String>()
+      : null;
+  double get temperature => _getDoubleAttributeValue('temperature');
+  double get currentTemperature => _getDoubleAttributeValue('current_temperature');
+  double get targetHigh => _getDoubleAttributeValue('target_temp_high');
+  double get targetLow => _getDoubleAttributeValue('target_temp_low');
+  double get maxTemp => _getDoubleAttributeValue('max_temp') ?? 100.0;
+  double get minTemp => _getDoubleAttributeValue('min_temp') ?? -100.0;
+  double get targetHumidity => _getDoubleAttributeValue('humidity');
+  double get maxHumidity => _getDoubleAttributeValue('max_humidity');
+  double get minHumidity => _getDoubleAttributeValue('min_humidity');
+  double get temperatureStep => _getDoubleAttributeValue('target_temp_step') ?? 0.5;
+  String get hvacAction => attributes['hvac_action'];
+  String get fanMode => attributes['fan_mode'];
+  String get presetMode => attributes['preset_mode'];
+  String get swingMode => attributes['swing_mode'];
+  bool get awayMode => attributes['away_mode'] == "on";
+  //bool get isOff => state == EntityState.off;
+  bool get auxHeat => attributes['aux_heat'] == "on";
+
+  @override
+  void update(Map rawData, String webHost) {
+    super.update(rawData, webHost);
+    if (supportTargetTemperature) {
+      historyConfig.numericAttributesToShow.add("temperature");
+    }
+    if (supportTargetTemperatureRange) {
+      historyConfig.numericAttributesToShow.add("target_temp_high");
+      historyConfig.numericAttributesToShow.add("target_temp_low");
+    }
+  }
+
+  @override
+  Widget _buildStatePart(BuildContext context) {
+    return ClimateStateWidget();
+  }
+
+  @override
+  Widget _buildAdditionalControlsForPage(BuildContext context) {
+    return ClimateControlWidget();
+  }
+
+  @override
+  double _getDoubleAttributeValue(String attributeName) {
+    var temp1 = attributes["$attributeName"];
+    if (temp1 is int) {
+      return temp1.toDouble();
+    } else if (temp1 is double) {
+      return temp1;
+    } else {
+      return null;
+    }
+  }
+
+}

lib/entities/climate/widgets/climate_controls.dart

@@ -1,4 +1,4 @@
-part of '../../main.dart';
+part of '../../../main.dart';
 
 class ClimateControlWidget extends StatefulWidget {
 
@@ -13,26 +13,28 @@ class _ClimateControlWidgetState extends State<ClimateControlWidget> {
   bool _showPending = false;
   bool _changedHere = false;
   Timer _resetTimer;
+  Timer _tempThrottleTimer;
+  Timer _targetTempThrottleTimer;
   double _tmpTemperature = 0.0;
   double _tmpTargetLow = 0.0;
   double _tmpTargetHigh = 0.0;
   double _tmpTargetHumidity = 0.0;
-  String _tmpOperationMode;
+  String _tmpHVACMode;
   String _tmpFanMode;
   String _tmpSwingMode;
-  bool _tmpAwayMode = false;
+  String _tmpPresetMode;
-  bool _tmpIsOff = false;
+  //bool _tmpIsOff = false;
   bool _tmpAuxHeat = false;
 
   void _resetVars(ClimateEntity entity) {
     _tmpTemperature = entity.temperature;
     _tmpTargetHigh = entity.targetHigh;
     _tmpTargetLow = entity.targetLow;
-    _tmpOperationMode = entity.operationMode;
+    _tmpHVACMode = entity.state;
     _tmpFanMode = entity.fanMode;
     _tmpSwingMode = entity.swingMode;
-    _tmpAwayMode = entity.awayMode;
+    _tmpPresetMode = entity.presetMode;
-    _tmpIsOff = entity.isOff;
+    //_tmpIsOff = entity.isOff;
     _tmpAuxHeat = entity.auxHeat;
     _tmpTargetHumidity = entity.targetHumidity;
 
@@ -40,52 +42,68 @@ class _ClimateControlWidgetState extends State<ClimateControlWidget> {
     _changedHere = false;
   }
 
-  void _temperatureUp(ClimateEntity entity, double step) {
+  void _temperatureUp(ClimateEntity entity) {
-    _tmpTemperature = ((_tmpTemperature + step) <= entity.maxTemp) ? _tmpTemperature + step : entity.maxTemp;
+    _tmpTemperature = ((_tmpTemperature + entity.temperatureStep) <= entity.maxTemp) ? _tmpTemperature + entity.temperatureStep : entity.maxTemp;
     _setTemperature(entity);
   }
 
-  void _temperatureDown(ClimateEntity entity, double step) {
+  void _temperatureDown(ClimateEntity entity) {
-    _tmpTemperature = ((_tmpTemperature - step) >= entity.minTemp) ? _tmpTemperature - step : entity.minTemp;
+    _tmpTemperature = ((_tmpTemperature - entity.temperatureStep) >= entity.minTemp) ? _tmpTemperature - entity.temperatureStep : entity.minTemp;
     _setTemperature(entity);
   }
 
-  void _targetLowUp(ClimateEntity entity, double step) {
+  void _targetLowUp(ClimateEntity entity) {
-    _tmpTargetLow = ((_tmpTargetLow + step) <= entity.maxTemp) ? _tmpTargetLow + step : entity.maxTemp;
+    _tmpTargetLow = ((_tmpTargetLow + entity.temperatureStep) <= entity.maxTemp) ? _tmpTargetLow + entity.temperatureStep : entity.maxTemp;
     _setTargetTemp(entity);
   }
 
-  void _targetLowDown(ClimateEntity entity, double step) {
+  void _targetLowDown(ClimateEntity entity) {
-    _tmpTargetLow = ((_tmpTargetLow - step) >= entity.minTemp) ? _tmpTargetLow - step : entity.minTemp;
+    _tmpTargetLow = ((_tmpTargetLow - entity.temperatureStep) >= entity.minTemp) ? _tmpTargetLow - entity.temperatureStep : entity.minTemp;
     _setTargetTemp(entity);
   }
 
-  void _targetHighUp(ClimateEntity entity, double step) {
+  void _targetHighUp(ClimateEntity entity) {
-    _tmpTargetHigh = ((_tmpTargetHigh + step) <= entity.maxTemp) ? _tmpTargetHigh + step : entity.maxTemp;
+    _tmpTargetHigh = ((_tmpTargetHigh + entity.temperatureStep) <= entity.maxTemp) ? _tmpTargetHigh + entity.temperatureStep : entity.maxTemp;
     _setTargetTemp(entity);
   }
 
-  void _targetHighDown(ClimateEntity entity, double step) {
+  void _targetHighDown(ClimateEntity entity) {
-    _tmpTargetHigh = ((_tmpTargetHigh - step) >= entity.minTemp) ? _tmpTargetHigh - step : entity.minTemp;
+    _tmpTargetHigh = ((_tmpTargetHigh - entity.temperatureStep) >= entity.minTemp) ? _tmpTargetHigh - entity.temperatureStep : entity.minTemp;
     _setTargetTemp(entity);
   }
 
   void _setTemperature(ClimateEntity entity) {
+    if (_tempThrottleTimer!=null) {
+      _tempThrottleTimer.cancel();
+    }
     setState(() {
-      _tmpTemperature = double.parse(_tmpTemperature.toStringAsFixed(1));
       _changedHere = true;
-      eventBus.fire(new ServiceCallEvent(entity.domain, "set_temperature", entity.entityId,{"temperature": "${_tmpTemperature.toStringAsFixed(1)}"}));
+      _tmpTemperature = double.parse(_tmpTemperature.toStringAsFixed(1));
-      _resetStateTimer(entity);
+    });
+    _tempThrottleTimer = Timer(Duration(seconds: 2), () {
+      setState(() {
+        _changedHere = true;
+        eventBus.fire(new ServiceCallEvent(entity.domain, "set_temperature", entity.entityId,{"temperature": "${_tmpTemperature.toStringAsFixed(1)}"}));
+        _resetStateTimer(entity);
+      });
     });
   }
 
   void _setTargetTemp(ClimateEntity entity) {
+    if (_targetTempThrottleTimer!=null) {
+      _targetTempThrottleTimer.cancel();
+    }
     setState(() {
+      _changedHere = true;
       _tmpTargetLow = double.parse(_tmpTargetLow.toStringAsFixed(1));
       _tmpTargetHigh = double.parse(_tmpTargetHigh.toStringAsFixed(1));
-      _changedHere = true;
+    });
-      eventBus.fire(new ServiceCallEvent(entity.domain, "set_temperature", entity.entityId,{"target_temp_high": "${_tmpTargetHigh.toStringAsFixed(1)}", "target_temp_low": "${_tmpTargetLow.toStringAsFixed(1)}"}));
+    _targetTempThrottleTimer = Timer(Duration(seconds: 2), () {
-      _resetStateTimer(entity);
+      setState(() {
+        _changedHere = true;
+        eventBus.fire(new ServiceCallEvent(entity.domain, "set_temperature", entity.entityId,{"target_temp_high": "${_tmpTargetHigh.toStringAsFixed(1)}", "target_temp_low": "${_tmpTargetLow.toStringAsFixed(1)}"}));
+        _resetStateTimer(entity);
+      });
     });
   }
 
@@ -98,11 +116,11 @@ class _ClimateControlWidgetState extends State<ClimateControlWidget> {
     });
   }
 
-  void _setOperationMode(ClimateEntity entity, value) {
+  void _setHVACMode(ClimateEntity entity, value) {
     setState(() {
-      _tmpOperationMode = value;
+      _tmpHVACMode = value;
       _changedHere = true;
-      eventBus.fire(new ServiceCallEvent(entity.domain, "set_operation_mode", entity.entityId,{"operation_mode": "$_tmpOperationMode"}));
+      eventBus.fire(new ServiceCallEvent(entity.domain, "set_hvac_mode", entity.entityId,{"hvac_mode": "$_tmpHVACMode"}));
       _resetStateTimer(entity);
     });
   }
@@ -125,23 +143,23 @@ class _ClimateControlWidgetState extends State<ClimateControlWidget> {
     });
   }
 
-  void _setAwayMode(ClimateEntity entity, value) {
+  void _setPresetMode(ClimateEntity entity, value) {
     setState(() {
-      _tmpAwayMode = value;
+      _tmpPresetMode = value;
       _changedHere = true;
-      eventBus.fire(new ServiceCallEvent(entity.domain, "set_away_mode", entity.entityId,{"away_mode": "${_tmpAwayMode ? 'on' : 'off'}"}));
+      eventBus.fire(new ServiceCallEvent(entity.domain, "set_preset_mode", entity.entityId,{"preset_mode": "$_tmpPresetMode"}));
       _resetStateTimer(entity);
     });
   }
 
-  void _setOnOf(ClimateEntity entity, value) {
+  /*void _setOnOf(ClimateEntity entity, value) {
     setState(() {
       _tmpIsOff = !value;
       _changedHere = true;
       eventBus.fire(new ServiceCallEvent(entity.domain, "${_tmpIsOff ? 'turn_off' : 'turn_on'}", entity.entityId, null));
       _resetStateTimer(entity);
     });
-  }
+  }*/
 
   void _setAuxHeat(ClimateEntity entity, value) {
     setState(() {
@@ -165,46 +183,47 @@ class _ClimateControlWidgetState extends State<ClimateControlWidget> {
   @override
   Widget build(BuildContext context) {
     final entityModel = EntityModel.of(context);
-    final ClimateEntity entity = entityModel.entity;
+    final ClimateEntity entity = entityModel.entityWrapper.entity;
     if (_changedHere) {
-      _showPending = (_tmpTemperature != entity.temperature);
+      _showPending = (_tmpTemperature != entity.temperature || _tmpTargetHigh != entity.targetHigh || _tmpTargetLow != entity.targetLow);
       _changedHere = false;
     } else {
       _resetTimer?.cancel();
       _resetVars(entity);
     }
     return Padding(
-      padding: EdgeInsets.fromLTRB(Entity.leftWidgetPadding, Entity.rowPadding, Entity.rightWidgetPadding, 0.0),
+      padding: EdgeInsets.fromLTRB(Sizes.leftWidgetPadding, Sizes.rowPadding, Sizes.rightWidgetPadding, 0.0),
       child: Column(
         crossAxisAlignment: CrossAxisAlignment.start,
         children: <Widget>[
-          _buildOnOffControl(entity),
+          //_buildOnOffControl(entity),
           _buildTemperatureControls(entity),
           _buildTargetTemperatureControls(entity),
           _buildHumidityControls(entity),
           _buildOperationControl(entity),
           _buildFanControl(entity),
           _buildSwingControl(entity),
-          _buildAwayModeControl(entity),
+          _buildPresetModeControl(entity),
           _buildAuxHeatControl(entity)
         ],
       ),
     );
   }
 
-  Widget _buildAwayModeControl(ClimateEntity entity) {
+  Widget _buildPresetModeControl(ClimateEntity entity) {
-    if (entity.supportAwayMode) {
+    if (entity.supportPresetMode) {
-      return ModeSwitchWidget(
+      return ModeSelectorWidget(
-        caption: "Away mode",
+        options: entity.presetModes,
-        onChange: (value) => _setAwayMode(entity, value),
+        onChange: (mode) => _setPresetMode(entity, mode),
-        value: _tmpAwayMode,
+        caption: "Preset",
+        value: _tmpPresetMode,
       );
     } else {
       return Container(height: 0.0, width: 0.0,);
     }
   }
 
-  Widget _buildOnOffControl(ClimateEntity entity) {
+  /*Widget _buildOnOffControl(ClimateEntity entity) {
     if (entity.supportOnOff) {
       return ModeSwitchWidget(
           onChange: (value) => _setOnOf(entity, value),
@@ -214,7 +233,7 @@ class _ClimateControlWidgetState extends State<ClimateControlWidget> {
     } else {
       return Container(height: 0.0, width: 0.0,);
     }
-  }
+  }*/
 
   Widget _buildAuxHeatControl(ClimateEntity entity) {
     if (entity.supportAuxHeat ) {
@@ -229,12 +248,12 @@ class _ClimateControlWidgetState extends State<ClimateControlWidget> {
   }
 
   Widget _buildOperationControl(ClimateEntity entity) {
-    if (entity.supportOperationMode) {
+    if (entity.hvacModes != null) {
       return ModeSelectorWidget(
-        onChange: (mode) => _setOperationMode(entity, mode),
+        onChange: (mode) => _setHVACMode(entity, mode),
-        options: entity.operationList,
+        options: entity.hvacModes,
         caption: "Operation",
-        value: _tmpOperationMode,
+        value: _tmpHVACMode,
       );
     } else {
       return Container(height: 0.0, width: 0.0);
@@ -244,7 +263,7 @@ class _ClimateControlWidgetState extends State<ClimateControlWidget> {
   Widget _buildFanControl(ClimateEntity entity) {
     if (entity.supportFanMode) {
       return ModeSelectorWidget(
-        options: entity.fanList,
+        options: entity.fanModes,
         onChange: (mode) => _setFanMode(entity, mode),
         caption: "Fan mode",
         value: _tmpFanMode,
@@ -258,7 +277,7 @@ class _ClimateControlWidgetState extends State<ClimateControlWidget> {
     if (entity.supportSwingMode) {
       return ModeSelectorWidget(
           onChange: (mode) => _setSwingMode(entity, mode),
-          options: entity.swingList,
+          options: entity.swingModes,
           value: _tmpSwingMode,
           caption: "Swing mode"
       );
@@ -273,15 +292,13 @@ class _ClimateControlWidgetState extends State<ClimateControlWidget> {
         crossAxisAlignment: CrossAxisAlignment.start,
         children: <Widget>[
           Text("Target temperature", style: TextStyle(
-              fontSize: Entity.stateFontSize
+              fontSize: Sizes.stateFontSize
           )),
           TemperatureControlWidget(
             value: _tmpTemperature,
             fontColor: _showPending ? Colors.red : Colors.black,
-            onLargeDec: () => _temperatureDown(entity, 0.5),
+            onDec: () => _temperatureDown(entity),
-            onLargeInc: () => _temperatureUp(entity, 0.5),
+            onInc: () => _temperatureUp(entity),
-            onSmallDec: () => _temperatureDown(entity, 0.1),
-            onSmallInc: () => _temperatureUp(entity, 0.1),
           )
         ],
       );
@@ -292,30 +309,26 @@ class _ClimateControlWidgetState extends State<ClimateControlWidget> {
 
   Widget _buildTargetTemperatureControls(ClimateEntity entity) {
     List<Widget> controls = [];
-    if ((entity.supportTargetTemperatureLow) && (entity.targetLow != null)) {
+    if ((entity.supportTargetTemperatureRange) && (entity.targetLow != null)) {
       controls.addAll(<Widget>[
         TemperatureControlWidget(
           value: _tmpTargetLow,
           fontColor: _showPending ? Colors.red : Colors.black,
-          onLargeDec: () => _targetLowDown(entity, 0.5),
+          onDec: () => _targetLowDown(entity),
-          onLargeInc: () => _targetLowUp(entity, 0.5),
+          onInc: () => _targetLowUp(entity),
-          onSmallDec: () => _targetLowDown(entity, 0.1),
-          onSmallInc: () => _targetLowUp(entity, 0.1),
         ),
         Expanded(
           child: Container(height: 10.0),
         )
       ]);
     }
-    if ((entity.supportTargetTemperatureHigh) && (entity.targetHigh != null)) {
+    if ((entity.supportTargetTemperatureRange) && (entity.targetHigh != null)) {
       controls.add(
           TemperatureControlWidget(
             value: _tmpTargetHigh,
             fontColor: _showPending ? Colors.red : Colors.black,
-            onLargeDec: () => _targetHighDown(entity, 0.5),
+            onDec: () => _targetHighDown(entity),
-            onLargeInc: () => _targetHighUp(entity, 0.5),
+            onInc: () => _targetHighUp(entity),
-            onSmallDec: () => _targetHighDown(entity, 0.1),
-            onSmallInc: () => _targetHighUp(entity, 0.1),
           )
       );
     }
@@ -324,7 +337,7 @@ class _ClimateControlWidgetState extends State<ClimateControlWidget> {
         crossAxisAlignment: CrossAxisAlignment.start,
         children: <Widget>[
           Text("Target temperature range", style: TextStyle(
-              fontSize: Entity.stateFontSize
+              fontSize: Sizes.stateFontSize
           )),
           Row(
             children: controls,
@@ -342,7 +355,7 @@ class _ClimateControlWidgetState extends State<ClimateControlWidget> {
       result.addAll(<Widget>[
         Text(
           "$_tmpTargetHumidity%",
-          style: TextStyle(fontSize: Entity.largeFontSize),
+          style: TextStyle(fontSize: Sizes.largeFontSize),
         ),
         Expanded(
           child: Slider(
@@ -366,9 +379,9 @@ class _ClimateControlWidgetState extends State<ClimateControlWidget> {
         children: <Widget>[
           Padding(
             padding: EdgeInsets.fromLTRB(
-                0.0, Entity.rowPadding, 0.0, Entity.rowPadding),
+                0.0, Sizes.rowPadding, 0.0, Sizes.rowPadding),
             child: Text("Target humidity", style: TextStyle(
-                fontSize: Entity.stateFontSize
+                fontSize: Sizes.stateFontSize
             )),
           ),
           Row(
@@ -376,7 +389,7 @@ class _ClimateControlWidgetState extends State<ClimateControlWidget> {
             children: result,
           ),
           Container(
-            height: Entity.rowPadding,
+            height: Sizes.rowPadding,
           )
         ],
       );
@@ -396,72 +409,3 @@ class _ClimateControlWidgetState extends State<ClimateControlWidget> {
   }
 
 }
-
-class TemperatureControlWidget extends StatelessWidget {
-  final double value;
-  final double fontSize;
-  final Color fontColor;
-  final onSmallInc;
-  final onLargeInc;
-  final onSmallDec;
-  final onLargeDec;
-
-  TemperatureControlWidget(
-      {Key key,
-        @required this.value,
-        @required this.onSmallInc,
-        @required this.onSmallDec,
-        @required this.onLargeInc,
-        @required this.onLargeDec,
-        this.fontSize,
-        this.fontColor})
-      : super(key: key);
-
-  @override
-  Widget build(BuildContext context) {
-    return Row(
-      crossAxisAlignment: CrossAxisAlignment.center,
-      children: <Widget>[
-        Text(
-          "$value",
-          style: TextStyle(
-              fontSize: fontSize ?? 24.0,
-              color: fontColor ?? Colors.black
-          ),
-        ),
-        Column(
-          children: <Widget>[
-            IconButton(
-              icon: Icon(MaterialDesignIcons.createIconDataFromIconName(
-                  'mdi:chevron-up')),
-              iconSize: 30.0,
-              onPressed: () => onSmallInc(),
-            ),
-            IconButton(
-              icon: Icon(MaterialDesignIcons.createIconDataFromIconName(
-                  'mdi:chevron-down')),
-              iconSize: 30.0,
-              onPressed: () => onSmallDec(),
-            )
-          ],
-        ),
-        Column(
-          children: <Widget>[
-            IconButton(
-              icon: Icon(MaterialDesignIcons.createIconDataFromIconName(
-                  'mdi:chevron-double-up')),
-              iconSize: 30.0,
-              onPressed: () => onLargeInc(),
-            ),
-            IconButton(
-              icon: Icon(MaterialDesignIcons.createIconDataFromIconName(
-                  'mdi:chevron-double-down')),
-              iconSize: 30.0,
-              onPressed: () => onLargeDec(),
-            )
-          ],
-        )
-      ],
-    );
-  }
-}

lib/entities/climate/widgets/climate_state.widget.dart

@@ -0,0 +1,58 @@
+part of '../../../main.dart';
+
+class ClimateStateWidget extends StatelessWidget {
+  @override
+  Widget build(BuildContext context) {
+    final entityModel = EntityModel.of(context);
+    final ClimateEntity entity = entityModel.entityWrapper.entity;
+    String targetTemp = "-";
+    if ((entity.supportTargetTemperature) && (entity.temperature != null)) {
+      targetTemp = "${entity.temperature}";
+    } else if ((entity.supportTargetTemperatureRange) &&
+        (entity.targetLow != null) &&
+        (entity.targetHigh != null)) {
+      targetTemp = "${entity.targetLow} - ${entity.targetHigh}";
+    }
+    String displayState = '';
+    if (entity.hvacAction != null) {
+      displayState = "${entity.hvacAction} (${entity.displayState})";
+    } else {
+      displayState = "${entity.displayState}";
+    }
+    if (entity.presetMode != null) {
+      displayState += " - ${entity.presetMode}";
+    }
+    return Padding(
+        padding: EdgeInsets.fromLTRB(
+            0.0, 0.0, Sizes.rightWidgetPadding, 0.0),
+        child: Column(
+          crossAxisAlignment: CrossAxisAlignment.end,
+          mainAxisAlignment: MainAxisAlignment.center,
+          children: <Widget>[
+            Row(
+              children: <Widget>[
+                Text("$displayState",
+                    textAlign: TextAlign.right,
+                    style: new TextStyle(
+                      fontWeight: FontWeight.bold,
+                      fontSize: Sizes.stateFontSize,
+                    )),
+                Text(" $targetTemp",
+                    textAlign: TextAlign.right,
+                    style: new TextStyle(
+                      fontSize: Sizes.stateFontSize,
+                    ))
+              ],
+            ),
+            entity.currentTemperature != null ?
+            Text("Currently: ${entity.currentTemperature}",
+                textAlign: TextAlign.right,
+                style: new TextStyle(
+                    fontSize: Sizes.stateFontSize,
+                    color: Colors.black45)
+            ) :
+            Container(height: 0.0,)
+          ],
+        ));
+  }
+}

lib/entities/climate/widgets/temperature_control_widget.dart

@@ -0,0 +1,50 @@
+part of '../../../main.dart';
+
+class TemperatureControlWidget extends StatelessWidget {
+  final double value;
+  final double fontSize;
+  final Color fontColor;
+  final onInc;
+  final onDec;
+
+  TemperatureControlWidget(
+      {Key key,
+        @required this.value,
+        @required this.onInc,
+        @required this.onDec,
+        this.fontSize,
+        this.fontColor})
+      : super(key: key);
+
+  @override
+  Widget build(BuildContext context) {
+    return Row(
+      crossAxisAlignment: CrossAxisAlignment.center,
+      children: <Widget>[
+        Text(
+          "$value",
+          style: TextStyle(
+              fontSize: fontSize ?? 24.0,
+              color: fontColor ?? Colors.black
+          ),
+        ),
+        Column(
+          children: <Widget>[
+            IconButton(
+              icon: Icon(MaterialDesignIcons.getIconDataFromIconName(
+                  'mdi:chevron-up')),
+              iconSize: 30.0,
+              onPressed: () => onInc(),
+            ),
+            IconButton(
+              icon: Icon(MaterialDesignIcons.getIconDataFromIconName(
+                  'mdi:chevron-down')),
+              iconSize: 30.0,
+              onPressed: () => onDec(),
+            )
+          ],
+        )
+      ],
+    );
+  }
+}

lib/entities/cover/cover_entity.class.dart

@@ -1,8 +1,6 @@
-part of '../main.dart';
+part of '../../main.dart';
 
 class CoverEntity extends Entity {
-  @override
-  double widgetHeight = 38.0;
 
   static const SUPPORT_OPEN = 1;
   static const SUPPORT_CLOSE = 2;
@@ -13,41 +11,41 @@ class CoverEntity extends Entity {
   static const SUPPORT_STOP_TILT = 64;
   static const SUPPORT_SET_TILT_POSITION = 128;
 
-  bool get supportOpen => ((attributes["supported_features"] &
+  CoverEntity(Map rawData, String webHost) : super(rawData, webHost);
+
+  bool get supportOpen => ((supportedFeatures &
   CoverEntity.SUPPORT_OPEN) ==
       CoverEntity.SUPPORT_OPEN);
-  bool get supportClose => ((attributes["supported_features"] &
+  bool get supportClose => ((supportedFeatures &
   CoverEntity.SUPPORT_CLOSE) ==
       CoverEntity.SUPPORT_CLOSE);
-  bool get supportSetPosition => ((attributes["supported_features"] &
+  bool get supportSetPosition => ((supportedFeatures &
   CoverEntity.SUPPORT_SET_POSITION) ==
       CoverEntity.SUPPORT_SET_POSITION);
-  bool get supportStop => ((attributes["supported_features"] &
+  bool get supportStop => ((supportedFeatures &
   CoverEntity.SUPPORT_STOP) ==
       CoverEntity.SUPPORT_STOP);
 
-  bool get supportOpenTilt => ((attributes["supported_features"] &
+  bool get supportOpenTilt => ((supportedFeatures &
   CoverEntity.SUPPORT_OPEN_TILT) ==
       CoverEntity.SUPPORT_OPEN_TILT);
-  bool get supportCloseTilt => ((attributes["supported_features"] &
+  bool get supportCloseTilt => ((supportedFeatures &
   CoverEntity.SUPPORT_CLOSE_TILT) ==
       CoverEntity.SUPPORT_CLOSE_TILT);
-  bool get supportStopTilt => ((attributes["supported_features"] &
+  bool get supportStopTilt => ((supportedFeatures &
   CoverEntity.SUPPORT_STOP_TILT) ==
       CoverEntity.SUPPORT_STOP_TILT);
-  bool get supportSetTiltPosition => ((attributes["supported_features"] &
+  bool get supportSetTiltPosition => ((supportedFeatures &
   CoverEntity.SUPPORT_SET_TILT_POSITION) ==
       CoverEntity.SUPPORT_SET_TILT_POSITION);
 
 
   double get currentPosition => _getDoubleAttributeValue('current_position');
   double get currentTiltPosition => _getDoubleAttributeValue('current_tilt_position');
-  bool get canBeOpened => ((state != "opening") && (state != "open"));
+  bool get canBeOpened => ((state != EntityState.opening) && (state != EntityState.open)) || (state == EntityState.open && currentPosition != null && currentPosition > 0.0 && currentPosition < 100.0);
-  bool get canBeClosed => ((state != "closing") && (state != "closed"));
+  bool get canBeClosed => ((state != EntityState.closing) && (state != EntityState.closed));
-  bool get canTiltBeOpened => currentPosition < 100;
+  bool get canTiltBeOpened => currentTiltPosition < 100;
-  bool get canTiltBeClosed => currentPosition > 0;
+  bool get canTiltBeClosed => currentTiltPosition > 0;
-
-  CoverEntity(Map rawData) : super(rawData);
 
   @override
   Widget _buildStatePart(BuildContext context) {

lib/entities/cover/widgets/cover_controls.widget.dart

@@ -1,4 +1,4 @@
-part of '../../main.dart';
+part of '../../../main.dart';
 
 class CoverControlWidget extends StatefulWidget {
 
@@ -38,15 +38,14 @@ class _CoverControlWidgetState extends State<CoverControlWidget> {
   @override
   Widget build(BuildContext context) {
     final entityModel = EntityModel.of(context);
-    final CoverEntity entity = entityModel.entity;
+    final CoverEntity entity = entityModel.entityWrapper.entity;
-    TheLogger.debug("${entity.state}");
     if (_changedHere) {
       _changedHere = false;
     } else {
       _resetVars(entity);
     }
     return Padding(
-      padding: EdgeInsets.fromLTRB(Entity.leftWidgetPadding, Entity.rowPadding, Entity.rightWidgetPadding, 0.0),
+      padding: EdgeInsets.fromLTRB(Sizes.leftWidgetPadding, Sizes.rowPadding, Sizes.rightWidgetPadding, 0.0),
       child: Column(
         crossAxisAlignment: CrossAxisAlignment.start,
         children: <Widget>[
@@ -64,9 +63,9 @@ class _CoverControlWidgetState extends State<CoverControlWidget> {
         children: <Widget>[
           Padding(
             padding: EdgeInsets.fromLTRB(
-                0.0, Entity.rowPadding, 0.0, Entity.rowPadding),
+                0.0, Sizes.rowPadding, 0.0, Sizes.rowPadding),
             child: Text("Position", style: TextStyle(
-                fontSize: Entity.stateFontSize
+                fontSize: Sizes.stateFontSize
             )),
           ),
           Slider(
@@ -82,7 +81,7 @@ class _CoverControlWidgetState extends State<CoverControlWidget> {
             },
             onChangeEnd: (double value) => _setNewPosition(entity, value),
           ),
-          Container(height: Entity.rowPadding,)
+          Container(height: Sizes.rowPadding,)
         ],
       );
     } else {
@@ -112,15 +111,15 @@ class _CoverControlWidgetState extends State<CoverControlWidget> {
           },
           onChangeEnd: (double value) => _setNewTiltPosition(entity, value),
         ),
-        Container(height: Entity.rowPadding,)
+        Container(height: Sizes.rowPadding,)
       ]);
     }
     if (controls.isNotEmpty) {
       controls.insert(0, Padding(
         padding: EdgeInsets.fromLTRB(
-            0.0, Entity.rowPadding, 0.0, Entity.rowPadding),
+            0.0, Sizes.rowPadding, 0.0, Sizes.rowPadding),
         child: Text("Tilt position", style: TextStyle(
-            fontSize: Entity.stateFontSize
+            fontSize: Sizes.stateFontSize
         )),
       ));
       return Column(
@@ -153,44 +152,44 @@ class CoverTiltControlsWidget extends StatelessWidget {
   @override
   Widget build(BuildContext context) {
     final entityModel = EntityModel.of(context);
-    final CoverEntity entity = entityModel.entity;
+    final CoverEntity entity = entityModel.entityWrapper.entity;
     List<Widget> buttons = [];
     if (entity.supportOpenTilt) {
       buttons.add(IconButton(
           icon: Icon(
-            MaterialDesignIcons.createIconDataFromIconName(
+            MaterialDesignIcons.getIconDataFromIconName(
                 "mdi:arrow-top-right"),
-            size: Entity.iconSize,
+            size: Sizes.iconSize,
           ),
           onPressed: entity.canTiltBeOpened ? () => _open(entity) : null));
     } else {
       buttons.add(Container(
-        width: Entity.iconSize + 20.0,
+        width: Sizes.iconSize + 20.0,
       ));
     }
     if (entity.supportStopTilt) {
       buttons.add(IconButton(
           icon: Icon(
-            MaterialDesignIcons.createIconDataFromIconName("mdi:stop"),
+            MaterialDesignIcons.getIconDataFromIconName("mdi:stop"),
-            size: Entity.iconSize,
+            size: Sizes.iconSize,
           ),
           onPressed: () => _stop(entity)));
     } else {
       buttons.add(Container(
-        width: Entity.iconSize + 20.0,
+        width: Sizes.iconSize + 20.0,
       ));
     }
     if (entity.supportCloseTilt) {
       buttons.add(IconButton(
           icon: Icon(
-            MaterialDesignIcons.createIconDataFromIconName(
+            MaterialDesignIcons.getIconDataFromIconName(
                 "mdi:arrow-bottom-left"),
-            size: Entity.iconSize,
+            size: Sizes.iconSize,
           ),
           onPressed: entity.canTiltBeClosed ? () => _close(entity) : null));
     } else {
       buttons.add(Container(
-        width: Entity.iconSize + 20.0,
+        width: Sizes.iconSize + 20.0,
       ));
     }
 

lib/entities/cover/widgets/cover_state.dart

@@ -1,4 +1,4 @@
-part of '../../main.dart';
+part of '../../../main.dart';
 
 class CoverStateWidget extends StatelessWidget {
   void _open(CoverEntity entity) {
@@ -19,42 +19,42 @@ class CoverStateWidget extends StatelessWidget {
   @override
   Widget build(BuildContext context) {
     final entityModel = EntityModel.of(context);
-    final CoverEntity entity = entityModel.entity;
+    final CoverEntity entity = entityModel.entityWrapper.entity;
     List<Widget> buttons = [];
     if (entity.supportOpen) {
       buttons.add(IconButton(
           icon: Icon(
-            MaterialDesignIcons.createIconDataFromIconName("mdi:arrow-up"),
+            MaterialDesignIcons.getIconDataFromIconName("mdi:arrow-up"),
-            size: Entity.iconSize,
+            size: Sizes.iconSize,
           ),
           onPressed: entity.canBeOpened ? () => _open(entity) : null));
     } else {
       buttons.add(Container(
-        width: Entity.iconSize + 20.0,
+        width: Sizes.iconSize + 20.0,
       ));
     }
     if (entity.supportStop) {
       buttons.add(IconButton(
           icon: Icon(
-            MaterialDesignIcons.createIconDataFromIconName("mdi:stop"),
+            MaterialDesignIcons.getIconDataFromIconName("mdi:stop"),
-            size: Entity.iconSize,
+            size: Sizes.iconSize,
           ),
           onPressed: () => _stop(entity)));
     } else {
       buttons.add(Container(
-        width: Entity.iconSize + 20.0,
+        width: Sizes.iconSize + 20.0,
       ));
     }
     if (entity.supportClose) {
       buttons.add(IconButton(
           icon: Icon(
-            MaterialDesignIcons.createIconDataFromIconName("mdi:arrow-down"),
+            MaterialDesignIcons.getIconDataFromIconName("mdi:arrow-down"),
-            size: Entity.iconSize,
+            size: Sizes.iconSize,
           ),
           onPressed: entity.canBeClosed ? () => _close(entity) : null));
     } else {
       buttons.add(Container(
-        width: Entity.iconSize + 20.0,
+        width: Sizes.iconSize + 20.0,
       ));
     }
 

lib/entities/date_time/date_time_entity.class.dart

@@ -1,6 +1,8 @@
-part of '../main.dart';
+part of '../../main.dart';
 
 class DateTimeEntity extends Entity {
+  DateTimeEntity(Map rawData, String webHost) : super(rawData, webHost);
+
   bool get hasDate => attributes["has_date"] ?? false;
   bool get hasTime => attributes["has_time"] ?? false;
   int get year => attributes["year"] ?? 1970;
@@ -12,8 +14,6 @@ class DateTimeEntity extends Entity {
   String get formattedState => _getFormattedState();
   DateTime get dateTimeState => _getDateTimeState();
 
-  DateTimeEntity(Map rawData) : super(rawData);
-
   @override
   Widget _buildStatePart(BuildContext context) {
     return DateTimeStateWidget();

lib/entities/date_time/widgets/date_time_state.dart

@@ -1,17 +1,17 @@
-part of '../../main.dart';
+part of '../../../main.dart';
 
 class DateTimeStateWidget extends StatelessWidget {
   @override
   Widget build(BuildContext context) {
     final entityModel = EntityModel.of(context);
-    final DateTimeEntity entity = entityModel.entity;
+    final DateTimeEntity entity = entityModel.entityWrapper.entity;
     return Padding(
-        padding: EdgeInsets.fromLTRB(0.0, 0.0, Entity.rightWidgetPadding, 0.0),
+        padding: EdgeInsets.fromLTRB(0.0, 0.0, Sizes.rightWidgetPadding, 0.0),
         child: GestureDetector(
           child: Text("${entity.formattedState}",
               textAlign: TextAlign.right,
               style: new TextStyle(
-                fontSize: Entity.stateFontSize,
+                fontSize: Sizes.stateFontSize,
               )),
           onTap: () => _handleStateTap(context, entity),
         ));
@@ -54,7 +54,7 @@ class DateTimeStateWidget extends StatelessWidget {
         }
       });
     } else {
-      TheLogger.warning( "${entity.entityId} has no date and no time");
+      Logger.w( "${entity.entityId} has no date and no time");
     }
   }
 

lib/entities/entity.class.dart

@@ -0,0 +1,282 @@
+part of '../main.dart';
+
+class StatelessEntityType {
+  static const NONE = 0;
+  static const MISSED = 1;
+  static const DIVIDER = 2;
+  static const SECTION = 3;
+  static const CALL_SERVICE = 4;
+  static const WEBLINK = 5;
+}
+
+class Entity {
+
+  static List badgeDomains = [
+    "alarm_control_panel",
+    "binary_sensor",
+    "device_tracker",
+    "updater",
+    "sun",
+    "timer",
+    "sensor"
+  ];
+
+  static Map StateByDeviceClass = {
+    "battery.on": "Low",
+    "battery.off": "Normal",
+    "cold.on": "Cold",
+    "cold.off": "Normal",
+    "connectivity.on": "Connected",
+    "connectivity.off": "Disconnected",
+    "door.on": "Open",
+    "door.off": "Closed",
+    "garage_door.on": "Open",
+    "garage_door.off": "Closed",
+    "gas.on": "Detected",
+    "gas.off": "Clear",
+    "heat.on": "Hot",
+    "heat.off": "Normal",
+    "light.on": "Detected",
+    "lignt.off": "No light",
+    "lock.on": "Unlocked",
+    "lock.off": "Locked",
+    "moisture.on": "Wet",
+    "moisture.off": "Dry",
+    "motion.on": "Detected",
+    "motion.off": "Clear",
+    "moving.on": "Moving",
+    "moving.off": "Stopped",
+    "occupancy.on": "Occupied",
+    "occupancy.off": "Clear",
+    "opening.on": "Open",
+    "opening.off": "Closed",
+    "plug.on": "Plugged in",
+    "plug.off": "Unplugged",
+    "power.on": "Powered",
+    "power.off": "No power",
+    "presence.on": "Home",
+    "presence.off": "Away",
+    "problem.on": "Problem",
+    "problem.off": "OK",
+    "safety.on": "Unsafe",
+    "safety.off": "Safe",
+    "smoke.on": "Detected",
+    "smoke.off": "Clear",
+    "sound.on": "Detected",
+    "sound.off": "Clear",
+    "vibration.on": "Detected",
+    "vibration.off": "Clear",
+    "window.on": "Open",
+    "window.off": "Closed"
+  };
+
+  Map attributes;
+  String domain;
+  String entityId;
+  String entityPicture;
+  String state;
+  String displayState;
+  DateTime _lastUpdated;
+  int statelessType = 0;
+
+  List<Entity> childEntities = [];
+  String deviceClass;
+  EntityHistoryConfig historyConfig = EntityHistoryConfig(
+    chartType: EntityHistoryWidgetType.simple
+  );
+
+  String get displayName =>
+      attributes["friendly_name"] ?? (attributes["name"] ?? entityId.split(".")[1].replaceAll("_", " "));
+
+  bool get isView =>
+      (domain == "group") &&
+      (attributes != null ? attributes["view"] ?? false : false);
+  bool get isGroup => domain == "group";
+  bool get isBadge => Entity.badgeDomains.contains(domain);
+  String get icon => attributes["icon"] ?? "";
+  bool get isOn => state == EntityState.on;
+  String get unitOfMeasurement => attributes["unit_of_measurement"] ?? "";
+  List get childEntityIds => attributes["entity_id"] ?? [];
+  String get lastUpdated => _getLastUpdatedFormatted();
+  bool get isHidden => attributes["hidden"] ?? false;
+  double get doubleState => double.tryParse(state) ?? 0.0;
+  int get supportedFeatures => attributes["supported_features"] ?? 0;
+
+  String _getEntityPictureUrl(String webHost) {
+    String result = attributes["entity_picture"];
+    if (result == null) return result;
+    if (!result.startsWith("http")) {
+      if (result.startsWith("/")) {
+        result = "$webHost$result";
+      } else {
+        result = "$webHost/$result";
+      }
+    }
+    return result;
+  }
+
+  Entity(Map rawData, String webHost) {
+    update(rawData, webHost);
+  }
+
+  Entity.missed(String entityId) {
+    statelessType = StatelessEntityType.MISSED;
+    attributes = {"hidden": false};
+    this.entityId = entityId;
+  }
+
+  Entity.divider() {
+    statelessType = StatelessEntityType.DIVIDER;
+    attributes = {"hidden": false};
+  }
+
+  Entity.section(String label) {
+    statelessType = StatelessEntityType.SECTION;
+    attributes = {"hidden": false, "friendly_name": "$label"};
+  }
+
+  Entity.callService({String icon, String name, String service, String actionName}) {
+    statelessType = StatelessEntityType.CALL_SERVICE;
+    entityId = service;
+    displayState = actionName?.toUpperCase() ?? "RUN";
+    attributes = {"hidden": false, "friendly_name": "$name", "icon": "$icon"};
+  }
+
+  Entity.weblink({String url, String name, String icon}) {
+    statelessType = StatelessEntityType.WEBLINK;
+    entityId = "custom.custom"; //TODO wtf??
+    attributes = {"hidden": false, "friendly_name": "${name ?? url}", "icon": "${icon ?? 'mdi:link'}"};
+  }
+
+  void update(Map rawData, String webHost) {
+    attributes = rawData["attributes"] ?? {};
+    domain = rawData["entity_id"].split(".")[0];
+    entityId = rawData["entity_id"];
+    deviceClass = attributes["device_class"];
+    state = rawData["state"];
+    displayState = Entity.StateByDeviceClass["$deviceClass.$state"] ?? (state.toLowerCase() == 'unknown' ? '-' : state);
+    _lastUpdated = DateTime.tryParse(rawData["last_updated"]);
+    entityPicture = _getEntityPictureUrl(webHost);
+  }
+
+  double _getDoubleAttributeValue(String attributeName) {
+    var temp1 = attributes["$attributeName"];
+    if (temp1 is int) {
+      return temp1.toDouble();
+    } else if (temp1 is double) {
+      return temp1;
+    } else {
+      return double.tryParse("$temp1");
+    }
+  }
+
+  int _getIntAttributeValue(String attributeName) {
+    var temp1 = attributes["$attributeName"];
+    if (temp1 is int) {
+      return temp1;
+    } else if (temp1 is double) {
+      return temp1.round();
+    } else {
+      return int.tryParse("$temp1");
+    }
+  }
+
+  List<String> getStringListAttributeValue(String attribute) {
+    if (attributes["$attribute"] != null) {
+      List<String> result = (attributes["$attribute"] as List).cast<String>();
+      return result;
+    } else {
+      return null;
+    }
+  }
+
+  Widget buildDefaultWidget(BuildContext context) {
+    return DefaultEntityContainer(
+        state: _buildStatePart(context)
+    );
+  }
+
+  Widget _buildStatePart(BuildContext context) {
+    return SimpleEntityState();
+  }
+
+  Widget _buildStatePartForPage(BuildContext context) {
+    return _buildStatePart(context);
+  }
+
+  Widget _buildAdditionalControlsForPage(BuildContext context) {
+    return Container(
+      width: 0.0,
+      height: 0.0,
+    );
+  }
+
+  Widget buildEntityPageWidget(BuildContext context) {
+    return EntityModel(
+      entityWrapper: EntityWrapper(entity: this),
+      child: EntityPageContainer(children: <Widget>[
+        Padding(
+          padding: EdgeInsets.only(top: Sizes.rowPadding, left: Sizes.leftWidgetPadding),
+          child: DefaultEntityContainer(state: _buildStatePartForPage(context)),
+        ),
+        LastUpdatedWidget(),
+        Divider(),
+        _buildAdditionalControlsForPage(context),
+        Divider(),
+        buildHistoryWidget(),
+        EntityAttributesList()
+      ]),
+      handleTap: false,
+    );
+  }
+
+  Widget buildHistoryWidget() {
+    return EntityHistoryWidget(
+      config: historyConfig,
+    );
+  }
+
+  Widget buildBadgeWidget(BuildContext context) {
+    return EntityModel(
+      entityWrapper: EntityWrapper(entity: this),
+      child: BadgeWidget(),
+      handleTap: true,
+    );
+  }
+
+  String getAttribute(String attributeName) {
+    if (attributes != null) {
+      return attributes["$attributeName"];
+    }
+    return null;
+  }
+
+  String _getLastUpdatedFormatted() {
+    if (_lastUpdated == null) {
+      return "-";
+    } else {
+      DateTime now = DateTime.now();
+      Duration d = now.difference(_lastUpdated);
+      String text;
+      int v;
+      if (d.inDays == 0) {
+        if (d.inHours == 0) {
+          if (d.inMinutes == 0) {
+            text = "seconds ago";
+            v = d.inSeconds;
+          } else {
+            text = "minutes ago";
+            v = d.inMinutes;
+          }
+        } else {
+          text = "hours ago";
+          v = d.inHours;
+        }
+      } else {
+        text = "days ago";
+        v = d.inDays;
+      }
+      return "$v $text";
+    }
+  }
+}

lib/entities/entity_wrapper.class.dart

@@ -0,0 +1,114 @@
+part of '../main.dart';
+
+class EntityWrapper {
+
+  String displayName;
+  String icon;
+  String entityPicture;
+  EntityUIAction uiAction;
+  Entity entity;
+
+
+  EntityWrapper({
+    this.entity,
+    String icon,
+    String displayName,
+    this.uiAction
+  }) {
+    if (entity.statelessType == StatelessEntityType.NONE || entity.statelessType == StatelessEntityType.CALL_SERVICE || entity.statelessType == StatelessEntityType.WEBLINK) {
+      this.icon = icon ?? entity.icon;
+      if (icon == null) {
+        entityPicture = entity.entityPicture;
+      }
+      this.displayName = displayName ?? entity.displayName;
+      if (uiAction == null) {
+        uiAction = EntityUIAction();
+      }
+    }
+  }
+
+  void handleTap() {
+    switch (uiAction.tapAction) {
+      case EntityUIAction.toggle: {
+        eventBus.fire(
+            ServiceCallEvent("homeassistant", "toggle", entity.entityId, null));
+        break;
+      }
+
+      case EntityUIAction.callService: {
+        if (uiAction.tapService != null) {
+          eventBus.fire(
+              ServiceCallEvent(uiAction.tapService.split(".")[0],
+                  uiAction.tapService.split(".")[1], null,
+                  uiAction.tapServiceData));
+        }
+        break;
+      }
+
+      case EntityUIAction.none: {
+        break;
+      }
+
+      case EntityUIAction.moreInfo: {
+        eventBus.fire(
+            new ShowEntityPageEvent(entity));
+        break;
+      }
+
+      case EntityUIAction.navigate: {
+        if (uiAction.tapService.startsWith("/")) {
+          //TODO handle local urls
+          Logger.w("Local urls is not supported yet");
+        } else {
+          Launcher.launchURL(uiAction.tapService);
+        }
+        break;
+      }
+
+      default: {
+        break;
+      }
+    }
+  }
+
+  void handleHold() {
+      switch (uiAction.holdAction) {
+        case EntityUIAction.toggle: {
+          eventBus.fire(
+              ServiceCallEvent("homeassistant", "toggle", entity.entityId, null));
+          break;
+        }
+
+        case EntityUIAction.callService: {
+          if (uiAction.holdService != null) {
+            eventBus.fire(
+                ServiceCallEvent(uiAction.holdService.split(".")[0],
+                    uiAction.holdService.split(".")[1], null,
+                    uiAction.holdServiceData));
+          }
+          break;
+        }
+
+        case EntityUIAction.moreInfo: {
+          eventBus.fire(
+              new ShowEntityPageEvent(entity));
+          break;
+        }
+
+        case EntityUIAction.navigate: {
+          if (uiAction.holdService.startsWith("/")) {
+            //TODO handle local urls
+            Logger.w("Local urls is not supported yet");
+          } else {
+            Launcher.launchURL(uiAction.holdService);
+          }
+          break;
+        }
+
+        default: {
+          break;
+        }
+      }
+  }
+
+}

lib/entities/fan/fan_entity.class.dart

@@ -0,0 +1,32 @@
+part of '../../main.dart';
+
+class FanEntity extends Entity {
+
+  static const SUPPORT_SET_SPEED = 1;
+  static const SUPPORT_OSCILLATE = 2;
+  static const SUPPORT_DIRECTION = 4;
+
+  FanEntity(Map rawData, String webHost) : super(rawData, webHost);
+
+  bool get supportSetSpeed => ((supportedFeatures &
+  FanEntity.SUPPORT_SET_SPEED) ==
+      FanEntity.SUPPORT_SET_SPEED);
+  bool get supportOscillate => ((supportedFeatures &
+  FanEntity.SUPPORT_OSCILLATE) ==
+      FanEntity.SUPPORT_OSCILLATE);
+  bool get supportDirection => ((supportedFeatures &
+  FanEntity.SUPPORT_DIRECTION) ==
+      FanEntity.SUPPORT_DIRECTION);
+
+  List<String> get speedList => getStringListAttributeValue("speed_list");
+
+  @override
+  Widget _buildStatePart(BuildContext context) {
+    return SwitchStateWidget();
+  }
+
+  @override
+  Widget _buildAdditionalControlsForPage(BuildContext context) {
+    return FanControlsWidget();
+  }
+}

lib/entities/fan/widgets/fan_controls.dart

@@ -0,0 +1,123 @@
+part of '../../../main.dart';
+
+class FanControlsWidget extends StatefulWidget {
+
+  @override
+  _FanControlsWidgetState createState() => _FanControlsWidgetState();
+
+}
+
+class _FanControlsWidgetState extends State<FanControlsWidget> {
+
+  bool _tmpOscillate;
+  bool _tmpDirectionForward;
+  bool _changedHere = false;
+  String _tmpSpeed;
+
+  void _resetState(FanEntity entity) {
+    _tmpOscillate = entity.attributes["oscillating"] ?? false;
+    _tmpDirectionForward = entity.attributes["direction"] == "forward";
+    _tmpSpeed = entity.attributes["speed"];
+  }
+
+  void _setOscillate(FanEntity entity, bool oscillate) {
+    setState(() {
+      _tmpOscillate = oscillate;
+      _changedHere = true;
+      eventBus.fire(new ServiceCallEvent(
+          "fan", "oscillate", entity.entityId,
+          {"oscillating": oscillate}));
+    });
+  }
+
+  void _setDirection(FanEntity entity, bool forward) {
+    setState(() {
+      _tmpDirectionForward = forward;
+      _changedHere = true;
+      eventBus.fire(new ServiceCallEvent(
+          "fan", "set_direction", entity.entityId,
+          {"direction": forward ? "forward" : "reverse"}));
+    });
+  }
+
+  void _setSpeed(FanEntity entity, String value) {
+    setState(() {
+      _tmpSpeed = value;
+      _changedHere = true;
+      eventBus.fire(new ServiceCallEvent(
+            "fan", "set_speed", entity.entityId,
+            {"speed": value}));
+    });
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    final entityModel = EntityModel.of(context);
+    final FanEntity entity = entityModel.entityWrapper.entity;
+    if (!_changedHere) {
+      _resetState(entity);
+    } else {
+      _changedHere = false;
+    }
+    return Column(
+      crossAxisAlignment: CrossAxisAlignment.center,
+      children: <Widget>[
+        _buildSpeedControl(entity),
+        _buildOscillateControl(entity),
+        _buildDirectionControl(entity)
+      ],
+    );
+  }
+
+  Widget _buildSpeedControl(FanEntity entity) {
+    if (entity.supportSetSpeed && entity.speedList != null && entity.speedList.isNotEmpty) {
+      return ModeSelectorWidget(
+        onChange: (effect) => _setSpeed(entity, effect),
+        caption: "Speed",
+        options: entity.speedList,
+        value: _tmpSpeed
+      );
+    } else {
+      return Container(width: 0.0, height: 0.0);
+    }
+  }
+
+  Widget _buildOscillateControl(FanEntity entity) {
+    if (entity.supportOscillate) {
+      return ModeSwitchWidget(
+          onChange: (value) => _setOscillate(entity, value),
+          caption: "Oscillate",
+          value: _tmpOscillate,
+          expanded: false,
+      );
+    } else {
+      return Container(width: 0.0, height: 0.0);
+    }
+  }
+
+  Widget _buildDirectionControl(FanEntity entity) {
+    if (entity.supportDirection) {
+      return Row(
+        mainAxisSize: MainAxisSize.min,
+        children: <Widget>[
+          IconButton(
+            onPressed: _tmpDirectionForward ?
+              () => _setDirection(entity, false) :
+              null,
+            icon: Icon(Icons.rotate_left),
+          ),
+          IconButton(
+            onPressed: !_tmpDirectionForward ?
+              () => _setDirection(entity, true) :
+              null,
+            icon: Icon(Icons.rotate_right),
+          ),
+        ],
+      );
+    } else {
+      return Container(width: 0.0, height: 0.0);
+    }
+  }
+
+
+}

lib/entities/group/group_entity.class.dart

@@ -0,0 +1,44 @@
+part of '../../main.dart';
+
+class GroupEntity extends Entity {
+
+  final List<String> _domainsForSwitchableGroup = ["switch", "light", "automation", "input_boolean"];
+  String mutualDomain;
+  bool switchable = false;
+
+  GroupEntity(Map rawData, String webHost) : super(rawData, webHost);
+
+  @override
+  Widget _buildStatePart(BuildContext context) {
+    if (switchable) {
+      return SwitchStateWidget(
+        domainForService: "homeassistant",
+      );
+    } else {
+      return super._buildStatePart(context);
+    }
+  }
+
+  @override
+  void update(Map rawData, String webHost) {
+    super.update(rawData, webHost);
+    if (_isOneDomain()) {
+      mutualDomain = attributes['entity_id'][0].split(".")[0];
+      switchable = _domainsForSwitchableGroup.contains(mutualDomain);
+    }
+  }
+
+  bool _isOneDomain() {
+    bool result = false;
+    if (attributes['entity_id'] != null && attributes['entity_id'] is List && attributes['entity_id'].isNotEmpty) {
+      String firstChildDomain = attributes['entity_id'][0].split(".")[0];
+      result = true;
+      attributes['entity_id'].forEach((childEntityId){
+        if (childEntityId.split(".")[0] != firstChildDomain) {
+          result = false;
+        }
+      });
+    }
+    return result;
+  }
+}

lib/entities/light/light_entity.class.dart

@@ -1,4 +1,4 @@
-part of '../main.dart';
+part of '../../main.dart';
 
 class LightEntity extends Entity {
 
@@ -10,43 +10,50 @@ class LightEntity extends Entity {
   static const SUPPORT_TRANSITION = 32;
   static const SUPPORT_WHITE_VALUE = 128;
 
-  bool get supportBrightness => ((attributes["supported_features"] &
+  bool get supportBrightness => ((supportedFeatures &
   LightEntity.SUPPORT_BRIGHTNESS) ==
       LightEntity.SUPPORT_BRIGHTNESS);
-  bool get supportColorTemp => ((attributes["supported_features"] &
+  bool get supportColorTemp => ((supportedFeatures &
   LightEntity.SUPPORT_COLOR_TEMP) ==
       LightEntity.SUPPORT_COLOR_TEMP);
-  bool get supportEffect => ((attributes["supported_features"] &
+  bool get supportEffect => ((supportedFeatures &
   LightEntity.SUPPORT_EFFECT) ==
       LightEntity.SUPPORT_EFFECT);
-  bool get supportFlash => ((attributes["supported_features"] &
+  bool get supportFlash => ((supportedFeatures &
   LightEntity.SUPPORT_FLASH) ==
       LightEntity.SUPPORT_FLASH);
-  bool get supportColor => ((attributes["supported_features"] &
+  bool get supportColor => ((supportedFeatures &
   LightEntity.SUPPORT_COLOR) ==
       LightEntity.SUPPORT_COLOR);
-  bool get supportTransition => ((attributes["supported_features"] &
+  bool get supportTransition => ((supportedFeatures &
   LightEntity.SUPPORT_TRANSITION) ==
       LightEntity.SUPPORT_TRANSITION);
-  bool get supportWhiteValue => ((attributes["supported_features"] &
+  bool get supportWhiteValue => ((supportedFeatures &
   LightEntity.SUPPORT_WHITE_VALUE) ==
       LightEntity.SUPPORT_WHITE_VALUE);
 
   int get brightness => _getIntAttributeValue("brightness");
+  int get whiteValue => _getIntAttributeValue("white_value");
+  String get effect => attributes["effect"];
   int get colorTemp => _getIntAttributeValue("color_temp");
   double get maxMireds => _getDoubleAttributeValue("max_mireds");
   double get minMireds => _getDoubleAttributeValue("min_mireds");
-  Color get color => _getColor();
+  HSVColor get color => _getColor();
-  bool get isAdditionalControls => ((attributes["supported_features"] != null) && (attributes["supported_features"] != 0));
+  bool get isAdditionalControls => ((supportedFeatures != null) && (supportedFeatures != 0));
-  List<String> get effectList => _getEffectList();
+  List<String> get effectList => getStringListAttributeValue("effect_list");
 
-  LightEntity(Map rawData) : super(rawData);
+  LightEntity(Map rawData, String webHost) : super(rawData, webHost);
 
-  Color _getColor() {
+  HSVColor _getColor() {
+    List hs = attributes["hs_color"];
     List rgb = attributes["rgb_color"];
     try {
-      if ((rgb != null) && (rgb.length > 0)) {
+      if (hs != null && hs.isNotEmpty) {
-        return Color.fromARGB(255, rgb[0], rgb[1], rgb[2]);
+        double sat = hs[1]/100;
+        String ssat = sat.toStringAsFixed(2);
+        return HSVColor.fromAHSV(1.0, hs[0], double.parse(ssat), 1.0);
+      } else if (rgb != null && rgb.isNotEmpty) {
+        return HSVColor.fromColor(Color.fromARGB(255, rgb[0], rgb[1], rgb[2]));
       } else {
         return null;
       }
@@ -55,15 +62,6 @@ class LightEntity extends Entity {
     }
   }
 
-  List<String> _getEffectList() {
-    if (attributes["effect_list"] != null) {
-      List<String> result = (attributes["effect_list"] as List).cast<String>();
-      return result;
-    } else {
-      return null;
-    }
-  }
-
   @override
   Widget _buildStatePart(BuildContext context) {
     return SwitchStateWidget();
@@ -71,7 +69,7 @@ class LightEntity extends Entity {
 
   @override
   Widget _buildAdditionalControlsForPage(BuildContext context) {
-    if (!isAdditionalControls) {
+    if (!isAdditionalControls || state == EntityState.unavailable) {
       return Container(height: 0.0, width: 0.0);
     } else {
       return LightControlsWidget();

lib/entities/light/widgets/light_controls.dart

@@ -0,0 +1,218 @@
+part of '../../../main.dart';
+
+class LightControlsWidget extends StatefulWidget {
+
+  @override
+  _LightControlsWidgetState createState() => _LightControlsWidgetState();
+
+}
+
+class _LightControlsWidgetState extends State<LightControlsWidget> {
+
+  int _tmpBrightness;
+  int _tmpWhiteValue;
+  int _tmpColorTemp = 0;
+  HSVColor _tmpColor = HSVColor.fromAHSV(1.0, 30.0, 0.0, 1.0);
+  bool _changedHere = false;
+  String _tmpEffect;
+
+  void _resetState(LightEntity entity) {
+    _tmpBrightness = entity.brightness ?? 1;
+    _tmpWhiteValue = entity.whiteValue ?? 0;
+    _tmpColorTemp = entity.colorTemp ?? entity.minMireds?.toInt();
+    _tmpColor = entity.color ?? _tmpColor;
+    _tmpEffect = entity.effect;
+  }
+
+  void _setBrightness(LightEntity entity, double value) {
+    setState(() {
+      _tmpBrightness = value.round();
+      _changedHere = true;
+      eventBus.fire(new ServiceCallEvent(
+          entity.domain, "turn_on", entity.entityId,
+          {"brightness": _tmpBrightness}));
+    });
+  }
+
+  void _setWhiteValue(LightEntity entity, double value) {
+    setState(() {
+      _tmpWhiteValue = value.round();
+      _changedHere = true;
+      eventBus.fire(new ServiceCallEvent(
+            entity.domain, "turn_on", entity.entityId,
+            {"white_value": _tmpWhiteValue}));
+
+    });
+  }
+
+  void _setColorTemp(LightEntity entity, double value) {
+    setState(() {
+      _tmpColorTemp = value.round();
+      _changedHere = true;
+      eventBus.fire(new ServiceCallEvent(
+          entity.domain, "turn_on", entity.entityId,
+          {"color_temp": _tmpColorTemp}));
+    });
+  }
+
+  void _setColor(LightEntity entity, HSVColor color) {
+    setState(() {
+      _tmpColor = color;
+      _changedHere = true;
+      Logger.d( "HS Color: [${color.hue}, ${color.saturation}]");
+      eventBus.fire(new ServiceCallEvent(
+        entity.domain, "turn_on", entity.entityId,
+          {"hs_color": [color.hue, color.saturation*100]}));
+    });
+  }
+
+  void _setEffect(LightEntity entity, String value) {
+    setState(() {
+      _tmpEffect = value;
+      _changedHere = true;
+      if (_tmpEffect != null) {
+        eventBus.fire(new ServiceCallEvent(
+            entity.domain, "turn_on", entity.entityId,
+            {"effect": "$value"}));
+      }
+    });
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    final entityModel = EntityModel.of(context);
+    final LightEntity entity = entityModel.entityWrapper.entity;
+    if (!_changedHere) {
+      _resetState(entity);
+    } else {
+      _changedHere = false;
+    }
+    return Column(
+      crossAxisAlignment: CrossAxisAlignment.center,
+      children: <Widget>[
+        _buildBrightnessControl(entity),
+        _buildWhiteValueControl(entity),
+        _buildColorTempControl(entity),
+        _buildColorControl(entity),
+        _buildEffectControl(entity)
+      ],
+    );
+  }
+
+  Widget _buildBrightnessControl(LightEntity entity) {
+    if ((entity.supportBrightness) && (_tmpBrightness != null)) {
+      return UniversalSlider(
+        onChanged: (value) {
+          setState(() {
+            _changedHere = true;
+            _tmpBrightness = value.round();
+          });
+        },
+        min: 1.0,
+        max: 255.0,
+        onChangeEnd: (value) => _setBrightness(entity, value),
+        value: _tmpBrightness == null ? 1.0 : _tmpBrightness.toDouble(),
+        leading: Icon(Icons.brightness_5),
+        title: "Brightness",
+      );
+    } else {
+      return Container(width: 0.0, height: 0.0);
+    }
+  }
+
+  Widget _buildWhiteValueControl(LightEntity entity) {
+    if ((entity.supportWhiteValue) && (_tmpWhiteValue != null)) {
+      return UniversalSlider(
+        onChanged: (value) {
+          setState(() {
+            _changedHere = true;
+            _tmpWhiteValue = value.round();
+          });
+        },
+        min: 0.0,
+        max: 255.0,
+        onChangeEnd: (value) => _setWhiteValue(entity, value),
+        value: _tmpWhiteValue == null ? 0.0 : _tmpWhiteValue.toDouble(),
+        leading: Icon(MaterialDesignIcons.getIconDataFromIconName("mdi:file-word-box")),
+        title: "White",
+      );
+    } else {
+      return Container(width: 0.0, height: 0.0);
+    }
+  }
+
+  Widget _buildColorTempControl(LightEntity entity) {
+    if (entity.supportColorTemp) {
+      return UniversalSlider(
+        title: "Color temperature",
+        leading: Text("Cold", style: TextStyle(color: Colors.lightBlue),),
+        value:  _tmpColorTemp == null ? entity.maxMireds : _tmpColorTemp.toDouble(),
+        onChangeEnd: (value) => _setColorTemp(entity, value),
+        max: entity.maxMireds,
+        min: entity.minMireds,
+        onChanged: (value) {
+          setState(() {
+            _changedHere = true;
+            _tmpColorTemp = value.round();
+          });
+        },
+        closing: Text("Warm", style: TextStyle(color: Colors.amberAccent),),
+      );
+    } else {
+      return Container(width: 0.0, height: 0.0);
+    }
+  }
+
+  Widget _buildColorControl(LightEntity entity) {
+    if (entity.supportColor) {
+      HSVColor savedColor = HomeAssistant().savedColor;
+      return Column(
+        mainAxisSize: MainAxisSize.min,
+        children: <Widget>[
+          LightColorPicker(
+            color: _tmpColor,
+            onColorSelected: (color) => _setColor(entity, color),
+          ),
+          Row(
+            mainAxisSize: MainAxisSize.min,
+            children: <Widget>[
+              FlatButton(
+                color: _tmpColor.toColor(),
+                child: Text('Copy color'),
+                onPressed: _tmpColor == null ? null : () {
+                  setState(() {
+                    HomeAssistant().savedColor = _tmpColor;
+                  });
+                },
+              ),
+              FlatButton(
+                color: savedColor?.toColor() ?? Colors.transparent,
+                child: Text('Paste color'),
+                onPressed: savedColor == null ? null : () {
+                  _setColor(entity, savedColor);
+                },
+              )
+            ],
+          )
+        ],
+      );
+    } else {
+      return Container(width: 0.0, height: 0.0);
+    }
+  }
+
+  Widget _buildEffectControl(LightEntity entity) {
+    if ((entity.supportEffect) && (entity.effectList != null)) {
+      return ModeSelectorWidget(
+          onChange: (effect) => _setEffect(entity, effect),
+          caption: "Effect",
+          options: entity.effectList,
+          value: _tmpEffect
+      );
+    } else {
+      return Container(width: 0.0, height: 0.0);
+    }
+  }
+
+
+}

lib/entities/lock/lock_entity.class.dart

@@ -0,0 +1,21 @@
+part of '../../main.dart';
+
+class LockEntity extends Entity {
+  LockEntity(Map rawData, String webHost) : super(rawData, webHost);
+
+  bool get isLocked => state == "locked";
+
+  @override
+  Widget _buildStatePart(BuildContext context) {
+    return LockStateWidget(
+      assumedState: false,
+    );
+  }
+
+  @override
+  Widget _buildStatePartForPage(BuildContext context) {
+    return LockStateWidget(
+      assumedState: true,
+    );
+  }
+}

lib/entities/lock/widgets/lock_state.dart

@@ -0,0 +1,66 @@
+part of '../../../main.dart';
+
+class LockStateWidget extends StatelessWidget {
+
+  final bool assumedState;
+
+  const LockStateWidget({Key key, this.assumedState: false}) : super(key: key);
+
+  void _lock(Entity entity) {
+    eventBus.fire(new ServiceCallEvent("lock", "lock", entity.entityId, null));
+  }
+
+  void _unlock(Entity entity) {
+    eventBus.fire(new ServiceCallEvent("lock", "unlock", entity.entityId, null));
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    final entityModel = EntityModel.of(context);
+    final LockEntity entity = entityModel.entityWrapper.entity;
+    if (assumedState) {
+      return Row(
+        mainAxisSize: MainAxisSize.min,
+        children: <Widget>[
+        SizedBox(
+        height: 34.0,
+        child: FlatButton(
+          onPressed: () => _unlock(entity),
+          child: Text("UNLOCK",
+              textAlign: TextAlign.right,
+              style:
+              new TextStyle(fontSize: Sizes.stateFontSize, color: Colors.blue),
+            ),
+          )
+        ),
+        SizedBox(
+            height: 34.0,
+            child: FlatButton(
+              onPressed: () => _lock(entity),
+              child: Text("LOCK",
+                textAlign: TextAlign.right,
+                style:
+                new TextStyle(fontSize: Sizes.stateFontSize, color: Colors.blue),
+              ),
+            )
+        )
+        ],
+      );
+    } else {
+      return SizedBox(
+          height: 34.0,
+          child: FlatButton(
+            onPressed: (() {
+              entity.isLocked ? _unlock(entity) : _lock(entity);
+            }),
+            child: Text(
+              entity.isLocked ? "UNLOCK" : "LOCK",
+              textAlign: TextAlign.right,
+              style:
+              new TextStyle(fontSize: Sizes.stateFontSize, color: Colors.blue),
+            ),
+          )
+      );
+    }
+  }
+}

lib/entities/media_player/media_player_entity.class.dart

@@ -0,0 +1,83 @@
+part of '../../main.dart';
+
+class MediaPlayerEntity extends Entity {
+
+  static const SUPPORT_PAUSE = 1;
+  static const SUPPORT_SEEK = 2;
+  static const SUPPORT_VOLUME_SET = 4;
+  static const SUPPORT_VOLUME_MUTE = 8;
+  static const SUPPORT_PREVIOUS_TRACK = 16;
+  static const SUPPORT_NEXT_TRACK = 32;
+
+  static const SUPPORT_TURN_ON = 128;
+  static const SUPPORT_TURN_OFF = 256;
+  static const SUPPORT_PLAY_MEDIA = 512;
+  static const SUPPORT_VOLUME_STEP = 1024;
+  static const SUPPORT_SELECT_SOURCE = 2048;
+  static const SUPPORT_STOP = 4096;
+  static const SUPPORT_CLEAR_PLAYLIST = 8192;
+  static const SUPPORT_PLAY = 16384;
+  static const SUPPORT_SHUFFLE_SET = 32768;
+  static const SUPPORT_SELECT_SOUND_MODE = 65536;
+
+  MediaPlayerEntity(Map rawData, String webHost) : super(rawData, webHost);
+
+  bool get supportPause => ((supportedFeatures &
+  MediaPlayerEntity.SUPPORT_PAUSE) ==
+      MediaPlayerEntity.SUPPORT_PAUSE);
+  bool get supportSeek => ((supportedFeatures &
+  MediaPlayerEntity.SUPPORT_SEEK) ==
+      MediaPlayerEntity.SUPPORT_SEEK);
+  bool get supportVolumeSet => ((supportedFeatures &
+  MediaPlayerEntity.SUPPORT_VOLUME_SET) ==
+      MediaPlayerEntity.SUPPORT_VOLUME_SET);
+  bool get supportVolumeMute => ((supportedFeatures &
+  MediaPlayerEntity.SUPPORT_VOLUME_MUTE) ==
+      MediaPlayerEntity.SUPPORT_VOLUME_MUTE);
+  bool get supportPreviousTrack => ((supportedFeatures &
+  MediaPlayerEntity.SUPPORT_PREVIOUS_TRACK) ==
+      MediaPlayerEntity.SUPPORT_PREVIOUS_TRACK);
+  bool get supportNextTrack => ((supportedFeatures &
+  MediaPlayerEntity.SUPPORT_NEXT_TRACK) ==
+      MediaPlayerEntity.SUPPORT_NEXT_TRACK);
+
+  bool get supportTurnOn => ((supportedFeatures &
+  MediaPlayerEntity.SUPPORT_TURN_ON) ==
+      MediaPlayerEntity.SUPPORT_TURN_ON);
+  bool get supportTurnOff => ((supportedFeatures &
+  MediaPlayerEntity.SUPPORT_TURN_OFF) ==
+      MediaPlayerEntity.SUPPORT_TURN_OFF);
+  bool get supportPlayMedia => ((supportedFeatures &
+  MediaPlayerEntity.SUPPORT_PLAY_MEDIA) ==
+      MediaPlayerEntity.SUPPORT_PLAY_MEDIA);
+  bool get supportVolumeStep => ((supportedFeatures &
+  MediaPlayerEntity.SUPPORT_VOLUME_STEP) ==
+      MediaPlayerEntity.SUPPORT_VOLUME_STEP);
+  bool get supportSelectSource => ((supportedFeatures &
+  MediaPlayerEntity.SUPPORT_SELECT_SOURCE) ==
+      MediaPlayerEntity.SUPPORT_SELECT_SOURCE);
+  bool get supportStop => ((supportedFeatures &
+  MediaPlayerEntity.SUPPORT_STOP) ==
+      MediaPlayerEntity.SUPPORT_STOP);
+  bool get supportClearPlaylist => ((supportedFeatures &
+  MediaPlayerEntity.SUPPORT_CLEAR_PLAYLIST) ==
+      MediaPlayerEntity.SUPPORT_CLEAR_PLAYLIST);
+  bool get supportPlay => ((supportedFeatures &
+  MediaPlayerEntity.SUPPORT_PLAY) ==
+      MediaPlayerEntity.SUPPORT_PLAY);
+  bool get supportShuffleSet => ((supportedFeatures &
+  MediaPlayerEntity.SUPPORT_SHUFFLE_SET) ==
+      MediaPlayerEntity.SUPPORT_SHUFFLE_SET);
+  bool get supportSelectSoundMode => ((supportedFeatures &
+  MediaPlayerEntity.SUPPORT_SELECT_SOUND_MODE) ==
+      MediaPlayerEntity.SUPPORT_SELECT_SOUND_MODE);
+
+  List<String> get soundModeList => getStringListAttributeValue("sound_mode_list");
+  List<String> get sourceList => getStringListAttributeValue("source_list");
+
+  @override
+  Widget _buildAdditionalControlsForPage(BuildContext context) {
+    return MediaPlayerControls();
+  }
+
+}

lib/entities/media_player/widgets/media_player_widgets.dart

@@ -0,0 +1,466 @@
+part of '../../../main.dart';
+
+class MediaPlayerWidget extends StatelessWidget {
+  
+  @override
+  Widget build(BuildContext context) {
+    final EntityModel entityModel = EntityModel.of(context);
+    final MediaPlayerEntity entity = entityModel.entityWrapper.entity;
+    //TheLogger.debug("stop: ${entity.supportStop}, seek: ${entity.supportSeek}");
+    return Column(
+      children: <Widget>[
+        Stack(
+          alignment: AlignmentDirectional.topEnd,
+          children: <Widget>[
+            _buildImage(entity),
+            Positioned(
+              bottom: 0.0,
+              left: 0.0,
+              right: 0.0,
+              child: Container(
+                color: Colors.black45,
+                child: _buildState(entity),
+              ),
+            ),
+            Positioned(
+                bottom: 0.0,
+                left: 0.0,
+                right: 0.0,
+                child: MediaPlayerProgressWidget()
+            )
+          ],
+        ),
+        MediaPlayerPlaybackControls()
+      ]
+    );
+  }
+
+  Widget _buildState(MediaPlayerEntity entity) {
+    TextStyle style = TextStyle(
+        fontSize: 14.0,
+        color: Colors.white,
+        fontWeight: FontWeight.normal,
+        height: 1.2
+    );
+    List<Widget> states = [];
+    states.add(Text("${entity.displayName}", style: style));
+    String state = entity.state;
+    if (state == null || state == EntityState.off || state == EntityState.unavailable || state == EntityState.idle) {
+      states.add(Text("${entity.state}", style: style.apply(fontSizeDelta: 4.0),));
+    }
+    if (entity.attributes['media_title'] != null) {
+      states.add(Text(
+        "${entity.attributes['media_title']}",
+        style: style.apply(fontSizeDelta: 6.0, fontWeightDelta: 50),
+        maxLines: 1,
+        softWrap: true,
+        overflow: TextOverflow.ellipsis,
+      ));
+    }
+    if (entity.attributes['media_content_type'] == "music") {
+      states.add(Text("${entity.attributes['media_artist'] ?? entity.attributes['app_name']}", style: style.apply(fontSizeDelta: 4.0),));
+    } else if (entity.attributes['app_name'] != null) {
+      states.add(Text("${entity.attributes['app_name']}", style: style.apply(fontSizeDelta: 4.0),));
+    }
+    return Padding(
+      padding: EdgeInsets.fromLTRB(Sizes.leftWidgetPadding, Sizes.rowPadding, Sizes.rightWidgetPadding, Sizes.rowPadding),
+      child: Column(
+        crossAxisAlignment: CrossAxisAlignment.start,
+        children: states,
+      ),
+    );
+  }
+
+  Widget _buildImage(MediaPlayerEntity entity) {
+    String state = entity.state;
+    if (entity.entityPicture != null && state != EntityState.off && state != EntityState.unavailable && state != EntityState.idle) {
+      return Container(
+        color: Colors.black,
+        child: Row(
+          mainAxisAlignment: MainAxisAlignment.center,
+          children: <Widget>[
+            Flexible(
+              child: Image(
+                image: CachedNetworkImageProvider("${entity.entityPicture}"),
+                height: 240.0,
+                //width: 320.0,
+                fit: BoxFit.contain,
+              ),
+            )
+          ],
+        ),
+      );
+    } else {
+      return Row(
+        mainAxisAlignment: MainAxisAlignment.center,
+        children: <Widget>[
+          Icon(
+            MaterialDesignIcons.getIconDataFromIconName("mdi:movie"),
+            size: 150.0,
+            color: EntityColor.stateColor("$state"),
+          )
+        ],
+      );
+      /*return Container(
+        color: Colors.blue,
+        height: 80.0,
+      );*/
+    }
+  }
+}
+
+class MediaPlayerPlaybackControls extends StatelessWidget {
+
+  final bool showMenu;
+  final bool showStop;
+
+  const MediaPlayerPlaybackControls({Key key, this.showMenu: true, this.showStop: false}) : super(key: key);
+
+
+  void _setPower(MediaPlayerEntity entity) {
+    if (entity.state != EntityState.unavailable && entity.state != EntityState.unknown) {
+      if (entity.state == EntityState.off) {
+        Logger.d("${entity.entityId} turn_on");
+        eventBus.fire(new ServiceCallEvent(
+            entity.domain, "turn_on", entity.entityId,
+            null));
+      } else {
+        Logger.d("${entity.entityId} turn_off");
+        eventBus.fire(new ServiceCallEvent(
+            entity.domain, "turn_off", entity.entityId,
+            null));
+      }
+    }
+  }
+
+  void _callAction(MediaPlayerEntity entity, String action) {
+    Logger.d("${entity.entityId} $action");
+    eventBus.fire(new ServiceCallEvent(
+        entity.domain, "$action", entity.entityId,
+        null));
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    final MediaPlayerEntity entity = EntityModel.of(context).entityWrapper.entity;
+    List<Widget> result = [];
+    if (entity.supportTurnOn || entity.supportTurnOff) {
+      result.add(
+          IconButton(
+            icon: Icon(Icons.power_settings_new),
+            onPressed: () => _setPower(entity),
+            iconSize: Sizes.iconSize,
+          )
+      );
+    } else {
+      result.add(
+          Container(
+            width: Sizes.iconSize,
+          )
+      );
+    }
+    List <Widget> centeredControlsChildren = [];
+    if (entity.supportPreviousTrack && entity.state != EntityState.off && entity.state != EntityState.unavailable) {
+      centeredControlsChildren.add(
+          IconButton(
+            icon: Icon(Icons.skip_previous),
+            onPressed: () => _callAction(entity, "media_previous_track"),
+            iconSize: Sizes.iconSize,
+          )
+      );
+    }
+    if (entity.supportPlay || entity.supportPause) {
+      if (entity.state == EntityState.playing) {
+        centeredControlsChildren.add(
+            IconButton(
+              icon: Icon(Icons.pause_circle_filled),
+              color: Colors.blue,
+              onPressed: () => _callAction(entity, "media_pause"),
+              iconSize: Sizes.iconSize*1.8,
+            )
+        );
+      } else if (entity.state == EntityState.paused || entity.state == EntityState.idle) {
+        centeredControlsChildren.add(
+            IconButton(
+              icon: Icon(Icons.play_circle_filled),
+              color: Colors.blue,
+              onPressed: () => _callAction(entity, "media_play"),
+              iconSize: Sizes.iconSize*1.8,
+            )
+        );
+      } else {
+        centeredControlsChildren.add(
+            Container(
+              width: Sizes.iconSize*1.8,
+              height: Sizes.iconSize*2.0,
+            )
+        );
+      }
+    }
+    if (entity.supportNextTrack && entity.state != EntityState.off && entity.state != EntityState.unavailable) {
+      centeredControlsChildren.add(
+          IconButton(
+            icon: Icon(Icons.skip_next),
+            onPressed: () => _callAction(entity, "media_next_track"),
+            iconSize: Sizes.iconSize,
+          )
+      );
+    }
+    if (centeredControlsChildren.isNotEmpty) {
+      result.add(
+          Expanded(
+              child: Row(
+                mainAxisAlignment: showMenu ? MainAxisAlignment.center : MainAxisAlignment.end,
+                children: centeredControlsChildren,
+              )
+          )
+      );
+    } else {
+      result.add(
+          Expanded(
+            child: Container(
+              height: 10.0,
+            ),
+          )
+      );
+    }
+    if (showMenu) {
+      result.add(
+          IconButton(
+              icon: Icon(MaterialDesignIcons.getIconDataFromIconName(
+                  "mdi:dots-vertical")),
+              onPressed: () => eventBus.fire(new ShowEntityPageEvent(entity))
+          )
+      );
+    } else if (entity.supportStop && entity.state != EntityState.off && entity.state != EntityState.unavailable) {
+      result.add(
+          IconButton(
+              icon: Icon(Icons.stop),
+              onPressed: () => _callAction(entity, "media_stop")
+          )
+      );
+    }
+    return Row(
+      children: result,
+      mainAxisAlignment: MainAxisAlignment.center,
+    );
+  }
+
+}
+
+class MediaPlayerControls extends StatefulWidget {
+  @override
+  _MediaPlayerControlsState createState() => _MediaPlayerControlsState();
+}
+
+class _MediaPlayerControlsState extends State<MediaPlayerControls> {
+
+  double _newVolumeLevel;
+  bool _changedHere = false;
+  String _newSoundMode;
+  String _newSource;
+
+  void _setVolume(double value, String entityId) {
+    setState(() {
+      _changedHere = true;
+      _newVolumeLevel = value;
+      eventBus.fire(ServiceCallEvent("media_player", "volume_set", entityId, {"volume_level": value}));
+    });
+  }
+
+  void _setVolumeMute(bool isMuted, String entityId) {
+    eventBus.fire(ServiceCallEvent("media_player", "volume_mute", entityId, {"is_volume_muted": isMuted}));
+  }
+
+  void _setVolumeUp(String entityId) {
+    eventBus.fire(ServiceCallEvent("media_player", "volume_up", entityId, null));
+  }
+
+  void _setVolumeDown(String entityId) {
+    eventBus.fire(ServiceCallEvent("media_player", "volume_down", entityId, null));
+  }
+
+  void _setSoundMode(String value, String entityId) {
+    setState(() {
+      _newSoundMode = value;
+      _changedHere = true;
+      eventBus.fire(ServiceCallEvent("media_player", "select_sound_mode", entityId, {"sound_mode": "$value"}));
+    });
+  }
+
+  void _setSource(String source, String entityId) {
+    setState(() {
+      _newSource = source;
+      _changedHere = true;
+      eventBus.fire(ServiceCallEvent("media_player", "select_source", entityId, {"source": "$source"}));
+    });
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    final MediaPlayerEntity entity = EntityModel.of(context).entityWrapper.entity;
+    List<Widget> children = [
+      MediaPlayerPlaybackControls(
+        showMenu: false,
+      )
+    ];
+    if (entity.state != EntityState.off && entity.state != EntityState.unknown && entity.state != EntityState.unavailable) {
+      Widget muteWidget;
+      Widget volumeStepWidget;
+      if (entity.supportVolumeMute  || entity.attributes["is_volume_muted"] != null) {
+        bool isMuted = entity.attributes["is_volume_muted"] ?? false;
+        muteWidget =
+            IconButton(
+                icon: Icon(isMuted ? Icons.volume_up : Icons.volume_off),
+                onPressed: () => _setVolumeMute(!isMuted, entity.entityId)
+            );
+      } else {
+        muteWidget = Container(width: 0.0, height: 0.0,);
+      }
+      if (entity.supportVolumeStep) {
+        volumeStepWidget = Row(
+          mainAxisSize: MainAxisSize.min,
+          children: <Widget>[
+            IconButton(
+                icon: Icon(MaterialDesignIcons.getIconDataFromIconName("mdi:plus")),
+                onPressed: () => _setVolumeUp(entity.entityId)
+            ),
+            IconButton(
+                icon: Icon(MaterialDesignIcons.getIconDataFromIconName("mdi:minus")),
+                onPressed: () => _setVolumeDown(entity.entityId)
+            )
+          ],
+        );
+      } else {
+        volumeStepWidget = Container(width: 0.0, height: 0.0,);
+      }
+      if (entity.supportVolumeSet) {
+        if (!_changedHere) {
+          _newVolumeLevel = entity._getDoubleAttributeValue("volume_level");
+        } else {
+          _changedHere = false;
+        }
+        children.add(
+            UniversalSlider(
+              leading: muteWidget,
+              closing: volumeStepWidget,
+              title: "Volume",
+              onChanged: (value) {
+                setState(() {
+                  _changedHere = true;
+                  _newVolumeLevel = value;
+                });
+              },
+              value: _newVolumeLevel,
+              onChangeEnd: (value) => _setVolume(value, entity.entityId),
+              max: 1.0,
+              min: 0.0,
+            )
+        );
+      } else {
+        children.add(Row(
+          mainAxisSize: MainAxisSize.min,
+          children: <Widget>[
+            muteWidget,
+            volumeStepWidget
+          ],
+        ));
+      }
+
+      if (entity.supportSelectSoundMode && entity.soundModeList != null) {
+        if (!_changedHere) {
+          _newSoundMode = entity.attributes["sound_mode"];
+        } else {
+          _changedHere = false;
+        }
+        children.add(
+          ModeSelectorWidget(
+              options: entity.soundModeList,
+              caption: "Sound mode",
+              value: _newSoundMode,
+              onChange: (value) => _setSoundMode(value, entity.entityId)
+          )
+        );
+      }
+
+      if (entity.supportSelectSource && entity.sourceList != null) {
+        if (!_changedHere) {
+          _newSource = entity.attributes["source"];
+        } else {
+          _changedHere = false;
+        }
+        children.add(
+            ModeSelectorWidget(
+                options: entity.sourceList,
+                caption: "Source",
+                value: _newSource,
+                onChange: (value) => _setSource(value, entity.entityId)
+            )
+        );
+      }
+
+    }
+    return Column(
+      children: children,
+    );
+  }
+
+}
+
+class MediaPlayerProgressWidget extends StatefulWidget {
+  @override
+  _MediaPlayerProgressWidgetState createState() => _MediaPlayerProgressWidgetState();
+}
+
+class _MediaPlayerProgressWidgetState extends State<MediaPlayerProgressWidget> {
+
+  Timer _timer;
+
+  @override
+  Widget build(BuildContext context) {
+    final EntityModel entityModel = EntityModel.of(context);
+    final MediaPlayerEntity entity = entityModel.entityWrapper.entity;
+    double progress;
+    try {
+      DateTime lastUpdated = DateTime.parse(
+          entity.attributes["media_position_updated_at"]).toLocal();
+      Duration duration = Duration(seconds: entity._getIntAttributeValue("media_duration") ?? 1);
+      Duration position = Duration(seconds: entity._getIntAttributeValue("media_position") ?? 0);
+      int currentPosition = position.inSeconds;
+      if (entity.state == EntityState.playing) {
+        _timer?.cancel();
+        _timer = Timer(Duration(seconds: 1), () {
+          setState(() {
+          });
+        });
+        int differenceInSeconds = DateTime
+            .now()
+            .difference(lastUpdated)
+            .inSeconds;
+        currentPosition = currentPosition + differenceInSeconds;
+      } else {
+        _timer?.cancel();
+      }
+      progress = currentPosition / duration.inSeconds;
+      return LinearProgressIndicator(
+        value: progress,
+        backgroundColor: Colors.black45,
+        valueColor: AlwaysStoppedAnimation<Color>(EntityColor.stateColor(EntityState.on)),
+      );
+    } catch (e) {
+      _timer?.cancel();
+      progress = 0.0;
+    }
+    return LinearProgressIndicator(
+      value: progress,
+      backgroundColor: Colors.black45,
+    );
+  }
+
+  @override
+  void dispose() {
+    _timer?.cancel();
+    super.dispose();
+  }
+
+}

lib/entities/select/select_entity.class.dart

@@ -1,11 +1,11 @@
-part of '../main.dart';
+part of '../../main.dart';
 
 class SelectEntity extends Entity {
   List<String> get listOptions => attributes["options"] != null
       ? (attributes["options"] as List).cast<String>()
       : [];
 
-  SelectEntity(Map rawData) : super(rawData);
+  SelectEntity(Map rawData, String webHost) : super(rawData, webHost);
 
   @override
   Widget _buildStatePart(BuildContext context) {

lib/entities/select/widgets/select_state.dart

@@ -1,4 +1,4 @@
-part of '../../main.dart';
+part of '../../../main.dart';
 
 class SelectStateWidget extends StatefulWidget {
 
@@ -18,11 +18,12 @@ class _SelectStateWidgetState extends State<SelectStateWidget> {
   @override
   Widget build(BuildContext context) {
     final entityModel = EntityModel.of(context);
-    final SelectEntity entity = entityModel.entity;
+    final SelectEntity entity = entityModel.entityWrapper.entity;
     Widget ctrl;
     if (entity.listOptions.isNotEmpty) {
       ctrl = DropdownButton<String>(
         value: entity.state,
+        isExpanded: true,
         items: entity.listOptions.map((String value) {
           return new DropdownMenuItem<String>(
             value: value,
@@ -36,7 +37,9 @@ class _SelectStateWidgetState extends State<SelectStateWidget> {
     } else {
       ctrl = Text('---');
     }
-    return Expanded(
+    return Flexible(
+      flex: 2,
+      fit: FlexFit.tight,
       //width: Entity.INPUT_WIDTH,
       child: ctrl,
     );

lib/entities/sensor/sensor_entity.class.dart

@@ -1,8 +1,4 @@
-part of '../main.dart';
+part of '../../main.dart';
-
-class SunEntity extends Entity {
-  SunEntity(Map rawData) : super(rawData);
-}
 
 class SensorEntity extends Entity {
 
@@ -12,6 +8,6 @@ class SensorEntity extends Entity {
       numericState: true
   );
 
-  SensorEntity(Map rawData) : super(rawData);
+  SensorEntity(Map rawData, String webHost) : super(rawData, webHost);
 
 }

lib/entities/slider/slider_entity.dart

@@ -1,13 +1,19 @@
-part of '../main.dart';
+part of '../../main.dart';
 
 class SliderEntity extends Entity {
-  SliderEntity(Map rawData) : super(rawData);
+  SliderEntity(Map rawData, String webHost) : super(rawData, webHost);
 
   double get minValue => _getDoubleAttributeValue("min") ?? 0.0;
   double get maxValue =>_getDoubleAttributeValue("max") ?? 100.0;
   double get valueStep => _getDoubleAttributeValue("step") ?? 1.0;
 
   @override
+  EntityHistoryConfig historyConfig = EntityHistoryConfig(
+      chartType: EntityHistoryWidgetType.numericState,
+      numericState: true
+  );
+
+  /*@override
   Widget _buildStatePart(BuildContext context) {
     return Expanded(
       //width: 200.0,
@@ -16,7 +22,9 @@ class SliderEntity extends Entity {
           SliderStateWidget(
             expanded: true,
           ),
-          SimpleEntityState(),
+          SimpleEntityState(
+            expanded: false,
+          ),
         ],
       ),
     );
@@ -24,13 +32,13 @@ class SliderEntity extends Entity {
 
   @override
   Widget _buildStatePartForPage(BuildContext context) {
-    return SimpleEntityState();
+    return SimpleEntityState(
-  }
+      expanded: false,
+    );
+  }*/
 
   @override
   Widget _buildAdditionalControlsForPage(BuildContext context) {
-    return SliderStateWidget(
+    return SliderControlsWidget();
-      expanded: false,
-    );
   }
 }

lib/entities/slider/widgets/slider_controls.dart

@@ -0,0 +1,70 @@
+part of '../../../main.dart';
+
+class SliderControlsWidget extends StatefulWidget {
+
+  SliderControlsWidget({Key key}) : super(key: key);
+
+  @override
+  _SliderControlsWidgetState createState() => _SliderControlsWidgetState();
+}
+
+class _SliderControlsWidgetState extends State<SliderControlsWidget> {
+  int _multiplier = 1;
+  double _newValue;
+  bool _changedHere = false;
+
+  void setNewState(newValue, domain, entityId) {
+    setState(() {
+      _newValue = newValue;
+      _changedHere = true;
+    });
+    eventBus.fire(new ServiceCallEvent(domain, "set_value", entityId,
+        {"value": "${newValue.toString()}"}));
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    final entityModel = EntityModel.of(context);
+    final SliderEntity entity = entityModel.entityWrapper.entity;
+    if (entity.valueStep < 1) {
+      _multiplier = 10;
+    } else if (entity.valueStep < 0.1) {
+      _multiplier = 100;
+    }
+    if (!_changedHere) {
+      _newValue = entity.doubleState;
+    } else {
+      _changedHere = false;
+    }
+    Widget slider = Slider(
+      min: entity.minValue * _multiplier,
+      max: entity.maxValue * _multiplier,
+      value: (_newValue <= entity.maxValue) &&
+          (_newValue >= entity.minValue)
+          ? _newValue * _multiplier
+          : entity.minValue * _multiplier,
+      onChanged: (value) {
+        setState(() {
+          _newValue = (value.roundToDouble() / _multiplier);
+          _changedHere = true;
+        });
+      },
+      onChangeEnd: (value) {
+        setNewState(value.roundToDouble() / _multiplier, entity.domain, entity.entityId);
+      },
+    );
+    return Column(
+      crossAxisAlignment: CrossAxisAlignment.center,
+      children: <Widget>[
+        Text(
+          "$_newValue",
+          style: TextStyle(
+            fontSize: Sizes.largeFontSize,
+            color: Colors.blue
+          ),
+        ),
+        slider
+      ],
+    );
+  }
+}

lib/entities/sun/sun_entity.class.dart

@@ -0,0 +1,5 @@
+part of '../../main.dart';
+
+class SunEntity extends Entity {
+  SunEntity(Map rawData, String webHost) : super(rawData, webHost);
+}

lib/entities/switch/switch_entity.class.dart

@@ -1,7 +1,7 @@
-part of '../main.dart';
+part of '../../main.dart';
 
 class SwitchEntity extends Entity {
-  SwitchEntity(Map rawData) : super(rawData);
+  SwitchEntity(Map rawData, String webHost) : super(rawData, webHost);
 
   @override
   Widget _buildStatePart(BuildContext context) {

lib/entities/switch/widget/switch_state.dart

@@ -0,0 +1,89 @@
+part of '../../../main.dart';
+
+class SwitchStateWidget extends StatefulWidget {
+
+  final String domainForService;
+
+  const SwitchStateWidget({Key key, this.domainForService}) : super(key: key);
+
+  @override
+  _SwitchStateWidgetState createState() => _SwitchStateWidgetState();
+}
+
+class _SwitchStateWidgetState extends State<SwitchStateWidget> {
+
+  String newState;
+  bool updatedHere = false;
+
+  @override
+  void initState() {
+    super.initState();
+  }
+
+  void _setNewState(newValue, Entity entity) {
+    setState(() {
+      newState = newValue ? EntityState.on : EntityState.off;
+      updatedHere = true;
+    });
+    Timer(Duration(seconds: 2), (){
+      setState(() {
+        newState = entity.state;
+        updatedHere = true;
+        //TheLogger.debug("Timer@!!");
+      });
+    });
+    String domain;
+    if (widget.domainForService != null) {
+      domain = widget.domainForService;
+    } else {
+      domain = entity.domain;
+    }
+    eventBus.fire(new ServiceCallEvent(
+        domain, (newValue as bool) ? "turn_on" : "turn_off", entity.entityId, null));
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    final entityModel = EntityModel.of(context);
+    final entity = entityModel.entityWrapper.entity;
+    if (!updatedHere) {
+      newState = entity.state;
+    } else {
+      updatedHere = false;
+    }
+    if (entity.state == EntityState.unavailable || entity.state == EntityState.unknown) {
+      return SimpleEntityState();
+    } else if ((entity.attributes["assumed_state"] == null) || (entity.attributes["assumed_state"] == false)) {
+      return SizedBox(
+        height: 32.0,
+        child: Switch(
+          value: newState == EntityState.on,
+          onChanged: ((switchState) {
+            _setNewState(switchState, entity);
+          }),
+        )
+      );
+    } else {
+      return SizedBox(
+        height: 32.0,
+        child: Row(
+          crossAxisAlignment: CrossAxisAlignment.start,
+          children: <Widget>[
+            IconButton(
+              onPressed: () => _setNewState(false, entity),
+              icon: Icon(MaterialDesignIcons.getIconDataFromIconName("mdi:flash-off")),
+              color: newState == EntityState.on ? Colors.black : Colors.blue,
+              iconSize: Sizes.iconSize,
+            ),
+            IconButton(
+                onPressed: () => _setNewState(true, entity),
+                icon: Icon(MaterialDesignIcons.getIconDataFromIconName("mdi:flash")),
+                color: newState == EntityState.on ? Colors.blue : Colors.black,
+                iconSize: Sizes.iconSize
+            )
+          ],
+        ),
+      );
+    }
+  }
+}

lib/entities/text/text_entity.class.dart

@@ -1,7 +1,7 @@
-part of '../main.dart';
+part of '../../main.dart';
 
 class TextEntity extends Entity {
-  TextEntity(Map rawData) : super(rawData);
+  TextEntity(Map rawData, String webHost) : super(rawData, webHost);
 
   int get valueMinLength => attributes["min"] ?? -1;
   int get valueMaxLength => attributes["max"] ?? -1;

lib/entities/text/widgets/text_input_state.dart

@@ -1,4 +1,4 @@
-part of '../../main.dart';
+part of '../../../main.dart';
 
 class TextInputStateWidget extends StatefulWidget {
 
@@ -55,7 +55,7 @@ class _TextInputStateWidgetState extends State<TextInputStateWidget> {
   @override
   Widget build(BuildContext context) {
     final entityModel = EntityModel.of(context);
-    final TextEntity entity = entityModel.entity;
+    final TextEntity entity = entityModel.entityWrapper.entity;
     _entityState = entity.state;
     _entityDomain = entity.domain;
     _entityId = entity.entityId;
@@ -66,24 +66,20 @@ class _TextInputStateWidgetState extends State<TextInputStateWidget> {
       _tmpValue = entity.state;
     }
     if (entity.isTextField || entity.isPasswordField) {
-      return Expanded(
+      return Flexible(
+        fit: FlexFit.tight,
+        flex: 2,
         //width: Entity.INPUT_WIDTH,
         child: TextField(
             focusNode: _focusNode,
             obscureText: entity.isPasswordField,
-            controller: new TextEditingController.fromValue(
+            controller: TextEditingController.fromValue(TextEditingValue(text: _tmpValue)),
-                new TextEditingValue(
-                    text: _tmpValue,
-                    selection:
-                    new TextSelection.collapsed(offset: _tmpValue.length)
-                )
-            ),
             onChanged: (value) {
               _tmpValue = value;
             }),
       );
     } else {
-      TheLogger.warning( "Unsupported input mode for ${entity.entityId}");
+      Logger.w( "Unsupported input mode for ${entity.entityId}");
       return SimpleEntityState();
     }
   }

lib/entities/timer/timer_entity.class.dart

@@ -0,0 +1,45 @@
+part of '../../main.dart';
+
+class TimerEntity extends Entity {
+  TimerEntity(Map rawData, String webHost) : super(rawData, webHost);
+
+  Duration duration;
+
+  @override
+  void update(Map rawData, String webHost) {
+    super.update(rawData, webHost);
+    String durationSource = "${attributes["duration"]}";
+    if (durationSource != null && durationSource.isNotEmpty) {
+      try {
+        List<String> durationList = durationSource.split(":");
+        if (durationList.length == 1) {
+          duration = Duration(seconds: int.tryParse(durationList[0] ?? 0));
+        } else if (durationList.length == 2) {
+          duration = Duration(
+              hours: int.tryParse(durationList[0]) ?? 0,
+              minutes: int.tryParse(durationList[1]) ?? 0
+          );
+        } else if (durationList.length == 3) {
+          duration = Duration(
+              hours: int.tryParse(durationList[0]) ?? 0,
+              minutes: int.tryParse(durationList[1]) ?? 0,
+              seconds: int.tryParse(durationList[2]) ?? 0
+          );
+        } else {
+          Logger.e("Strange $entityId duration format: $durationSource");
+          duration = Duration(seconds: 0);
+        }
+      } catch (e) {
+        Logger.e("Error parsing duration for $entityId: ${e.toString()}");
+        duration = Duration(seconds: 0);
+      }
+    } else {
+      duration = Duration(seconds: 0);
+    }
+  }
+
+  @override
+  Widget _buildStatePart(BuildContext context) {
+    return TimerState();
+  }
+}

lib/entities/timer/widgets/timer_state.dart

@@ -0,0 +1,65 @@
+part of '../../../main.dart';
+
+class TimerState extends StatefulWidget  {
+  //final bool expanded;
+  //final TextAlign textAlign;
+  //final EdgeInsetsGeometry padding;
+  //final int maxLines;
+
+  const TimerState({Key key}) : super(key: key);
+
+  @override
+  _TimerStateState createState() => _TimerStateState();
+
+}
+
+class _TimerStateState extends State<TimerState> {
+
+  Timer timer;
+  Duration remaining = Duration(seconds: 0);
+
+  void checkState(TimerEntity entity) {
+    if (entity.state == EntityState.active) {
+      //Logger.d("Timer is active");
+      if (timer == null || !timer.isActive) {
+        timer = Timer.periodic(Duration(seconds: 1), (timer) {
+          setState(() {
+            try {
+              int passed = DateTime
+                  .now()
+                  .difference(entity._lastUpdated)
+                  .inSeconds;
+              remaining = Duration(seconds: entity.duration.inSeconds - passed);
+            } catch (e) {
+              Logger.e("Error calculating ${entity.entityId} remaining time: ${e.toString()}");
+              remaining = Duration(seconds: 0);
+            }
+          });
+        });
+      }
+    } else {
+      timer?.cancel();
+    }
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    EntityModel model = EntityModel.of(context);
+    TimerEntity entity = model.entityWrapper.entity;
+    checkState(entity);
+    if (entity.state != EntityState.active) {
+      return SimpleEntityState();
+    } else {
+      return SimpleEntityState(
+        customValue: "${remaining.toString().split('.')[0]}",
+      );
+    }
+  }
+
+  @override
+  void dispose() {
+    timer?.cancel();
+    super.dispose();
+  }
+
+}

lib/entity_class/button_entity.class.dart

@@ -1,10 +0,0 @@
-part of '../main.dart';
-
-class ButtonEntity extends Entity {
-  ButtonEntity(Map rawData) : super(rawData);
-
-  @override
-  Widget _buildStatePart(BuildContext context) {
-    return ButtonStateWidget();
-  }
-}

lib/entity_class/climate_entity.class.dart

@@ -1,130 +0,0 @@
-part of '../main.dart';
-
-class ClimateEntity extends Entity {
-  @override
-  double widgetHeight = 38.0;
-
-  @override
-  EntityHistoryConfig historyConfig = EntityHistoryConfig(
-    chartType: EntityHistoryWidgetType.numericAttributes,
-    numericState: false,
-    numericAttributesToShow: ["current_temperature"]
-  );
-
-  static const SUPPORT_TARGET_TEMPERATURE = 1;
-  static const SUPPORT_TARGET_TEMPERATURE_HIGH = 2;
-  static const SUPPORT_TARGET_TEMPERATURE_LOW = 4;
-  static const SUPPORT_TARGET_HUMIDITY = 8;
-  static const SUPPORT_TARGET_HUMIDITY_HIGH = 16;
-  static const SUPPORT_TARGET_HUMIDITY_LOW = 32;
-  static const SUPPORT_FAN_MODE = 64;
-  static const SUPPORT_OPERATION_MODE = 128;
-  static const SUPPORT_HOLD_MODE = 256;
-  static const SUPPORT_SWING_MODE = 512;
-  static const SUPPORT_AWAY_MODE = 1024;
-  static const SUPPORT_AUX_HEAT = 2048;
-  static const SUPPORT_ON_OFF = 4096;
-
-  bool get supportTargetTemperature => ((attributes["supported_features"] &
-  ClimateEntity.SUPPORT_TARGET_TEMPERATURE) ==
-      ClimateEntity.SUPPORT_TARGET_TEMPERATURE);
-  bool get supportTargetTemperatureHigh => ((attributes["supported_features"] &
-  ClimateEntity.SUPPORT_TARGET_TEMPERATURE_HIGH) ==
-      ClimateEntity.SUPPORT_TARGET_TEMPERATURE_HIGH);
-  bool get supportTargetTemperatureLow => ((attributes["supported_features"] &
-  ClimateEntity.SUPPORT_TARGET_TEMPERATURE_LOW) ==
-      ClimateEntity.SUPPORT_TARGET_TEMPERATURE_LOW);
-  bool get supportTargetHumidity => ((attributes["supported_features"] &
-  ClimateEntity.SUPPORT_TARGET_HUMIDITY) ==
-      ClimateEntity.SUPPORT_TARGET_HUMIDITY);
-  bool get supportTargetHumidityHigh => ((attributes["supported_features"] &
-  ClimateEntity.SUPPORT_TARGET_HUMIDITY_HIGH) ==
-      ClimateEntity.SUPPORT_TARGET_HUMIDITY_HIGH);
-  bool get supportTargetHumidityLow => ((attributes["supported_features"] &
-  ClimateEntity.SUPPORT_TARGET_HUMIDITY_LOW) ==
-      ClimateEntity.SUPPORT_TARGET_HUMIDITY_LOW);
-  bool get supportFanMode =>
-      ((attributes["supported_features"] & ClimateEntity.SUPPORT_FAN_MODE) ==
-          ClimateEntity.SUPPORT_FAN_MODE);
-  bool get supportOperationMode => ((attributes["supported_features"] &
-  ClimateEntity.SUPPORT_OPERATION_MODE) ==
-      ClimateEntity.SUPPORT_OPERATION_MODE);
-  bool get supportHoldMode =>
-      ((attributes["supported_features"] & ClimateEntity.SUPPORT_HOLD_MODE) ==
-          ClimateEntity.SUPPORT_HOLD_MODE);
-  bool get supportSwingMode =>
-      ((attributes["supported_features"] & ClimateEntity.SUPPORT_SWING_MODE) ==
-          ClimateEntity.SUPPORT_SWING_MODE);
-  bool get supportAwayMode =>
-      ((attributes["supported_features"] & ClimateEntity.SUPPORT_AWAY_MODE) ==
-          ClimateEntity.SUPPORT_AWAY_MODE);
-  bool get supportAuxHeat =>
-      ((attributes["supported_features"] & ClimateEntity.SUPPORT_AUX_HEAT) ==
-          ClimateEntity.SUPPORT_AUX_HEAT);
-  bool get supportOnOff =>
-      ((attributes["supported_features"] & ClimateEntity.SUPPORT_ON_OFF) ==
-          ClimateEntity.SUPPORT_ON_OFF);
-
-  List<String> get operationList => attributes["operation_list"] != null
-      ? (attributes["operation_list"] as List).cast<String>()
-      : null;
-  List<String> get fanList => attributes["fan_list"] != null
-      ? (attributes["fan_list"] as List).cast<String>()
-      : null;
-  List<String> get swingList => attributes["swing_list"] != null
-      ? (attributes["swing_list"] as List).cast<String>()
-      : null;
-  double get temperature => _getDoubleAttributeValue('temperature');
-  double get targetHigh => _getDoubleAttributeValue('target_temp_high');
-  double get targetLow => _getDoubleAttributeValue('target_temp_low');
-  double get maxTemp => _getDoubleAttributeValue('max_temp') ?? 100.0;
-  double get minTemp => _getDoubleAttributeValue('min_temp') ?? -100.0;
-  double get targetHumidity => _getDoubleAttributeValue('humidity');
-  double get maxHumidity => _getDoubleAttributeValue('max_humidity');
-  double get minHumidity => _getDoubleAttributeValue('min_humidity');
-  String get operationMode => attributes['operation_mode'];
-  String get fanMode => attributes['fan_mode'];
-  String get swingMode => attributes['swing_mode'];
-  bool get awayMode => attributes['away_mode'] == "on";
-  bool get isOff => state == "off";
-  bool get auxHeat => attributes['aux_heat'] == "on";
-
-  ClimateEntity(Map rawData) : super(rawData);
-
-  @override
-  void update(Map rawData) {
-    super.update(rawData);
-    if (supportTargetTemperature) {
-      historyConfig.numericAttributesToShow.add("temperature");
-    }
-    if (supportTargetTemperatureHigh) {
-      historyConfig.numericAttributesToShow.add("target_temp_high");
-    }
-    if (supportTargetTemperatureLow) {
-      historyConfig.numericAttributesToShow.add("target_temp_low");
-    }
-  }
-
-  @override
-  Widget _buildStatePart(BuildContext context) {
-    return ClimateStateWidget();
-  }
-
-  @override
-  Widget _buildAdditionalControlsForPage(BuildContext context) {
-    return ClimateControlWidget();
-  }
-
-  @override
-  double _getDoubleAttributeValue(String attributeName) {
-    var temp1 = attributes["$attributeName"];
-    if (temp1 is int) {
-      return temp1.toDouble();
-    } else if (temp1 is double) {
-      return temp1;
-    } else {
-      return null;
-    }
-  }
-
-}

lib/entity_class/entity.class.dart

@@ -1,188 +0,0 @@
-part of '../main.dart';
-
-class Entity {
-
-  static const badgeColors = {
-    "default": Color.fromRGBO(223, 76, 30, 1.0),
-    "binary_sensor": Color.fromRGBO(3, 155, 229, 1.0)
-  };
-  static List badgeDomains = [
-    "alarm_control_panel",
-    "binary_sensor",
-    "device_tracker",
-    "updater",
-    "sun",
-    "timer",
-    "sensor"
-  ];
-
-  static const rightWidgetPadding = 14.0;
-  static const leftWidgetPadding = 8.0;
-  static const extendedWidgetHeight = 50.0;
-  static const iconSize = 28.0;
-  static const stateFontSize = 16.0;
-  static const nameFontSize = 16.0;
-  static const smallFontSize = 14.0;
-  static const largeFontSize = 24.0;
-  static const inputWidth = 160.0;
-  static const rowPadding = 10.0;
-
-  double widgetHeight = 34.0;
-
-  Map attributes;
-  String domain;
-  String entityId;
-  String state;
-  String assumedState;
-  DateTime _lastUpdated;
-
-  List<Entity> childEntities = [];
-  List<String> attributesToShow = ["all"];
-  EntityHistoryConfig historyConfig = EntityHistoryConfig(
-    chartType: EntityHistoryWidgetType.simple
-  );
-
-  String get displayName =>
-      attributes["friendly_name"] ?? (attributes["name"] ?? "_");
-
-  String get deviceClass => attributes["device_class"] ?? null;
-  bool get isView =>
-      (domain == "group") &&
-      (attributes != null ? attributes["view"] ?? false : false);
-  bool get isGroup => domain == "group";
-  bool get isBadge => Entity.badgeDomains.contains(domain);
-  String get icon => attributes["icon"] ?? "";
-  bool get isOn => state == "on";
-  String get entityPicture => attributes["entity_picture"];
-  String get unitOfMeasurement => attributes["unit_of_measurement"] ?? "";
-  List get childEntityIds => attributes["entity_id"] ?? [];
-  String get lastUpdated => _getLastUpdatedFormatted();
-  bool get isHidden => attributes["hidden"] ?? false;
-  double get doubleState => double.tryParse(state) ?? 0.0;
-
-  Entity(Map rawData) {
-    update(rawData);
-  }
-
-  void update(Map rawData) {
-    attributes = rawData["attributes"] ?? {};
-    domain = rawData["entity_id"].split(".")[0];
-    entityId = rawData["entity_id"];
-    state = rawData["state"];
-    assumedState = state;
-    _lastUpdated = DateTime.tryParse(rawData["last_updated"]);
-  }
-
-  double _getDoubleAttributeValue(String attributeName) {
-    var temp1 = attributes["$attributeName"];
-    if (temp1 is int) {
-      return temp1.toDouble();
-    } else if (temp1 is double) {
-      return temp1;
-    } else {
-      return double.tryParse("$temp1");
-    }
-  }
-
-  int _getIntAttributeValue(String attributeName) {
-    var temp1 = attributes["$attributeName"];
-    if (temp1 is int) {
-      return temp1;
-    } else if (temp1 is double) {
-      return temp1.round();
-    } else {
-      return int.tryParse("$temp1");
-    }
-  }
-
-  Widget buildDefaultWidget(BuildContext context) {
-    return EntityModel(
-      entity: this,
-      child: DefaultEntityContainer(
-          state: _buildStatePart(context),
-          height: widgetHeight,
-      ),
-      handleTap: true,
-    );
-  }
-
-  Widget _buildStatePart(BuildContext context) {
-    return SimpleEntityState();
-  }
-
-  Widget _buildStatePartForPage(BuildContext context) {
-    return _buildStatePart(context);
-  }
-
-  Widget _buildAdditionalControlsForPage(BuildContext context) {
-    return Container(
-      width: 0.0,
-      height: 0.0,
-    );
-  }
-
-  Widget buildEntityPageWidget(BuildContext context) {
-    return EntityModel(
-      entity: this,
-      child: EntityPageContainer(children: <Widget>[
-        DefaultEntityContainer(state: _buildStatePartForPage(context), height: widgetHeight),
-        LastUpdatedWidget(),
-        Divider(),
-        buildHistoryWidget(),
-        _buildAdditionalControlsForPage(context),
-        EntityAttributesList()
-      ]),
-      handleTap: false,
-    );
-  }
-
-  Widget buildHistoryWidget() {
-    return EntityHistoryWidget(
-      config: historyConfig,
-    );
-  }
-
-  Widget buildBadgeWidget(BuildContext context) {
-    return EntityModel(
-      entity: this,
-      child: BadgeWidget(),
-      handleTap: true,
-    );
-  }
-
-  String getAttribute(String attributeName) {
-    if (attributes != null) {
-      return attributes["$attributeName"];
-    }
-    return null;
-  }
-
-  String _getLastUpdatedFormatted() {
-    if (_lastUpdated == null) {
-      return "-";
-    } else {
-      DateTime now = DateTime.now();
-      Duration d = now.difference(_lastUpdated);
-      String text;
-      int v;
-      if (d.inDays == 0) {
-        if (d.inHours == 0) {
-          if (d.inMinutes == 0) {
-            text = "seconds ago";
-            v = d.inSeconds;
-          } else {
-            text = "minutes ago";
-            v = d.inMinutes;
-          }
-        } else {
-          text = "hours ago";
-          v = d.inHours;
-        }
-      } else {
-        text = "days ago";
-        v = d.inDays;
-      }
-      return "$v $text";
-    }
-  }
-}

lib/entity_collection.class.dart

@@ -2,13 +2,15 @@ part of 'main.dart';
 
 class EntityCollection {
 
+  final homeAssistantWebHost;
+
   Map<String, Entity> _allEntities;
   //Map<String, Entity> views;
 
   bool get isEmpty => _allEntities.isEmpty;
   List<Entity> get viewEntities => _allEntities.values.where((entity) => entity.isView).toList();
 
-  EntityCollection() {
+  EntityCollection(this.homeAssistantWebHost) {
     _allEntities = {};
     //views = {};
   }
@@ -19,7 +21,7 @@ class EntityCollection {
     _allEntities.clear();
     //views.clear();
 
-    TheLogger.debug("Parsing ${rawData.length} Home Assistant entities");
+    Logger.d("Parsing ${rawData.length} Home Assistant entities");
     rawData.forEach((rawEntityData) {
       addFromRaw(rawEntityData);
     });
@@ -33,55 +35,85 @@ class EntityCollection {
     });
   }
 
+  void clear() {
+    _allEntities.clear();
+  }
+
   Entity _createEntityInstance(rawEntityData) {
     switch (rawEntityData["entity_id"].split(".")[0]) {
       case 'sun': {
-        return SunEntity(rawEntityData);
+        return SunEntity(rawEntityData, homeAssistantWebHost);
+      }
+      case "media_player": {
+        return MediaPlayerEntity(rawEntityData, homeAssistantWebHost);
       }
       case 'sensor': {
-        return SensorEntity(rawEntityData);
+        return SensorEntity(rawEntityData, homeAssistantWebHost);
       }
-      case "automation":
+      case 'lock': {
+        return LockEntity(rawEntityData, homeAssistantWebHost);
+      }
+      case "automation": {
+        return AutomationEntity(rawEntityData, homeAssistantWebHost);
+      }
+
       case "input_boolean":
       case "switch": {
-        return SwitchEntity(rawEntityData);
+        return SwitchEntity(rawEntityData, homeAssistantWebHost);
       }
       case "light": {
-        return LightEntity(rawEntityData);
+        return LightEntity(rawEntityData, homeAssistantWebHost);
+      }
+      case "group": {
+        return GroupEntity(rawEntityData, homeAssistantWebHost);
       }
       case "script":
       case "scene": {
-        return ButtonEntity(rawEntityData);
+        return ButtonEntity(rawEntityData, homeAssistantWebHost);
       }
       case "input_datetime": {
-        return DateTimeEntity(rawEntityData);
+        return DateTimeEntity(rawEntityData, homeAssistantWebHost);
       }
       case "input_select": {
-        return SelectEntity(rawEntityData);
+        return SelectEntity(rawEntityData, homeAssistantWebHost);
       }
       case "input_number": {
-        return SliderEntity(rawEntityData);
+        return SliderEntity(rawEntityData, homeAssistantWebHost);
       }
       case "input_text": {
-        return TextEntity(rawEntityData);
+        return TextEntity(rawEntityData, homeAssistantWebHost);
       }
       case "climate": {
-        return ClimateEntity(rawEntityData);
+        return ClimateEntity(rawEntityData, homeAssistantWebHost);
       }
       case "cover": {
-        return CoverEntity(rawEntityData);
+        return CoverEntity(rawEntityData, homeAssistantWebHost);
+      }
+      case "fan": {
+        return FanEntity(rawEntityData, homeAssistantWebHost);
+      }
+      case "camera": {
+        return CameraEntity(rawEntityData, homeAssistantWebHost);
+      }
+      case "alarm_control_panel": {
+        return AlarmControlPanelEntity(rawEntityData, homeAssistantWebHost);
+      }
+      case "timer": {
+        return TimerEntity(rawEntityData, homeAssistantWebHost);
       }
       default: {
-        return Entity(rawEntityData);
+        return Entity(rawEntityData, homeAssistantWebHost);
       }
     }
   }
 
-  void updateState(Map rawStateData) {
+  bool updateState(Map rawStateData) {
     if (isExist(rawStateData["entity_id"])) {
       updateFromRaw(rawStateData["new_state"] ?? rawStateData["old_state"]);
+      return false;
     } else {
       addFromRaw(rawStateData["new_state"] ?? rawStateData["old_state"]);
+      return true;
     }
   }
 
@@ -89,14 +121,13 @@ class EntityCollection {
     _allEntities[entity.entityId] = entity;
   }
 
-  Entity addFromRaw(Map rawEntityData) {
+  void addFromRaw(Map rawEntityData) {
     Entity entity = _createEntityInstance(rawEntityData);
     _allEntities[entity.entityId] = entity;
-    return entity;
   }
 
   void updateFromRaw(Map rawEntityData) {
-    get("${rawEntityData["entity_id"]}")?.update(rawEntityData);
+    get("${rawEntityData["entity_id"]}")?.update(rawEntityData, homeAssistantWebHost);
   }
 
   Entity get(String entityId) {
@@ -123,7 +154,7 @@ class EntityCollection {
     List<Entity> groups = [];
     List<Entity> nonGroupEntities = [];
     _allEntities.forEach((id, entity){
-      if ((id.indexOf("group.") == 0) && (id.indexOf(".all_") == -1) && (!entity.isView)) {
+      if (entity.isGroup && (entity.attributes['auto'] == null || (entity.attributes['auto'] && !entity.isHidden)) && (!entity.isView)) {
         groups.add(entity);
       }
       if (!entity.isGroup) {

lib/entity_widgets/button_entity_container.dart

@@ -0,0 +1,50 @@
+part of '../main.dart';
+
+class ButtonEntityContainer extends StatelessWidget {
+
+  ButtonEntityContainer({
+    Key key,
+  }) : super(key: key);
+
+  @override
+  Widget build(BuildContext context) {
+    final EntityWrapper entityWrapper = EntityModel.of(context).entityWrapper;
+    if (entityWrapper.entity.statelessType == StatelessEntityType.MISSED) {
+      return MissedEntityWidget();
+    }
+    if (entityWrapper.entity.statelessType > StatelessEntityType.MISSED) {
+      return Container(width: 0.0, height: 0.0,);
+    }
+    return InkWell(
+      onTap: () => entityWrapper.handleTap(),
+      onLongPress: () => entityWrapper.handleHold(),
+      child: Column(
+        mainAxisSize: MainAxisSize.min,
+        children: <Widget>[
+          FractionallySizedBox(
+            widthFactor: 0.4,
+            child: FittedBox(
+                fit: BoxFit.fitHeight,
+                child: EntityIcon(
+                  padding: EdgeInsets.fromLTRB(2.0, 6.0, 2.0, 2.0),
+                  size: Sizes.iconSize,
+                )
+            ),
+          ),
+          _buildName()
+        ],
+      ),
+    );
+  }
+
+  Widget _buildName() {
+    return EntityName(
+      padding: EdgeInsets.fromLTRB(Sizes.buttonPadding, 0.0, Sizes.buttonPadding, Sizes.rowPadding),
+      textOverflow: TextOverflow.ellipsis,
+      maxLines: 3,
+      wordsWrap: true,
+      textAlign: TextAlign.center,
+      fontSize: Sizes.nameFontSize,
+    );
+  }
+}

lib/entity_widgets/common/badge.dart

@@ -1,4 +1,4 @@
-part of '../main.dart';
+part of '../../main.dart';
 
 class BadgeWidget extends StatelessWidget {
   @override
@@ -7,47 +7,67 @@ class BadgeWidget extends StatelessWidget {
     double iconSize = 26.0;
     Widget badgeIcon;
     String onBadgeTextValue;
-    Color iconColor = Entity.badgeColors[entityModel.entity.domain] ??
+    Color iconColor = EntityColor.badgeColors[entityModel.entityWrapper.entity.domain] ??
-        Entity.badgeColors["default"];
+        EntityColor.badgeColors["default"];
-    switch (entityModel.entity.domain) {
+    switch (entityModel.entityWrapper.entity.domain) {
       case "sun":
         {
-          badgeIcon = entityModel.entity.state == "below_horizon"
+          badgeIcon = entityModel.entityWrapper.entity.state == "below_horizon"
               ? Icon(
-            MaterialDesignIcons.createIconDataFromIconCode(0xf0dc),
+            MaterialDesignIcons.getIconDataFromIconCode(0xf0dc),
             size: iconSize,
           )
               : Icon(
-            MaterialDesignIcons.createIconDataFromIconCode(0xf5a8),
+            MaterialDesignIcons.getIconDataFromIconCode(0xf5a8),
             size: iconSize,
           );
           break;
         }
-      case "sensor":
+      case "camera":
+      case "media_player":
+      case "binary_sensor":
         {
-          onBadgeTextValue = entityModel.entity.unitOfMeasurement;
+          badgeIcon = EntityIcon(
-          badgeIcon = Center(
+            padding: EdgeInsets.all(0.0),
-            child: Text(
+            size: iconSize,
-              "${entityModel.entity.state}",
+            color: Colors.black
-              overflow: TextOverflow.fade,
-              softWrap: false,
-              textAlign: TextAlign.center,
-              style: TextStyle(fontSize: 17.0),
-            ),
           );
           break;
         }
       case "device_tracker":
+      case "person":
         {
-          badgeIcon = MaterialDesignIcons.createIconWidgetFromEntityData(
+          badgeIcon = EntityIcon(
-              entityModel.entity, iconSize, Colors.black);
+              padding: EdgeInsets.all(0.0),
-          onBadgeTextValue = entityModel.entity.state;
+              size: iconSize,
+              color: Colors.black
+          );
+          onBadgeTextValue = entityModel.entityWrapper.entity.displayState;
           break;
         }
       default:
         {
-          badgeIcon = MaterialDesignIcons.createIconWidgetFromEntityData(
+          double stateFontSize;
-              entityModel.entity, iconSize, Colors.black);
+          if (entityModel.entityWrapper.entity.displayState.length <= 3) {
+            stateFontSize = 18.0;
+          } else if (entityModel.entityWrapper.entity.displayState.length <= 4) {
+            stateFontSize = 15.0;
+          } else if (entityModel.entityWrapper.entity.displayState.length <= 6) {
+            stateFontSize = 10.0;
+          } else if (entityModel.entityWrapper.entity.displayState.length <= 10) {
+            stateFontSize = 8.0;
+          }
+          onBadgeTextValue = entityModel.entityWrapper.entity.unitOfMeasurement;
+          badgeIcon = Center(
+            child: Text(
+              "${entityModel.entityWrapper.entity.displayState}",
+              overflow: TextOverflow.fade,
+              softWrap: false,
+              textAlign: TextAlign.center,
+              style: TextStyle(fontSize: stateFontSize),
+            ),
+          );
+          break;
         }
     }
     Widget onBadgeText;
@@ -109,7 +129,7 @@ class BadgeWidget extends StatelessWidget {
             Container(
               width: 60.0,
               child: Text(
-                "${entityModel.entity.displayName}",
+                "${entityModel.entityWrapper.displayName}",
                 textAlign: TextAlign.center,
                 style: TextStyle(fontSize: 12.0),
                 softWrap: true,
@@ -120,6 +140,6 @@ class BadgeWidget extends StatelessWidget {
           ],
         ),
         onTap: () =>
-            eventBus.fire(new ShowEntityPageEvent(entityModel.entity)));
+            eventBus.fire(new ShowEntityPageEvent(entityModel.entityWrapper.entity)));
   }
 }

lib/entity_widgets/common/camera_stream_view.dart

@@ -0,0 +1,70 @@
+part of '../../main.dart';
+
+class CameraStreamView extends StatefulWidget {
+
+  CameraStreamView({Key key}) : super(key: key);
+
+  @override
+  _CameraStreamViewState createState() => _CameraStreamViewState();
+}
+
+class _CameraStreamViewState extends State<CameraStreamView> {
+
+  @override
+  void initState() {
+    super.initState();
+  }
+
+  CameraEntity _entity;
+  bool started = false;
+  String streamUrl = "";
+
+  launchStream() {
+    Navigator.push(
+        context,
+        MaterialPageRoute(
+          builder: (context) => WebviewScaffold(
+            url: "$streamUrl",
+            withZoom: true,
+            appBar: new AppBar(
+              leading: IconButton(
+                  icon: Icon(Icons.close),
+                  onPressed: () => Navigator.pop(context)
+              ),
+              title: new Text("${_entity.displayName}"),
+            ),
+          ),
+        )
+    );
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    if (!started) {
+      _entity = EntityModel
+          .of(context)
+          .entityWrapper
+          .entity;
+      started = true;
+    }
+    streamUrl = '${ConnectionManager().httpWebHost}/api/camera_proxy_stream/${_entity
+        .entityId}?token=${_entity.attributes['access_token']}';
+    return Column(
+      children: <Widget>[
+        Container(
+            padding: const EdgeInsets.all(20.0),
+            child: IconButton(
+              icon: Icon(MaterialDesignIcons.getIconDataFromIconName("mdi:monitor-screenshot"), color: Colors.amber),
+              iconSize: 50.0,
+              onPressed: () => launchStream(),
+            )
+        )
+      ],
+    );
+  }
+
+  @override
+  void dispose() {
+    super.dispose();
+  }
+}

lib/entity_widgets/common/entity_attributes_list.dart

@@ -0,0 +1,49 @@
+part of '../../main.dart';
+
+class EntityAttributesList extends StatelessWidget {
+  EntityAttributesList({Key key}) : super(key: key);
+
+  @override
+  Widget build(BuildContext context) {
+    final entityModel = EntityModel.of(context);
+    List<Widget> attrs = [];
+    entityModel.entityWrapper.entity.attributes.forEach((name, value) {
+      attrs.add(_buildSingleAttribute("$name", "${value ?? '-'}"));
+    });
+    return Padding(
+      padding: EdgeInsets.only(bottom: Sizes.rowPadding),
+      child: Column(
+        children: attrs,
+        crossAxisAlignment: CrossAxisAlignment.start,
+        mainAxisSize: MainAxisSize.min,
+      )
+    );
+  }
+
+  Widget _buildSingleAttribute(String name, String value) {
+    return Row(
+      children: <Widget>[
+        Expanded(
+          child: Padding(
+            padding: EdgeInsets.fromLTRB(
+                Sizes.leftWidgetPadding, Sizes.rowPadding, 0.0, 0.0),
+            child: Text(
+              "$name",
+              textAlign: TextAlign.left,
+            ),
+          ),
+        ),
+        Expanded(
+          child: Padding(
+            padding: EdgeInsets.fromLTRB(
+                0.0, Sizes.rowPadding, Sizes.rightWidgetPadding, 0.0),
+            child: Text(
+              "${value}",
+              textAlign: TextAlign.right,
+            ),
+          ),
+        )
+      ],
+    );
+  }
+}

lib/entity_widgets/common/flat_service_button.dart

@@ -0,0 +1,41 @@
+part of '../../main.dart';
+
+class FlatServiceButton extends StatelessWidget {
+
+  final String serviceDomain;
+  final String serviceName;
+  final String entityId;
+  final String text;
+  final double fontSize;
+
+  FlatServiceButton({
+    Key key,
+    @required this.serviceDomain,
+    @required this.serviceName,
+    @required this.entityId,
+    @required this.text,
+    this.fontSize: Sizes.stateFontSize
+  }) : super(key: key);
+
+  void _setNewState() {
+    eventBus.fire(new ServiceCallEvent(serviceDomain, serviceName, entityId, null));
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return SizedBox(
+        height: fontSize*2.5,
+        child: FlatButton(
+          onPressed: (() {
+            _setNewState();
+          }),
+          child: Text(
+            text,
+            textAlign: TextAlign.right,
+            style:
+            new TextStyle(fontSize: fontSize, color: Colors.blue),
+          ),
+        )
+    );
+  }
+}

lib/entity_widgets/common/last_updated.dart

@@ -1,4 +1,4 @@
-part of '../main.dart';
+part of '../../main.dart';
 
 class LastUpdatedWidget extends StatelessWidget {
   @override
@@ -6,12 +6,12 @@ class LastUpdatedWidget extends StatelessWidget {
     final entityModel = EntityModel.of(context);
     return Padding(
       padding: EdgeInsets.fromLTRB(
-          Entity.leftWidgetPadding, 0.0, 0.0, 0.0),
+          Sizes.leftWidgetPadding, Sizes.rowPadding, 0.0, 0.0),
       child: Text(
-        '${entityModel.entity.lastUpdated}',
+        '${entityModel.entityWrapper.entity.lastUpdated}',
         textAlign: TextAlign.left,
         style: TextStyle(
-            fontSize: Entity.smallFontSize, color: Colors.black26),
+            fontSize: Sizes.smallFontSize, color: Colors.black26),
       ),
     );
   }

lib/entity_widgets/common/light_color_picker.dart

@@ -0,0 +1,101 @@
+part of '../../main.dart';
+
+class LightColorPicker extends StatefulWidget {
+
+  final HSVColor color;
+  final onColorSelected;
+  final double hueStep;
+  final double saturationStep;
+  final EdgeInsets padding;
+
+  LightColorPicker({this.color, this.onColorSelected, this.hueStep: 15.0, this.saturationStep: 0.2, this.padding: const EdgeInsets.fromLTRB(Sizes.leftWidgetPadding, Sizes.rowPadding, Sizes.rightWidgetPadding, 0.0)});
+
+  @override
+  LightColorPickerState createState() => new LightColorPickerState();
+}
+
+class LightColorPickerState extends State<LightColorPicker> {
+
+  @override
+  void initState() {
+    super.initState();
+
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    List<Widget> colorRows = [];
+    Border border;
+    bool isSomethingSelected = false;
+    Logger.d("Current colotfor picker: [${widget.color.hue}, ${widget.color.saturation}]");
+    for (double saturation = 1.0; saturation >= (0.0 + widget.saturationStep); saturation = double.parse((saturation - widget.saturationStep).toStringAsFixed(2))) {
+      List<Widget> rowChildren = [];
+      //Logger.d("$saturation");
+      double roundedSaturation = double.parse(widget.color.saturation.toStringAsFixed(1));
+      //Logger.d("Rounded saturation=$roundedSaturation");
+      for (double hue = 0; hue <= (365 - widget.hueStep);
+      hue += widget.hueStep) {
+        bool isExactHue = widget.color.hue.round() == hue;
+        bool isHueInRange = widget.color.hue.round() > hue && widget.color.hue.round() < (hue+widget.hueStep);
+        bool isExactSaturation = roundedSaturation == saturation;
+        bool isSaturationInRange = roundedSaturation > saturation && roundedSaturation < double.parse((saturation+widget.saturationStep).toStringAsFixed(1));
+        if ((isExactHue || isHueInRange) && (isExactSaturation || isSaturationInRange)) {
+          //Logger.d("$isExactHue $isHueInRange $isExactSaturation $isSaturationInRange (${saturation+widget.saturationStep})");
+          border = Border.all(
+            width: 2.0,
+            color: Colors.white,
+          );
+          isSomethingSelected = true;
+        } else {
+          border = null;
+        }
+        HSVColor currentColor = HSVColor.fromAHSV(1.0, hue, double.parse(saturation.toStringAsFixed(2)), 1.0);
+        rowChildren.add(
+            Flexible(
+                child: GestureDetector(
+                  child: Container(
+                    height: 40.0,
+                    decoration: BoxDecoration(
+                        color: currentColor.toColor(),
+                        border: border,
+                    ),
+                  ),
+                  onTap: () => widget.onColorSelected(currentColor),
+                )
+            )
+        );
+      }
+      colorRows.add(
+          Row(
+            children: rowChildren,
+          )
+      );
+    }
+    colorRows.add(
+        Flexible(
+            child: GestureDetector(
+              child: Container(
+                height: 40.0,
+                decoration: BoxDecoration(
+                  color: Colors.white,
+                  border: isSomethingSelected ? null : Border.all(
+                    width: 2.0,
+                    color: Colors.amber[200],
+                  )
+                ),
+              ),
+              onTap: () => widget.onColorSelected(HSVColor.fromAHSV(1.0, 30.0, 0.0, 1.0)),
+            )
+        )
+    );
+    return Padding(
+      child: Column(
+        mainAxisSize: MainAxisSize.min,
+        crossAxisAlignment: CrossAxisAlignment.center,
+        children: colorRows,
+      ),
+      padding: widget.padding,
+    );
+
+  }
+}

lib/entity_widgets/common/mode_selector.dart

@@ -0,0 +1,64 @@
+part of '../../main.dart';
+
+class ModeSelectorWidget extends StatelessWidget {
+
+  final String caption;
+  final List<String> options;
+  final String value;
+  final double captionFontSize;
+  final double valueFontSize;
+  final onChange;
+  final EdgeInsets padding;
+
+  ModeSelectorWidget({
+    Key key,
+    @required this.caption,
+    @required this.options,
+    this.value,
+    @required this.onChange,
+    this.captionFontSize,
+    this.valueFontSize,
+    this.padding: const EdgeInsets.fromLTRB(Sizes.leftWidgetPadding, Sizes.rowPadding, Sizes.rightWidgetPadding, 0.0),
+  }) : super(key: key);
+
+  @override
+  Widget build(BuildContext context) {
+    return Padding(
+      padding: padding,
+      child: Column(
+        crossAxisAlignment: CrossAxisAlignment.start,
+        children: <Widget>[
+          Text("$caption", style: TextStyle(
+              fontSize: captionFontSize ?? Sizes.stateFontSize
+          )),
+          Row(
+            children: <Widget>[
+              Expanded(
+                child: ButtonTheme(
+                  alignedDropdown: true,
+                  child: DropdownButton<String>(
+                    value: value,
+                    iconSize: 30.0,
+                    isExpanded: true,
+                    style: TextStyle(
+                      fontSize: valueFontSize ?? Sizes.largeFontSize,
+                      color: Colors.black,
+                    ),
+                    hint: Text("Select ${caption.toLowerCase()}"),
+                    items: options.map((String value) {
+                      return new DropdownMenuItem<String>(
+                        value: value,
+                        child: Text(value),
+                      );
+                    }).toList(),
+                    onChanged: (mode) => onChange(mode),
+                  ),
+                ),
+              )
+            ],
+          )
+        ],
+      ),
+    );
+  }
+}

lib/entity_widgets/common/mode_swicth.dart

@@ -0,0 +1,53 @@
+part of '../../main.dart';
+
+class ModeSwitchWidget extends StatelessWidget {
+
+  final String caption;
+  final onChange;
+  final double captionFontSize;
+  final bool value;
+  final bool expanded;
+  final EdgeInsets padding;
+
+  ModeSwitchWidget({
+    Key key,
+    @required this.caption,
+    @required this.onChange,
+    this.captionFontSize,
+    this.value,
+    this.expanded: true,
+    this.padding: const EdgeInsets.only(left: Sizes.leftWidgetPadding, right: Sizes.rightWidgetPadding)
+  }) : super(key: key);
+
+  @override
+  Widget build(BuildContext context) {
+    return Padding(
+      padding: this.padding,
+      child: Row(
+        children: <Widget>[
+          _buildCaption(),
+          Switch(
+            onChanged: (value) => onChange(value),
+            value: value ?? false,
+          )
+        ],
+      )
+    );
+  }
+
+  Widget _buildCaption() {
+    Widget captionWidget = Text(
+      "$caption",
+      style: TextStyle(
+          fontSize: captionFontSize ?? Sizes.stateFontSize
+      ),
+    );
+    if (expanded) {
+      return Expanded(
+        child: captionWidget,
+      );
+    }
+    return captionWidget;
+  }
+
+}

lib/entity_widgets/common/simple_state.dart

@@ -0,0 +1,53 @@
+part of '../../main.dart';
+
+class SimpleEntityState extends StatelessWidget {
+
+  final bool expanded;
+  final TextAlign textAlign;
+  final EdgeInsetsGeometry padding;
+  final int maxLines;
+  final String customValue;
+
+  const SimpleEntityState({Key key, this.maxLines: 10, this.expanded: true, this.textAlign: TextAlign.right, this.padding: const EdgeInsets.fromLTRB(0.0, 0.0, Sizes.rightWidgetPadding, 0.0), this.customValue}) : super(key: key);
+
+  @override
+  Widget build(BuildContext context) {
+    final entityModel = EntityModel.of(context);
+    String state;
+    if (customValue == null) {
+      state = entityModel.entityWrapper.entity.displayState ?? "";
+      state = state.replaceAll("\n", "").replaceAll("\t", " ").trim();
+    } else {
+      state = customValue;
+    }
+    TextStyle textStyle =  TextStyle(
+      fontSize: Sizes.stateFontSize,
+    );
+    if (entityModel.entityWrapper.entity.statelessType == StatelessEntityType.CALL_SERVICE) {
+      textStyle = textStyle.apply(color: Colors.blue);
+    }
+    while (state.contains("  ")){
+      state = state.replaceAll("  ", " ");
+    }
+    Widget result = Padding(
+      padding: padding,
+      child: Text(
+        "$state ${entityModel.entityWrapper.entity.unitOfMeasurement}",
+        textAlign: textAlign,
+        maxLines: maxLines,
+        overflow: TextOverflow.ellipsis,
+        softWrap: true,
+        style: textStyle
+      )
+    );
+    if (expanded) {
+      return Flexible(
+        fit: FlexFit.tight,
+        flex: 2,
+        child: result,
+      );
+    } else {
+      return result;
+    }
+  }
+}

lib/entity_widgets/common/universal_slider.dart

@@ -0,0 +1,58 @@
+part of '../../main.dart';
+
+class UniversalSlider extends StatelessWidget {
+
+  final onChanged;
+  final onChangeEnd;
+  final Widget leading;
+  final Widget closing;
+  final String title;
+  final double min;
+  final double max;
+  final double value;
+  final EdgeInsets padding;
+
+  const UniversalSlider({Key key, this.onChanged, this.onChangeEnd, this.leading, this.closing, this.title, this.min, this.max, this.value, this.padding: const EdgeInsets.fromLTRB(Sizes.leftWidgetPadding, Sizes.rowPadding, Sizes.rightWidgetPadding, 0.0)}) : super(key: key);
+
+  @override
+  Widget build(BuildContext context) {
+    List <Widget> row = [];
+    if (leading != null) {
+      row.add(leading);
+    }
+    row.add(
+        Flexible(
+          child: Slider(
+            value: value,
+            min: min,
+            max: max,
+            onChanged: (value) => onChanged(value),
+            onChangeEnd: (value) => onChangeEnd(value),
+          ),
+        )
+    );
+    if (closing != null) {
+      row.add(closing);
+    }
+    return Padding(
+      padding: padding,
+      child: Column(
+        crossAxisAlignment: CrossAxisAlignment.start,
+        children: <Widget>[
+          Container(height: Sizes.rowPadding,),
+          Text(
+            "$title",
+            style: TextStyle(fontSize: Sizes.stateFontSize),
+          ),
+          Container(height: Sizes.rowPadding,),
+          Row(
+            mainAxisSize: MainAxisSize.min,
+            children: row,
+          ),
+          Container(height: Sizes.rowPadding,)
+        ],
+      ),
+    );
+  }
+
+}

lib/entity_widgets/controls/light_controls.dart

@@ -1,240 +0,0 @@
-part of '../../main.dart';
-
-class LightControlsWidget extends StatefulWidget {
-
-  @override
-  _LightControlsWidgetState createState() => _LightControlsWidgetState();
-
-}
-
-class _LightControlsWidgetState extends State<LightControlsWidget> {
-
-  int _tmpBrightness;
-  int _tmpColorTemp;
-  Color _tmpColor;
-  bool _changedHere = false;
-  String _tmpEffect;
-
-  void _resetState(LightEntity entity) {
-    _tmpBrightness = entity.brightness ?? 0;
-    _tmpColorTemp = entity.colorTemp;
-    _tmpColor = entity.color;
-    _tmpEffect = null;
-  }
-
-  void _setBrightness(LightEntity entity, double value) {
-    setState(() {
-      _tmpBrightness = value.round();
-      _changedHere = true;
-      if (_tmpBrightness > 0) {
-        eventBus.fire(new ServiceCallEvent(
-            entity.domain, "turn_on", entity.entityId,
-            {"brightness": _tmpBrightness}));
-      } else {
-        eventBus.fire(new ServiceCallEvent(
-            entity.domain, "turn_off", entity.entityId,
-            null));
-      }
-    });
-  }
-
-  void _setColorTemp(LightEntity entity, double value) {
-    setState(() {
-      _tmpColorTemp = value.round();
-      _changedHere = true;
-      eventBus.fire(new ServiceCallEvent(
-          entity.domain, "turn_on", entity.entityId,
-          {"color_temp": _tmpColorTemp}));
-    });
-  }
-
-  void _setColor(LightEntity entity, Color color) {
-    setState(() {
-      _tmpColor = color;
-      _changedHere = true;
-      TheLogger.debug( "Color: [${color.red}, ${color.green}, ${color.blue}]");
-      if ((color == Colors.black) || ((color.red == color.green) && (color.green == color.blue)))  {
-        eventBus.fire(new ServiceCallEvent(
-            entity.domain, "turn_off", entity.entityId,
-            null));
-      } else {
-        eventBus.fire(new ServiceCallEvent(
-            entity.domain, "turn_on", entity.entityId,
-            {"rgb_color": [color.red, color.green, color.blue]}));
-      }
-    });
-  }
-
-  void _setEffect(LightEntity entity, String value) {
-    setState(() {
-      _tmpEffect = value;
-      _changedHere = true;
-      if (_tmpEffect != null) {
-        eventBus.fire(new ServiceCallEvent(
-            entity.domain, "turn_on", entity.entityId,
-            {"effect": "$value"}));
-      }
-    });
-  }
-
-  @override
-  Widget build(BuildContext context) {
-    final entityModel = EntityModel.of(context);
-    final LightEntity entity = entityModel.entity;
-    if (!_changedHere) {
-      _resetState(entity);
-    } else {
-      _changedHere = false;
-    }
-    return Column(
-      crossAxisAlignment: CrossAxisAlignment.center,
-      children: <Widget>[
-        _buildBrightnessControl(entity),
-        _buildColorTempControl(entity),
-        _buildColorControl(entity),
-        _buildEffectControl(entity)
-      ],
-    );
-  }
-
-  Widget _buildBrightnessControl(LightEntity entity) {
-    if ((entity.supportBrightness) && (_tmpBrightness != null)) {
-      return Column(
-        crossAxisAlignment: CrossAxisAlignment.start,
-        children: <Widget>[
-          Container(height: Entity.rowPadding,),
-          Text(
-            "Brightness",
-            style: TextStyle(fontSize: Entity.stateFontSize),
-          ),
-          Container(height: Entity.rowPadding,),
-          Row(
-            children: <Widget>[
-              Icon(Icons.brightness_5),
-              Expanded(
-                child: Slider(
-                  value: _tmpBrightness.toDouble(),
-                  min: 0.0,
-                  max: 255.0,
-                  onChanged: (value) {
-                    setState(() {
-                      _changedHere = true;
-                      _tmpBrightness = value.round();
-                    });
-                  },
-                  onChangeEnd: (value) => _setBrightness(entity, value),
-                ),
-              )
-            ],
-          ),
-          Container(height: Entity.rowPadding,)
-        ],
-      );
-    } else {
-      return Container(width: 0.0, height: 0.0);
-    }
-  }
-
-  Widget _buildColorTempControl(LightEntity entity) {
-    if ((entity.supportColorTemp) && (_tmpColorTemp != null)) {
-      return Column(
-        crossAxisAlignment: CrossAxisAlignment.start,
-        children: <Widget>[
-          Container(height: Entity.rowPadding,),
-          Text(
-            "Color temperature",
-            style: TextStyle(fontSize: Entity.stateFontSize),
-          ),
-          Container(height: Entity.rowPadding,),
-          Row(
-            children: <Widget>[
-              Text("Cold", style: TextStyle(color: Colors.lightBlue),),
-              Expanded(
-                child: Slider(
-                  value: _tmpColorTemp.toDouble(),
-                  min: entity.minMireds,
-                  max: entity.maxMireds,
-                  onChanged: (value) {
-                    setState(() {
-                      _changedHere = true;
-                      _tmpColorTemp = value.round();
-                    });
-                  },
-                  onChangeEnd: (value) => _setColorTemp(entity, value),
-                ),
-              ),
-              Text("Warm", style: TextStyle(color: Colors.amberAccent),),
-            ],
-          ),
-          Container(height: Entity.rowPadding,)
-        ],
-      );
-    } else {
-      return Container(width: 0.0, height: 0.0);
-    }
-  }
-
-  Widget _buildColorControl(LightEntity entity) {
-    if ((entity.supportColor) && (entity.color != null)) {
-      return Column(
-        crossAxisAlignment: CrossAxisAlignment.center,
-        children: <Widget>[
-          Container(height: Entity.rowPadding,),
-          RaisedButton(
-            onPressed: () => _showColorPicker(entity),
-            color: _tmpColor ?? Colors.black45,
-            child: Text(
-              "COLOR",
-              textAlign: TextAlign.center,
-              style: TextStyle(
-                fontSize: 50.0,
-                fontWeight: FontWeight.bold,
-                color: Colors.black12,
-              ),
-            ),
-          ),
-          Container(height: 2*Entity.rowPadding,),
-        ],
-      );
-    } else {
-      return Container(width: 0.0, height: 0.0);
-    }
-  }
-
-  void _showColorPicker(LightEntity entity) {
-    showDialog(
-      context: context,
-      builder: (BuildContext context) {
-        return AlertDialog(
-          titlePadding: EdgeInsets.all(0.0),
-          contentPadding: EdgeInsets.all(0.0),
-          content: SingleChildScrollView(
-            child: MaterialPicker(
-              pickerColor: _tmpColor,
-              onColorChanged: (color) {
-                _setColor(entity, color);
-                Navigator.of(context).pop();
-              },
-              enableLabel: true,
-            ),
-          ),
-        );
-      },
-    );
-  }
-
-  Widget _buildEffectControl(LightEntity entity) {
-    if ((entity.supportEffect) && (entity.effectList != null)) {
-      return ModeSelectorWidget(
-          onChange: (effect) => _setEffect(entity, effect),
-          caption: "Effect",
-          options: entity.effectList,
-          value: _tmpEffect
-      );
-    } else {
-      return Container(width: 0.0, height: 0.0);
-    }
-  }
-
-
-}

lib/entity_widgets/default_entity_container.dart

@@ -3,22 +3,59 @@ part of '../main.dart';
 class DefaultEntityContainer extends StatelessWidget {
   DefaultEntityContainer({
     Key key,
-    @required this.state,
+    @required this.state
-    @required this.height
   }) : super(key: key);
 
   final Widget state;
-  final double height;
 
   @override
   Widget build(BuildContext context) {
-    return SizedBox(
+    final EntityModel entityModel = EntityModel.of(context);
-      height: height,
+    if (entityModel.entityWrapper.entity.statelessType == StatelessEntityType.MISSED) {
+      return MissedEntityWidget();
+    }
+    if (entityModel.entityWrapper.entity.statelessType == StatelessEntityType.DIVIDER) {
+      return Divider(
+        color: Colors.black45,
+      );
+    }
+    if (entityModel.entityWrapper.entity.statelessType == StatelessEntityType.SECTION) {
+      return Column(
+        crossAxisAlignment: CrossAxisAlignment.start,
+        mainAxisSize: MainAxisSize.min,
+        children: <Widget>[
+          Divider(
+            color: Colors.black45,
+          ),
+          Text(
+              "${entityModel.entityWrapper.entity.displayName}",
+            style: TextStyle(color: Colors.blue),
+          )
+        ],
+      );
+    }
+    return InkWell(
+      onLongPress: () {
+        if (entityModel.handleTap) {
+          entityModel.entityWrapper.handleHold();
+        }
+      },
+      onTap: () {
+        if (entityModel.handleTap) {
+          entityModel.entityWrapper.handleTap();
+        }
+      },
       child: Row(
+        mainAxisSize: MainAxisSize.max,
         children: <Widget>[
           EntityIcon(),
-          Expanded(
+
-            child: EntityName(),
+          Flexible(
+            fit: FlexFit.tight,
+            flex: 3,
+            child: EntityName(
+              padding: EdgeInsets.fromLTRB(10.0, 2.0, 10.0, 2.0),
+            ),
           ),
           state
         ],

lib/entity_widgets/entity_attributes_list.dart

@@ -1,57 +0,0 @@
-part of '../main.dart';
-
-class EntityAttributesList extends StatelessWidget {
-  EntityAttributesList({Key key}) : super(key: key);
-
-  @override
-  Widget build(BuildContext context) {
-    final entityModel = EntityModel.of(context);
-    List<Widget> attrs = [];
-    if ((entityModel.entity.attributesToShow == null) ||
-        (entityModel.entity.attributesToShow.contains("all"))) {
-      entityModel.entity.attributes.forEach((name, value) {
-        attrs.add(_buildSingleAttribute("$name", "$value"));
-      });
-    } else {
-      entityModel.entity.attributesToShow.forEach((String attr) {
-        String attrValue = entityModel.entity.getAttribute("$attr");
-        if (attrValue != null) {
-          attrs.add(
-              _buildSingleAttribute("$attr", "$attrValue"));
-        }
-      });
-    }
-    return Column(
-      children: attrs,
-      crossAxisAlignment: CrossAxisAlignment.start,
-      mainAxisSize: MainAxisSize.min,
-    );
-  }
-
-  Widget _buildSingleAttribute(String name, String value) {
-    return Row(
-      children: <Widget>[
-        Expanded(
-          child: Padding(
-            padding: EdgeInsets.fromLTRB(
-                Entity.leftWidgetPadding, Entity.rowPadding, 0.0, 0.0),
-            child: Text(
-              "$name",
-              textAlign: TextAlign.left,
-            ),
-          ),
-        ),
-        Expanded(
-          child: Padding(
-            padding: EdgeInsets.fromLTRB(
-                0.0, Entity.rowPadding, Entity.rightWidgetPadding, 0.0),
-            child: Text(
-              "$value",
-              textAlign: TextAlign.right,
-            ),
-          ),
-        )
-      ],
-    );
-  }
-}

lib/entity_widgets/entity_colors.class.dart

@@ -1,22 +1,40 @@
 part of '../main.dart';
 
-class EntityColors {
+class EntityColor {
+
+  static const defaultStateColor = Color.fromRGBO(68, 115, 158, 1.0);
+
+  static const badgeColors = {
+    "default": Color.fromRGBO(223, 76, 30, 1.0),
+    "binary_sensor": Color.fromRGBO(3, 155, 229, 1.0)
+  };
+
   static const _stateColors = {
-    "on": Colors.amber,
+    EntityState.on: Colors.amber,
     "auto": Colors.amber,
-    "idle": Colors.amber,
+    EntityState.active: Colors.amber,
-    "playing": Colors.amber,
+    EntityState.playing: Colors.amber,
     "above_horizon": Colors.amber,
-    "home":  Colors.amber,
+    EntityState.home:  Colors.amber,
-    "open":  Colors.amber,
+    EntityState.open:  Colors.amber,
-    "off": Color.fromRGBO(68, 115, 158, 1.0),
+    EntityState.off: defaultStateColor,
-    "closed": Color.fromRGBO(68, 115, 158, 1.0),
+    EntityState.closed: defaultStateColor,
-    "below_horizon": Color.fromRGBO(68, 115, 158, 1.0),
+    "below_horizon": defaultStateColor,
-    "default": Color.fromRGBO(68, 115, 158, 1.0),
+    "default": defaultStateColor,
+    EntityState.idle: defaultStateColor,
     "heat": Colors.redAccent,
     "cool": Colors.lightBlue,
-    "unavailable": Colors.black26,
+    EntityState.unavailable: Colors.black26,
-    "unknown": Colors.black26,
+    EntityState.unknown: Colors.black26,
+    EntityState.alarm_disarmed: Colors.green,
+    EntityState.alarm_armed_away: Colors.redAccent,
+    EntityState.alarm_armed_custom_bypass: Colors.redAccent,
+    EntityState.alarm_armed_home: Colors.redAccent,
+    EntityState.alarm_armed_night: Colors.redAccent,
+    EntityState.alarm_triggered: Colors.redAccent,
+    EntityState.alarm_arming: Colors.amber,
+    EntityState.alarm_disarming: Colors.amber,
+    EntityState.alarm_pending: Colors.amber,
   };
 
   static Color stateColor(String state) {
@@ -33,7 +51,8 @@ class EntityColors {
           a: c.alpha
       );
     } else {
-      return charts.MaterialPalette.getOrderedPalettes(id+1)[id].shadeDefault;
+      double r = id.toDouble() % 10;
+      return charts.MaterialPalette.getOrderedPalettes(10)[r.round()].shadeDefault;
     }
   }
 
@@ -43,10 +62,11 @@ class EntityColors {
       return c;
     } else {
       if (id > -1) {
-        charts.Color c1 = charts.MaterialPalette.getOrderedPalettes(id + 1)[id].shadeDefault;
+        double r = id.toDouble() % 10;
+        charts.Color c1 = charts.MaterialPalette.getOrderedPalettes(10)[r.round()].shadeDefault;
         return Color.fromARGB(c1.a, c1.r, c1.g, c1.b);
       } else {
-        return _stateColors["on"];
+        return _stateColors[EntityState.on];
       }
     }
   }

lib/entity_widgets/entity_icon.dart

@@ -1,22 +1,74 @@
 part of '../main.dart';
 
 class EntityIcon extends StatelessWidget {
+
+  final EdgeInsetsGeometry padding;
+  final double size;
+  final Color color;
+
+  const EntityIcon({Key key, this.color, this.size: Sizes.iconSize, this.padding: const EdgeInsets.all(0.0)}) : super(key: key);
+
+  int getDefaultIconByEntityId(String entityId, String deviceClass, String state) {
+    String domain = entityId.split(".")[0];
+    String iconNameByDomain = MaterialDesignIcons.defaultIconsByDomains["$domain.$state"] ?? MaterialDesignIcons.defaultIconsByDomains["$domain"];
+    String iconNameByDeviceClass;
+    if (deviceClass != null) {
+      iconNameByDeviceClass = MaterialDesignIcons.defaultIconsByDeviceClass["$domain.$deviceClass.$state"] ?? MaterialDesignIcons.defaultIconsByDeviceClass["$domain.$deviceClass"];
+    }
+    String iconName = iconNameByDeviceClass ?? iconNameByDomain;
+    if (iconName != null) {
+      return MaterialDesignIcons.iconsDataMap[iconName] ?? 0;
+    } else {
+      return 0;
+    }
+  }
+
+  Widget buildIcon(EntityWrapper data, Color color) {
+    if (data == null) {
+      return null;
+    }
+    if (data.entityPicture != null) {
+      return Container(
+        height: size+12,
+        width: size+12,
+        decoration: BoxDecoration(
+            shape: BoxShape.circle,
+            image: DecorationImage(
+              fit:BoxFit.cover,
+              image: CachedNetworkImageProvider(
+                "${data.entityPicture}"
+              ),
+            )
+        ),
+      );
+    }
+    String iconName = data.icon;
+    int iconCode = 0;
+    if (iconName.length > 0) {
+      iconCode = MaterialDesignIcons.getIconCodeByIconName(iconName);
+    } else {
+      iconCode = getDefaultIconByEntityId(data.entity.entityId,
+          data.entity.deviceClass, data.entity.state); //
+    }
+    return Padding(
+        padding: EdgeInsets.fromLTRB(6.0, 6.0, 6.0, 6.0),
+        child: Icon(
+          IconData(iconCode, fontFamily: 'Material Design Icons'),
+          size: size,
+          color: color,
+        )
+    );
+  }
+
   @override
   Widget build(BuildContext context) {
-    final entityModel = EntityModel.of(context);
+    final EntityWrapper entityWrapper = EntityModel.of(context).entityWrapper;
-    return GestureDetector(
+    return Padding(
-      child: Padding(
+      padding: padding,
-        padding: EdgeInsets.fromLTRB(
+      child: buildIcon(
-            Entity.leftWidgetPadding, 0.0, 12.0, 0.0),
+          entityWrapper,
-        child: MaterialDesignIcons.createIconWidgetFromEntityData(
+          color ?? EntityColor.stateColor(entityWrapper.entity.state)
-            entityModel.entity,
-            Entity.iconSize,
-            EntityColors.stateColor(entityModel.entity.state)
-        ),
       ),
-      onTap: () => entityModel.handleTap
-          ? eventBus.fire(new ShowEntityPageEvent(entityModel.entity))
-          : null,
     );
   }
 }

lib/entity_widgets/entity_name.dart

@@ -1,23 +1,33 @@
 part of '../main.dart';
 
 class EntityName extends StatelessWidget {
+
+  final EdgeInsetsGeometry padding;
+  final TextOverflow textOverflow;
+  final bool wordsWrap;
+  final double fontSize;
+  final TextAlign textAlign;
+  final int maxLines;
+
+  const EntityName({Key key, this.maxLines, this.padding: const EdgeInsets.only(right: 10.0), this.textOverflow: TextOverflow.ellipsis, this.wordsWrap: true, this.fontSize: Sizes.nameFontSize, this.textAlign: TextAlign.left}) : super(key: key);
+
   @override
   Widget build(BuildContext context) {
-    final entityModel = EntityModel.of(context);
+    final EntityWrapper entityWrapper = EntityModel.of(context).entityWrapper;
-    return GestureDetector(
+    TextStyle textStyle = TextStyle(fontSize: fontSize);
-      child: Padding(
+    if (entityWrapper.entity.statelessType == StatelessEntityType.WEBLINK) {
-        padding: EdgeInsets.only(right: 10.0),
+      textStyle = textStyle.apply(color: Colors.blue, decoration: TextDecoration.underline);
-        child: Text(
+    }
-          "${entityModel.entity.displayName}",
+    return Padding(
-          overflow: TextOverflow.ellipsis,
+      padding: padding,
-          softWrap: false,
+      child: Text(
-          style: TextStyle(fontSize: Entity.nameFontSize),
+        "${entityWrapper.displayName}",
-        ),
+        overflow: textOverflow,
+        softWrap: wordsWrap,
+        maxLines: maxLines,
+        style: textStyle,
+        textAlign: textAlign,
       ),
-      onTap: () =>
-      entityModel.handleTap
-          ? eventBus.fire(new ShowEntityPageEvent(entityModel.entity))
-          : null,
     );
   }
 }

lib/entity_widgets/glance_entity_container.dart

@@ -0,0 +1,90 @@
+part of '../main.dart';
+
+class GlanceEntityContainer extends StatelessWidget {
+
+  final bool showName;
+  final bool showState;
+  final bool nameInTheBottom;
+  final double iconSize;
+  final double nameFontSize;
+  final bool wordsWrapInName;
+
+  GlanceEntityContainer({
+    Key key,
+    @required this.showName,
+    @required this.showState,
+    this.nameInTheBottom: false,
+    this.iconSize: Sizes.iconSize,
+    this.nameFontSize: Sizes.smallFontSize,
+    this.wordsWrapInName: false
+  }) : super(key: key);
+
+  @override
+  Widget build(BuildContext context) {
+    final EntityWrapper entityWrapper = EntityModel.of(context).entityWrapper;
+    if (entityWrapper.entity.statelessType == StatelessEntityType.MISSED) {
+      return MissedEntityWidget();
+    }
+    if (entityWrapper.entity.statelessType > StatelessEntityType.MISSED) {
+      return Container(width: 0.0, height: 0.0,);
+    }
+    List<Widget> result = [];
+    if (!nameInTheBottom) {
+      if (showName) {
+        result.add(_buildName());
+      }
+    } else {
+      if (showState) {
+        result.add(_buildState());
+      }
+    }
+    result.add(
+      EntityIcon(
+        padding: EdgeInsets.all(0.0),
+        size: iconSize,
+      )
+    );
+    if (!nameInTheBottom) {
+      if (showState) {
+        result.add(_buildState());
+      }
+    } else {
+      result.add(_buildName());
+    }
+
+    return Center(
+      child: InkResponse(
+        child: ConstrainedBox(
+          constraints: BoxConstraints(minWidth: Sizes.iconSize * 2),
+          child: Column(
+            mainAxisSize: MainAxisSize.min,
+            //mainAxisAlignment: MainAxisAlignment.start,
+            //crossAxisAlignment: CrossAxisAlignment.center,
+            children: result,
+          ),
+        ),
+        onTap: () => entityWrapper.handleTap(),
+        onLongPress: () => entityWrapper.handleHold(),
+      ),
+    );
+  }
+
+  Widget _buildName() {
+    return EntityName(
+      padding: EdgeInsets.only(bottom: Sizes.rowPadding),
+      textOverflow: TextOverflow.ellipsis,
+      wordsWrap: wordsWrapInName,
+      textAlign: TextAlign.center,
+      fontSize: nameFontSize,
+    );
+  }
+
+  Widget _buildState() {
+    return SimpleEntityState(
+      textAlign: TextAlign.center,
+      expanded: false,
+      maxLines: 1,
+      padding: EdgeInsets.only(top: Sizes.rowPadding),
+    );
+  }
+}

lib/entity_widgets/history_chart/combined_history_chart.dart

@@ -69,7 +69,7 @@ class _CombinedHistoryChartWidgetState extends State<CombinedHistoryChartWidget>
             selectionModels: [
               new charts.SelectionModelConfig(
                 type: charts.SelectionModelType.info,
-                listener: (model) => _onSelectionChanged(model),
+                changedListener: (model) => _onSelectionChanged(model),
               )
             ],
             customSeriesRenderers: [
@@ -94,11 +94,11 @@ class _CombinedHistoryChartWidgetState extends State<CombinedHistoryChartWidget>
   }
 
   List<charts.Series<EntityHistoryMoment, DateTime>> _parseHistory() {
-    TheLogger.debug("  parsing history...");
+    Logger.d("  parsing history...");
     Map<String, List<EntityHistoryMoment>> numericDataLists = {};
     int colorIdCounter = 0;
     widget.config.numericAttributesToShow.forEach((String attrName) {
-      TheLogger.debug("    parsing attribute $attrName");
+      Logger.d("    parsing attribute $attrName");
       List<EntityHistoryMoment> data = [];
       DateTime now = DateTime.now();
       for (var i = 0; i < widget.rawHistory.length; i++) {
@@ -148,15 +148,15 @@ class _CombinedHistoryChartWidgetState extends State<CombinedHistoryChartWidget>
     });
 
     if ((_selectedId == -1) && (numericDataLists.isNotEmpty)) {
-      _selectedId = 0;
+      _selectedId = numericDataLists.length -1;
     }
     List<charts.Series<EntityHistoryMoment, DateTime>> result = [];
     numericDataLists.forEach((attrName, dataList) {
-      TheLogger.debug("  adding ${dataList.length} data values");
+      Logger.d("  adding ${dataList.length} data values");
       result.add(
         new charts.Series<EntityHistoryMoment, DateTime>(
           id: "value",
-          colorFn: (EntityHistoryMoment historyMoment, __) => EntityColors.chartHistoryStateColor("_", historyMoment.colorId),
+          colorFn: (EntityHistoryMoment historyMoment, __) => EntityColor.chartHistoryStateColor("_", historyMoment.colorId),
           radiusPxFn: (EntityHistoryMoment historyMoment, __) {
               if (historyMoment.hiddenDot) {
                 return 0.0;
@@ -179,7 +179,7 @@ class _CombinedHistoryChartWidgetState extends State<CombinedHistoryChartWidget>
         new charts.Series<EntityHistoryMoment, DateTime>(
           id: 'state',
           radiusPxFn: (EntityHistoryMoment historyMoment, __) => (historyMoment.id == _selectedId) ? 5.0 : 4.0,
-          colorFn: (EntityHistoryMoment historyMoment, __) => EntityColors.chartHistoryStateColor(historyMoment.state, historyMoment.colorId),
+          colorFn: (EntityHistoryMoment historyMoment, __) => EntityColor.chartHistoryStateColor(historyMoment.state, historyMoment.colorId),
           domainFn: (EntityHistoryMoment historyMoment, _) => historyMoment.startTime,
           domainLowerBoundFn: (EntityHistoryMoment historyMoment, _) => historyMoment.startTime,
           domainUpperBoundFn: (EntityHistoryMoment historyMoment, _) => historyMoment.endTime ?? DateTime.now(),
@@ -202,6 +202,11 @@ class _CombinedHistoryChartWidgetState extends State<CombinedHistoryChartWidget>
         _selectedId -= 1;
       });
     }
+    else {
+      setState(() {
+        _selectedId = _parsedHistory.first.data.length - 1;
+      });
+    }
   }
 
   void _selectNext() {
@@ -210,6 +215,12 @@ class _CombinedHistoryChartWidgetState extends State<CombinedHistoryChartWidget>
         _selectedId += 1;
       });
     }
+    else {
+      setState(() {
+        _selectedId = 0;
+      });
+
+    }
   }
 
   void _onSelectionChanged(charts.SelectionModel model) {

lib/entity_widgets/history_chart/entity_history.dart

@@ -31,6 +31,8 @@ class _EntityHistoryWidgetState extends State<EntityHistoryWidget> {
 
   List _history;
   bool _needToUpdateHistory;
+  DateTime _historyLastUpdated;
+  bool _disposed = false;
 
   @override
   void initState() {
@@ -38,30 +40,40 @@ class _EntityHistoryWidgetState extends State<EntityHistoryWidget> {
     _needToUpdateHistory = true;
   }
 
-  void _loadHistory(HomeAssistant ha, String entityId) {
+  void _loadHistory(String entityId) {
-    ha.getHistory(entityId).then((history){
+    DateTime now = DateTime.now();
-      setState(() {
+    if (_historyLastUpdated != null) {
-        _history = history.isNotEmpty ? history[0] : [];
+      Logger.d("History was updated ${now.difference(_historyLastUpdated).inSeconds} seconds ago");
-        _needToUpdateHistory = false;
+    }
+    if (_historyLastUpdated == null || now.difference(_historyLastUpdated).inSeconds > 30) {
+      _historyLastUpdated = now;
+      ConnectionManager().getHistory(entityId).then((history){
+        if (!_disposed) {
+          setState(() {
+            _history = history.isNotEmpty ? history[0] : [];
+            _needToUpdateHistory = false;
+          });
+        }
+      }).catchError((e) {
+        Logger.e("Error loading $entityId history: $e");
+        if (!_disposed) {
+          setState(() {
+            _history = [];
+            _needToUpdateHistory = false;
+          });
+        }
       });
-    }).catchError((e) {
+    }
-      TheLogger.error("Error loading $entityId history: $e");
-      setState(() {
-        _history = [];
-        _needToUpdateHistory = false;
-      });
-    });
   }
 
   @override
   Widget build(BuildContext context) {
-    final HomeAssistantModel homeAssistantModel = HomeAssistantModel.of(context);
     final EntityModel entityModel = EntityModel.of(context);
-    final Entity entity = entityModel.entity;
+    final Entity entity = entityModel.entityWrapper.entity;
     if (!_needToUpdateHistory) {
       _needToUpdateHistory = true;
     } else {
-      _loadHistory(homeAssistantModel.homeAssistant, entity.entityId);
+      _loadHistory(entity.entityId);
     }
     return _buildChart();
   }
@@ -83,7 +95,7 @@ class _EntityHistoryWidgetState extends State<EntityHistoryWidget> {
     }
     children.add(Divider());
     return Padding(
-      padding: EdgeInsets.fromLTRB(0.0, 0.0, 0.0, Entity.rowPadding),
+      padding: EdgeInsets.fromLTRB(0.0, 0.0, 0.0, Sizes.rowPadding),
       child: Column(
         children: children,
       ),
@@ -91,18 +103,15 @@ class _EntityHistoryWidgetState extends State<EntityHistoryWidget> {
   }
 
   Widget _selectChartWidget() {
-    TheLogger.debug("  selecting history widget (${widget.config.chartType})");
     switch (widget.config.chartType) {
 
       case EntityHistoryWidgetType.simple: {
-          TheLogger.debug("  Simple selected");
           return SimpleStateHistoryChartWidget(
             rawHistory: _history,
           );
       }
 
       case EntityHistoryWidgetType.numericState: {
-        TheLogger.debug("  EntityHistory selected");
         return NumericStateHistoryChartWidget(
           rawHistory: _history,
           config: widget.config,
@@ -110,7 +119,6 @@ class _EntityHistoryWidgetState extends State<EntityHistoryWidget> {
       }
 
       case EntityHistoryWidgetType.numericAttributes: {
-        TheLogger.debug("  NumericAttributes selected");
         return CombinedHistoryChartWidget(
           rawHistory: _history,
           config: widget.config,
@@ -118,7 +126,7 @@ class _EntityHistoryWidgetState extends State<EntityHistoryWidget> {
       }
 
       default: {
-        TheLogger.debug("  Simple selected as default");
+        Logger.d("  Simple selected as default");
         return SimpleStateHistoryChartWidget(
           rawHistory: _history,
         );
@@ -127,4 +135,10 @@ class _EntityHistoryWidgetState extends State<EntityHistoryWidget> {
 
   }
 
+  @override
+  void dispose() {
+    _disposed = true;
+    super.dispose();
+  }
+
 }

lib/entity_widgets/history_chart/history_control_widget.dart

@@ -55,7 +55,7 @@ class HistoryControlWidget extends StatelessWidget {
             textAlign: TextAlign.right,
             style: TextStyle(
                 fontWeight: FontWeight.bold,
-                color: EntityColors.historyStateColor(selectedStates[i], colorIndexes[i]),
+                color: EntityColor.historyStateColor(selectedStates[i], colorIndexes[i]),
                 fontSize: 22.0
             ),
           )

lib/entity_widgets/history_chart/numeric_state_history_chart.dart

@@ -57,7 +57,7 @@ class _NumericStateHistoryChartWidgetState extends State<NumericStateHistoryChar
             selectionModels: [
               new charts.SelectionModelConfig(
                 type: charts.SelectionModelType.info,
-                listener: (model) => _onSelectionChanged(model),
+                changedListener: (model) => _onSelectionChanged(model),
               )
             ],
           ),
@@ -103,12 +103,12 @@ class _NumericStateHistoryChartWidgetState extends State<NumericStateHistoryChar
         id: widget.rawHistory.length
     ));
     if (_selectedId == -1) {
-      _selectedId = 0;
+      _selectedId = data.length - 1;
     }
     return [
       new charts.Series<EntityHistoryMoment, DateTime>(
         id: 'State',
-        colorFn: (EntityHistoryMoment historyMoment, __) => EntityColors.chartHistoryStateColor("on", -1),
+        colorFn: (EntityHistoryMoment historyMoment, __) => EntityColor.chartHistoryStateColor(EntityState.on, -1),
         domainFn: (EntityHistoryMoment historyMoment, _) => historyMoment.startTime,
         measureFn: (EntityHistoryMoment historyMoment, _) => historyMoment.value ?? historyMoment.previousValue,
         data: data,
@@ -132,6 +132,11 @@ class _NumericStateHistoryChartWidgetState extends State<NumericStateHistoryChar
         _selectedId -= 1;
       });
     }
+    else {
+      setState(() {
+        _selectedId = _parsedHistory.first.data.length - 1;
+      });
+    }
   }
 
   void _selectNext() {
@@ -140,6 +145,12 @@ class _NumericStateHistoryChartWidgetState extends State<NumericStateHistoryChar
         _selectedId += 1;
       });
     }
+    else {
+      setState(() {
+        _selectedId = 0;
+      });
+
+    }
   }
 
   void _onSelectionChanged(charts.SelectionModel model) {

lib/entity_widgets/history_chart/simple_state_history_chart.dart

@@ -53,7 +53,7 @@ class _SimpleStateHistoryChartWidgetState extends State<SimpleStateHistoryChartW
             selectionModels: [
               new charts.SelectionModelConfig(
                 type: charts.SelectionModelType.info,
-                listener: (model) => _onSelectionChanged(model),
+                changedListener: (model) => _onSelectionChanged(model),
               )
             ],
             customSeriesRenderers: [
@@ -101,13 +101,13 @@ class _SimpleStateHistoryChartWidgetState extends State<SimpleStateHistoryChartW
         colorId: data.last.colorId
     ));
     if (_selectedId == -1) {
-      _selectedId = 0;
+      _selectedId = data.length - 1;
     }
     return [
       new charts.Series<EntityHistoryMoment, DateTime>(
         id: 'State',
         strokeWidthPxFn: (EntityHistoryMoment historyMoment, __) => (historyMoment.id == _selectedId) ? 6.0 : 3.0,
-        colorFn: (EntityHistoryMoment historyMoment, __) => EntityColors.chartHistoryStateColor(historyMoment.state, historyMoment.colorId),
+        colorFn: (EntityHistoryMoment historyMoment, __) => EntityColor.chartHistoryStateColor(historyMoment.state, historyMoment.colorId),
         domainFn: (EntityHistoryMoment historyMoment, _) => historyMoment.startTime,
         measureFn: (EntityHistoryMoment historyMoment, _) => 10,
         data: data,
@@ -115,7 +115,7 @@ class _SimpleStateHistoryChartWidgetState extends State<SimpleStateHistoryChartW
       new charts.Series<EntityHistoryMoment, DateTime>(
         id: 'State',
         radiusPxFn: (EntityHistoryMoment historyMoment, __) => (historyMoment.id == _selectedId) ? 5.0 : 3.0,
-        colorFn: (EntityHistoryMoment historyMoment, __) => EntityColors.chartHistoryStateColor(historyMoment.state, historyMoment.colorId),
+        colorFn: (EntityHistoryMoment historyMoment, __) => EntityColor.chartHistoryStateColor(historyMoment.state, historyMoment.colorId),
         domainFn: (EntityHistoryMoment historyMoment, _) => historyMoment.startTime,
         measureFn: (EntityHistoryMoment historyMoment, _) => 10,
         data: data,
@@ -123,7 +123,7 @@ class _SimpleStateHistoryChartWidgetState extends State<SimpleStateHistoryChartW
       new charts.Series<EntityHistoryMoment, DateTime>(
         id: 'State',
         radiusPxFn: (EntityHistoryMoment historyMoment, __) => (historyMoment.id == _selectedId) ? 5.0 : 3.0,
-        colorFn: (EntityHistoryMoment historyMoment, __) => EntityColors.chartHistoryStateColor(historyMoment.state, historyMoment.colorId),
+        colorFn: (EntityHistoryMoment historyMoment, __) => EntityColor.chartHistoryStateColor(historyMoment.state, historyMoment.colorId),
         domainFn: (EntityHistoryMoment historyMoment, _) => historyMoment.endTime ?? DateTime.now(),
         measureFn: (EntityHistoryMoment historyMoment, _) => 10,
         data: data,
@@ -137,14 +137,25 @@ class _SimpleStateHistoryChartWidgetState extends State<SimpleStateHistoryChartW
         _selectedId -= 1;
       });
     }
+    else {
+      setState(() {
+        _selectedId = _parsedHistory.first.data.length - 1;
+      });
+    }
   }
 
   void _selectNext() {
-    if (_selectedId < (_parsedHistory.first.data.length - 2)) {
+    if (_selectedId < (_parsedHistory.first.data.length - 1)) {
       setState(() {
         _selectedId += 1;
       });
     }
+    else {
+      setState(() {
+        _selectedId = 0;
+      });
+
+    }
   }
 
   void _onSelectionChanged(charts.SelectionModel model) {

lib/entity_widgets/missed_entity.dart

@@ -0,0 +1,19 @@
+part of '../main.dart';
+
+class MissedEntityWidget extends StatelessWidget {
+  MissedEntityWidget({
+    Key key
+  }) : super(key: key);
+
+  @override
+  Widget build(BuildContext context) {
+    final EntityModel entityModel = EntityModel.of(context);
+    return Container(
+        child: Padding(
+          padding: EdgeInsets.all(5.0),
+          child: Text("Entity not available: ${entityModel.entityWrapper.entity.entityId}"),
+        ),
+        color: Colors.amber[100],
+    );
+  }
+}

lib/entity_widgets/mode_selector.dart

@@ -1,62 +0,0 @@
-part of '../main.dart';
-
-class ModeSelectorWidget extends StatelessWidget {
-
-  final String caption;
-  final List<String> options;
-  final String value;
-  final double captionFontSize;
-  final double valueFontSize;
-  final double bottomPadding;
-  final onChange;
-
-  ModeSelectorWidget({
-    Key key,
-    this.caption,
-    @required this.options,
-    this.value,
-    @required this.onChange,
-    this.captionFontSize,
-    this.valueFontSize,
-    this.bottomPadding
-  }) : super(key: key);
-
-  @override
-  Widget build(BuildContext context) {
-    return Column(
-      crossAxisAlignment: CrossAxisAlignment.start,
-      children: <Widget>[
-        Text("$caption", style: TextStyle(
-            fontSize: captionFontSize ?? Entity.stateFontSize
-        )),
-        Row(
-          children: <Widget>[
-            Expanded(
-              child: ButtonTheme(
-                alignedDropdown: true,
-                child: DropdownButton<String>(
-                  value: value,
-                  iconSize: 30.0,
-                  isExpanded: true,
-                  style: TextStyle(
-                    fontSize: valueFontSize ?? Entity.largeFontSize,
-                    color: Colors.black,
-                  ),
-                  hint: Text("Select ${caption.toLowerCase()}"),
-                  items: options.map((String value) {
-                    return new DropdownMenuItem<String>(
-                      value: value,
-                      child: Text(value),
-                    );
-                  }).toList(),
-                  onChanged: (mode) => onChange(mode),
-                ),
-              ),
-            )
-          ],
-        ),
-        Container(height: bottomPadding ?? Entity.rowPadding,)
-      ],
-    );
-  }
-}

lib/entity_widgets/mode_swicth.dart

@@ -1,38 +0,0 @@
-part of '../main.dart';
-
-class ModeSwitchWidget extends StatelessWidget {
-
-  final String caption;
-  final onChange;
-  final double captionFontSize;
-  final bool value;
-
-  ModeSwitchWidget({
-    Key key,
-    @required this.caption,
-    @required this.onChange,
-    this.captionFontSize,
-    this.value
-  }) : super(key: key);
-
-  @override
-  Widget build(BuildContext context) {
-    return Row(
-      children: <Widget>[
-        Expanded(
-          child: Text(
-            "$caption",
-            style: TextStyle(
-                fontSize: captionFontSize ?? Entity.stateFontSize
-            ),
-          ),
-        ),
-        Switch(
-          onChanged: (value) => onChange(value),
-          value: value ?? false,
-        )
-      ],
-    );
-  }
-
-}

lib/entity_widgets/model_widgets.dart

@@ -3,12 +3,12 @@ part of '../main.dart';
 class EntityModel extends InheritedWidget {
   const EntityModel({
     Key key,
-    @required this.entity,
+    @required this.entityWrapper,
     @required this.handleTap,
     @required Widget child,
   }) : super(key: key, child: child);
 
-  final Entity entity;
+  final EntityWrapper entityWrapper;
   final bool handleTap;
 
   static EntityModel of(BuildContext context) {
@@ -20,23 +20,3 @@ class EntityModel extends InheritedWidget {
     return true;
   }
 }
-
-class HomeAssistantModel extends InheritedWidget {
-
-  const HomeAssistantModel({
-    Key key,
-    @required this.homeAssistant,
-    @required Widget child,
-  }) : super(key: key, child: child);
-
-  final HomeAssistant homeAssistant;
-
-  static HomeAssistantModel of(BuildContext context) {
-    return context.inheritFromWidgetOfExactType(HomeAssistantModel);
-  }
-
-  @override
-  bool updateShouldNotify(InheritedWidget oldWidget) {
-    return true;
-  }
-}

lib/entity_widgets/state/button_state.dart

@@ -1,24 +0,0 @@
-part of '../../main.dart';
-
-class ButtonStateWidget extends StatelessWidget {
-
-  void _setNewState(Entity entity) {
-    eventBus.fire(new ServiceCallEvent(entity.domain, "turn_on", entity.entityId, null));
-  }
-
-  @override
-  Widget build(BuildContext context) {
-    final entityModel = EntityModel.of(context);
-    return FlatButton(
-      onPressed: (() {
-        _setNewState(entityModel.entity);
-      }),
-      child: Text(
-        "EXECUTE",
-        textAlign: TextAlign.right,
-        style:
-        new TextStyle(fontSize: Entity.stateFontSize, color: Colors.blue),
-      ),
-    );
-  }
-}

lib/entity_widgets/state/climate_state.dart

@@ -1,57 +0,0 @@
-part of '../../main.dart';
-
-class ClimateStateWidget extends StatelessWidget {
-  @override
-  Widget build(BuildContext context) {
-    final entityModel = EntityModel.of(context);
-    final ClimateEntity entity = entityModel.entity;
-    String targetTemp = "-";
-    if ((entity.supportTargetTemperature) && (entity.temperature != null)) {
-      targetTemp = "${entity.temperature}";
-    } else if ((entity.supportTargetTemperatureLow) &&
-        (entity.targetLow != null)) {
-      targetTemp = "${entity.targetLow}";
-      if ((entity.supportTargetTemperatureHigh) &&
-          (entity.targetHigh != null)) {
-        targetTemp += " - ${entity.targetHigh}";
-      }
-    }
-    return Padding(
-        padding: EdgeInsets.fromLTRB(
-            0.0, 0.0, Entity.rightWidgetPadding, 0.0),
-        child: GestureDetector(
-          child: Column(
-            crossAxisAlignment: CrossAxisAlignment.end,
-            mainAxisAlignment: MainAxisAlignment.center,
-            children: <Widget>[
-              Row(
-                children: <Widget>[
-                  Text("${entity.state}",
-                      textAlign: TextAlign.right,
-                      style: new TextStyle(
-                        fontWeight: FontWeight.bold,
-                        fontSize: Entity.stateFontSize,
-                      )),
-                  Text(" $targetTemp",
-                      textAlign: TextAlign.right,
-                      style: new TextStyle(
-                        fontSize: Entity.stateFontSize,
-                      ))
-                ],
-              ),
-              entity.attributes["current_temperature"] != null ?
-              Text("Currently: ${entity.attributes["current_temperature"]}",
-                  textAlign: TextAlign.right,
-                  style: new TextStyle(
-                      fontSize: Entity.stateFontSize,
-                      color: Colors.black45)
-              ) :
-              Container(height: 0.0,)
-            ],
-          ),
-          onTap: () => entityModel.handleTap
-              ? eventBus.fire(new ShowEntityPageEvent(entity))
-              : null,
-        ));
-  }
-}