896

890

.github/ISSUE_TEMPLATE/bug_report.md

@@ -7,35 +7,16 @@ assignees: ''
 
 ---
 
-<!-- 
+**HA Client version:** [Main menu -> About HA Client]
-Please provide as much information as possible.
- -->
-**HA Client version:** <!-- Main app menu => About HA Client -->
 
-**Home Assistant version:** <!-- 0.94.1 for example -->
+**Home Assistant version:**
 
-**Device name:** <!-- Pixel 2 for example -->
+**Device name:**
 
-**Android version:** <!-- 8.1 for example -->
+**Android version:**
-
-**Connection type:** <!-- For example "Local IP" or "Remote UI" or "Own domain"-->
-
-**Login type:** <!-- For example "HA Login" or "Manual token"-->
 
 **Description**
-<!-- 
+[Replace with description]
-Describe your issue here
--->
 
 **Screenshots**
-<!-- 
+[Replace with screenshots]
-Please provide screenshots if it is a UI issue. Also you can attach screenshot from Home Assistant web UI as an expected result
--->
-
-**Logs**
-<!-- 
-Right after issue reproduced go to app menu and tap "Log". Copy log with a "Copy" button in the upper-right corner and post it below
--->
-```
-[Replace this text with your logs] 
-```

.gitignore

@@ -15,7 +15,8 @@ build/
 .settings/
 
 flutter_export_environment.sh
+.flutter-plugins-dependencies
 
 key.properties
-premium_features_manager.class.dart
+.secrets.dart
 pubspec.lock

.gitpod.dockerfile

@@ -4,9 +4,5 @@ ENV ANDROID_HOME=/workspace/android-sdk \
     FLUTTER_ROOT=/workspace/flutter \
     FLUTTER_HOME=/workspace/flutter
 
-USER root
+RUN bash -c ". /home/gitpod/.sdkman/bin/sdkman-init.sh \
-
+             && sdk install java 8.0.242.j9-adpt"
-RUN apt-get update && \
-    apt-get -y install build-essential libkrb5-dev gcc make gradle openjdk-8-jdk && \
-    apt-get clean && \
-    apt-get -y autoremove

.gitpod.yml

@@ -3,12 +3,12 @@ image:
 
 tasks:
 - before: |
-    export PATH=$FLUTTER_HOME/bin:$ANDROID_HOME/bin:$ANDROID_HOME/platform-tools:$PATH
+    export PATH=$FLUTTER_HOME/bin:$FLUTTER_HOME/bin/cache/dart-sdk/bin:$ANDROID_HOME/bin:$ANDROID_HOME/platform-tools:$PATH
     mkdir -p /home/gitpod/.android
     touch /home/gitpod/.android/repositories.cfg
   init: |
     echo "Installing Flutter SDK..."
-    cd /workspace && wget -qO flutter_sdk.tar.xz https://storage.googleapis.com/flutter_infra/releases/stable/linux/flutter_linux_v1.9.1+hotfix.4-stable.tar.xz && tar -xf flutter_sdk.tar.xz && rm -f flutter_sdk.tar.xz
+    cd /workspace && wget -qO flutter_sdk.tar.xz https://storage.googleapis.com/flutter_infra/releases/stable/linux/flutter_linux_v1.12.13+hotfix.7-stable.tar.xz && tar -xf flutter_sdk.tar.xz && rm -f flutter_sdk.tar.xz
     echo "Installing Android SDK..."
     mkdir -p /workspace/android-sdk && cd /workspace/android-sdk && wget https://dl.google.com/android/repository/sdk-tools-linux-4333796.zip && unzip sdk-tools-linux-4333796.zip && rm -f sdk-tools-linux-4333796.zip
     /workspace/android-sdk/tools/bin/sdkmanager "platform-tools" "platforms;android-28" "build-tools;28.0.3"
@@ -18,7 +18,6 @@ tasks:
     flutter doctor --android-licenses
     flutter pub get
   command: |
-    flutter pub upgrade
     echo "Ready to go!"
     flutter doctor
 vscode:

README.md

@@ -1,13 +1,14 @@
-[![Open in Gitpod](https://gitpod.io/button/open-in-gitpod.svg)](https://gitpod.io/#https://github.com/estevez-dev/ha_client)
 # HA Client
 ## Native Android client for Home Assistant
 ### With notifications and Lovelace UI support
 
-Visit [homemade.systems](http://ha-client.homemade.systems/) for more info.
+Visit [ha-client.app](http://ha-client.app/) 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)
+Discuss it on [Discord](https://discord.gg/nd6FZQ) or at [Home Assistant community](https://community.home-assistant.io/c/mobile-apps/ha-client-android)
+
+[![Gitpod Ready-to-Code](https://img.shields.io/badge/Gitpod-Ready--to--Code-blue?logo=gitpod)](https://gitpod.io/#https://github.com/estevez-dev/ha_client) 
 
 #### Pre-release CI build
 [![Codemagic build status](https://api.codemagic.io/apps/5da8bdab9f20ef798f7c2c65/5da8bdab9f20ef798f7c2c64/status_badge.svg)](https://codemagic.io/apps/5da8bdab9f20ef798f7c2c65/5da8bdab9f20ef798f7c2c64/latest_build)

android/app/build.gradle

@@ -78,10 +78,11 @@ flutter {
 }
 
 dependencies {
-    implementation 'com.google.firebase:firebase-core:16.0.8'
+    implementation 'com.google.firebase:firebase-analytics:17.2.2'
     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: 'io.fabric'
 apply plugin: 'com.google.gms.google-services'

android/app/src/main/AndroidManifest.xml

@@ -8,6 +8,7 @@
     <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
     <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED"/>
     <uses-permission android:name="android.permission.WAKE_LOCK"/>
+    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
 
 
     <!-- io.flutter.app.FlutterApplication is an android.app.Application that
@@ -16,11 +17,14 @@
          additional functionality it is fine to subclass or reimplement
          FlutterApplication and put your custom class here. -->
     <application
-        android:name=".Application"
+        android:name="io.flutter.app.FlutterApplication"
         android:label="HA Client"
         android:icon="@mipmap/ic_launcher"
-        android:usesCleartextTraffic="true"
+        android:usesCleartextTraffic="true">
-        android:networkSecurityConfig="@xml/network_security_config">
+
+        <meta-data
+            android:name="flutterEmbedding"
+            android:value="2" />
 
         <meta-data
             android:name="com.google.firebase.messaging.default_notification_channel_id"
@@ -33,13 +37,12 @@
             android:configChanges="orientation|keyboardHidden|keyboard|screenSize|locale|layoutDirection|fontScale|screenLayout|density"
             android:hardwareAccelerated="true"
             android:windowSoftInputMode="adjustResize">
-            <!-- 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).
             <meta-data
-                android:name="io.flutter.app.android.SplashScreenUntilFirstFrame"
+                android:name="io.flutter.embedding.android.SplashScreenDrawable"
-                android:value="true" />-->
+                android:resource="@drawable/launch_background" />
+            <meta-data
+                android:name="io.flutter.embedding.android.NormalTheme"
+                android:resource="@style/NormalTheme" />
             <intent-filter>
                 <action android:name="FLUTTER_NOTIFICATION_CLICK" />
                 <category android:name="android.intent.category.DEFAULT" />
@@ -48,14 +51,6 @@
                 <action android:name="android.intent.action.MAIN"/>
                 <category android:name="android.intent.category.LAUNCHER"/>
             </intent-filter>
-            <intent-filter android:autoVerify="true">
-                <action android:name="android.intent.action.VIEW" />
-                <category android:name="android.intent.category.DEFAULT" />
-                <category android:name="android.intent.category.BROWSABLE" />
-                <data
-                android:scheme="haclient"
-                android:host="auth" />
-            </intent-filter>
         </activity>
 
         <service

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

@@ -1,20 +0,0 @@
-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;
-import be.tramckrijte.workmanager.WorkmanagerPlugin;
-
-public class Application extends FlutterApplication implements PluginRegistrantCallback {
-    @Override
-    public void onCreate() {
-        super.onCreate();
-        WorkmanagerPlugin.setPluginRegistrantCallback(this);
-    }
-
-    @Override
-    public void registerWith(PluginRegistry registry) {
-        GeneratedPluginRegistrant.registerWith(registry);
-    }
-}

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

@@ -1,15 +1,15 @@
 package com.keyboardcrumbs.hassclient;
 
-import android.os.Bundle;
+import androidx.annotation.NonNull;
-import io.flutter.app.FlutterActivity;
+import io.flutter.embedding.android.FlutterActivity;
+import io.flutter.embedding.engine.FlutterEngine;
 import io.flutter.plugins.GeneratedPluginRegistrant;
-import io.flutter.plugins.share.FlutterShareReceiverActivity;
 
-public class MainActivity extends FlutterShareReceiverActivity {
+public class MainActivity extends FlutterActivity {
   
     @Override
-  protected void onCreate(Bundle savedInstanceState) {
+    public void configureFlutterEngine(@NonNull FlutterEngine flutterEngine) {
-    super.onCreate(savedInstanceState);
+        GeneratedPluginRegistrant.registerWith(flutterEngine);
-    GeneratedPluginRegistrant.registerWith(this);
     }
+
 }

android/app/src/main/res/values/styles.xml

@@ -5,4 +5,7 @@
              Flutter draws its first frame -->
         <item name="android:windowBackground">@drawable/launch_background</item>
     </style>
+    <style name="NormalTheme" parent="@android:style/Theme.Black.NoTitleBar">
+        <item name="android:windowBackground">@drawable/launch_background</item>
+    </style>
 </resources>

android/app/src/main/res/xml/network_security_config.xml

@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<network-security-config>
-    <base-config>
-        <trust-anchors>
-            <certificates src="system"/>
-            <certificates src="user"/>
-        </trust-anchors>
-    </base-config>
-</network-security-config>

android/build.gradle

@@ -2,11 +2,15 @@ buildscript {
     repositories {
         google()
         jcenter()
+        maven {
+            url 'https://maven.fabric.io/public'
+        }
     }
 
     dependencies {
         classpath 'com.android.tools.build:gradle:3.3.2'
-        classpath 'com.google.gms:google-services:4.2.0'
+        classpath 'com.google.gms:google-services:4.3.3'
+        classpath 'io.fabric.tools:gradle:1.26.1'
     }
 }
 
@@ -14,6 +18,9 @@ allprojects {
     repositories {
         google()
         jcenter()
+        maven {
+            url 'https://maven.fabric.io/public'
+        }
     }
 }
 

android/gradle.properties

@@ -3,3 +3,4 @@ org.gradle.daemon=true
 org.gradle.caching=true
 android.useAndroidX=true
 android.enableJetifier=true
+android.enableR8=true

android/settings_aar.gradle

@@ -0,0 +1 @@
+include ':app'

assets/html/cameraLiveView.html

@@ -0,0 +1,61 @@
+<html>
+<head>
+<script src="https://cdn.jsdelivr.net/npm/hls.js@latest"></script>
+<style>
+    body {
+        padding: 0;
+        margin: 0;
+        widows: 100%;
+        height: 100%;
+    }
+
+    video {
+        width: 100%;
+    }
+</style>
+<script>
+    var messageChannel = '{{message_channel}}';
+</script>
+</head>
+<body>
+<video id="screen" width="100%" controls></video>
+<script>
+if (Hls.isSupported()) {
+    var video = document.getElementById('screen');
+    var hls = new Hls();
+    hls.on(Hls.Events.ERROR, function (event, data) {
+            if (data.fatal) {
+            switch(data.type) {
+            case Hls.ErrorTypes.NETWORK_ERROR:
+            // try to recover network error
+                console.log("fatal network error encountered, try to recover");
+                hls.startLoad();
+                break;
+            case Hls.ErrorTypes.MEDIA_ERROR:
+                console.log("fatal media error encountered, try to recover");
+                hls.recoverMediaError();
+                break;
+            default:
+            // cannot recover
+                hls.destroy();
+                break;
+            }
+            }
+        });
+    // bind them together
+    hls.attachMedia(video);
+    hls.on(Hls.Events.MEDIA_ATTACHED, function () {
+        console.log("video and hls.js are now bound together !");
+        hls.loadSource("{{stream_url}}");
+        hls.on(Hls.Events.MANIFEST_PARSED, function (event, data) {
+            console.log("manifest loaded, found " + data.levels.length + " quality level");
+            video.play();
+            video.onloadedmetadata = function() {
+                window[messageChannel].postMessage(document.body.clientWidth / video.offsetHeight);
+            };
+        });
+    });
+}
+</script>
+</body>
+</html>

assets/html/cameraView.html

@@ -0,0 +1,28 @@
+<html>
+<head>
+<style>
+    body {
+        padding: 0;
+        margin: 0;
+        widows: 100%;
+        height: 100%;
+    }
+
+    img {
+        width: 100%;
+    }
+</style>
+<script>
+    var messageChannel = '{{message_channel}}';
+    window.onload = function() {
+        var img = document.getElementById('screen');
+        if (img) {
+            window[messageChannel].postMessage(document.body.clientWidth / img.offsetHeight);
+        }
+    };
+</script>
+</head>
+<body>
+<img id="screen" src="{{stream_url}}">
+</body>
+</html>

assets/js/externalAuth.js

@@ -14,3 +14,22 @@ window.externalApp.getExternalAuth = function(options) {
         }, 500);
     }
 };
+window.externalApp.externalBus = function(message) {
+    console.log("External bus message: " + message);
+    var messageObj = JSON.parse(message);
+    if (messageObj.type == "config/get") {
+        var responseData = {
+            id: messageObj.id,
+            type: "result",
+            success: true,
+            result: {
+                hasSettingsScreen: true
+            }
+        };
+        setTimeout(function(){
+            window.externalBus(responseData);
+        }, 500);
+    } else if (messageObj.type == "config_screen/show") {
+        HAClient.postMessage('show-settings');
+    }
+};

lib/cards/alarm_panel_card.dart

@@ -0,0 +1,62 @@
+part of '../main.dart';
+
+class AlarmPanelCard extends StatelessWidget {
+  final AlarmPanelCardData card;
+
+  const AlarmPanelCard({Key key, this.card}) : super(key: key);
+
+  @override
+  Widget build(BuildContext context) {
+    if (card.entity.entity.statelessType == StatelessEntityType.missed) {
+      return EntityModel(
+        entityWrapper: card.entity,
+        child: MissedEntityWidget(),
+        handleTap: false,
+      );
+    }
+    List<Widget> body = [];
+    body.add(CardHeader(
+      name: card.name ?? "",
+      subtitle: Text("${card.entity.entity.displayState}",
+    ),
+    trailing: Row(
+      mainAxisSize: MainAxisSize.min,
+      mainAxisAlignment: MainAxisAlignment.end,
+      children: [
+        EntityIcon(
+          size: 50.0,
+        ),
+        Container(
+            width: 26.0,
+            child: IconButton(
+                padding: EdgeInsets.all(0.0),
+                alignment: Alignment.centerRight,
+                icon: Icon(MaterialDesignIcons.getIconDataFromIconName(
+                    "mdi:dots-vertical")),
+                onPressed: () => eventBus.fire(new ShowEntityPageEvent(entity: card.entity.entity))
+            )
+        )
+      ]
+    ),
+    ));
+    body.add(
+        AlarmControlPanelControlsWidget(
+          extended: true,
+          states: card.states,
+        )
+    );
+    return CardWrapper(
+        child: EntityModel(
+            entityWrapper: card.entity,
+            handleTap: null,
+            child: Column(
+                crossAxisAlignment: CrossAxisAlignment.center,
+                mainAxisSize: MainAxisSize.min,
+                children: body
+            )
+        )
+    );
+  }
+
+  
+}

lib/cards/card.class.dart

@@ -1,64 +1,510 @@
 part of '../main.dart';
 
-class HACard {
+class CardData {
-  List<EntityWrapper> entities = [];
+
-  List<HACard> childCards = [];
-  EntityWrapper linkedEntityWrapper;
-  String name;
-  String id;
   String type;
-  bool showName;
+  List<EntityWrapper> entities = [];
-  bool showState;
-  bool showEmpty;
-  int columnsCount;
-  List stateFilter;
-  List states;
   List conditions;
-  String content;
+  bool showEmpty;
+  List stateFilter;
+  bool stateColor = true;
+
+  EntityWrapper get entity => entities.isNotEmpty ? entities[0] : null;
+
+  factory CardData.parse(Map<String, dynamic> rawData) {
+    switch (rawData['type']) {
+      case CardType.ENTITIES:
+        return EntitiesCardData(rawData);
+        break;
+      case CardType.ALARM_PANEL:
+        return AlarmPanelCardData(rawData);
+        break;
+      case CardType.BUTTON:
+        return ButtonCardData(rawData);
+        break;
+      case CardType.ENTITY_BUTTON:
+        return ButtonCardData(rawData);
+        break;
+      case CardType.CONDITIONAL:
+        return CardData.parse(rawData['card']);
+        break;
+      case CardType.ENTITY_FILTER:
+        Map<String, dynamic> cardData = Map.from(rawData);
+        cardData.remove('type');
+        if (rawData.containsKey('card')) {
+          cardData.addAll(rawData['card']);
+        }
+        cardData['type'] ??= CardType.ENTITIES;
+        return CardData.parse(cardData);
+        break;
+      case CardType.GAUGE:
+        return GaugeCardData(rawData);
+        break;
+      case CardType.GLANCE:
+        return GlanceCardData(rawData);
+        break;
+      case CardType.HORIZONTAL_STACK:
+        return HorizontalStackCardData(rawData);
+        break;
+      case CardType.VERTICAL_STACK:
+        return VerticalStackCardData(rawData);
+        break;
+      case CardType.MARKDOWN:
+        return MarkdownCardData(rawData);
+        break;
+      case CardType.MEDIA_CONTROL:
+        return MediaControlCardData(rawData);
+        break;
+      default:
+        if (rawData.containsKey('entities')) {
+          return EntitiesCardData(rawData);
+        } else if (rawData.containsKey('entity')) {
+          rawData['entities'] = [rawData['entity']];
+          return EntitiesCardData(rawData);
+        }
+        return CardData(rawData);
+    }
+  }
+
+  CardData(Map<String, dynamic> rawData) {
+    type = rawData['type'] ?? CardType.ENTITIES;
+    conditions = rawData['conditions'] ?? [];
+    showEmpty = rawData['show_empty'] ?? true;
+    stateFilter = rawData['state_filter'] ?? [];
+  }
+
+  Widget buildCardWidget() {
+    return UnsupportedCard(card: this);
+  }
+
+  List<EntityWrapper> getEntitiesToShow() {
+    return entities.where((entityWrapper) {
+      if (HomeAssistant().autoUi && entityWrapper.entity.isHidden) {
+        return false;
+      }
+      List currentStateFilter;
+      if (entityWrapper.stateFilter != null && entityWrapper.stateFilter.isNotEmpty) {
+        currentStateFilter = entityWrapper.stateFilter;
+      } else {
+        currentStateFilter = stateFilter;
+      }
+      bool showByFilter = currentStateFilter.isEmpty;
+      for (var allowedState in currentStateFilter) {
+        if (allowedState is String && allowedState == entityWrapper.entity.state) {
+          showByFilter = true;
+          break;
+        } else if (allowedState is Map) {
+          try {
+            var tmpVal = allowedState['attribute'] != null ? entityWrapper.entity.getAttribute(allowedState['attribute']) : entityWrapper.entity.state;
+            var valToCompareWith = allowedState['value'];
+            var valToCompare;
+            if (valToCompareWith is! String && tmpVal is String) {
+              valToCompare = double.tryParse(tmpVal);
+            } else {
+              valToCompare = tmpVal;
+            }
+            if (valToCompare != null) {
+              bool result;
+              switch (allowedState['operator']) {
+                case '<=': { result = valToCompare <= valToCompareWith;}
+                break;
+                
+                case '<': { result = valToCompare < valToCompareWith;}
+                break;
+
+                case '>=': { result = valToCompare >= valToCompareWith;}
+                break;
+
+                case '>': { result = valToCompare > valToCompareWith;}
+                break;
+
+                case '!=': { result = valToCompare != valToCompareWith;}
+                break;
+
+                case 'regex': {
+                  RegExp regExp = RegExp(valToCompareWith.toString());
+                  result = regExp.hasMatch(valToCompare.toString());
+                }
+                break;
+
+                default: {
+                    result = valToCompare == valToCompareWith;
+                  }
+              }
+              if (result) {
+                showByFilter = true;
+                break;
+              }  
+            }
+          } catch (e) {
+            Logger.e('Error filtering ${entityWrapper.entity.entityId} by $allowedState');
+            Logger.e('$e');
+          }
+        }
+      }
+      return showByFilter;
+    }).toList();
+  }
+
+}
+
+class EntitiesCardData extends CardData {
+
+  String title;
+  String icon;
+  bool showHeaderToggle;
+
+  @override
+  Widget buildCardWidget() {
+    return EntitiesCard(card: this);
+  }
+  
+  EntitiesCardData(Map<String, dynamic> rawData) : super(rawData) {
+    //Parsing card data
+    title = rawData["title"];
+    icon = rawData['icon'];
+    stateColor = rawData['state_color'] ?? false;
+    showHeaderToggle = rawData['show_header_toggle'] ?? false;
+    //Parsing entities
+    var rawEntities = rawData["entities"] ?? [];
+    rawEntities.forEach((rawEntity) {
+      if (rawEntity is String) {
+        if (HomeAssistant().entities.isExist(rawEntity)) {
+          entities.add(EntityWrapper(entity: HomeAssistant().entities.get(rawEntity)));
+        } else {
+          entities.add(EntityWrapper(entity: Entity.missed(rawEntity)));
+        }
+      } else {
+        if (rawEntity["type"] == "divider") {
+          entities.add(EntityWrapper(entity: Entity.divider()));
+        } else if (rawEntity["type"] == "section") {
+          entities.add(EntityWrapper(entity: Entity.section(rawEntity["label"] ?? "")));
+        } else if (rawEntity["type"] == "call-service") {
+          Map uiActionData = {
+            "tap_action": {
+              "action": EntityUIAction.callService,
+              "service": rawEntity["service"],
+              "service_data": rawEntity["service_data"]
+            },
+            "hold_action": EntityUIAction.none
+          };
+          entities.add(
+            EntityWrapper(
+              entity: Entity.callService(
+                icon: rawEntity["icon"],
+                name: rawEntity["name"],
+                service: rawEntity["service"],
+                actionName: rawEntity["action_name"]
+              ),
+              stateColor: rawEntity["state_color"] ?? stateColor,
+              uiAction: EntityUIAction(rawEntityData: uiActionData)
+            )
+          );
+        } else if (rawEntity["type"] == "weblink") {
+          Map uiActionData = {
+            "tap_action": {
+              "action": EntityUIAction.navigate,
+              "service": rawEntity["url"]
+            },
+            "hold_action": EntityUIAction.none
+          };
+          entities.add(EntityWrapper(
+              entity: Entity.weblink(
+                  icon: rawEntity["icon"],
+                  name: rawEntity["name"],
+                  url: rawEntity["url"]
+              ),
+              stateColor: rawEntity["state_color"] ?? stateColor,
+              uiAction: EntityUIAction(rawEntityData: uiActionData)
+          )
+          );
+        } else if (HomeAssistant().entities.isExist(rawEntity["entity"])) {
+          Entity e = HomeAssistant().entities.get(rawEntity["entity"]);
+          entities.add(
+            EntityWrapper(
+                entity: e,
+                stateColor: rawEntity["state_color"] ?? stateColor,
+                overrideName: rawEntity["name"],
+                overrideIcon: rawEntity["icon"],
+                stateFilter: rawEntity['state_filter'] ?? [],
+                uiAction: EntityUIAction(rawEntityData: rawEntity)
+            )
+          );
+        } else {
+          entities.add(EntityWrapper(entity: Entity.missed(rawEntity["entity"])));
+        }
+      }
+    });
+  }
+
+}
+
+class AlarmPanelCardData extends CardData {
+
+  String name;
+  List<dynamic> states;
+  
+  @override
+  Widget buildCardWidget() {
+    return AlarmPanelCard(card: this);
+  }
+  
+  AlarmPanelCardData(Map<String, dynamic> rawData) : super(rawData) {
+    //Parsing card data
+    name = rawData['name'];
+    states = rawData['states'];
+    //Parsing entity
+    var entitiId = rawData["entity"];
+    if (entitiId != null && entitiId is String) {
+      if (HomeAssistant().entities.isExist(entitiId)) {
+        entities.add(EntityWrapper(
+            entity: HomeAssistant().entities.get(entitiId),
+            stateColor: true,
+            overrideName: name
+        ));
+      } else {
+        entities.add(EntityWrapper(entity: Entity.missed(entitiId)));
+      }
+    }
+    
+  }
+
+}
+
+class ButtonCardData extends CardData {
+
+  String name;
+  String icon;
+  bool showName;
+  bool showIcon;
+  double iconHeightPx = 0;
+  double iconHeightRem = 0;
+  
+  @override
+  Widget buildCardWidget() {
+    return EntityButtonCard(card: this);
+  }
+  
+  ButtonCardData(Map<String, dynamic> rawData) : super(rawData) {
+    //Parsing card data
+    name = rawData['name'];
+    icon = rawData['icon'];
+    showName = rawData['show_name'] ?? true;
+    showIcon = rawData['show_icon'] ?? true;
+    stateColor = rawData['state_color'] ?? true;
+    var rawHeight = rawData['icon_height'];
+    if (rawHeight != null && rawHeight is String) {
+      if (rawHeight.contains('px')) {
+        iconHeightPx = double.tryParse(rawHeight.replaceFirst('px', '')) ?? 0;
+      } else if (rawHeight.contains('rem')) {
+        iconHeightRem = double.tryParse(rawHeight.replaceFirst('rem', '')) ?? 0; 
+      } else if (rawHeight.contains('em')) {
+        iconHeightRem = double.tryParse(rawHeight.replaceFirst('em', '')) ?? 0;
+      }
+    }
+    //Parsing entity
+    var entitiId = rawData["entity"];
+    if (entitiId != null && entitiId is String) {
+      if (HomeAssistant().entities.isExist(entitiId)) {
+        entities.add(EntityWrapper(
+            entity: HomeAssistant().entities.get(entitiId),
+            overrideName: name,
+            overrideIcon: icon,
+            stateColor: stateColor,
+            uiAction: EntityUIAction(
+              rawEntityData: rawData
+            )
+        ));
+      } else {
+        entities.add(EntityWrapper(entity: Entity.missed(entitiId)));
+      }
+    } else if (entitiId == null) {
+      entities.add(
+        EntityWrapper(
+          entity: Entity.ghost(
+            name,
+            icon,
+          ),
+          stateColor: stateColor,
+          uiAction: EntityUIAction(
+            rawEntityData: rawData
+          )
+        )
+      );
+    }
+  }
+}
+
+class GaugeCardData extends CardData {
+
+  String name;
   String unit;
   int min;
   int max;
   Map severity;
 
-  HACard({
+  @override
-    this.name,
+  Widget buildCardWidget() {
-    this.id,
+    return GaugeCard(card: this);
-    this.linkedEntityWrapper,
-    this.columnsCount: 4,
-    this.showName: true,
-    this.showState: true,
-    this.stateFilter: const [],
-    this.showEmpty: true,
-    this.content,
-    this.states,
-    this.conditions: const [],
-    this.unit,
-    this.min,
-    this.max,
-    this.severity,
-    @required this.type
-  }) {
-    if (this.columnsCount <= 0) {
-      this.columnsCount = 4;
-    }
   }
   
-  List<EntityWrapper> getEntitiesToShow() {
+  GaugeCardData(Map<String, dynamic> rawData) : super(rawData) {
-    return entities.where((entityWrapper) {
+    //Parsing card data
-      if (!ConnectionManager().useLovelace && entityWrapper.entity.isHidden) {
+    name = rawData['name'];
-        return false;
+    unit = rawData['unit'];
+    min = rawData['min'] ?? 0;
+    max = rawData['max'] ?? 100;
+    severity = rawData['severity'];
+    //Parsing entity
+    var entitiId = rawData["entity"];
+    if (entitiId != null && entitiId is String) {
+      if (HomeAssistant().entities.isExist(entitiId)) {
+        entities.add(EntityWrapper(
+            entity: HomeAssistant().entities.get(entitiId),
+            overrideName: name
+        ));
+      } else {
+        entities.add(EntityWrapper(entity: Entity.missed(entitiId)));
       }
-      if (stateFilter.isNotEmpty) {
+    } else {
-        return stateFilter.contains(entityWrapper.entity.state);
+      entities.add(EntityWrapper(entity: Entity.missed(entitiId)));
-      }
-      return true;
-    }).toList();
     }
     
-  Widget build(BuildContext context) {
+  }
-    return CardWidget(
+
-      card: this,
+}
-    );
+
+class GlanceCardData extends CardData {
+
+  String title;
+  bool showName;
+  bool showIcon;
+  bool showState;
+  bool stateColor;
+  int columnsCount;
+
+  @override
+  Widget buildCardWidget() {
+    return GlanceCard(card: this);
+  }
+  
+  GlanceCardData(Map<String, dynamic> rawData) : super(rawData) {
+    //Parsing card data
+    title = rawData["title"];
+    showName = rawData['show_name'] ?? true;
+    showIcon = rawData['show_icon'] ?? true;
+    showState = rawData['show_state'] ?? true;
+    stateColor = rawData['state_color'] ?? true;
+    columnsCount = rawData['columns'] ?? 4;
+    //Parsing entities
+    var rawEntities = rawData["entities"] ?? [];
+    rawEntities.forEach((rawEntity) {
+      if (rawEntity is String) {
+        if (HomeAssistant().entities.isExist(rawEntity)) {
+          entities.add(EntityWrapper(entity: HomeAssistant().entities.get(rawEntity)));
+        } else {
+          entities.add(EntityWrapper(entity: Entity.missed(rawEntity)));
+        }
+      } else {
+        if (HomeAssistant().entities.isExist(rawEntity["entity"])) {
+          Entity e = HomeAssistant().entities.get(rawEntity["entity"]);
+          entities.add(
+            EntityWrapper(
+                entity: e,
+                stateColor: stateColor,
+                overrideName: rawEntity["name"],
+                overrideIcon: rawEntity["icon"],
+                stateFilter: rawEntity['state_filter'] ?? [],
+                uiAction: EntityUIAction(rawEntityData: rawEntity)
+            )
+          );
+        } else {
+          entities.add(EntityWrapper(entity: Entity.missed(rawEntity["entity"])));
+        }
+      }
+    });
+  }
+
+}
+
+class HorizontalStackCardData extends CardData {
+
+  List<CardData> childCards;
+
+  @override
+  Widget buildCardWidget() {
+    return HorizontalStackCard(card: this);
+  }
+  
+  HorizontalStackCardData(Map<String, dynamic> rawData) : super(rawData) {
+    if (rawData.containsKey('cards')) {
+      childCards = rawData['cards'].map<CardData>((childCard) {
+        return CardData.parse(childCard);
+      }).toList();
+    } else {
+      childCards = [];
+    }
+  }
+
+}
+
+class VerticalStackCardData extends CardData {
+
+  List<CardData> childCards;
+
+  @override
+  Widget buildCardWidget() {
+    return VerticalStackCard(card: this);
+  }
+  
+  VerticalStackCardData(Map<String, dynamic> rawData) : super(rawData) {
+    if (rawData.containsKey('cards')) {
+      childCards = rawData['cards'].map<CardData>((childCard) {
+        return CardData.parse(childCard);
+      }).toList();
+    } else {
+      childCards = [];
+    }
+  }
+
+}
+
+class MarkdownCardData extends CardData {
+
+  String title;
+  String content;
+
+  @override
+  Widget buildCardWidget() {
+    return MarkdownCard(card: this);
+  }
+  
+  MarkdownCardData(Map<String, dynamic> rawData) : super(rawData) {
+    //Parsing card data
+    title = rawData['title'];
+    content = rawData['content'];
+  }
+
+}
+
+class MediaControlCardData extends CardData {
+
+  @override
+  Widget buildCardWidget() {
+    return MediaControlsCard(card: this);
+  }
+
+  MediaControlCardData(Map<String, dynamic> rawData) : super(rawData) {
+    var entitiId = rawData["entity"];
+    if (entitiId != null && entitiId is String) {
+      if (HomeAssistant().entities.isExist(entitiId)) {
+        entities.add(EntityWrapper(
+            entity: HomeAssistant().entities.get(entitiId),
+        ));
+      } else {
+        entities.add(EntityWrapper(entity: Entity.missed(entitiId)));
+      }
+    }
   }
 
 }

lib/cards/card_widget.dart

@@ -1,361 +0,0 @@
-part of '../main.dart';
-
-class CardWidget extends StatelessWidget {
-
-  final HACard card;
-
-  const CardWidget({
-    Key key,
-    this.card
-  }) : super(key: key);
-
-  @override
-  Widget build(BuildContext context) {
-    if (card.linkedEntityWrapper!= null) {
-      if (card.linkedEntityWrapper.entity.isHidden) {
-        return Container(width: 0.0, height: 0.0,);
-      }
-      if (card.linkedEntityWrapper.entity.statelessType == StatelessEntityType.MISSED) {
-        return EntityModel(
-          entityWrapper: card.linkedEntityWrapper,
-          child: MissedEntityWidget(),
-          handleTap: false,
-        );
-      }
-    }
-
-    if (card.conditions.isNotEmpty) {
-      bool showCardByConditions = true;
-      for (var condition in card.conditions) {
-        Entity conditionEntity = HomeAssistant().entities.get(condition['entity']);
-        if (conditionEntity != null &&
-            ((condition['state'] != null && conditionEntity.state != condition['state']) ||
-            (condition['state_not'] != null && conditionEntity.state == condition['state_not']))
-          ) {
-          showCardByConditions = false;
-          break;
-        }
-      }
-      if (!showCardByConditions) {
-        return Container(width: 0.0, height: 0.0,);
-      }
-    }
-
-    switch (card.type) {
-
-      case CardType.ENTITIES: {
-        return _buildEntitiesCard(context);
-      }
-
-      case CardType.GLANCE: {
-        return _buildGlanceCard(context);
-      }
-
-      case CardType.MEDIA_CONTROL: {
-        return _buildMediaControlsCard(context);
-      }
-
-      case CardType.ENTITY_BUTTON: {
-        return _buildEntityButtonCard(context);
-      }
-
-      case CardType.GAUGE: {
-        return _buildGaugeCard(context);
-      }
-
-/*      case CardType.LIGHT: {
-        return _buildLightCard(context);
-      }*/
-
-      case CardType.MARKDOWN: {
-        return _buildMarkdownCard(context);
-      }
-
-      case CardType.ALARM_PANEL: {
-        return _buildAlarmPanelCard(context);
-      }
-
-      case CardType.HORIZONTAL_STACK: {
-        if (card.childCards.isNotEmpty) {
-          List<Widget> children = [];
-          card.childCards.forEach((card) {
-            if (card.getEntitiesToShow().isNotEmpty || card.showEmpty) {
-              children.add(
-                  Flexible(
-                    fit: FlexFit.tight,
-                    child: card.build(context),
-                  )
-              );
-            }
-          });
-          return Row(
-            mainAxisSize: MainAxisSize.max,
-            mainAxisAlignment: MainAxisAlignment.center,
-            crossAxisAlignment: CrossAxisAlignment.start,
-            children: children,
-          );
-        }
-        return Container(height: 0.0, width: 0.0,);
-      }
-
-      case CardType.VERTICAL_STACK: {
-        if (card.childCards.isNotEmpty) {
-          List<Widget> children = [];
-          card.childCards.forEach((card) {
-            children.add(
-                card.build(context)
-            );
-          });
-          return Column(
-            mainAxisSize: MainAxisSize.min,
-            mainAxisAlignment: MainAxisAlignment.start,
-            children: children,
-          );
-        }
-        return Container(height: 0.0, width: 0.0,);
-      }
-
-      default: {
-        if ((card.linkedEntityWrapper == null) && (card.entities.isNotEmpty)) {
-          return _buildEntitiesCard(context);
-        } else {
-          return _buildUnsupportedCard(context);
-        }
-      }
-
-    }
-  }
-
-  Widget _buildEntitiesCard(BuildContext context) {
-    List<EntityWrapper> entitiesToShow = card.getEntitiesToShow();
-    if (entitiesToShow.isEmpty && !card.showEmpty) {
-      return Container(height: 0.0, width: 0.0,);
-    }
-    List<Widget> body = [];
-    body.add(CardHeader(name: card.name));
-    entitiesToShow.forEach((EntityWrapper entity) {
-      body.add(
-          Padding(
-            padding: EdgeInsets.fromLTRB(0.0, 4.0, 0.0, 4.0),
-            child: EntityModel(
-                entityWrapper: entity,
-                handleTap: true,
-                child: entity.entity.buildDefaultWidget(context)
-            ),
-          ));
-    });
-    return Card(
-        child: Padding(
-          padding: EdgeInsets.only(right: Sizes.rightWidgetPadding, left: Sizes.leftWidgetPadding),
-          child: Column(mainAxisSize: MainAxisSize.min, children: body),
-        )
-    );
-  }
-
-  Widget _buildMarkdownCard(BuildContext context) {
-    if (card.content == null) {
-      return Container(height: 0.0, width: 0.0,);
-    }
-    List<Widget> body = [];
-    body.add(CardHeader(name: card.name));
-    body.add(MarkdownBody(data: card.content));
-    return Card(
-        child: Padding(
-          padding: EdgeInsets.fromLTRB(Sizes.leftWidgetPadding, Sizes.rowPadding, Sizes.rightWidgetPadding, Sizes.rowPadding),
-          child: new Column(mainAxisSize: MainAxisSize.min, children: body),
-        )
-    );
-  }
-
-  Widget _buildAlarmPanelCard(BuildContext context) {
-    List<Widget> body = [];
-    body.add(CardHeader(
-      name: card.name ?? "",
-      subtitle: Text("${card.linkedEntityWrapper.entity.displayState}",
-        style: TextStyle(
-            color: Colors.grey
-        ),
-      ),
-      trailing: Row(
-          mainAxisSize: MainAxisSize.min,
-          mainAxisAlignment: MainAxisAlignment.end,
-          children: [
-            EntityIcon(
-              size: 50.0,
-            ),
-            Container(
-                width: 26.0,
-                child: IconButton(
-                    padding: EdgeInsets.all(0.0),
-                    alignment: Alignment.centerRight,
-                    icon: Icon(MaterialDesignIcons.getIconDataFromIconName(
-                        "mdi:dots-vertical")),
-                    onPressed: () => eventBus.fire(new ShowEntityPageEvent(entity: card.linkedEntityWrapper.entity))
-                )
-            )
-          ]
-      ),
-    ));
-    body.add(
-        AlarmControlPanelControlsWidget(
-          extended: true,
-          states: card.states,
-        )
-    );
-    return Card(
-        child: EntityModel(
-            entityWrapper: card.linkedEntityWrapper,
-            handleTap: null,
-            child: Column(
-                crossAxisAlignment: CrossAxisAlignment.center,
-                mainAxisSize: MainAxisSize.min,
-                children: body
-            )
-        )
-    );
-  }
-
-  Widget _buildGlanceCard(BuildContext context) {
-    List<EntityWrapper> entitiesToShow = card.getEntitiesToShow();
-    if (entitiesToShow.isEmpty && !card.showEmpty) {
-      return Container(height: 0.0, width: 0.0,);
-    }
-    List<Widget> rows = [];
-    rows.add(CardHeader(name: card.name));
-
-    int columnsCount = entitiesToShow.length >= card.columnsCount ? card.columnsCount : entitiesToShow.length;
-
-    rows.add(
-        Padding(
-          padding: EdgeInsets.only(bottom: Sizes.rowPadding, top: Sizes.rowPadding),
-          child: FractionallySizedBox(
-            widthFactor: 1,
-            child: LayoutBuilder(
-                builder: (BuildContext context, BoxConstraints constraints) {
-                  List<Widget> buttons = [];
-                  double buttonWidth = constraints.maxWidth / columnsCount;
-                  entitiesToShow.forEach((EntityWrapper entity) {
-                    buttons.add(
-                        SizedBox(
-                          width: buttonWidth,
-                          child: EntityModel(
-                              entityWrapper: entity,
-                              child: GlanceCardEntityContainer(
-                                showName: card.showName,
-                                showState: card.showState,
-                              ),
-                              handleTap: true
-                          ),
-                        )
-                    );
-                  });
-                  return Wrap(
-                    //spacing: 5.0,
-                    //alignment: WrapAlignment.spaceEvenly,
-                    runSpacing: Sizes.doubleRowPadding,
-                    children: buttons,
-                  );
-                }
-            ),
-          ),
-        )
-    );
-
-    return Card(
-        child: Column(
-            mainAxisSize: MainAxisSize.min,
-            children: rows
-        )
-    );
-  }
-
-  Widget _buildMediaControlsCard(BuildContext context) {
-    return Card(
-        child: EntityModel(
-            entityWrapper: card.linkedEntityWrapper,
-            handleTap: null,
-            child: MediaPlayerWidget()
-        )
-    );
-  }
-
-  Widget _buildEntityButtonCard(BuildContext context) {
-    card.linkedEntityWrapper.displayName = card.name?.toUpperCase() ??
-        card.linkedEntityWrapper.displayName.toUpperCase();
-    return Card(
-        child: EntityModel(
-            entityWrapper: card.linkedEntityWrapper,
-            child: EntityButtonCardBody(),
-            handleTap: true
-        )
-    );
-  }
-
-  Widget _buildGaugeCard(BuildContext context) {
-    card.linkedEntityWrapper.displayName = card.name ??
-        card.linkedEntityWrapper.displayName;
-    card.linkedEntityWrapper.unitOfMeasurement = card.unit ??
-        card.linkedEntityWrapper.unitOfMeasurement;
-    return Card(
-        child: EntityModel(
-            entityWrapper: card.linkedEntityWrapper,
-            child: GaugeCardBody(
-              min: card.min,
-              max: card.max,
-              severity: card.severity,
-            ),
-            handleTap: true
-        )
-    );
-  }
-
-  Widget _buildLightCard(BuildContext context) {
-    card.linkedEntityWrapper.displayName = card.name ??
-        card.linkedEntityWrapper.displayName;
-    return Card(
-        child: EntityModel(
-            entityWrapper: card.linkedEntityWrapper,
-            child: LightCardBody(
-              min: card.min,
-              max: card.max,
-              severity: card.severity,
-            ),
-            handleTap: true
-        )
-    );
-  }
-
-  Widget _buildUnsupportedCard(BuildContext context) {
-    List<Widget> body = [];
-    body.add(CardHeader(name: card.name ?? ""));
-    List<Widget> result = [];
-    if (card.linkedEntityWrapper != null) {
-      result.addAll(<Widget>[
-        Padding(
-          padding: EdgeInsets.fromLTRB(0.0, Sizes.rowPadding, 0.0, Sizes.rowPadding),
-          child: EntityModel(
-              entityWrapper: card.linkedEntityWrapper,
-              handleTap: true,
-              child: card.linkedEntityWrapper.entity.buildDefaultWidget(context)
-          ),
-        )
-      ]);
-    } else {
-      result.addAll(<Widget>[
-        Padding(
-          padding: EdgeInsets.fromLTRB(Sizes.leftWidgetPadding, Sizes.rowPadding, Sizes.rightWidgetPadding, Sizes.rowPadding),
-          child: Text("'${card.type}' card is not supported yet"),
-        ),
-      ]);
-    }
-    body.addAll(result);
-    return Card(
-        child: new Column(
-            crossAxisAlignment: CrossAxisAlignment.start,
-            mainAxisSize: MainAxisSize.min,
-            children: body
-        )
-    );
-  }
-
-}

lib/cards/entities_card.dart

@@ -0,0 +1,79 @@
+part of '../main.dart';
+
+class EntitiesCard extends StatelessWidget {
+  final EntitiesCardData card;
+
+  const EntitiesCard({Key key, this.card}) : super(key: key);
+
+  @override
+  Widget build(BuildContext context) {
+    List<EntityWrapper> entitiesToShow = card.getEntitiesToShow();
+    if (entitiesToShow.isEmpty && !card.showEmpty) {
+      return Container(height: 0.0, width: 0.0,);
+    }
+    List<Widget> body = [];
+    Widget headerSwitch;
+    if (card.showHeaderToggle) {
+      bool headerToggleVal = entitiesToShow.any((EntityWrapper en){ return en.entity.state == EntityState.on; });
+      List<String> entitiesToToggle = entitiesToShow.where((EntityWrapper enw) {
+        return <String>["switch", "light", "automation", "input_boolean"].contains(enw.entity.domain);
+      }).map((EntityWrapper en) {
+          return en.entity.entityId;
+      }).toList();
+      headerSwitch = Switch(
+        value: headerToggleVal,
+        onChanged: (val) {
+          if (entitiesToToggle.isNotEmpty) {
+            ConnectionManager().callService(
+              domain: "homeassistant",
+              service: val ? "turn_on" : "turn_off",
+              entityId: entitiesToToggle
+            );
+          }
+        },
+      );
+    }
+    body.add(
+      CardHeader(
+        name: card.title,
+        trailing: headerSwitch,
+        emptyPadding: Sizes.rowPadding,
+        leading: card.icon != null ? Icon(
+          MaterialDesignIcons.getIconDataFromIconName(card.icon),
+          size: Sizes.iconSize,
+          color: Theme.of(context).textTheme.headline.color
+        ) : null,
+      )
+    );
+    body.addAll(
+      entitiesToShow.map((EntityWrapper entity) {
+        return Padding(
+            padding: EdgeInsets.fromLTRB(0.0, 4.0, 0.0, 4.0),
+            child: EntityModel(
+                entityWrapper: entity,
+                handleTap: true,
+                child: entity.entity.buildDefaultWidget(context)
+            ),
+          );
+      })  
+    );
+    return CardWrapper(
+        child: Padding(
+          padding: EdgeInsets.only(
+            right: Sizes.rightWidgetPadding,
+            left: Sizes.leftWidgetPadding,
+            bottom: Sizes.rowPadding,
+          ),
+          child: Center(
+            child: Column(
+              mainAxisSize: MainAxisSize.min,
+              mainAxisAlignment: MainAxisAlignment.start,
+              children: body
+            )
+          ),
+        )
+    );
+  }
+
+  
+}

lib/cards/entity_button_card.dart

@@ -0,0 +1,93 @@
+part of '../main.dart';
+
+class EntityButtonCard extends StatelessWidget {
+
+  final ButtonCardData card;
+
+  EntityButtonCard({
+    Key key, this.card
+  }) : super(key: key);
+
+  @override
+  Widget build(BuildContext context) {
+    EntityWrapper entityWrapper = card.entity;
+    if (entityWrapper.entity.statelessType == StatelessEntityType.missed) {
+      return EntityModel(
+        entityWrapper: card.entity,
+        child: MissedEntityWidget(),
+        handleTap: false,
+      );
+    } else if (entityWrapper.entity.statelessType != StatelessEntityType.ghost && entityWrapper.entity.statelessType != StatelessEntityType.none) {
+      return Container(width: 0.0, height: 0.0,);
+    }
+    
+    double iconSize = math.max(card.iconHeightPx, card.iconHeightRem * Theme.of(context).textTheme.body1.fontSize);
+    
+    Widget buttonIcon;
+    if (!card.showIcon) {
+      buttonIcon = Container(height: Sizes.rowPadding, width: 10);
+    } else if (iconSize > 0) {
+      buttonIcon = SizedBox(
+        height: iconSize,
+        child: FractionallySizedBox(
+          widthFactor: 0.5,
+          child: FittedBox(
+            fit: BoxFit.contain,
+            child: EntityIcon(
+              //padding: EdgeInsets.only(top: 6),
+            ),
+          )
+        ),
+      );
+    } else {
+      buttonIcon = AspectRatio(
+        aspectRatio: 2,
+        child: FractionallySizedBox(
+          widthFactor: 0.5,
+          child: FittedBox(
+            fit: BoxFit.fitWidth,
+            child: EntityIcon(
+              //padding: EdgeInsets.only(top: 6),
+            ),
+          )
+        ),
+      );
+    }
+
+    return CardWrapper(
+      child: EntityModel(
+        entityWrapper: card.entity,
+        child: InkWell(
+          onTap: () => entityWrapper.handleTap(),
+          onLongPress: () => entityWrapper.handleHold(),
+          onDoubleTap: () => entityWrapper.handleDoubleTap(),
+          child: Center(
+            child: Column(
+              mainAxisSize: MainAxisSize.min,
+              crossAxisAlignment: CrossAxisAlignment.stretch,
+              children: <Widget>[
+                buttonIcon,
+                _buildName(context)
+              ],
+            )
+          ),
+        ),
+        handleTap: true
+      )
+    );
+  }
+
+  Widget _buildName(BuildContext context) {
+    if (card.showName) {
+      return EntityName(
+        padding: EdgeInsets.fromLTRB(Sizes.buttonPadding, 0.0, Sizes.buttonPadding, Sizes.rowPadding),
+        textOverflow: TextOverflow.ellipsis,
+        maxLines: 3,
+        textStyle: Theme.of(context).textTheme.subhead,
+        wordsWrap: true,
+        textAlign: TextAlign.center
+      );
+    }
+    return Container(width: 0, height: 0);
+  }
+}

lib/cards/gauge_card.dart

@@ -0,0 +1,198 @@
+part of '../main.dart';
+
+class GaugeCard extends StatelessWidget {
+
+  final GaugeCardData card;
+
+  GaugeCard({Key key, this.card}) : super(key: key);
+
+  @override
+  Widget build(BuildContext context) {
+    EntityWrapper entityWrapper = card.entity;
+    if (entityWrapper.entity.statelessType == StatelessEntityType.missed) {
+      return EntityModel(
+        entityWrapper: card.entity,
+        child: MissedEntityWidget(),
+        handleTap: false,
+      );
+    }
+    entityWrapper.overrideName = card.name ??
+        entityWrapper.displayName;
+    entityWrapper.unitOfMeasurementOverride = card.unit ??
+        entityWrapper.unitOfMeasurement;
+    double fixedValue;
+    double value = entityWrapper.entity.doubleState;
+    if (value > card.max) {
+      fixedValue = card.max.toDouble();
+    } else if (value < card.min) {
+      fixedValue = card.min.toDouble();
+    } else {
+      fixedValue = value;
+    }
+    
+    List<GaugeRange> ranges;
+    Color currentColor;
+    if (card.severity != null && card.severity["green"] is int && card.severity["red"] is int && card.severity["yellow"] is int) {
+      List<RangeContainer> rangesList = <RangeContainer>[
+        RangeContainer(card.severity["green"], HAClientTheme().getGreenGaugeColor()),
+        RangeContainer(card.severity["red"], HAClientTheme().getRedGaugeColor()),
+        RangeContainer(card.severity["yellow"], HAClientTheme().getYellowGaugeColor())
+      ];
+      rangesList.sort((current, next) {
+        if (current.startFrom > next.startFrom) {
+          return 1;
+        }
+        if (current.startFrom < next.startFrom) {
+          return -1;
+        }
+        return 0;
+      });
+
+      if (fixedValue < rangesList[1].startFrom) {
+        currentColor = rangesList[0].color;
+      } else if (fixedValue < rangesList[2].startFrom && fixedValue >= rangesList[1].startFrom) {
+        currentColor = rangesList[1].color;
+      } else {
+        currentColor = rangesList[2].color;
+      }
+
+      ranges = [
+        GaugeRange(
+          startValue: rangesList[0].startFrom.toDouble(),
+          endValue: rangesList[1].startFrom.toDouble(),
+          color: rangesList[0].color.withOpacity(0.1),
+          sizeUnit: GaugeSizeUnit.factor,
+          endWidth: 0.3,
+          startWidth: 0.3
+        ),
+        GaugeRange(
+          startValue: rangesList[1].startFrom.toDouble(),
+          endValue: rangesList[2].startFrom.toDouble(),
+          color: rangesList[1].color.withOpacity(0.1),
+          sizeUnit: GaugeSizeUnit.factor,
+          endWidth: 0.3,
+          startWidth: 0.3
+        ),
+        GaugeRange(
+          startValue: rangesList[2].startFrom.toDouble(),
+          endValue: card.max.toDouble(),
+          color: rangesList[2].color.withOpacity(0.1),
+          sizeUnit: GaugeSizeUnit.factor,
+          endWidth: 0.3,
+          startWidth: 0.3
+        )
+      ];
+    }
+    if (ranges == null) {
+      currentColor = Theme.of(context).primaryColorDark;
+      ranges = <GaugeRange>[
+        GaugeRange(
+          startValue: card.min.toDouble(),
+          endValue: card.max.toDouble(),
+          color: Theme.of(context).primaryColorDark.withOpacity(0.1),
+          sizeUnit: GaugeSizeUnit.factor,
+          endWidth: 0.3,
+          startWidth: 0.3,
+        )
+      ];
+    }
+
+    return CardWrapper(
+      padding: EdgeInsets.all(4),
+      child: EntityModel(
+        entityWrapper: entityWrapper,
+        child: InkWell(
+          onTap: () => entityWrapper.handleTap(),
+          onLongPress: () => entityWrapper.handleHold(),
+          onDoubleTap: () => entityWrapper.handleDoubleTap(),
+          child: AspectRatio(
+            aspectRatio: 1.8,
+            child: Stack(
+              alignment: Alignment.bottomCenter,
+              children: <Widget>[
+                SfRadialGauge(
+                  axes: <RadialAxis>[
+                    RadialAxis(
+                      maximum: card.max.toDouble(),
+                      minimum: card.min.toDouble(),
+                      showLabels: false,
+                      useRangeColorForAxis: true,
+                      showTicks: false,
+                      canScaleToFit: true,
+                      ranges: ranges,
+                      axisLineStyle: AxisLineStyle(
+                        thickness: 0.3,
+                        thicknessUnit: GaugeSizeUnit.factor,
+                        color: Colors.transparent
+                      ),
+                      startAngle: 180,
+                      endAngle: 0,
+                      pointers: <GaugePointer>[
+                        RangePointer(
+                          value: fixedValue,
+                          sizeUnit: GaugeSizeUnit.factor,
+                          width: 0.3,
+                          color: currentColor,
+                          enableAnimation: true,
+                          animationType: AnimationType.bounceOut,
+                        )
+                      ]
+                    )
+                  ],
+                ),
+                Column(
+                  mainAxisSize: MainAxisSize.max,
+                  crossAxisAlignment: CrossAxisAlignment.center,
+                  children: <Widget>[
+                    Flexible(
+                      flex: 8,
+                      fit: FlexFit.tight,
+                      child: Container()
+                    ),
+                    Flexible(
+                      flex: 6,
+                      fit: FlexFit.tight,
+                      child: FractionallySizedBox(
+                        widthFactor: 0.4,
+                        child: FittedBox(
+                          fit: BoxFit.contain,
+                          alignment: Alignment.bottomCenter,
+                          child: SimpleEntityState(
+                            padding: EdgeInsets.all(0),
+                            expanded: false,
+                            maxLines: 1,
+                            textAlign: TextAlign.center
+                          ),
+                        )
+                      )
+                    ),
+                    Flexible(
+                      flex: 3,
+                      fit: FlexFit.tight,
+                      child: FittedBox(
+                        fit: BoxFit.contain,
+                        child: EntityName(
+                          padding: EdgeInsets.all(0),
+                          textStyle: Theme.of(context).textTheme.subhead
+                        ),
+                      )
+                    ),  
+                  ],
+                )
+              ],
+            )
+          ),
+        ),
+        handleTap: true
+      )
+    );
+  }
+  
+}
+
+class RangeContainer {
+  final int startFrom;
+  Color color;
+
+  RangeContainer(this.startFrom, this.color);
+}

lib/cards/glance_card.dart

@@ -0,0 +1,120 @@
+part of '../main.dart';
+
+class GlanceCard extends StatelessWidget {
+  final GlanceCardData card;
+
+  const GlanceCard({Key key, this.card}) : super(key: key);
+
+  @override
+  Widget build(BuildContext context) {
+    List<EntityWrapper> entitiesToShow = card.getEntitiesToShow();
+    if (entitiesToShow.isEmpty && !card.showEmpty) {
+      return Container(height: 0.0, width: 0.0,);
+    }
+    int length = entitiesToShow.length;
+    int rowsCount;
+    int columnsCount;
+    if (length == 0) {
+      columnsCount = 0;
+      rowsCount = 0;
+    } else {
+      columnsCount = length >= card.columnsCount ? card.columnsCount : entitiesToShow.length;
+      rowsCount = (length / columnsCount).round();
+    }
+    List<TableRow> rows = [];
+    for (int i = 0; i < rowsCount; i++) {
+      int start = i*columnsCount;
+      int end = start + math.min(columnsCount, length - start);
+      List<Widget> rowChildren = [];
+      rowChildren.addAll(entitiesToShow.sublist(
+          start, end
+        ).map(
+          (EntityWrapper entity){
+            return EntityModel(
+              entityWrapper: entity,
+              child: _buildEntityContainer(context, entity),
+              handleTap: true
+            );
+          }
+        ).toList()
+      );
+      while (rowChildren.length < columnsCount) {
+        rowChildren.add(
+          Container()
+        );
+      }
+      rows.add(
+        TableRow(
+          children: rowChildren
+        )
+      );
+    }
+    return CardWrapper(
+      child: Column(
+        mainAxisSize: MainAxisSize.min,
+        children: <Widget>[
+          CardHeader(name: card.title),
+          Padding(
+            padding: EdgeInsets.symmetric(vertical: Sizes.rowPadding),
+            child: Table(
+              children: rows
+            )
+          )
+        ],
+      )
+    );
+  }
+
+  Widget _buildEntityContainer(BuildContext context, EntityWrapper entityWrapper) {
+    if (entityWrapper.entity.statelessType == StatelessEntityType.missed) {
+      return MissedEntityWidget();
+    } else if (entityWrapper.entity.statelessType != StatelessEntityType.none) {
+      return Container(width: 0.0, height: 0.0,);
+    }
+    List<Widget> result = [];
+    if (card.showName) {
+      result.add(_buildName(context));
+    }
+    result.add(
+        EntityIcon(
+          padding: EdgeInsets.all(0.0),
+          size: Sizes.iconSize,
+        )
+    );
+    if (card.showState) {
+      result.add(_buildState());
+    }
+
+    return Center(
+      child: InkResponse(
+        child: Column(
+          mainAxisSize: MainAxisSize.min,
+          children: result,
+        ),
+        onTap: () => entityWrapper.handleTap(),
+        onLongPress: () => entityWrapper.handleHold(),
+        onDoubleTap: () => entityWrapper.handleDoubleTap(),
+      ),
+    );
+  }
+
+  Widget _buildName(BuildContext context) {
+    return EntityName(
+      padding: EdgeInsets.only(bottom: Sizes.rowPadding),
+      textOverflow: TextOverflow.ellipsis,
+      wordsWrap: false,
+      textAlign: TextAlign.center,
+      textStyle: Theme.of(context).textTheme.body1,
+    );
+  }
+
+  Widget _buildState() {
+    return SimpleEntityState(
+      textAlign: TextAlign.center,
+      expanded: false,
+      maxLines: 1,
+      padding: EdgeInsets.only(top: Sizes.rowPadding),
+    );
+  }
+
+}

lib/cards/horizontal_srack_card.dart

@@ -0,0 +1,30 @@
+part of '../main.dart';
+
+class HorizontalStackCard extends StatelessWidget {
+  final HorizontalStackCardData card;
+
+  const HorizontalStackCard({Key key, this.card}) : super(key: key);
+
+  @override
+  Widget build(BuildContext context) {
+    if (card.childCards.isNotEmpty) {
+      List<Widget> children = [];
+      children = card.childCards.map((childCard) => Flexible(
+          fit: FlexFit.tight,
+          child: childCard.buildCardWidget()
+        )
+      ).toList();
+      return IntrinsicHeight(
+        child: Row(
+          mainAxisSize: MainAxisSize.max,
+          mainAxisAlignment: MainAxisAlignment.center,
+          crossAxisAlignment: CrossAxisAlignment.stretch,
+          children: children,
+        ),
+      );
+    }
+    return Container(height: 0.0, width: 0.0,);
+  }
+
+  
+}

lib/cards/markdown_card.dart

@@ -0,0 +1,33 @@
+part of '../main.dart';
+
+class MarkdownCard extends StatelessWidget {
+  final MarkdownCardData card;
+
+  const MarkdownCard({Key key, this.card}) : super(key: key);
+
+  @override
+  Widget build(BuildContext context) {
+    if (card.content == null) {
+      return Container(height: 0.0, width: 0.0,);
+    } else if (card.content == '***') {
+      return Container(height: Sizes.rowPadding, width: 0.0,);
+    }
+    return CardWrapper(
+        child: Padding(
+          padding: EdgeInsets.fromLTRB(Sizes.leftWidgetPadding, Sizes.rowPadding, Sizes.rightWidgetPadding, Sizes.rowPadding),
+          child: Column(
+            mainAxisSize: MainAxisSize.min,
+            crossAxisAlignment: CrossAxisAlignment.stretch,
+            children: <Widget>[
+              CardHeader(name: card.title),
+              MarkdownBody(
+                data: card.content,
+              )
+            ],
+          ),
+        )
+    );
+  }
+
+  
+}

lib/cards/media_control_card.dart

@@ -0,0 +1,27 @@
+part of '../main.dart';
+
+class MediaControlsCard extends StatelessWidget {
+  final MediaControlCardData card;
+
+  const MediaControlsCard({Key key, this.card}) : super(key: key);
+
+  @override
+  Widget build(BuildContext context) {
+    if (card.entity.entity.statelessType == StatelessEntityType.missed) {
+      return EntityModel(
+        entityWrapper: card.entity,
+        child: MissedEntityWidget(),
+        handleTap: false,
+      );
+    }
+    return CardWrapper(
+        child: EntityModel(
+            entityWrapper: card.entity,
+            handleTap: null,
+            child: MediaPlayerWidget()
+        )
+    );
+  }
+
+  
+}

lib/cards/unsupported_card.dart

@@ -0,0 +1,17 @@
+part of '../main.dart';
+
+class UnsupportedCard extends StatelessWidget {
+  final CardData card;
+
+  const UnsupportedCard({Key key, this.card}) : super(key: key);
+
+  @override
+  Widget build(BuildContext context) {
+    return CardWrapper(
+      child: Padding(
+        padding: EdgeInsets.fromLTRB(Sizes.leftWidgetPadding, Sizes.rowPadding, Sizes.rightWidgetPadding, Sizes.rowPadding),
+        child: Text("'${card.type}' card is not supported yet"),
+      )
+    );
+  }  
+}

lib/cards/vertical_stack_card.dart

@@ -0,0 +1,23 @@
+part of '../main.dart';
+
+class VerticalStackCard extends StatelessWidget {
+  final VerticalStackCardData card;
+
+  const VerticalStackCard({Key key, this.card}) : super(key: key);
+
+  @override
+  Widget build(BuildContext context) {
+    if (card.childCards.isNotEmpty) {
+      return Column(
+        mainAxisSize: MainAxisSize.min,
+        mainAxisAlignment: MainAxisAlignment.start,
+        children: card.childCards.map<Widget>(
+          (childCard) => childCard.buildCardWidget()
+        ).toList(),
+      );
+    }
+    return Container(height: 0.0, width: 0.0,);
+  }
+
+  
+}

lib/cards/widgets/card_header.widget.dart

@@ -4,9 +4,11 @@ class CardHeader extends StatelessWidget {
 
   final String name;
   final Widget trailing;
+  final Widget leading;
   final Widget subtitle;
+  final double emptyPadding;
 
-  const CardHeader({Key key, this.name, this.trailing, this.subtitle}) : super(key: key);
+  const CardHeader({Key key, this.name, this.leading, this.emptyPadding: 0, this.trailing, this.subtitle}) : super(key: key);
 
   @override
   Widget build(BuildContext context) {
@@ -14,14 +16,15 @@ class CardHeader extends StatelessWidget {
     if ((name != null) && (name.trim().length > 0)) {
       result = new ListTile(
         trailing: trailing,
+        leading: leading,
         subtitle: subtitle,
         title: Text("$name",
             textAlign: TextAlign.left,
             overflow: TextOverflow.ellipsis,
-            style: new TextStyle(fontWeight: FontWeight.bold, fontSize: Sizes.largeFontSize)),
+            style: Theme.of(context).textTheme.headline),
       );
     } else {
-      result = new Container(width: 0.0, height: 0.0);
+      result = new Container(width: 0.0, height: emptyPadding);
     }
     return result;
   }

lib/cards/widgets/card_wrapper.widget.dart

@@ -0,0 +1,21 @@
+part of '../../main.dart';
+
+class CardWrapper extends StatelessWidget {
+  
+  final Widget child;
+  final EdgeInsets padding;
+
+  const CardWrapper({Key key, this.child, this.padding: const EdgeInsets.all(0)}) : super(key: key);
+
+  @override
+  Widget build(BuildContext context) {
+    return Card(
+      child: Padding(
+        padding: padding,
+        child: child
+      ),
+    );
+  }
+
+
+}

lib/cards/widgets/entity_button_card_body.widget.dart

@@ -1,51 +0,0 @@
-part of '../../main.dart';
-
-class EntityButtonCardBody extends StatelessWidget {
-
-  EntityButtonCardBody({
-    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: FractionallySizedBox(
-        widthFactor: 1,
-        child: Column(
-          children: <Widget>[
-            LayoutBuilder(
-                builder: (BuildContext context, BoxConstraints constraints) {
-                  return EntityIcon(
-                    padding: EdgeInsets.fromLTRB(2.0, 6.0, 2.0, 2.0),
-                    size: constraints.maxWidth / 2.5,
-                  );
-                }
-            ),
-            _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/cards/widgets/gauge_card_body.dart

@@ -1,153 +0,0 @@
-part of '../../main.dart';
-
-class GaugeCardBody extends StatefulWidget {
-
-  final int min;
-  final int max;
-  final Map severity;
-
-  GaugeCardBody({Key key, this.min, this.max, this.severity}) : super(key: key);
-
-  @override
-  _GaugeCardBodyState createState() => _GaugeCardBodyState();
-}
-
-class _GaugeCardBodyState extends State<GaugeCardBody> {
-
-  List<charts.Series> seriesList;
-
-  List<charts.Series<GaugeSegment, String>> _createData(double value) {
-    double fixedValue;
-    if (value > widget.max) {
-      fixedValue = widget.max.toDouble();
-    } else if (value < widget.min) {
-      fixedValue = widget.min.toDouble();
-    } else {
-      fixedValue = value;
-    }
-    double toShow = ((fixedValue - widget.min) / (widget.max - widget.min)) * 100;
-    Color mainColor;
-    if (widget.severity != null) {
-      if (widget.severity["red"] is int && fixedValue >= widget.severity["red"]) {
-        mainColor = Colors.red;
-      } else if (widget.severity["yellow"] is int && fixedValue >= widget.severity["yellow"]) {
-        mainColor = Colors.amber;
-      } else {
-        mainColor = Colors.green;
-      }
-    } else {
-      mainColor = Colors.green;
-    }
-    final data = [
-      GaugeSegment('Main', toShow, mainColor),
-      GaugeSegment('Rest', 100 - toShow, Colors.black45),
-    ];
-
-    return [
-      charts.Series<GaugeSegment, String>(
-        id: 'Segments',
-        domainFn: (GaugeSegment segment, _) => segment.segment,
-        measureFn: (GaugeSegment segment, _) => segment.value,
-        colorFn: (GaugeSegment segment, _) => segment.color,
-        // Set a label accessor to control the text of the arc label.
-        labelAccessorFn: (GaugeSegment segment, _) =>
-        segment.segment == 'Main' ? '${segment.value}' : null,
-        data: data,
-      )
-    ];
-  }
-
-  @override
-  Widget build(BuildContext context) {
-    EntityWrapper entityWrapper = EntityModel.of(context).entityWrapper;
-
-    return InkWell(
-      onTap: () => entityWrapper.handleTap(),
-      onLongPress: () => entityWrapper.handleHold(),
-      child: AspectRatio(
-          aspectRatio: 1.5,
-          child: Stack(
-              fit: StackFit.expand,
-              overflow: Overflow.clip,
-              children: [
-                LayoutBuilder(
-                    builder: (BuildContext context, BoxConstraints constraints) {
-                      double verticalOffset;
-                      if(constraints.maxWidth > 150.0) {
-                        verticalOffset = 0.2;
-                      } else if (constraints.maxWidth > 100.0)  {
-                        verticalOffset = 0.3;
-                      } else {
-                        verticalOffset = 0.3;
-                      }
-                      return FractionallySizedBox(
-                        heightFactor: 2,
-                        widthFactor: 1,
-                        alignment: FractionalOffset(0,verticalOffset),
-                        child: charts.PieChart(
-                          _createData(entityWrapper.entity.doubleState),
-                          animate: false,
-                          defaultRenderer: charts.ArcRendererConfig(
-                            arcRatio: 0.4,
-                            startAngle: pi,
-                            arcLength: pi,
-                          ),
-                        ),
-                      );
-                    }
-                ),
-                Align(
-                  alignment: Alignment.bottomCenter,
-                  child: LayoutBuilder(
-                      builder: (BuildContext context, BoxConstraints constraints) {
-                        double fontSize = constraints.maxHeight / 7;
-                        return Padding(
-                          padding: EdgeInsets.only(bottom: 2*fontSize),
-                          child: SimpleEntityState(
-                            //textAlign: TextAlign.center,
-                            expanded: false,
-                            maxLines: 1,
-                            bold: true,
-                            textAlign: TextAlign.center,
-                            padding: EdgeInsets.all(0.0),
-                            fontSize: fontSize,
-                            //padding: EdgeInsets.only(top: Sizes.rowPadding),
-                          ),
-                        );
-                      }
-                  ),
-                ),
-                Align(
-                  alignment: Alignment.bottomCenter,
-                  child: LayoutBuilder(
-                      builder: (BuildContext context, BoxConstraints constraints) {
-                        double fontSize = constraints.maxHeight / 7;
-                        return Padding(
-                          padding: EdgeInsets.only(bottom: fontSize),
-                          child: EntityName(
-                            fontSize: fontSize,
-                            maxLines: 1,
-                            padding: EdgeInsets.all(0.0),
-                            textAlign: TextAlign.center,
-                            textOverflow: TextOverflow.ellipsis,
-                          ),
-                        );
-                      }
-                  ),
-                )
-              ]
-          )
-      ),
-    );
-  }
-}
-
-class GaugeSegment {
-  final String segment;
-  final double value;
-  final charts.Color color;
-
-  GaugeSegment(this.segment, this.value, Color color)
-      : this.color = charts.Color(
-      r: color.red, g: color.green, b: color.blue, a: color.alpha);
-}

lib/cards/widgets/glance_card_entity_container.dart

@@ -1,85 +0,0 @@
-part of '../../main.dart';
-
-class GlanceCardEntityContainer extends StatelessWidget {
-
-  final bool showName;
-  final bool showState;
-  final bool nameInTheBottom;
-  final double iconSize;
-  final double nameFontSize;
-  final bool wordsWrapInName;
-
-  GlanceCardEntityContainer({
-    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: Column(
-          mainAxisSize: MainAxisSize.min,
-          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/cards/widgets/light_card_body.dart

@@ -1,90 +0,0 @@
-part of '../../main.dart';
-
-class LightCardBody extends StatefulWidget {
-
-  final int min;
-  final int max;
-  final Map severity;
-
-  LightCardBody({Key key, this.min, this.max, this.severity}) : super(key: key);
-
-  @override
-  _LightCardBodyState createState() => _LightCardBodyState();
-}
-
-class _LightCardBodyState extends State<LightCardBody> {
-
-  @override
-  Widget build(BuildContext context) {
-    EntityWrapper entityWrapper = EntityModel.of(context).entityWrapper;
-    LightEntity entity = entityWrapper.entity;
-    Logger.d("Light brightness: ${entity.brightness}");
-
-    return FractionallySizedBox(
-      widthFactor: 0.5,
-      child: Container(
-        //color: Colors.redAccent,
-        child: SingleCircularSlider(
-            255,
-            entity.brightness ?? 0,
-          baseColor: Colors.white,
-          handlerColor: Colors.blue[200],
-          selectionColor: Colors.blue[100],
-        ),
-      ),
-    );
-
-    return InkWell(
-      onTap: () => entityWrapper.handleTap(),
-      onLongPress: () => entityWrapper.handleHold(),
-      child: AspectRatio(
-          aspectRatio: 1.5,
-          child: Stack(
-              fit: StackFit.expand,
-              overflow: Overflow.clip,
-              children: [
-                Align(
-                  alignment: Alignment.bottomCenter,
-                  child: LayoutBuilder(
-                      builder: (BuildContext context, BoxConstraints constraints) {
-                        double fontSize = constraints.maxHeight / 7;
-                        return Padding(
-                          padding: EdgeInsets.only(bottom: 2*fontSize),
-                          child: SimpleEntityState(
-                            //textAlign: TextAlign.center,
-                            expanded: false,
-                            maxLines: 1,
-                            bold: true,
-                            textAlign: TextAlign.center,
-                            padding: EdgeInsets.all(0.0),
-                            fontSize: fontSize,
-                            //padding: EdgeInsets.only(top: Sizes.rowPadding),
-                          ),
-                        );
-                      }
-                  ),
-                ),
-                Align(
-                  alignment: Alignment.bottomCenter,
-                  child: LayoutBuilder(
-                      builder: (BuildContext context, BoxConstraints constraints) {
-                        double fontSize = constraints.maxHeight / 7;
-                        return Padding(
-                          padding: EdgeInsets.only(bottom: fontSize),
-                          child: EntityName(
-                            fontSize: fontSize,
-                            maxLines: 1,
-                            padding: EdgeInsets.all(0.0),
-                            textAlign: TextAlign.center,
-                            textOverflow: TextOverflow.ellipsis,
-                          ),
-                        );
-                      }
-                  ),
-                )
-              ]
-          )
-      ),
-    );
-  }
-}

lib/const.dart

@@ -51,6 +51,10 @@ class EntityUIAction {
   String holdNavigationPath;
   String holdService;
   Map<String, dynamic> holdServiceData;
+  String doubleTapAction = EntityUIAction.none;
+  String doubleTapNavigationPath;
+  String doubleTapService;
+  Map<String, dynamic> doubleTapServiceData;
 
   EntityUIAction({rawEntityData}) {
     if (rawEntityData != null) {
@@ -76,6 +80,17 @@ class EntityUIAction {
           holdServiceData = rawEntityData["hold_action"]["service_data"];
         }
       }
+      if (rawEntityData["double_tap_action"] != null) {
+        if (rawEntityData["double_tap_action"] is String) {
+          doubleTapAction = rawEntityData["double_tap_action"];
+        } else {
+          doubleTapAction =
+              rawEntityData["double_tap_action"]["action"] ?? EntityUIAction.none;
+          doubleTapNavigationPath = rawEntityData["double_tap_action"]["navigation_path"];
+          doubleTapService = rawEntityData["double_tap_action"]["service"];
+          doubleTapServiceData = rawEntityData["double_tap_action"]["service_data"];
+        }
+      }
     }
   }
 
@@ -98,10 +113,12 @@ class CardType {
   static const IFRAME = "iframe";
   static const GAUGE = "gauge";
   static const ENTITY_BUTTON = "entity-button";
+  static const BUTTON = "button";
   static const CONDITIONAL = "conditional";
   static const ALARM_PANEL = "alarm-panel";
   static const MARKDOWN = "markdown";
   static const LIGHT = "light";
+  static const ENTITY_FILTER = "entity-filter";
 }
 
 class Sizes {
@@ -111,10 +128,10 @@ class Sizes {
   static const extendedWidgetHeight = 50.0;
   static const iconSize = 28.0;
   static const largeIconSize = 46.0;
-  static const stateFontSize = 15.0;
+  //static const stateFontSize = 15.0;
-  static const nameFontSize = 15.0;
+  //static const nameFontSize = 15.0;
-  static const smallFontSize = 14.0;
+  //static const smallFontSize = 14.0;
-  static const largeFontSize = 24.0;
+  //static const largeFontSize = 24.0;
   static const inputWidth = 160.0;
   static const rowPadding = 10.0;
   static const doubleRowPadding = rowPadding*2;

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

@@ -248,7 +248,9 @@ class _AlarmControlPanelControlsWidgetWidgetState extends State<AlarmControlPane
         FlatButton(
           child: Text(
             "TRIGGER",
-            style: TextStyle(color: Colors.redAccent)
+            style: Theme.of(context).textTheme.subhead.copyWith(
+              color: Theme.of(context).errorColor
+            )
           ),
           onPressed: () => _askToTrigger(entity),
         )

lib/entities/badge.widget.dart

@@ -7,8 +7,7 @@ class BadgeWidget extends StatelessWidget {
     double iconSize = 26.0;
     Widget badgeIcon;
     String onBadgeTextValue;
-    Color iconColor = EntityColor.badgeColors[entityModel.entityWrapper.entity.domain] ??
+    Color iconColor = HAClientTheme().getBadgeColor(entityModel.entityWrapper.entity.domain);
-        EntityColor.badgeColors["default"];
     switch (entityModel.entityWrapper.entity.domain) {
       case "sun":
         {
@@ -30,7 +29,7 @@ class BadgeWidget extends StatelessWidget {
           badgeIcon = EntityIcon(
             padding: EdgeInsets.all(0.0),
             size: iconSize,
-            color: Colors.black
+            color: Theme.of(context).textTheme.body1.color
           );
           break;
         }
@@ -40,7 +39,7 @@ class BadgeWidget extends StatelessWidget {
           badgeIcon = EntityIcon(
               padding: EdgeInsets.all(0.0),
               size: iconSize,
-              color: Colors.black
+              color: Theme.of(context).textTheme.body1.color
           );
           onBadgeTextValue = entityModel.entityWrapper.entity.displayState;
           break;
@@ -64,7 +63,9 @@ class BadgeWidget extends StatelessWidget {
               overflow: TextOverflow.fade,
               softWrap: false,
               textAlign: TextAlign.center,
-              style: TextStyle(fontSize: stateFontSize),
+              style: Theme.of(context).textTheme.body1.copyWith(
+                fontSize: stateFontSize
+              )
             ),
           );
           break;
@@ -77,7 +78,9 @@ class BadgeWidget extends StatelessWidget {
       onBadgeText = Container(
           padding: EdgeInsets.fromLTRB(6.0, 2.0, 6.0, 2.0),
           child: Text("$onBadgeTextValue",
-              style: TextStyle(fontSize: 12.0, color: Colors.white),
+              style: Theme.of(context).textTheme.overline.copyWith(
+                color: HAClientTheme().getOnBadgeTextColor()
+              ),
               textAlign: TextAlign.center,
               softWrap: false,
               overflow: TextOverflow.fade),
@@ -98,7 +101,7 @@ class BadgeWidget extends StatelessWidget {
               decoration: new BoxDecoration(
                 // Circle shape
                 shape: BoxShape.circle,
-                color: Colors.white,
+                color: Theme.of(context).cardColor,
                 // The border you want
                 border: new Border.all(
                   width: 2.0,
@@ -131,7 +134,7 @@ class BadgeWidget extends StatelessWidget {
               child: Text(
                 "${entityModel.entityWrapper.displayName}",
                 textAlign: TextAlign.center,
-                style: TextStyle(fontSize: 12.0),
+                style: Theme.of(context).textTheme.caption,
                 softWrap: true,
                 maxLines: 3,
                 overflow: TextOverflow.ellipsis,

lib/entities/camera/camera_entity.class.dart

@@ -3,12 +3,16 @@ part of '../../main.dart';
 class CameraEntity extends Entity {
 
   static const SUPPORT_ON_OFF = 1;
+  static const SUPPORT_STREAM = 2;
 
   CameraEntity(Map rawData, String webHost) : super(rawData, webHost);
 
   bool get supportOnOff => ((supportedFeatures &
   CameraEntity.SUPPORT_ON_OFF) ==
       CameraEntity.SUPPORT_ON_OFF);
+  bool get supportStream => ((supportedFeatures &
+  CameraEntity.SUPPORT_STREAM) ==
+      CameraEntity.SUPPORT_STREAM);
 
   @override
   Widget _buildAdditionalControlsForPage(BuildContext context) {

lib/entities/camera/widgets/camera_stream_view.dart

@@ -2,7 +2,9 @@ part of '../../../main.dart';
 
 class CameraStreamView extends StatefulWidget {
 
-  CameraStreamView({Key key}) : super(key: key);
+  final bool withControls;
+
+  CameraStreamView({Key key, this.withControls: true}) : super(key: key);
 
   @override
   _CameraStreamViewState createState() => _CameraStreamViewState();
@@ -10,45 +12,176 @@ class CameraStreamView extends StatefulWidget {
 
 class _CameraStreamViewState extends State<CameraStreamView> {
 
+  CameraEntity _entity;
+  String _streamUrl = "";
+  bool _isLoaded = false;
+  double _aspectRatio = 1.33;
+  String _webViewHtml;
+  String _jsMessageChannelName = 'unknown';
+  Completer _loading;
+
   @override
   void initState() {
     super.initState();
   }
 
-  CameraEntity _entity;
+  Future _loadResources() {
-  bool started = false;
+    if (_loading != null && !_loading.isCompleted) {
-  String streamUrl = "";
+      Logger.d("[Camera Player] Resources loading is not finished yet");
+      return _loading.future;  
+    }
+    Logger.d("[Camera Player] Loading resources");
+    _loading = Completer();
+    _entity = EntityModel
+          .of(context)
+          .entityWrapper
+          .entity;
+    if (_entity.supportStream && HomeAssistant().isComponentEnabled('stream')) {
+      HomeAssistant().getCameraStream(_entity.entityId)
+        .then((data) {
+          _jsMessageChannelName = 'HA_${_entity.entityId.replaceAll('.', '_')}';
+            rootBundle.loadString('assets/html/cameraLiveView.html').then((file) {
+              _webViewHtml = Uri.dataFromString(
+                  file.replaceFirst('{{stream_url}}', '${ConnectionManager().httpWebHost}${data["url"]}').replaceFirst('{{message_channel}}', _jsMessageChannelName),
+                  mimeType: 'text/html',
+                  encoding: Encoding.getByName('utf-8')
+              ).toString();
+              _loading.complete();
+            });
+        })
+        .catchError((e) {
+          if (e == 'start_stream_failed') {
+            Logger.e("[Camera Player] Home Assistant failed starting stream. Forcing MJPEG: $e");
+            _loadMJPEG().then((_) {
+              _loading.complete();
+            });
+          } else {
+            _loading.completeError(e);
+            Logger.e("[Camera Player] Error loading stream: $e");
+          }
+        });
+    } else {
+      _loadMJPEG().then((_) {
+        _loading.complete();
+      });
+    }
+    return _loading.future;
+  }
 
-  launchStream() {
+  Future _loadMJPEG() async {
-    Launcher.launchURLInCustomTab(
+    _streamUrl = '${ConnectionManager().httpWebHost}/api/camera_proxy_stream/${_entity
-      context: context,
+        .entityId}?token=${_entity.attributes['access_token']}';
-      url: streamUrl
+    _jsMessageChannelName = 'HA_${_entity.entityId.replaceAll('.', '_')}';
+    var file = await rootBundle.loadString('assets/html/cameraView.html');
+    _webViewHtml = Uri.dataFromString(
+        file.replaceFirst('{{stream_url}}', _streamUrl).replaceFirst('{{message_channel}}', _jsMessageChannelName),
+        mimeType: 'text/html',
+        encoding: Encoding.getByName('utf-8')
+    ).toString();
+  }
+
+  Widget _buildScreen() {
+    Widget screenWidget;
+    if (!_isLoaded) {
+      screenWidget = Center(
+        child: EntityPicture(
+          fit: BoxFit.contain,
+        )
+      );
+    } else {
+      screenWidget = WebView(
+        initialUrl: _webViewHtml,
+        initialMediaPlaybackPolicy: AutoMediaPlaybackPolicy.always_allow,
+        debuggingEnabled: Logger.isInDebugMode,
+        gestureNavigationEnabled: false,
+        javascriptMode: JavascriptMode.unrestricted,
+        javascriptChannels: {
+          JavascriptChannel(
+            name: _jsMessageChannelName,
+            onMessageReceived: ((message) {
+              Logger.d('[Camera Player] Message from page: $message');
+              setState((){
+                _aspectRatio = double.tryParse(message.message) ?? 1.33;
+              });
+            })
+          )
+        }
+      );
+    }
+    return AspectRatio(
+      aspectRatio: _aspectRatio,
+      child: screenWidget
+    );
+  }
+
+  Widget _buildControls() {
+      return Row(
+        mainAxisSize: MainAxisSize.max,
+        crossAxisAlignment: CrossAxisAlignment.center,
+        mainAxisAlignment: MainAxisAlignment.center,
+        children: <Widget>[
+          IconButton(
+            icon: Icon(Icons.refresh),
+            iconSize: 40,
+            color: Theme.of(context).accentColor,
+            onPressed: _isLoaded ? () {
+              setState(() {
+                _isLoaded = false;  
+              });
+            } : null,
+          ),
+          Expanded(
+            child: Container(),
+          ),
+          IconButton(
+            icon: Icon(Icons.fullscreen),
+            iconSize: 40,
+            color: Theme.of(context).accentColor,
+            onPressed: _isLoaded ? () {
+              eventBus.fire(ShowEntityPageEvent());
+              Navigator.of(context).push(
+                MaterialPageRoute(
+                  builder: (conext) => FullScreenPage(
+                    child: EntityModel(
+                      child: CameraStreamView(
+                        withControls: false
+                      ),
+                      handleTap: false,
+                      entityWrapper: EntityWrapper(
+                        entity: _entity
+                      ),
+                    ),
+                  ),
+                  fullscreenDialog: true
+                )
+              ).then((_) {
+                eventBus.fire(ShowEntityPageEvent(entity: _entity));
+              });
+            } : null,
+          )
+        ],
       );
   }
 
   @override
   Widget build(BuildContext context) {
-    if (!started) {
+    if (!_isLoaded && (_loading == null || _loading.isCompleted)) {
-      _entity = EntityModel
+      _loadResources().then((_) => setState((){ _isLoaded = true; }));
-          .of(context)
-          .entityWrapper
-          .entity;
-      started = true;
     }
-    streamUrl = '${ConnectionManager().httpWebHost}/api/camera_proxy_stream/${_entity
+    if (widget.withControls) {
-        .entityId}?token=${_entity.attributes['access_token']}';
+      return Card(
-    return Column(
+        child: Column(
+          mainAxisSize: MainAxisSize.min,
           children: <Widget>[
-        Container(
+            _buildScreen(),
-            padding: const EdgeInsets.all(20.0),
+            _buildControls()
-            child: IconButton(
-              icon: Icon(MaterialDesignIcons.getIconDataFromIconName("mdi:monitor-screenshot"), color: Colors.amber),
-              iconSize: 50.0,
-              onPressed: () => launchStream(),
-            )
-        )
           ],
+        ),
       );
+    } else {
+      return _buildScreen();
+    }
+    
   }
 
   @override

lib/entities/climate/widgets/climate_controls.dart

@@ -10,9 +10,8 @@ class ClimateControlWidget extends StatefulWidget {
 
 class _ClimateControlWidgetState extends State<ClimateControlWidget> {
 
-  bool _showPending = false;
+  bool _temperaturePending = false;
   bool _changedHere = false;
-  Timer _resetTimer;
   Timer _tempThrottleTimer;
   Timer _targetTempThrottleTimer;
   double _tmpTemperature = 0.0;
@@ -27,9 +26,11 @@ class _ClimateControlWidgetState extends State<ClimateControlWidget> {
   bool _tmpAuxHeat = false;
 
   void _resetVars(ClimateEntity entity) {
+    if (!_temperaturePending) {
       _tmpTemperature = entity.temperature;
       _tmpTargetHigh = entity.targetHigh;
       _tmpTargetLow = entity.targetLow;
+    }
     _tmpHVACMode = entity.state;
     _tmpFanMode = entity.fanMode;
     _tmpSwingMode = entity.swingMode;
@@ -38,7 +39,6 @@ class _ClimateControlWidgetState extends State<ClimateControlWidget> {
     _tmpAuxHeat = entity.auxHeat;
     _tmpTargetHumidity = entity.targetHumidity;
 
-    _showPending = false;
     _changedHere = false;
   }
 
@@ -73,46 +73,44 @@ class _ClimateControlWidgetState extends State<ClimateControlWidget> {
   }
 
   void _setTemperature(ClimateEntity entity) {
-    if (_tempThrottleTimer!=null) {
+    _tempThrottleTimer?.cancel();
-      _tempThrottleTimer.cancel();
-    }
     setState(() {
       _changedHere = true;
+      _temperaturePending = true;
       _tmpTemperature = double.parse(_tmpTemperature.toStringAsFixed(1));
     });
     _tempThrottleTimer = Timer(Duration(seconds: 2), () {
       setState(() {
         _changedHere = true;
+        _temperaturePending = false;
         ConnectionManager().callService(
           domain: entity.domain,
           service: "set_temperature",
           entityId: entity.entityId,
           data: {"temperature": "${_tmpTemperature.toStringAsFixed(1)}"}
         );
-        _resetStateTimer(entity);
       });
     });
   }
 
   void _setTargetTemp(ClimateEntity entity) {
-    if (_targetTempThrottleTimer!=null) {
+    _targetTempThrottleTimer?.cancel();
-      _targetTempThrottleTimer.cancel();
-    }
     setState(() {
       _changedHere = true;
+      _temperaturePending = true;
       _tmpTargetLow = double.parse(_tmpTargetLow.toStringAsFixed(1));
       _tmpTargetHigh = double.parse(_tmpTargetHigh.toStringAsFixed(1));
     });
     _targetTempThrottleTimer = Timer(Duration(seconds: 2), () {
       setState(() {
         _changedHere = true;
+        _temperaturePending = false;
         ConnectionManager().callService(
           domain: entity.domain,
           service: "set_temperature",
           entityId: entity.entityId,
           data: {"target_temp_high": "${_tmpTargetHigh.toStringAsFixed(1)}", "target_temp_low": "${_tmpTargetLow.toStringAsFixed(1)}"}
         );
-        _resetStateTimer(entity);
       });
     });
   }
@@ -127,7 +125,6 @@ class _ClimateControlWidgetState extends State<ClimateControlWidget> {
           entityId: entity.entityId,
           data: {"humidity": "$_tmpTargetHumidity"}
         );
-      _resetStateTimer(entity);
     });
   }
 
@@ -141,7 +138,6 @@ class _ClimateControlWidgetState extends State<ClimateControlWidget> {
           entityId: entity.entityId,
           data: {"hvac_mode": "$_tmpHVACMode"}
         );
-      _resetStateTimer(entity);
     });
   }
 
@@ -155,7 +151,6 @@ class _ClimateControlWidgetState extends State<ClimateControlWidget> {
           entityId: entity.entityId,
           data: {"swing_mode": "$_tmpSwingMode"}
         );
-      _resetStateTimer(entity);
     });
   }
 
@@ -164,7 +159,6 @@ class _ClimateControlWidgetState extends State<ClimateControlWidget> {
       _tmpFanMode = value;
       _changedHere = true;
       ConnectionManager().callService(domain: entity.domain, service: "set_fan_mode", entityId: entity.entityId, data: {"fan_mode": "$_tmpFanMode"});
-      _resetStateTimer(entity);
     });
   }
 
@@ -173,7 +167,6 @@ class _ClimateControlWidgetState extends State<ClimateControlWidget> {
       _tmpPresetMode = value;
       _changedHere = true;
       ConnectionManager().callService(domain: entity.domain, service: "set_preset_mode", entityId: entity.entityId, data: {"preset_mode": "$_tmpPresetMode"});
-      _resetStateTimer(entity);
     });
   }
 
@@ -191,17 +184,6 @@ class _ClimateControlWidgetState extends State<ClimateControlWidget> {
       _tmpAuxHeat = value;
       _changedHere = true;
       ConnectionManager().callService(domain: entity.domain, service: "set_aux_heat", entityId: entity.entityId, data: {"aux_heat": "$_tmpAuxHeat"});
-      _resetStateTimer(entity);
-    });
-  }
-
-  void _resetStateTimer(ClimateEntity entity) {
-    if (_resetTimer!=null) {
-      _resetTimer.cancel();
-    }
-    _resetTimer = Timer(Duration(seconds: 3), () {
-      setState(() {});
-      _resetVars(entity);
     });
   }
 
@@ -209,11 +191,11 @@ class _ClimateControlWidgetState extends State<ClimateControlWidget> {
   Widget build(BuildContext context) {
     final entityModel = EntityModel.of(context);
     final ClimateEntity entity = entityModel.entityWrapper.entity;
+    Logger.d("[Climate widget build] changed here = $_changedHere");
     if (_changedHere) {
-      _showPending = (_tmpTemperature != entity.temperature || _tmpTargetHigh != entity.targetHigh || _tmpTargetLow != entity.targetLow);
+      //_showPending = (_tmpTemperature != entity.temperature || _tmpTargetHigh != entity.targetHigh || _tmpTargetLow != entity.targetLow);
       _changedHere = false;
     } else {
-      _resetTimer?.cancel();
       _resetVars(entity);
     }
     return Padding(
@@ -222,20 +204,20 @@ class _ClimateControlWidgetState extends State<ClimateControlWidget> {
         crossAxisAlignment: CrossAxisAlignment.start,
         children: <Widget>[
           //_buildOnOffControl(entity),
-          _buildTemperatureControls(entity),
+          _buildTemperatureControls(entity, context),
-          _buildTargetTemperatureControls(entity),
+          _buildTargetTemperatureControls(entity, context),
-          _buildHumidityControls(entity),
+          _buildHumidityControls(entity, context),
-          _buildOperationControl(entity),
+          _buildOperationControl(entity, context),
-          _buildFanControl(entity),
+          _buildFanControl(entity, context),
-          _buildSwingControl(entity),
+          _buildSwingControl(entity, context),
-          _buildPresetModeControl(entity),
+          _buildPresetModeControl(entity, context),
-          _buildAuxHeatControl(entity)
+          _buildAuxHeatControl(entity, context)
         ],
       ),
     );
   }
 
-  Widget _buildPresetModeControl(ClimateEntity entity) {
+  Widget _buildPresetModeControl(ClimateEntity entity, BuildContext context) {
     if (entity.supportPresetMode) {
       return ModeSelectorWidget(
         options: entity.presetModes,
@@ -260,7 +242,7 @@ class _ClimateControlWidgetState extends State<ClimateControlWidget> {
     }
   }*/
 
-  Widget _buildAuxHeatControl(ClimateEntity entity) {
+  Widget _buildAuxHeatControl(ClimateEntity entity, BuildContext context) {
     if (entity.supportAuxHeat ) {
       return ModeSwitchWidget(
           caption: "Aux heat",
@@ -272,7 +254,7 @@ class _ClimateControlWidgetState extends State<ClimateControlWidget> {
     }
   }
 
-  Widget _buildOperationControl(ClimateEntity entity) {
+  Widget _buildOperationControl(ClimateEntity entity, BuildContext context) {
     if (entity.hvacModes != null) {
       return ModeSelectorWidget(
         onChange: (mode) => _setHVACMode(entity, mode),
@@ -285,7 +267,7 @@ class _ClimateControlWidgetState extends State<ClimateControlWidget> {
     }
   }
 
-  Widget _buildFanControl(ClimateEntity entity) {
+  Widget _buildFanControl(ClimateEntity entity, BuildContext context) {
     if (entity.supportFanMode) {
       return ModeSelectorWidget(
         options: entity.fanModes,
@@ -298,7 +280,7 @@ class _ClimateControlWidgetState extends State<ClimateControlWidget> {
     }
   }
 
-  Widget _buildSwingControl(ClimateEntity entity) {
+  Widget _buildSwingControl(ClimateEntity entity, BuildContext context) {
     if (entity.supportSwingMode) {
       return ModeSelectorWidget(
           onChange: (mode) => _setSwingMode(entity, mode),
@@ -311,17 +293,15 @@ class _ClimateControlWidgetState extends State<ClimateControlWidget> {
     }
   }
 
-  Widget _buildTemperatureControls(ClimateEntity entity) {
+  Widget _buildTemperatureControls(ClimateEntity entity, BuildContext context) {
     if ((entity.supportTargetTemperature) && (entity.temperature != null)) {
       return Column(
         crossAxisAlignment: CrossAxisAlignment.start,
         children: <Widget>[
-          Text("Target temperature", style: TextStyle(
+          Text("Target temperature", style: Theme.of(context).textTheme.body1),
-              fontSize: Sizes.stateFontSize
-          )),
           TemperatureControlWidget(
             value: _tmpTemperature,
-            fontColor: _showPending ? Colors.red : Colors.black,
+            active: _temperaturePending,
             onDec: () => _temperatureDown(entity),
             onInc: () => _temperatureUp(entity),
           )
@@ -332,13 +312,13 @@ class _ClimateControlWidgetState extends State<ClimateControlWidget> {
     }
   }
 
-  Widget _buildTargetTemperatureControls(ClimateEntity entity) {
+  Widget _buildTargetTemperatureControls(ClimateEntity entity, BuildContext context) {
     List<Widget> controls = [];
     if ((entity.supportTargetTemperatureRange) && (entity.targetLow != null)) {
       controls.addAll(<Widget>[
         TemperatureControlWidget(
           value: _tmpTargetLow,
-          fontColor: _showPending ? Colors.red : Colors.black,
+          active: _temperaturePending,
           onDec: () => _targetLowDown(entity),
           onInc: () => _targetLowUp(entity),
         ),
@@ -351,7 +331,7 @@ class _ClimateControlWidgetState extends State<ClimateControlWidget> {
       controls.add(
           TemperatureControlWidget(
             value: _tmpTargetHigh,
-            fontColor: _showPending ? Colors.red : Colors.black,
+            active: _temperaturePending,
             onDec: () => _targetHighDown(entity),
             onInc: () => _targetHighUp(entity),
           )
@@ -361,9 +341,7 @@ class _ClimateControlWidgetState extends State<ClimateControlWidget> {
       return Column(
         crossAxisAlignment: CrossAxisAlignment.start,
         children: <Widget>[
-          Text("Target temperature range", style: TextStyle(
+          Text("Target temperature range", style: Theme.of(context).textTheme.body1),
-              fontSize: Sizes.stateFontSize
-          )),
           Row(
             children: controls,
           )
@@ -374,13 +352,13 @@ class _ClimateControlWidgetState extends State<ClimateControlWidget> {
     }
   }
 
-  Widget _buildHumidityControls(ClimateEntity entity) {
+  Widget _buildHumidityControls(ClimateEntity entity, BuildContext context) {
     List<Widget> result = [];
     if (entity.supportTargetHumidity) {
       result.addAll(<Widget>[
         Text(
           "$_tmpTargetHumidity%",
-          style: TextStyle(fontSize: Sizes.largeFontSize),
+          style: Theme.of(context).textTheme.display1,
         ),
         Expanded(
           child: Slider(
@@ -405,9 +383,7 @@ class _ClimateControlWidgetState extends State<ClimateControlWidget> {
           Padding(
             padding: EdgeInsets.fromLTRB(
                 0.0, Sizes.rowPadding, 0.0, Sizes.rowPadding),
-            child: Text("Target humidity", style: TextStyle(
+            child: Text("Target humidity", style: Theme.of(context).textTheme.body1),
-                fontSize: Sizes.stateFontSize
-            )),
           ),
           Row(
             crossAxisAlignment: CrossAxisAlignment.center,
@@ -429,7 +405,6 @@ class _ClimateControlWidgetState extends State<ClimateControlWidget> {
 
   @override
   void dispose() {
-    _resetTimer?.cancel();
     super.dispose();
   }
 

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

@@ -33,23 +33,16 @@ class ClimateStateWidget extends StatelessWidget {
               children: <Widget>[
                 Text("$displayState",
                     textAlign: TextAlign.right,
-                    style: new TextStyle(
+                    style: Theme.of(context).textTheme.body2),
-                      fontWeight: FontWeight.bold,
-                      fontSize: Sizes.stateFontSize,
-                    )),
                 Text(" $targetTemp",
                     textAlign: TextAlign.right,
-                    style: new TextStyle(
+                    style: Theme.of(context).textTheme.body1)
-                      fontSize: Sizes.stateFontSize,
-                    ))
               ],
             ),
             entity.currentTemperature != null ?
             Text("Currently: ${entity.currentTemperature}",
                 textAlign: TextAlign.right,
-                style: new TextStyle(
+                style: Theme.of(context).textTheme.subtitle
-                    fontSize: Sizes.stateFontSize,
-                    color: Colors.black45)
             ) :
             Container(height: 0.0,)
           ],

lib/entities/climate/widgets/mode_selector.dart

@@ -3,10 +3,8 @@ part of '../../../main.dart';
 class ModeSelectorWidget extends StatelessWidget {
 
   final String caption;
-  final List<String> options;
+  final List options;
   final String value;
-  final double captionFontSize;
-  final double valueFontSize;
   final onChange;
   final EdgeInsets padding;
 
@@ -16,8 +14,6 @@ class ModeSelectorWidget extends StatelessWidget {
     @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);
 
@@ -28,9 +24,7 @@ class ModeSelectorWidget extends StatelessWidget {
       child: Column(
         crossAxisAlignment: CrossAxisAlignment.start,
         children: <Widget>[
-          Text("$caption", style: TextStyle(
+          Text("$caption", style: Theme.of(context).textTheme.body1),
-              fontSize: captionFontSize ?? Sizes.stateFontSize
-          )),
           Row(
             children: <Widget>[
               Expanded(
@@ -40,15 +34,12 @@ class ModeSelectorWidget extends StatelessWidget {
                     value: value,
                     iconSize: 30.0,
                     isExpanded: true,
-                    style: TextStyle(
+                    style: Theme.of(context).textTheme.title,
-                      fontSize: valueFontSize ?? Sizes.largeFontSize,
-                      color: Colors.black,
-                    ),
                     hint: Text("Select ${caption.toLowerCase()}"),
-                    items: options.map((String value) {
+                    items: options.map((value) {
                       return new DropdownMenuItem<String>(
-                        value: value,
+                        value: '$value',
-                        child: Text(value),
+                        child: Text('$value'),
                       );
                     }).toList(),
                     onChanged: (mode) => onChange(mode),

lib/entities/climate/widgets/mode_swicth.dart

@@ -4,7 +4,6 @@ class ModeSwitchWidget extends StatelessWidget {
 
   final String caption;
   final onChange;
-  final double captionFontSize;
   final bool value;
   final bool expanded;
   final EdgeInsets padding;
@@ -13,7 +12,6 @@ class ModeSwitchWidget extends StatelessWidget {
     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)
@@ -25,7 +23,7 @@ class ModeSwitchWidget extends StatelessWidget {
       padding: this.padding,
       child: Row(
         children: <Widget>[
-          _buildCaption(),
+          _buildCaption(context),
           Switch(
             onChanged: (value) => onChange(value),
             value: value ?? false,
@@ -35,12 +33,10 @@ class ModeSwitchWidget extends StatelessWidget {
     );
   }
 
-  Widget _buildCaption() {
+  Widget _buildCaption(BuildContext context) {
     Widget captionWidget = Text(
       "$caption",
-      style: TextStyle(
+      style: Theme.of(context).textTheme.body1,
-          fontSize: captionFontSize ?? Sizes.stateFontSize
-      ),
     );
     if (expanded) {
       return Expanded(

lib/entities/climate/widgets/temperature_control_widget.dart

@@ -2,8 +2,7 @@ part of '../../../main.dart';
 
 class TemperatureControlWidget extends StatelessWidget {
   final double value;
-  final double fontSize;
+  final bool active;
-  final Color fontColor;
   final onInc;
   final onDec;
 
@@ -12,8 +11,9 @@ class TemperatureControlWidget extends StatelessWidget {
         @required this.value,
         @required this.onInc,
         @required this.onDec,
-        this.fontSize,
+        //this.fontSize,
-        this.fontColor})
+        this.active: false
+      })
       : super(key: key);
 
   @override
@@ -23,10 +23,7 @@ class TemperatureControlWidget extends StatelessWidget {
       children: <Widget>[
         Text(
           "$value",
-          style: TextStyle(
+          style: active ? Theme.of(context).textTheme.display2 : Theme.of(context).textTheme.display1,
-              fontSize: fontSize ?? 24.0,
-              color: fontColor ?? Colors.black
-          ),
         ),
         Column(
           children: <Widget>[

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

@@ -64,9 +64,7 @@ class _CoverControlWidgetState extends State<CoverControlWidget> {
           Padding(
             padding: EdgeInsets.fromLTRB(
                 0.0, Sizes.rowPadding, 0.0, Sizes.rowPadding),
-            child: Text("Position", style: TextStyle(
+            child: Text("Position"),
-                fontSize: Sizes.stateFontSize
-            )),
           ),
           Slider(
             value: _tmpPosition,
@@ -118,9 +116,7 @@ class _CoverControlWidgetState extends State<CoverControlWidget> {
       controls.insert(0, Padding(
         padding: EdgeInsets.fromLTRB(
             0.0, Sizes.rowPadding, 0.0, Sizes.rowPadding),
-        child: Text("Tilt position", style: TextStyle(
+        child: Text("Tilt position"),
-            fontSize: Sizes.stateFontSize
-        )),
       ));
       return Column(
         crossAxisAlignment: CrossAxisAlignment.start,

lib/entities/date_time/widgets/date_time_state.dart

@@ -9,10 +9,8 @@ class DateTimeStateWidget extends StatelessWidget {
         padding: EdgeInsets.fromLTRB(0.0, 0.0, Sizes.rightWidgetPadding, 0.0),
         child: GestureDetector(
           child: Text("${entity.formattedState}",
-              textAlign: TextAlign.right,
+              textAlign: TextAlign.right
-              style: new TextStyle(
+            ),
-                fontSize: Sizes.stateFontSize,
-              )),
           onTap: () => _handleStateTap(context, entity),
         ));
   }

lib/entities/default_entity_container.widget.dart

@@ -11,25 +11,23 @@ class DefaultEntityContainer extends StatelessWidget {
   @override
   Widget build(BuildContext context) {
     final EntityModel entityModel = EntityModel.of(context);
-    if (entityModel.entityWrapper.entity.statelessType == StatelessEntityType.MISSED) {
+    if (entityModel.entityWrapper.entity.statelessType == StatelessEntityType.missed) {
       return MissedEntityWidget();
     }
-    if (entityModel.entityWrapper.entity.statelessType == StatelessEntityType.DIVIDER) {
+    if (entityModel.entityWrapper.entity.statelessType == StatelessEntityType.divider) {
-      return Divider(
+      return Divider();
-        color: Colors.black45,
-      );
     }
-    if (entityModel.entityWrapper.entity.statelessType == StatelessEntityType.SECTION) {
+    if (entityModel.entityWrapper.entity.statelessType == StatelessEntityType.section) {
       return Column(
         crossAxisAlignment: CrossAxisAlignment.start,
         mainAxisSize: MainAxisSize.min,
         children: <Widget>[
-          Divider(
+          Divider(),
-            color: Colors.black45,
-          ),
           Text(
               "${entityModel.entityWrapper.entity.displayName}",
-            style: TextStyle(color: Colors.blue),
+            style: HAClientTheme().getLinkTextStyle(context).copyWith(
+              decoration: TextDecoration.none
+            )
           )
         ],
       );
@@ -61,6 +59,11 @@ class DefaultEntityContainer extends StatelessWidget {
             entityModel.entityWrapper.handleTap();
           }
         },
+        onDoubleTap: () {
+          if (entityModel.handleTap) {
+            entityModel.entityWrapper.handleDoubleTap();
+          }
+        },
         child: result,
       );
     } else {

lib/entities/entity.class.dart

@@ -1,13 +1,6 @@
 part of '../main.dart';
 
-class StatelessEntityType {
+enum StatelessEntityType {none, missed, ghost, divider, section, callService, webLink}
-  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 {
 
@@ -76,8 +69,8 @@ class Entity {
   String entityPicture;
   String state;
   String displayState;
-  DateTime _lastUpdated;
+  DateTime lastUpdatedTimestamp;
-  int statelessType = 0;
+  StatelessEntityType statelessType = StatelessEntityType.none;
 
   List<Entity> childEntities = [];
   String deviceClass;
@@ -120,31 +113,36 @@ class Entity {
   }
 
   Entity.missed(String entityId) {
-    statelessType = StatelessEntityType.MISSED;
+    statelessType = StatelessEntityType.missed;
     attributes = {"hidden": false};
     this.entityId = entityId;
   }
 
   Entity.divider() {
-    statelessType = StatelessEntityType.DIVIDER;
+    statelessType = StatelessEntityType.divider;
     attributes = {"hidden": false};
   }
 
   Entity.section(String label) {
-    statelessType = StatelessEntityType.SECTION;
+    statelessType = StatelessEntityType.section;
     attributes = {"hidden": false, "friendly_name": "$label"};
   }
 
+  Entity.ghost(String name, String icon) {
+    statelessType = StatelessEntityType.ghost;
+    attributes = {"icon": icon, "hidden": false, "friendly_name": name};
+  }
+
   Entity.callService({String icon, String name, String service, String actionName}) {
-    statelessType = StatelessEntityType.CALL_SERVICE;
+    statelessType = StatelessEntityType.callService;
     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;
+    statelessType = StatelessEntityType.webLink;
-    entityId = "custom.custom"; //TODO wtf??
+    entityId = "custom.custom";
     attributes = {"hidden": false, "friendly_name": "${name ?? url}", "icon": "${icon ?? 'mdi:link'}"};
   }
 
@@ -155,7 +153,7 @@ class Entity {
     deviceClass = attributes["device_class"];
     state = rawData["state"] is bool ? (rawData["state"] ? EntityState.on : EntityState.off) : rawData["state"];
     displayState = Entity.StateByDeviceClass["$deviceClass.$state"] ?? (state.toLowerCase() == 'unknown' ? '-' : state);
-    _lastUpdated = DateTime.tryParse(rawData["last_updated"]);
+    lastUpdatedTimestamp = DateTime.tryParse(rawData["last_updated"]);
     entityPicture = _getEntityPictureUrl(webHost);
   }
 
@@ -221,17 +219,17 @@ class Entity {
 
   String getAttribute(String attributeName) {
     if (attributes != null) {
-      return attributes["$attributeName"];
+      return attributes["$attributeName"].toString();
     }
     return null;
   }
 
   String _getLastUpdatedFormatted() {
-    if (_lastUpdated == null) {
+    if (lastUpdatedTimestamp == null) {
       return "-";
     } else {
       DateTime now = DateTime.now();
-      Duration d = now.difference(_lastUpdated);
+      Duration d = now.difference(lastUpdatedTimestamp);
       String text;
       int v;
       if (d.inDays == 0) {

lib/entities/entity_colors.class.dart

@@ -1,77 +0,0 @@
-part of '../main.dart';
-
-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 = {
-    EntityState.on: Colors.amber,
-    "auto": Colors.amber,
-    EntityState.active: Colors.amber,
-    EntityState.playing: Colors.amber,
-    EntityState.paused: Colors.amber,
-    "above_horizon": Colors.amber,
-    EntityState.home:  Colors.amber,
-    EntityState.open:  Colors.amber,
-    EntityState.cleaning:  Colors.amber,
-    EntityState.returning:  Colors.amber,
-    EntityState.off: defaultStateColor,
-    EntityState.closed: defaultStateColor,
-    "below_horizon": defaultStateColor,
-    "default": defaultStateColor,
-    EntityState.idle: defaultStateColor,
-    "heat": Colors.redAccent,
-    "cool": Colors.lightBlue,
-    EntityState.unavailable: 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) {
-    return _stateColors[state] ?? _stateColors["default"];
-  }
-
-  static charts.Color chartHistoryStateColor(String state, int id) {
-    Color c = _stateColors[state];
-    if (c != null) {
-      return charts.Color(
-          r: c.red,
-          g: c.green,
-          b: c.blue,
-          a: c.alpha
-      );
-    } else {
-      double r = id.toDouble() % 10;
-      return charts.MaterialPalette.getOrderedPalettes(10)[r.round()].shadeDefault;
-    }
-  }
-
-  static Color historyStateColor(String state, int id) {
-    Color c = _stateColors[state];
-    if (c != null) {
-      return c;
-    } else {
-      if (id > -1) {
-        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[EntityState.on];
-      }
-    }
-  }
-
-}

lib/entities/entity_icon.widget.dart

@@ -50,24 +50,29 @@ class EntityIcon extends StatelessWidget {
       iconCode = getDefaultIconByEntityId(data.entity.entityId,
           data.entity.deviceClass, data.entity.state); //
     }
-    return Padding(
+    return Icon(
-        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 EntityWrapper entityWrapper = EntityModel.of(context).entityWrapper;
+    Color iconColor;
+    if (color != null) {
+      iconColor = color;
+    } else if (entityWrapper.stateColor) {
+      iconColor = HAClientTheme().getColorByEntityState(entityWrapper.entity.state, context);
+    } else {
+      iconColor = HAClientTheme().getOffStateColor(context);
+    }
     return Padding(
       padding: padding,
       child: buildIcon(
         entityWrapper,
-          color ?? EntityColor.stateColor(entityWrapper.entity.state)
+        iconColor 
       ),
     );
   }

lib/entities/entity_model.widget.dart

@@ -12,11 +12,11 @@ class EntityModel extends InheritedWidget {
   final bool handleTap;
 
   static EntityModel of(BuildContext context) {
-    return context.inheritFromWidgetOfExactType(EntityModel);
+    return context.dependOnInheritedWidgetOfExactType<EntityModel>();
   }
 
   @override
-  bool updateShouldNotify(InheritedWidget oldWidget) {
+  bool updateShouldNotify(EntityModel oldWidget) {
-    return true;
+    return entityWrapper.entity.lastUpdatedTimestamp != oldWidget.entityWrapper.entity.lastUpdatedTimestamp;
   }
 }

lib/entities/entity_name.widget.dart

@@ -5,18 +5,24 @@ class EntityName extends StatelessWidget {
   final EdgeInsetsGeometry padding;
   final TextOverflow textOverflow;
   final bool wordsWrap;
-  final double fontSize;
   final TextAlign textAlign;
   final int maxLines;
+  final TextStyle textStyle;
 
-  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);
+  const EntityName({Key key, this.maxLines, this.padding: const EdgeInsets.only(right: 10.0), this.textOverflow: TextOverflow.ellipsis, this.textStyle, this.wordsWrap: true, this.textAlign: TextAlign.left}) : super(key: key);
 
   @override
   Widget build(BuildContext context) {
     final EntityWrapper entityWrapper = EntityModel.of(context).entityWrapper;
-    TextStyle textStyle = TextStyle(fontSize: fontSize);
+    TextStyle tStyle;
-    if (entityWrapper.entity.statelessType == StatelessEntityType.WEBLINK) {
+    if (textStyle == null) {
-      textStyle = textStyle.apply(color: Colors.blue, decoration: TextDecoration.underline);
+      if (entityWrapper.entity.statelessType == StatelessEntityType.webLink) {
+        tStyle = HAClientTheme().getLinkTextStyle(context);
+      } else {
+        tStyle = Theme.of(context).textTheme.body1;
+      }
+    } else {
+      tStyle = textStyle;
     }
     return Padding(
       padding: padding,
@@ -25,7 +31,7 @@ class EntityName extends StatelessWidget {
         overflow: textOverflow,
         softWrap: wordsWrap,
         maxLines: maxLines,
-        style: textStyle,
+        style: tStyle,
         textAlign: textAlign,
       ),
     );

lib/entities/entity_page_layout.widget.dart

@@ -16,7 +16,7 @@ class EntityPageLayout extends StatelessWidget {
           children: <Widget>[
             showClose ?
             Container(
-              color: Colors.blue[300],
+              color: Theme.of(context).primaryColor,
               height: 40,
               child: Row(
                 children: <Widget>[
@@ -25,18 +25,14 @@ class EntityPageLayout extends StatelessWidget {
                       padding: EdgeInsets.only(left: 8),
                       child: Text(
                         entity.displayName,
-                        style: TextStyle(
+                        style: Theme.of(context).primaryTextTheme.headline
-                            fontWeight: FontWeight.bold,
-                            color: Colors.white,
-                            fontSize: 22
-                        ),
                       ),
                     ),
                   ),
                   IconButton(
                     padding: EdgeInsets.all(0),
                     icon: Icon(Icons.close),
-                    color: Colors.white,
+                    color: Theme.of(context).primaryTextTheme.headline.color,
                     iconSize: 36.0,
                     onPressed: () {
                       eventBus.fire(ShowEntityPageEvent());

lib/entities/entity_picture.widget.dart

@@ -0,0 +1,71 @@
+part of '../main.dart';
+
+class EntityPicture extends StatelessWidget {
+
+  final EdgeInsetsGeometry padding;
+  final BoxFit fit;
+  
+  const EntityPicture({Key key, this.padding: const EdgeInsets.all(0.0), this.fit: BoxFit.cover}) : 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, BuildContext context) {
+    if (data == null) {
+      return null;
+    }
+    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); //
+    }
+    Widget iconPicture = Container(
+      child: Center(
+        child: Icon(
+          IconData(iconCode, fontFamily: 'Material Design Icons'),
+          size: Sizes.largeIconSize,
+          color: HAClientTheme().getOffStateColor(context),
+        )
+      )
+    );
+    
+    
+    if (data.entityPicture != null) {
+      return CachedNetworkImage(
+        imageUrl: data.entityPicture,
+        fit: this.fit,
+        errorWidget: (context, _, __) => iconPicture,
+        placeholder: (context, _) => iconPicture,
+      );
+    }
+    
+    return iconPicture;
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    final EntityWrapper entityWrapper = EntityModel.of(context).entityWrapper;
+    return Padding(
+      padding: padding,
+      child: buildIcon(
+          entityWrapper,
+          context
+      ),
+    );
+  }
+}

lib/entities/entity_wrapper.class.dart

@@ -2,30 +2,31 @@ part of '../main.dart';
 
 class EntityWrapper {
 
-  String displayName;
+  String overrideName;
-  String icon;
+  final String overrideIcon;
-  String unitOfMeasurement;
+  final bool stateColor;
-  String entityPicture;
   EntityUIAction uiAction;
   Entity entity;
+  String unitOfMeasurementOverride;
+  final List stateFilter;
 
+  String get icon => overrideIcon ?? entity.icon;
+  String get entityPicture => entity.entityPicture;
+  String get displayName => overrideName ?? entity.displayName;
+  String get unitOfMeasurement => unitOfMeasurementOverride ?? entity.unitOfMeasurement;
 
   EntityWrapper({
     this.entity,
-    String icon,
+    this.overrideIcon,
-    String displayName,
+    this.overrideName,
-    this.uiAction
+    this.stateColor: true,
+    this.uiAction,
+    this.stateFilter
   }) {
-    if (entity.statelessType == StatelessEntityType.NONE || entity.statelessType == StatelessEntityType.CALL_SERVICE || entity.statelessType == StatelessEntityType.WEBLINK) {
+    if (entity.statelessType == StatelessEntityType.ghost || entity.statelessType == StatelessEntityType.none || entity.statelessType == StatelessEntityType.callService || 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();
       }
-      unitOfMeasurement = entity.unitOfMeasurement;
     }
   }
 
@@ -58,7 +59,7 @@ class EntityWrapper {
       }
 
       case EntityUIAction.navigate: {
-        if (uiAction.tapService.startsWith("/")) {
+        if (uiAction.tapService != null && uiAction.tapService.startsWith("/")) {
           //TODO handle local urls
           Logger.w("Local urls is not supported yet");
         } else {
@@ -98,7 +99,7 @@ class EntityWrapper {
         }
 
         case EntityUIAction.navigate: {
-          if (uiAction.holdService.startsWith("/")) {
+          if (uiAction.holdService != null && uiAction.holdService.startsWith("/")) {
             //TODO handle local urls
             Logger.w("Local urls is not supported yet");
           } else {
@@ -113,4 +114,44 @@ class EntityWrapper {
       }
   }
 
+  void handleDoubleTap() {
+      switch (uiAction.doubleTapAction) {
+        case EntityUIAction.toggle: {
+          ConnectionManager().callService(domain: "homeassistant", service: "toggle", entityId: entity.entityId);
+          break;
+        }
+
+        case EntityUIAction.callService: {
+          if (uiAction.doubleTapService != null) {
+            ConnectionManager().callService(
+              domain: uiAction.doubleTapService.split(".")[0],
+              service: uiAction.doubleTapService.split(".")[1],
+              data: uiAction.doubleTapServiceData
+            );
+          }
+          break;
+        }
+
+        case EntityUIAction.moreInfo: {
+          eventBus.fire(
+              new ShowEntityPageEvent(entity: entity));
+          break;
+        }
+
+        case EntityUIAction.navigate: {
+          if (uiAction.doubleTapService != null && uiAction.doubleTapService.startsWith("/")) {
+            //TODO handle local urls
+            Logger.w("Local urls is not supported yet");
+          } else {
+            Launcher.launchURL(uiAction.doubleTapService);
+          }
+          break;
+        }
+
+        default: {
+          break;
+        }
+      }
+  }
+
 }

lib/entities/flat_service_button.widget.dart

@@ -6,7 +6,6 @@ class FlatServiceButton extends StatelessWidget {
   final String serviceName;
   final String entityId;
   final String text;
-  final double fontSize;
 
   FlatServiceButton({
     Key key,
@@ -14,7 +13,6 @@ class FlatServiceButton extends StatelessWidget {
     @required this.serviceName,
     @required this.entityId,
     @required this.text,
-    this.fontSize: Sizes.stateFontSize
   }) : super(key: key);
 
   void _setNewState() {
@@ -24,7 +22,7 @@ class FlatServiceButton extends StatelessWidget {
   @override
   Widget build(BuildContext context) {
     return SizedBox(
-        height: fontSize*2.5,
+        height: Theme.of(context).textTheme.subhead.fontSize*2.5,
         child: FlatButton(
           onPressed: (() {
             _setNewState();
@@ -32,8 +30,7 @@ class FlatServiceButton extends StatelessWidget {
           child: Text(
             text,
             textAlign: TextAlign.right,
-            style:
+            style: HAClientTheme().getActionTextStyle(context),
-            new TextStyle(fontSize: fontSize, color: Colors.blue),
           ),
         )
     );

lib/entities/light/widgets/light_controls.dart

@@ -183,7 +183,7 @@ class _LightControlsWidgetState extends State<LightControlsWidget> {
       }
       return UniversalSlider(
         title: "Color temperature",
-        leading: Text("Cold", style: TextStyle(color: Colors.lightBlue),),
+        leading: Text("Cold", style: Theme.of(context).textTheme.body1.copyWith(color: Colors.lightBlue)),
         value:  val,
         onChangeEnd: (value) => _setColorTemp(entity, value),
         max: entity.maxMireds,
@@ -194,7 +194,7 @@ class _LightControlsWidgetState extends State<LightControlsWidget> {
             _tmpColorTemp = value.round();
           });
         },
-        closing: Text("Warm", style: TextStyle(color: Colors.amberAccent),),
+        closing: Text("Warm", style: Theme.of(context).textTheme.body1.copyWith(color: Colors.amberAccent),),
       );
     } else {
       return Container(width: 0.0, height: 0.0);
@@ -224,7 +224,7 @@ class _LightControlsWidgetState extends State<LightControlsWidget> {
                 },
               ),
               FlatButton(
-                color: savedColor?.toColor() ?? Colors.transparent,
+                color: savedColor?.toColor() ?? Theme.of(context).backgroundColor,
                 child: Text('Paste color'),
                 onPressed: savedColor == null ? null : () {
                   _setColor(entity, savedColor);

lib/entities/lock/widgets/lock_state.dart

@@ -28,8 +28,7 @@ class LockStateWidget extends StatelessWidget {
           onPressed: () => _unlock(entity),
           child: Text("UNLOCK",
               textAlign: TextAlign.right,
-              style:
+              style: HAClientTheme().getActionTextStyle(context)
-              new TextStyle(fontSize: Sizes.stateFontSize, color: Colors.blue),
             ),
           )
         ),
@@ -39,8 +38,7 @@ class LockStateWidget extends StatelessWidget {
               onPressed: () => _lock(entity),
               child: Text("LOCK",
                 textAlign: TextAlign.right,
-                style:
+                style: HAClientTheme().getActionTextStyle(context),
-                new TextStyle(fontSize: Sizes.stateFontSize, color: Colors.blue),
               ),
             )
         )
@@ -56,8 +54,7 @@ class LockStateWidget extends StatelessWidget {
             child: Text(
               entity.isLocked ? "UNLOCK" : "LOCK",
               textAlign: TextAlign.right,
-              style:
+              style: HAClientTheme().getActionTextStyle(context),
-              new TextStyle(fontSize: Sizes.stateFontSize, color: Colors.blue),
             ),
           )
       );

lib/entities/media_player/media_player_entity.class.dart

@@ -84,12 +84,11 @@ class MediaPlayerEntity extends Entity {
   }
 
   bool canCalculateActualPosition() {
-    return positionLastUpdated != null && durationSeconds != null && positionSeconds != null && durationSeconds >= 0;
+    return positionLastUpdated != null && durationSeconds != null && positionSeconds != null && durationSeconds > 0;
   }
 
   double getActualPosition() {
     double result = 0;
-    if (canCalculateActualPosition()) {
     Duration durationD;
     Duration positionD;
     durationD = Duration(seconds: durationSeconds);
@@ -101,8 +100,6 @@ class MediaPlayerEntity extends Entity {
           .difference(positionLastUpdated)
           .inSeconds;
     result = ((result + differenceInSeconds) <= durationD.inSeconds) ? (result + differenceInSeconds) : durationD.inSeconds.toDouble();
-    }
-
     return result;
 
   }

lib/entities/media_player/widgets/media_player_progress_bar.widget.dart

@@ -22,18 +22,18 @@ class _MediaPlayerProgressBarState extends State<MediaPlayerProgressBar> {
   Widget build(BuildContext context) {
     final EntityModel entityModel = EntityModel.of(context);
     final MediaPlayerEntity entity = entityModel.entityWrapper.entity;
-    double progress;
+    double progress = 0;
     int currentPosition;
     if (entity.canCalculateActualPosition()) {
       currentPosition = entity.getActualPosition().toInt();
+      if (currentPosition > 0) {
           progress = (currentPosition <= entity.durationSeconds) ? currentPosition / entity.durationSeconds : 100;
-    } else {
+      }
-      progress = 0;
     }
     return LinearProgressIndicator(
       value: progress,
       backgroundColor: Colors.black45,
-      valueColor: AlwaysStoppedAnimation<Color>(EntityColor.stateColor(EntityState.on)),
+      valueColor: AlwaysStoppedAnimation<Color>(HAClientTheme().getOnStateColor(context)),
     );
   }
 

lib/entities/media_player/widgets/media_player_seek_bar.widget.dart

@@ -13,12 +13,6 @@ class _MediaPlayerSeekBarState extends State<MediaPlayerSeekBar> {
   double _currentPosition = 0;
   int _savedPosition = 0;
 
-  final TextStyle _seekTextStyle = TextStyle(
-      fontSize: 20,
-      color: Colors.blue,
-      fontWeight: FontWeight.bold
-  );
-
   @override
   initState() {
     super.initState();
@@ -53,8 +47,7 @@ class _MediaPlayerSeekBarState extends State<MediaPlayerSeekBar> {
         buttons.add(
             RaisedButton(
               child: Text("Jump to ${Duration(seconds: _savedPosition).toString().split('.')[0]}"),
-              color: Colors.orange,
+              color: Theme.of(context).accentColor,
-              focusColor: Colors.white,
               onPressed: () {
                 ConnectionManager().callService(
                     domain: "media_player",
@@ -79,7 +72,13 @@ class _MediaPlayerSeekBarState extends State<MediaPlayerSeekBar> {
               children: <Widget>[
                 Text("00:00"),
                 Expanded(
-                  child: Text("${Duration(seconds: _currentPosition.toInt()).toString().split(".")[0]}",textAlign: TextAlign.center, style: _seekTextStyle),
+                  child: Text(
+                    "${Duration(seconds: _currentPosition.toInt()).toString().split(".")[0]}",
+                    textAlign: TextAlign.center,
+                    style: Theme.of(context).textTheme.title.copyWith(
+                      color: Colors.blue
+                    )
+                  ),
                 ),
                 Text("${Duration(seconds: entity.durationSeconds).toString().split(".")[0]}")
               ],
@@ -87,8 +86,7 @@ class _MediaPlayerSeekBarState extends State<MediaPlayerSeekBar> {
             Container(height: 10,),
             Slider(
               min: 0,
-              activeColor: Colors.amber,
+              activeColor: Theme.of(context).accentColor,
-              inactiveColor: Colors.black26,
               max: entity.durationSeconds.toDouble(),
               value: _currentPosition,
               onChangeStart: (val) {

lib/entities/media_player/widgets/media_player_widgets.dart

@@ -12,14 +12,14 @@ class MediaPlayerWidget extends StatelessWidget {
         Stack(
           alignment: AlignmentDirectional.topEnd,
           children: <Widget>[
-            _buildImage(entity),
+            _buildImage(entity, context),
             Positioned(
               bottom: 0.0,
               left: 0.0,
               right: 0.0,
               child: Container(
                 color: Colors.black45,
-                child: _buildState(entity),
+                child: _buildState(entity, context),
               ),
             ),
             Positioned(
@@ -35,12 +35,9 @@ class MediaPlayerWidget extends StatelessWidget {
     );
   }
 
-  Widget _buildState(MediaPlayerEntity entity) {
+  Widget _buildState(MediaPlayerEntity entity, BuildContext context) {
-    TextStyle style = TextStyle(
+    TextStyle style = Theme.of(context).textTheme.body1.copyWith(
-        fontSize: 14.0,
+      color: Colors.white
-        color: Colors.white,
-        fontWeight: FontWeight.normal,
-        height: 1.2
     );
     List<Widget> states = [];
     states.add(Text("${entity.displayName}", style: style));
@@ -71,7 +68,7 @@ class MediaPlayerWidget extends StatelessWidget {
     );
   }
 
-  Widget _buildImage(MediaPlayerEntity entity) {
+  Widget _buildImage(MediaPlayerEntity entity, BuildContext context) {
     String state = entity.state;
     if (entity.entityPicture != null && state != EntityState.off && state != EntityState.unavailable && state != EntityState.idle) {
       return Container(
@@ -97,7 +94,7 @@ class MediaPlayerWidget extends StatelessWidget {
           Icon(
             MaterialDesignIcons.getIconDataFromIconName("mdi:movie"),
             size: 150.0,
-            color: EntityColor.stateColor("$state"),
+            color: HAClientTheme().getColorByEntityState("$state", context),
           )
         ],
       );
@@ -356,13 +353,13 @@ class _MediaPlayerControlsState extends State<MediaPlayerControls> {
         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)
+            ),
+            IconButton(
+                icon: Icon(MaterialDesignIcons.getIconDataFromIconName("mdi:plus")),
+                onPressed: () => _setVolumeUp(entity.entityId)
             )
           ],
         );
@@ -460,7 +457,11 @@ class _MediaPlayerControlsState extends State<MediaPlayerControls> {
   }
 
   void _duplicateTo(entity) {
+    if (entity.canCalculateActualPosition()) {
         HomeAssistant().savedPlayerPosition = entity.getActualPosition().toInt();
+    } else {
+        HomeAssistant().savedPlayerPosition = 0;
+    }
     Navigator.of(context).pushNamed("/play-media", arguments: {
         "url": entity.attributes["media_content_id"],
         "type": entity.attributes["media_content_type"]

lib/entities/simple_state.widget.dart

@@ -7,10 +7,10 @@ class SimpleEntityState extends StatelessWidget {
   final EdgeInsetsGeometry padding;
   final int maxLines;
   final String customValue;
-  final double fontSize;
+  final TextStyle textStyle;
-  final bool bold;
+  //final bool bold;
 
-  const SimpleEntityState({Key key,this.bold: false, this.maxLines: 10, this.fontSize: Sizes.stateFontSize, 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);
+  const SimpleEntityState({Key key,/*this.bold: false,*/ this.maxLines: 10, this.expanded: true, this.textAlign: TextAlign.right, this.textStyle, this.padding: const EdgeInsets.fromLTRB(0.0, 0.0, Sizes.rightWidgetPadding, 0.0), this.customValue}) : super(key: key);
 
   @override
   Widget build(BuildContext context) {
@@ -22,16 +22,19 @@ class SimpleEntityState extends StatelessWidget {
     } else {
       state = customValue;
     }
-    TextStyle textStyle =  TextStyle(
+    TextStyle tStyle;
-      fontSize: this.fontSize,
+    if (textStyle != null) {
-      fontWeight: FontWeight.normal
+      tStyle = textStyle;
+    } else if (entityModel.entityWrapper.entity.statelessType == StatelessEntityType.callService) {
+      tStyle = Theme.of(context).textTheme.subhead.copyWith(
+        color: Colors.blue
       );
-    if (entityModel.entityWrapper.entity.statelessType == StatelessEntityType.CALL_SERVICE) {
+    } else {
-      textStyle = textStyle.apply(color: Colors.blue);
+      tStyle = Theme.of(context).textTheme.body1;
     }
-    if (this.bold) {
+    /*if (this.bold) {
       textStyle = textStyle.apply(fontWeightDelta: 100);
-    }
+    }*/
     while (state.contains("  ")){
       state = state.replaceAll("  ", " ");
     }
@@ -43,7 +46,7 @@ class SimpleEntityState extends StatelessWidget {
         maxLines: maxLines,
         overflow: TextOverflow.ellipsis,
         softWrap: true,
-        style: textStyle
+        style: tStyle
       )
     );
     if (expanded) {

lib/entities/slider/widgets/slider_controls.dart

@@ -62,8 +62,7 @@ class _SliderControlsWidgetState extends State<SliderControlsWidget> {
       children: <Widget>[
         Text(
           "$_newValue",
-          style: TextStyle(
+          style: Theme.of(context).textTheme.display1.copyWith(
-            fontSize: Sizes.largeFontSize,
             color: Colors.blue
           ),
         ),

lib/entities/timer/widgets/timer_state.dart

@@ -27,7 +27,7 @@ class _TimerStateState extends State<TimerState> {
             try {
               int passed = DateTime
                   .now()
-                  .difference(entity._lastUpdated)
+                  .difference(entity.lastUpdatedTimestamp)
                   .inSeconds;
               remaining = Duration(seconds: entity.duration.inSeconds - passed);
             } catch (e) {

lib/entities/universal_slider.widget.dart

@@ -1,6 +1,6 @@
 part of '../main.dart';
 
-class UniversalSlider extends StatelessWidget {
+class UniversalSlider extends StatefulWidget {
 
   final onChanged;
   final onChangeEnd;
@@ -14,36 +14,69 @@ class UniversalSlider extends StatelessWidget {
 
   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
+  State<StatefulWidget> createState() {
+    return UniversalSliderState();
+  }
+
+}
+
+class UniversalSliderState extends State<UniversalSlider> {
+
+  double _value;
+  bool _changeStarted = false;
+
+  @override
+  void initState() {
+    _value = widget.value;
+    super.initState();
+  }
+
   @override
   Widget build(BuildContext context) {
     List <Widget> row = [];
-    if (leading != null) {
+    if (widget.leading != null) {
-      row.add(leading);
+      row.add(widget.leading);
     }
     row.add(
       Flexible(
         child: Slider(
-            value: value,
+          value: _value,
-            min: min,
+          min: widget.min,
-            max: max,
+          max: widget.max,
-            onChanged: (value) => onChanged(value),
+          onChangeStart: (_) {
-            onChangeEnd: (value) => onChangeEnd(value),
+            _changeStarted = true; 
+          },
+          onChanged: (value) {
+            setState(() {
+              _value = value;
+            });
+            widget.onChanged(value);
+          },
+          onChangeEnd: (value) {
+            _changeStarted = false;
+            Timer(Duration(milliseconds: 500), () {
+              if (!_changeStarted) {
+                setState(() {
+                  _value = value;
+                });
+                widget.onChangeEnd(value);
+              }
+            });
+          }
         ),
       )
     );
-    if (closing != null) {
+    if (widget.closing != null) {
-      row.add(closing);
+      row.add(widget.closing);
     }
     return Padding(
-      padding: padding,
+      padding: widget.padding,
       child: Column(
         crossAxisAlignment: CrossAxisAlignment.start,
         children: <Widget>[
           Container(height: Sizes.rowPadding,),
-          Text(
+          Text('${widget.title}'),
-            "$title",
-            style: TextStyle(fontSize: Sizes.stateFontSize),
-          ),
           Container(height: Sizes.rowPadding,),
           Row(
             mainAxisSize: MainAxisSize.min,
@@ -54,5 +87,4 @@ class UniversalSlider extends StatelessWidget {
       ),
     );
   }
-
 }

lib/entities/vacuum/widgets/vacuum_controls.dart

@@ -10,7 +10,7 @@ class VacuumControls extends StatelessWidget {
       child: Column(
         mainAxisSize: MainAxisSize.min,
         children: <Widget>[
-          _buildStatusAndBattery(entity),
+          _buildStatusAndBattery(entity, context),
           _buildCommands(entity),
           _buildFanSpeed(entity),
           _buildAdditionalInfo(entity)
@@ -19,12 +19,12 @@ class VacuumControls extends StatelessWidget {
     );
   }
 
-  Widget _buildStatusAndBattery(VacuumEntity entity) {
+  Widget _buildStatusAndBattery(VacuumEntity entity, BuildContext context) {
     List<Widget> result = [];
     if (entity.supportStatus) {
       result.addAll(
           <Widget>[
-            Text("Status:", style: TextStyle(fontSize: Sizes.stateFontSize),),
+            Text("Status:"),
             Container(width: 6,),
             Expanded(
               //flex: 1,
@@ -33,10 +33,7 @@ class VacuumControls extends StatelessWidget {
                 maxLines: 1,
                 softWrap: true,
                 overflow: TextOverflow.ellipsis,
-                style: TextStyle(
+                style: Theme.of(context).textTheme.body2,
-                    fontSize: Sizes.stateFontSize,
-                    fontWeight: FontWeight.bold
-                ),
               ),
             ),
           ]
@@ -48,7 +45,7 @@ class VacuumControls extends StatelessWidget {
       result.addAll(<Widget>[
         Icon(MaterialDesignIcons.getIconDataFromIconName(iconName)),
         Container(width: 6,),
-        Text("$batteryLevel %", style: TextStyle(fontSize: Sizes.stateFontSize))
+        Text("$batteryLevel %")
       ]
       );
     }
@@ -172,7 +169,7 @@ class VacuumControls extends StatelessWidget {
         mainAxisSize: MainAxisSize.min,
         crossAxisAlignment: CrossAxisAlignment.start,
         children: <Widget>[
-          Text("Vacuum cleaner commands:", style: TextStyle(fontSize: Sizes.stateFontSize)),
+          Text("Vacuum cleaner commands:"),
           Container(height: Sizes.rowPadding,),
           Row(
             mainAxisSize: MainAxisSize.max,

lib/entities/vacuum/widgets/vacuum_state_button.dart

@@ -27,10 +27,7 @@ class VacuumStateButton extends StatelessWidget {
           text: "RETURN TO DOCK"
       );
     } else {
-      result = Text(entity.state.toUpperCase(), style: TextStyle(
+      result = Text(entity.state.toUpperCase(), style: Theme.of(context).textTheme.subhead);
-          fontSize: 16,
-          color: Colors.grey
-      ));
     }
     return Padding(
       padding: EdgeInsets.only(right: 15),

lib/entity_collection.class.dart

@@ -152,39 +152,12 @@ class EntityCollection {
     return _allEntities[entityId] != null;
   }
 
-  List<Entity> getByDomains({List<String> domains, List<String> stateFiler}) {
+  List<Entity> getByDomains({List<String> includeDomains: const [], List<String> excludeDomains: const [], List<String> stateFiler}) {
     return _allEntities.values.where((entity) {
-      return domains.contains(entity.domain) &&
+      return
+        (excludeDomains.isEmpty || !excludeDomains.contains(entity.domain)) && 
+        (includeDomains.isEmpty || includeDomains.contains(entity.domain)) &&
         ((stateFiler != null && stateFiler.contains(entity.state)) || stateFiler == null);
     }).toList();
   }
-
-  List<Entity> filterEntitiesForDefaultView() {
-    List<Entity> result = [];
-    List<Entity> groups = [];
-    List<Entity> nonGroupEntities = [];
-    _allEntities.forEach((id, entity){
-      if (entity.isGroup && (entity.attributes['auto'] == null || (entity.attributes['auto'] && !entity.isHidden)) && (!entity.isView)) {
-        groups.add(entity);
-      }
-      if (!entity.isGroup) {
-        nonGroupEntities.add(entity);
-      }
-    });
-
-    nonGroupEntities.forEach((entity) {
-      bool foundInGroup = false;
-      groups.forEach((groupEntity) {
-        if (groupEntity.childEntityIds.contains(entity.entityId)) {
-          foundInGroup = true;
-        }
-      });
-      if (!foundInGroup) {
-        result.add(entity);
-      }
-    });
-    result.insertAll(0, groups);
-
-    return result;
-  }
 }

lib/home_assistant.class.dart

@@ -2,6 +2,8 @@ part of 'main.dart';
 
 class HomeAssistant {
 
+  static const DEFAULT_DASHBOARD = 'lovelace';
+
   static final HomeAssistant _instance = HomeAssistant._internal();
 
   factory HomeAssistant() {
@@ -11,69 +13,73 @@ class HomeAssistant {
   EntityCollection entities;
   HomeAssistantUI ui;
   Map _instanceConfig = {};
-  Map services;
   String _userName;
-  bool childMode;
+  String _lovelaceDashbordUrl;
   HSVColor savedColor;
   int savedPlayerPosition;
   String sendToPlayerId;
   String sendFromPlayerId;
+  Map services;
+  bool autoUi = false;
 
   String fcmToken;
 
   Map _rawLovelaceData;
+  var _rawStates;
+  var _rawUserInfo;
+  var _rawPanels;
+
+  set lovelaceDashboardUrl(String val) => _lovelaceDashbordUrl = val;
 
   List<Panel> panels = [];
 
   Duration fetchTimeout = Duration(seconds: 30);
 
   String get locationName {
-    if (ConnectionManager().useLovelace) {
+    if (!autoUi) {
-      return ui?.title ?? "";
+      return ui?.title ?? "Home";
     } else {
-      return _instanceConfig["location_name"] ?? "";
+      return _instanceConfig["location_name"] ?? "Home";
     }
   }
   String get userName => _userName ?? locationName;
   String get userAvatarText => userName.length > 0 ? userName[0] : "";
   bool get isNoEntities => entities == null || entities.isEmpty;
   bool get isNoViews => ui == null || ui.isEmpty;
-  bool get isMobileAppEnabled => _instanceConfig["components"] != null && (_instanceConfig["components"] as List).contains("mobile_app");
 
   HomeAssistant._internal() {
     ConnectionManager().onStateChangeCallback = _handleEntityStateChange;
+    ConnectionManager().onLovelaceUpdatedCallback = _handleLovelaceUpdate;
     DeviceInfoManager().loadDeviceInfo();
   }
 
   Completer _fetchCompleter;
 
-  Future fetchData() {
+  Future fetchData(bool uiOnly) {
     if (_fetchCompleter != null && !_fetchCompleter.isCompleted) {
       Logger.w("Previous data fetch is not completed yet");
       return _fetchCompleter.future;
     }
-    if (entities == null) entities = EntityCollection(ConnectionManager().httpWebHost);
     _fetchCompleter = Completer();
     List<Future> futures = [];
-    futures.add(_getStates());
+    if (!uiOnly) {
-    if (ConnectionManager().useLovelace) {
+      if (entities == null) entities = EntityCollection(ConnectionManager().httpWebHost);
-      futures.add(_getLovelace());
+      futures.add(_getStates(null));
+      futures.add(_getConfig(null));
+      futures.add(_getUserInfo(null));
+      futures.add(_getPanels(null));
+      futures.add(_getServices(null));
+    }
+    if (!autoUi) {
+      futures.add(_getLovelace(null));
     }
-    futures.add(_getConfig());
-    futures.add(_getServices());
-    futures.add(_getUserInfo());
-    futures.add(_getPanels());
-    futures.add(ConnectionManager().sendSocketMessage(
-      type: "subscribe_events",
-      additionalData: {"event_type": "state_changed"},
-    ));
     Future.wait(futures).then((_) {
-      if (isMobileAppEnabled) {
+      if (isComponentEnabled('mobile_app')) {
-        if (!childMode) _createUI();
+        _createUI();
         _fetchCompleter.complete();
-        MobileAppIntegrationManager.checkAppRegistration();
+        if (!uiOnly) MobileAppIntegrationManager.checkAppRegistration();
       } else {
-        _fetchCompleter.completeError(HAError("Mobile app component not found", actions: [HAErrorAction.tryAgain(), HAErrorAction(type: HAErrorActionType.URL ,title: "Help",url: "http://ha-client.homemade.systems/docs#mobile-app-integration")]));
+        _fetchCompleter.completeError(HAError("Mobile app component not found", actions: [HAErrorAction.tryAgain(), HAErrorAction(type: HAErrorActionType.URL ,title: "Help",url: "http://ha-client.app/docs#mobile-app-integration")]));
       }
     }).catchError((e) {
       _fetchCompleter.completeError(e);
@@ -81,6 +87,48 @@ class HomeAssistant {
     return _fetchCompleter.future;
   }
 
+  Future<void> fetchDataFromCache() async {
+    Logger.d('Loading cached data');
+    SharedPreferences prefs = await SharedPreferences.getInstance();
+    bool cached = prefs.getBool('cached');
+    if (cached != null && cached) {
+      if (entities == null) entities = EntityCollection(ConnectionManager().httpWebHost);
+      try {
+        _getStates(prefs);
+        if (!autoUi) {
+          _getLovelace(prefs);
+        }
+        _getConfig(prefs);
+        _getUserInfo(prefs);
+        _getPanels(prefs);
+        _getServices(prefs);
+        if (isComponentEnabled('mobile_app')) {
+          _createUI();
+        }  
+      } catch (e) {
+        Logger.d('Didnt get cached data: $e');  
+      }
+    }
+  }
+
+  void saveCache() async {
+    Logger.d('Saving data to cache...');
+    SharedPreferences prefs = await SharedPreferences.getInstance();
+    try {
+      await prefs.setString('cached_states', json.encode(_rawStates));
+      await prefs.setString('cached_lovelace', json.encode(_rawLovelaceData));
+      await prefs.setString('cached_user', json.encode(_rawUserInfo));
+      await prefs.setString('cached_config', json.encode(_instanceConfig));
+      await prefs.setString('cached_panels', json.encode(_rawPanels));
+      await prefs.setString('cached_services', json.encode(services));
+      await prefs.setBool('cached', true);
+    } catch (e) {
+      await prefs.setBool('cached', false);
+      Logger.e('Error saving cache: $e');
+    }
+    Logger.d('Done saving cache');
+  }
+
   Future logout() async {
     Logger.d("Logging out...");
     await ConnectionManager().logout().then((_) {
@@ -90,30 +138,75 @@ class HomeAssistant {
     });
   }
 
-  Future _getConfig() async {
+  Future _getConfig(SharedPreferences sharedPrefs) async {
-    await ConnectionManager().sendSocketMessage(type: "get_config").then((data) {
+    if (sharedPrefs != null) {
-      _instanceConfig = Map.from(data);
+      try {
-    }).catchError((e) {
+        var data = json.decode(sharedPrefs.getString('cached_config'));
-      throw HAError("Error getting config: ${e}");
+        _parseConfig(data);
+      } catch (e) {
+        throw HAError("Error getting config: $e");
+      }
+    } else {
+      await ConnectionManager().sendSocketMessage(type: "get_config").then((data) => _parseConfig(data)).catchError((e) {
+        throw HAError("Error getting config: $e");
       });
     }
+  }
 
-  Future _getStates() async {
+  void _parseConfig(data) {
+    _instanceConfig = Map.from(data);
+    Logger.d('stream: ${_instanceConfig['components'].contains('stream')}');
+  }
+
+  Future _getStates(SharedPreferences sharedPrefs) async {
+    if (sharedPrefs != null) {
+      try {
+        var data = json.decode(sharedPrefs.getString('cached_states'));
+        _parseStates(data);
+      } catch (e) {
+        throw HAError("Error getting states: $e");
+      }
+    } else {
       await ConnectionManager().sendSocketMessage(type: "get_states").then(
-            (data) => entities.parse(data)
+              (data) => _parseStates(data)
       ).catchError((e) {
         throw HAError("Error getting states: $e");
       });
     }
+  }
 
-  Future _getLovelace() {
+  void _parseStates(data) {
+    _rawStates = data;
+    entities.parse(data);
+  }
+
+  Future _getLovelace(SharedPreferences sharedPrefs) {
+    if (sharedPrefs != null) {
+      try {
+        var data = json.decode(sharedPrefs.getString('cached_lovelace'));
+        _rawLovelaceData = data;
+      } catch (e) {
+        autoUi = true;
+      }
+      return Future.value();
+    } else {
       Completer completer = Completer();
-    ConnectionManager().sendSocketMessage(type: "lovelace/config").then((data) {
+      var additionalData;
+      if (_lovelaceDashbordUrl != HomeAssistant.DEFAULT_DASHBOARD) {
+        additionalData = {
+          'url_path': _lovelaceDashbordUrl
+        };
+      }
+      ConnectionManager().sendSocketMessage(
+        type: 'lovelace/config',
+        additionalData: additionalData
+      ).then((data) {
         _rawLovelaceData = data;
         completer.complete();
       }).catchError((e) {
         if ("$e" == "config_not_found") {
-        ConnectionManager().useLovelace = false;
+          autoUi = true;
+          _rawLovelaceData = null;
           completer.complete();
         } else {
           completer.completeError(HAError("Error getting lovelace config: $e"));
@@ -121,49 +214,110 @@ class HomeAssistant {
       });
       return completer.future;
     }
-
-  Future _getUserInfo() async {
-    _userName = null;
-    await ConnectionManager().sendSocketMessage(type: "auth/current_user").then((data) {
-        _userName = data["name"];
-        childMode = _userName.startsWith("[child]");
-    }).catchError((e) {
-      Logger.w("Can't get user info: $e");
-    });
   }
 
-  Future _getServices() async {
+  Future _getServices(SharedPreferences prefs) async {	
-    await ConnectionManager().sendSocketMessage(type: "get_services").then((data) {
+    if (prefs != null) {
-      Logger.d("Got ${data.length} services");
+      try {
-      services = data;
+        var data = json.decode(prefs.getString('cached_services'));
-    }).catchError((e) {
+        _parseServices(data);
+      } catch (e) {
+        Logger.w("Can't get services: $e");  
+      }
+    }
+    await ConnectionManager().sendSocketMessage(type: "get_services").then((data) => _parseServices(data)).catchError((e) {	
       Logger.w("Can't get services: $e");	
     });	
   }
 
-  Future _getPanels() async {
+  void _parseServices(data) {
-    panels.clear();
+    services = data;
-    await ConnectionManager().sendSocketMessage(type: "get_panels").then((data) {
+  }
-      data.forEach((k,v) {
+
-        String title = v['title'] == null ? "${k[0].toUpperCase()}${k.substring(1)}" : "${v['title'][0].toUpperCase()}${v['title'].substring(1)}";
+  Future _getUserInfo(SharedPreferences sharedPrefs) async {
-        panels.add(Panel(
+    _userName = null;
-            id: k,
+    await ConnectionManager().sendSocketMessage(type: "auth/current_user").then((data) => _parseUserInfo(data)).catchError((e) {
-            type: v["component_name"],
+      Logger.w("Can't get user info: $e");
-            title: title,
-            urlPath: v["url_path"],
-            config: v["config"],
-            icon: v["icon"]
-        )
-        );
     });
-    }).catchError((e) {
+  }
+
+  void _parseUserInfo(data) {
+    _rawUserInfo = data;
+    _userName = data["name"];
+  }
+
+  Future _getPanels(SharedPreferences sharedPrefs) async {
+    if (sharedPrefs != null) {
+      try {
+        var data = json.decode(sharedPrefs.getString('cached_panels'));
+        _parsePanels(data);
+      } catch (e) {
+        throw HAError("Error getting panels list: $e");
+      }
+    } else {
+      await ConnectionManager().sendSocketMessage(type: "get_panels").then((data) => _parsePanels(data)).catchError((e) {
         throw HAError("Error getting panels list: $e");
       });
     }
+  }
+
+  void _parsePanels(data) {
+    _rawPanels = data;
+    panels.clear();
+    List<Panel> dashboards = [];
+    data.forEach((k,v) {
+        String title = v['title'] == null ? "${k[0].toUpperCase()}${k.substring(1)}" : "${v['title'][0].toUpperCase()}${v['title'].substring(1)}";
+        if (v['component_name'] != null && v['component_name'] == 'lovelace') {
+          dashboards.add(
+            Panel(
+              id: k,
+              componentName: v['component_name'],
+              title: title,
+              urlPath: v['url_path'],
+              config: v['config'],
+              icon: (v['icon'] == null || v['icon'] == 'hass:view-dashboard') ? 'mdi:view-dashboard' : v['icon']
+            )  
+          );
+        } else {
+          panels.add(
+            Panel(
+              id: k,
+              componentName: v['component_name'],
+              title: title,
+              urlPath: v['url_path'],
+              config: v['config'],
+              icon: v['icon']
+            )
+          );
+        }
+    });
+    panels.insertAll(0, dashboards);
+  }
+
+  Future getCameraStream(String entityId) {
+    Completer completer = Completer();
+
+    ConnectionManager().sendSocketMessage(type: "camera/stream", additionalData: {"entity_id": entityId}).then((data) {
+      completer.complete(data);
+    }).catchError((e) {
+      completer.completeError(e);
+    });
+    return completer.future;
+  }
+
+  bool isComponentEnabled(String name) {
+    return _instanceConfig["components"] != null && (_instanceConfig["components"] as List).contains("$name");
+  }
+
+  void _handleLovelaceUpdate() {
+    if (_fetchCompleter != null && _fetchCompleter.isCompleted) {
+      eventBus.fire(new LovelaceChangedEvent());
+    }
+  }
 
   void _handleEntityStateChange(Map eventData) {
     //TheLogger.debug( "New state for ${eventData['entity_id']}");
-    if (_fetchCompleter.isCompleted) {
+    if (_fetchCompleter != null && _fetchCompleter.isCompleted) {
       Map data = Map.from(eventData);
       eventBus.fire(new StateChangedEvent(
           entityId: data["entity_id"],
@@ -172,214 +326,26 @@ class HomeAssistant {
     }
   }
 
-  void _parseLovelace() {
+  bool isServiceExist(String service) {
-      Logger.d("--Title: ${_rawLovelaceData["title"]}");
+    return services != null &&
-      ui.title = _rawLovelaceData["title"];
+      services.isNotEmpty &&
-      int viewCounter = 0;
+      services.containsKey(service);
-      Logger.d("--Views count: ${_rawLovelaceData['views'].length}");
-      _rawLovelaceData["views"].forEach((rawView){
-        Logger.d("----view id: ${rawView['id']}");
-        HAView view = HAView(
-            count: viewCounter,
-            id: "${rawView['id']}",
-            name: rawView['title'],
-            iconName: rawView['icon'],
-            panel: rawView['panel'] ?? false,
-        );
-
-        if (rawView['badges'] != null && rawView['badges'] is List) {
-          rawView['badges'].forEach((entity) {
-            if (entity is String) {
-              if (entities.isExist(entity)) {
-                Entity e = entities.get(entity);
-                view.badges.add(e);
-              }
-            } else {
-              String eId = '${entity['entity']}';
-              if (entities.isExist(eId)) {
-                Entity e = entities.get(eId);
-                view.badges.add(e);
-              }
-            }
-          });
-        }
-
-        view.cards.addAll(_createLovelaceCards(rawView["cards"] ?? []));
-        ui.views.add(
-            view
-        );
-        viewCounter += 1;
-      });
-  }
-
-  List<HACard> _createLovelaceCards(List rawCards) {
-    List<HACard> result = [];
-    rawCards.forEach((rawCard){
-      try {
-        //bool isThereCardOptionsInside = rawCard["card"] != null;
-        var rawCardInfo =  rawCard["card"] ?? rawCard;
-        if (rawCardInfo['state_filter'] != null) {
-            Logger.d("Hey!!!!!! We found a card with state filter: ${rawCardInfo['state_filter']}");
-        }
-        HACard card = HACard(
-            id: "card",
-            name: rawCardInfo["title"] ?? rawCardInfo["name"],
-            type: rawCardInfo['type'] ?? CardType.ENTITIES,
-            columnsCount: rawCardInfo['columns'] ?? 4,
-            showName: rawCardInfo['show_name'] ?? true,
-            showState: rawCardInfo['show_state'] ?? true,
-            showEmpty: rawCardInfo['show_empty'] ?? true,
-            stateFilter: (rawCard['state_filter'] ?? rawCardInfo['state_filter']) ?? [],
-            states: rawCardInfo['states'],
-            conditions: rawCard['conditions'] ?? [],
-            content: rawCardInfo['content'],
-            min: rawCardInfo['min'] ?? 0,
-            max: rawCardInfo['max'] ?? 100,
-            unit: rawCardInfo['unit'],
-            severity: rawCardInfo['severity']
-        );
-        if (rawCardInfo["cards"] != null) {
-          card.childCards = _createLovelaceCards(rawCardInfo["cards"]);
-        }
-        var rawEntities = rawCard["entities"] ?? rawCardInfo["entities"];
-        rawEntities?.forEach((rawEntity) {
-          if (rawEntity is String) {
-            if (entities.isExist(rawEntity)) {
-              card.entities.add(EntityWrapper(entity: entities.get(rawEntity)));
-            } else {
-              card.entities.add(EntityWrapper(entity: Entity.missed(rawEntity)));
-            }
-          } else {
-            if (rawEntity["type"] == "divider") {
-              card.entities.add(EntityWrapper(entity: Entity.divider()));
-            } else if (rawEntity["type"] == "section") {
-              card.entities.add(EntityWrapper(entity: Entity.section(rawEntity["label"] ?? "")));
-            } else if (rawEntity["type"] == "call-service") {
-              Map uiActionData = {
-                "tap_action": {
-                  "action": EntityUIAction.callService,
-                  "service": rawEntity["service"],
-                  "service_data": rawEntity["service_data"]
-                },
-                "hold_action": EntityUIAction.none
-              };
-              card.entities.add(EntityWrapper(
-                  entity: Entity.callService(
-                    icon: rawEntity["icon"],
-                    name: rawEntity["name"],
-                    service: rawEntity["service"],
-                    actionName: rawEntity["action_name"]
-                  ),
-                uiAction: EntityUIAction(rawEntityData: uiActionData)
-              )
-              );
-            } else if (rawEntity["type"] == "weblink") {
-              Map uiActionData = {
-                "tap_action": {
-                  "action": EntityUIAction.navigate,
-                  "service": rawEntity["url"]
-                },
-                "hold_action": EntityUIAction.none
-              };
-              card.entities.add(EntityWrapper(
-                  entity: Entity.weblink(
-                      icon: rawEntity["icon"],
-                      name: rawEntity["name"],
-                      url: rawEntity["url"]
-                  ),
-                  uiAction: EntityUIAction(rawEntityData: uiActionData)
-              )
-              );
-            } else if (entities.isExist(rawEntity["entity"])) {
-              Entity e = entities.get(rawEntity["entity"]);
-              card.entities.add(
-                  EntityWrapper(
-                      entity: e,
-                      displayName: rawEntity["name"],
-                      icon: rawEntity["icon"],
-                      uiAction: EntityUIAction(rawEntityData: rawEntity)
-                  )
-              );
-            } else {
-              card.entities.add(EntityWrapper(entity: Entity.missed(rawEntity["entity"])));
-            }
-          }
-        });
-        var rawSingleEntity = rawCard["entity"] ?? rawCardInfo["entity"];
-        if (rawSingleEntity != null) {
-          var en = rawSingleEntity;
-          if (en is String) {
-            if (entities.isExist(en)) {
-              Entity e = entities.get(en);
-              card.linkedEntityWrapper = EntityWrapper(
-                  entity: e,
-                  icon: rawCardInfo["icon"],
-                  displayName: rawCardInfo["name"],
-                  uiAction: EntityUIAction(rawEntityData: rawCard)
-              );
-            } else {
-              card.linkedEntityWrapper = EntityWrapper(entity: Entity.missed(en));
-            }
-          } else {
-            if (entities.isExist(en["entity"])) {
-              Entity e = entities.get(en["entity"]);
-              card.linkedEntityWrapper = EntityWrapper(
-                  entity: e,
-                  icon: en["icon"],
-                  displayName: en["name"],
-                  uiAction: EntityUIAction(rawEntityData: rawCard)
-              );
-            } else {
-              card.linkedEntityWrapper = EntityWrapper(entity: Entity.missed(en["entity"]));
-            }
-          }
-        }
-        result.add(card);
-      } catch (e) {
-          Logger.e("There was an error parsing card: ${e.toString()}");
-      }
-    });
-    return result;
   }
 
   void _createUI() {
-    ui = HomeAssistantUI();
-    if ((ConnectionManager().useLovelace) && (_rawLovelaceData != null)) {
     Logger.d("Creating Lovelace UI");
-      _parseLovelace();
+    ui = HomeAssistantUI(rawLovelaceConfig: _rawLovelaceData);
-    } else {
+    /*if (isServiceExist('zha_map')) {
-      Logger.d("Creating group-based UI");
+      panels.add(
-      int viewCounter = 0;
+          Panel(
-      if (!entities.hasDefaultView) {
+            id: 'haclient_zha',
-        HAView view = HAView(
+            componentName: 'haclient_zha',
-            count: viewCounter,
+            title: 'ZHA',
-            id: "group.default_view",
+            urlPath: '/haclient_zha',
-            name: "Home",
+            icon: 'mdi:zigbee'
-            childEntities: entities.filterEntitiesForDefaultView()
+          )
         );
-        ui.views.add(
+    }*/
-            view
-        );
-        viewCounter += 1;
-      }
-      entities.viewEntities.forEach((viewEntity) {
-        HAView view = HAView(
-            count: viewCounter,
-            id: viewEntity.entityId,
-            name: viewEntity.displayName,
-            childEntities: viewEntity.childEntities
-        );
-        view.linkedEntity = viewEntity;
-        ui.views.add(
-            view
-        );
-        viewCounter += 1;
-      });
-    }
-  }
-
-  Widget buildViews(BuildContext context, TabController tabController) {
-    return ui.build(context, tabController);
   }
 }
 

lib/main.dart

@@ -1,6 +1,7 @@
 import 'dart:convert';
 import 'dart:async';
-import 'dart:math';
+import 'dart:math' as math;
+import 'package:flutter/foundation.dart';
 import 'package:flutter/rendering.dart';
 import 'package:flutter/material.dart';
 import 'package:shared_preferences/shared_preferences.dart';
@@ -13,7 +14,6 @@ import 'package:flutter/services.dart';
 import 'package:date_format/date_format.dart';
 import 'package:http/http.dart' as http;
 import 'package:charts_flutter/flutter.dart' as charts;
-import 'package:progress_indicators/progress_indicators.dart';
 import 'package:flutter_markdown/flutter_markdown.dart';
 import 'package:flutter_custom_tabs/flutter_custom_tabs.dart';
 import 'package:firebase_messaging/firebase_messaging.dart';
@@ -21,17 +21,19 @@ import 'package:flutter_secure_storage/flutter_secure_storage.dart';
 import 'package:device_info/device_info.dart';
 import 'package:flutter_local_notifications/flutter_local_notifications.dart';
 import 'package:in_app_purchase/in_app_purchase.dart';
-import 'plugins/circular_slider/single_circular_slider.dart';
-import 'package:share/receive_share_state.dart';
-import 'package:share/share.dart';
 import 'plugins/dynamic_multi_column_layout.dart';
 import 'plugins/spoiler_card.dart';
-import 'package:uni_links/uni_links.dart';
 import 'package:workmanager/workmanager.dart' as workManager;
 import 'package:geolocator/geolocator.dart';
 import 'package:battery/battery.dart';
+import 'package:firebase_crashlytics/firebase_crashlytics.dart';
+import 'package:flutter_webview_plugin/flutter_webview_plugin.dart' as standaloneWebview;
+import 'package:webview_flutter/webview_flutter.dart';
+import 'package:syncfusion_flutter_core/core.dart';
+import 'package:syncfusion_flutter_gauges/gauges.dart';
 
 import 'utils/logger.dart';
+import '.secrets.dart';
 
 part 'const.dart';
 part 'utils/launcher.dart';
@@ -60,8 +62,7 @@ part 'entities/badge.widget.dart';
 part 'entities/entity_model.widget.dart';
 part 'entities/default_entity_container.widget.dart';
 part 'entities/missed_entity.widget.dart';
-part 'cards/widgets/glance_card_entity_container.dart';
+part 'cards/entity_button_card.dart';
-part 'cards/widgets/entity_button_card_body.widget.dart';
 part 'pages/widgets/entity_attributes_list.dart';
 part 'entities/entity_icon.widget.dart';
 part 'entities/entity_name.widget.dart';
@@ -72,7 +73,6 @@ part 'entities/universal_slider.widget.dart';
 part 'entities/flat_service_button.widget.dart';
 part 'entities/light/widgets/light_color_picker.dart';
 part 'entities/camera/widgets/camera_stream_view.dart';
-part 'entities/entity_colors.class.dart';
 part 'plugins/history_chart/entity_history.dart';
 part 'plugins/history_chart/simple_state_history_chart.dart';
 part 'plugins/history_chart/numeric_state_history_chart.dart';
@@ -84,6 +84,7 @@ part 'entities/slider/widgets/slider_controls.dart';
 part 'entities/text/widgets/text_input_state.dart';
 part 'entities/select/widgets/select_state.dart';
 part 'entities/simple_state.widget.dart';
+part 'entities/entity_picture.widget.dart';
 part 'entities/timer/widgets/timer_state.dart';
 part 'entities/climate/widgets/climate_state.widget.dart';
 part 'entities/cover/widgets/cover_state.dart';
@@ -99,14 +100,18 @@ part 'entities/alarm_control_panel/widgets/alarm_control_panel_controls.widget.d
 part 'entities/vacuum/vacuum_entity.class.dart';
 part 'entities/vacuum/widgets/vacuum_controls.dart';
 part 'entities/vacuum/widgets/vacuum_state_button.dart';
-part 'pages/settings.page.dart';
+part 'pages/settings/connection_settings.part.dart';
 part 'pages/purchase.page.dart';
 part 'pages/widgets/product_purchase.widget.dart';
 part 'pages/widgets/page_loading_indicator.dart';
+part 'pages/widgets/bottom_info_bar.dart';
 part 'pages/widgets/page_loading_error.dart';
 part 'pages/panel.page.dart';
-part 'pages/main.page.dart';
+part 'pages/main/main.page.dart';
-part 'pages/integration_settings.page.dart';
+part 'pages/settings/integration_settings.part.dart';
+part 'pages/settings/app_settings.page.dart';
+part 'pages/settings/lookandfeel_settings.part.dart';
+part 'pages/zha_page.dart';
 part 'home_assistant.class.dart';
 part 'pages/log.page.dart';
 part 'pages/entity.page.dart';
@@ -118,80 +123,190 @@ part 'managers/mobile_app_integration_manager.class.dart';
 part 'managers/connection_manager.class.dart';
 part 'managers/device_info_manager.class.dart';
 part 'managers/startup_user_messages_manager.class.dart';
+part 'managers/theme_manager.dart';
 part 'ui.dart';
 part 'view.class.dart';
 part 'cards/card.class.dart';
 part 'panels/panel_class.dart';
 part 'viewWidget.widget.dart';
-part 'cards/card_widget.dart';
 part 'cards/widgets/card_header.widget.dart';
 part 'panels/config_panel_widget.dart';
 part 'panels/widgets/link_to_web_config.dart';
 part 'types/ha_error.dart';
 part 'types/event_bus_events.dart';
-part 'cards/widgets/gauge_card_body.dart';
+part 'cards/gauge_card.dart';
-part 'cards/widgets/light_card_body.dart';
+part 'cards/widgets/card_wrapper.widget.dart';
+part 'cards/entities_card.dart';
+part 'cards/alarm_panel_card.dart';
+part 'cards/horizontal_srack_card.dart';
+part 'cards/markdown_card.dart';
+part 'cards/media_control_card.dart';
+part 'cards/unsupported_card.dart';
+part 'cards/vertical_stack_card.dart';
+part 'cards/glance_card.dart';
 part 'pages/play_media.page.dart';
 part 'entities/entity_page_layout.widget.dart';
 part 'entities/media_player/widgets/media_player_seek_bar.widget.dart';
 part 'entities/media_player/widgets/media_player_progress_bar.widget.dart';
 part 'pages/whats_new.page.dart';
+part 'pages/fullscreen.page.dart';
 
 EventBus eventBus = new EventBus();
 final FirebaseMessaging _firebaseMessaging = FirebaseMessaging();
 FlutterLocalNotificationsPlugin flutterLocalNotificationsPlugin = new FlutterLocalNotificationsPlugin();
 const String appName = "HA Client";
-const appVersionNumber = "0.7.2";
+const appVersionNumber = "0.8.5";
 const appVersionAdd = "";
-const appVersion = "$appVersionNumber-$appVersionAdd";
+const appVersion = "$appVersionNumber$appVersionAdd";
+
+Future<void> _reportError(dynamic error, dynamic stackTrace) async {
+    // Print the exception to the console.
+    if (Logger.isInDebugMode) {
+      Logger.e('Caught error: $error');
+      Logger.p(stackTrace);
+    }
+    Crashlytics.instance.recordError(error, stackTrace);
+
+}
 
 void main() async {
-  FlutterError.onError = (errorDetails) {
+  Crashlytics.instance.enableInDevMode = true;
-    Logger.e( "${errorDetails.exception}");
+  SyncfusionLicense.registerLicense(secrets['syncfusion_license_key']); 
+
+  FlutterError.onError = (FlutterErrorDetails details) {
+    Logger.e("Caut Flutter runtime error: ${details.exception}");
     if (Logger.isInDebugMode) {
-      FlutterError.dumpErrorToConsole(errorDetails);
+      FlutterError.dumpErrorToConsole(details);
     }
+    Crashlytics.instance.recordFlutterError(details);
   };
 
+  WidgetsFlutterBinding.ensureInitialized();
+  SharedPreferences prefs = await SharedPreferences.getInstance();
+  AppTheme theme = AppTheme.values[prefs.getInt('app-theme') ?? AppTheme.defaultTheme.index];
+
   runZoned(() {
+      runApp(new HAClientApp(
+        theme: theme,
+      ));
+  }, onError: (error, stack) {
+    _reportError(error, stack);
+  });
+}
+
+class HAClientApp extends StatefulWidget {
+
+  final AppTheme theme;
+
+  const HAClientApp({Key key, this.theme: AppTheme.defaultTheme}) : super(key: key);
+
+  @override
+  _HAClientAppState createState() => new _HAClientAppState();
+
+}
+
+class _HAClientAppState extends State<HAClientApp> {
+  StreamSubscription<List<PurchaseDetails>> _purchaseUpdateSubscription;
+  StreamSubscription _themeChangeSubscription;
+  AppTheme _currentTheme = AppTheme.defaultTheme;
+  
+  @override
+  void initState() {
+    InAppPurchaseConnection.enablePendingPurchases();
+    final Stream purchaseUpdates =
+        InAppPurchaseConnection.instance.purchaseUpdatedStream;
+    _purchaseUpdateSubscription = purchaseUpdates.listen((purchases) {
+      _handlePurchaseUpdates(purchases);
+    });
+    _currentTheme = widget.theme;
+    _themeChangeSubscription = eventBus.on<ChangeThemeEvent>().listen((event){
+      setState(() {
+        _currentTheme = event.theme;
+      });
+    });
     workManager.Workmanager.initialize(
       updateDeviceLocationIsolate,
       isInDebugMode: false
     );
-      runApp(new HAClientApp());
+    super.initState();
-
-  }, onError: (error, stack) {
-    Logger.e("$error");
-    Logger.e("$stack");
-    if (Logger.isInDebugMode) {
-      debugPrint("$stack");
   }
-  });
-}
 
-class HAClientApp extends StatelessWidget {
+  void _handlePurchaseUpdates(purchase) {
+    if (purchase is List<PurchaseDetails>) {
+      if (purchase[0].status == PurchaseStatus.purchased) {
+        eventBus.fire(ShowPopupMessageEvent(
+            title: "Thanks a lot!",
+            body: "Thank you for supporting HA Client development!",
+            buttonText: "Ok"
+        ));
+      } else {
+        Logger.d("Purchase change handler: ${purchase[0].status}");
+      }
+    } else {
+      Logger.e("Something wrong with purchase handling. Got: $purchase");
+    }
+  }
 
   // This widget is the root of your application.
   @override
   Widget build(BuildContext context) {
     return new MaterialApp(
       title: appName,
-      theme: new ThemeData(
+      theme: HAClientTheme().getThemeData(_currentTheme),
-        primarySwatch: Colors.blue,
+      darkTheme: HAClientTheme().darkTheme,
-      ),
+      debugShowCheckedModeBanner: false,
       initialRoute: "/",
       routes: {
         "/": (context) => MainPage(title: 'HA Client'),
-        "/connection-settings": (context) => ConnectionSettingsPage(title: "Settings"),
+        "/app-settings": (context) => AppSettingsPage(),
-        "/integration-settings": (context) => IntegrationSettingsPage(title: "Integration settings"),
+        "/connection-settings": (context) => AppSettingsPage(showSection: AppSettingsSection.connectionSettings),
+        "/integration-settings": (context) => AppSettingsPage(showSection: AppSettingsSection.integrationSettings),
         "/putchase": (context) => PurchasePage(title: "Support app development"),
         "/play-media": (context) => PlayMediaPage(
           mediaUrl: "${ModalRoute.of(context).settings.arguments != null ? (ModalRoute.of(context).settings.arguments as Map)['url'] : ''}",
           mediaType: "${ModalRoute.of(context).settings.arguments != null ? (ModalRoute.of(context).settings.arguments as Map)['type'] ?? '' : ''}",
         ),
         "/log-view": (context) => LogViewPage(title: "Log"),
-        "/whats-new": (context) => WhatsNewPage()
+        "/webview": (context) => standaloneWebview.WebviewScaffold(
+          url: "${(ModalRoute.of(context).settings.arguments as Map)['url']}",
+          appBar: new AppBar(
+            leading: IconButton(
+                icon: Icon(Icons.arrow_back),
+                onPressed: () => Navigator.of(context).pop()
+            ),
+            title: new Text("${(ModalRoute.of(context).settings.arguments as Map)['title']}"),
+          ),
+        ),
+        "/whats-new": (context) => WhatsNewPage(),
+        "/haclient_zha": (context) => ZhaPage(),
+        "/auth": (context) => new standaloneWebview.WebviewScaffold(
+          url: "${ConnectionManager().oauthUrl}",
+          appBar: new AppBar(
+            leading: IconButton(
+                icon: Icon(Icons.help),
+                onPressed: () => Launcher.launchURLInCustomTab(context: context, url: "http://ha-client.app/docs#authentication")
+            ),
+            title: new Text("Login with HA"),
+            actions: <Widget>[
+              FlatButton(
+                child: Text("Manual", style: Theme.of(context).textTheme.button.copyWith(
+                  decoration: TextDecoration.underline
+                )),
+                onPressed: () {
+                  eventBus.fire(ShowPageEvent(path: "/connection-settings", goBackFirst: true));
+                },
+              )
+            ],
+          ),
+        )
       },
     );
   }
+
+  @override
+  void dispose() {
+    _purchaseUpdateSubscription.cancel();
+    _themeChangeSubscription.cancel();
+    super.dispose();
+  }
 }

lib/managers/auth_manager.class.dart

@@ -9,46 +9,37 @@ class AuthManager {
   }
 
   AuthManager._internal();
-  StreamSubscription deepLinksSubscription;
 
   Future start({String oauthUrl}) {
     Completer completer = Completer();
-    deepLinksSubscription?.cancel();
+    final flutterWebviewPlugin = new standaloneWebview.FlutterWebviewPlugin();
-    deepLinksSubscription = getUriLinksStream().listen((Uri uri) {
+    flutterWebviewPlugin.onUrlChanged.listen((String url) {
-            Logger.d("[LINKED AUTH] We got something private");
+      if (url.startsWith("https://ha-client.app/service/auth_callback.html")) {
-            _getTempToken(oauthUrl, uri.queryParameters["code"])
+        Logger.d("url=$url");
-              .then((tempToken) => completer.complete(tempToken))
+        String authCode = url.split("=")[1];
-              .catchError((_){
+        Logger.d("authCode=$authCode");
-                completer.completeError(HAError("Auth error"));
+        Logger.d("We have auth code. Getting temporary access token...");
-              });
+        ConnectionManager().sendHTTPPost(
-          }, onError: (err) {
+          endPoint: "/auth/token",
-            Logger.e("[LINKED AUTH] Error handling linked auth: $e");
+          contentType: "application/x-www-form-urlencoded",
-            completer.completeError(HAError("Auth error"));
+          includeAuthHeader: false,
+          data: "grant_type=authorization_code&code=$authCode&client_id=${Uri.encodeComponent('https://ha-client.app')}"
+        ).then((response) {
+          Logger.d("Got temp token");
+          String tempToken = json.decode(response)['access_token'];
+          Logger.d("Closing webview...");
+          eventBus.fire(StartAuthEvent(oauthUrl, false));
+          completer.complete(tempToken);
+        }).catchError((e) {
+          Logger.e("Error getting temp token: ${e.toString()}");
+          eventBus.fire(StartAuthEvent(oauthUrl, false));
+          completer.completeError(HAError("Error getting temp token"));
+        }).whenComplete(() => flutterWebviewPlugin.close());
+      }
     });
     Logger.d("Launching OAuth");
     eventBus.fire(StartAuthEvent(oauthUrl, true));
     return completer.future;
     }
 
-  Future _getTempToken(String oauthUrl,String authCode) {
-    Completer completer = Completer();
-    ConnectionManager().sendHTTPPost(
-            endPoint: "/auth/token",
-            contentType: "application/x-www-form-urlencoded",
-            includeAuthHeader: false,
-            data: "grant_type=authorization_code&code=$authCode&client_id=${Uri.encodeComponent('http://ha-client.homemade.systems')}"
-        ).then((response) {
-          Logger.d("Got temp token");
-          String tempToken = json.decode(response)['access_token'];
-          eventBus.fire(StartAuthEvent(oauthUrl, false));
-          completer.complete(tempToken);
-        }).catchError((e) {
-          //flutterWebviewPlugin.close();
-          Logger.e("Error getting temp token: ${e.toString()}");
-          eventBus.fire(StartAuthEvent(oauthUrl, false));
-          completer.completeError(HAError("Error getting temp token"));
-        });
-    return completer.future;
-  }
-
 }

lib/managers/connection_manager.class.dart

@@ -19,8 +19,8 @@ class ConnectionManager {
   String _tempToken;
   String oauthUrl;
   String webhookId;
-  bool useLovelace = true;
   bool settingsLoaded = false;
+  int appIntegrationVersion;
   bool get isAuthenticated => _token != null;
   StreamSubscription _socketSubscription;
   Duration connectTimeout = Duration(seconds: 15);
@@ -28,6 +28,7 @@ class ConnectionManager {
   bool isConnected = false;
 
   var onStateChangeCallback;
+  var onLovelaceUpdatedCallback;
 
   IOWebSocketChannel _socket;
 
@@ -38,12 +39,12 @@ class ConnectionManager {
     Completer completer = Completer();
     bool stopInit = false;
     if (loadSettings) {
-      Logger.e("Loading settings...");
+      Logger.d("Loading settings...");
       SharedPreferences prefs = await SharedPreferences.getInstance();
-      useLovelace = prefs.getBool('use-lovelace') ?? true;
       _domain = prefs.getString('hassio-domain');
       _port = prefs.getString('hassio-port');
       webhookId = prefs.getString('app-webhook-id');
+      appIntegrationVersion = prefs.getInt('app-integration-version') ?? 0;
       displayHostname = "$_domain:$_port";
       _webSocketAPIEndpoint =
       "${prefs.getString('hassio-protocol')}://$_domain:$_port/api/websocket";
@@ -59,9 +60,9 @@ class ConnectionManager {
           _token = await storage.read(key: "hacl_llt");
           Logger.e("Long-lived token read successful");
           oauthUrl = "$httpWebHost/auth/authorize?client_id=${Uri.encodeComponent(
-              'http://ha-client.homemade.systems')}&redirect_uri=${Uri
+              'https://ha-client.app')}&redirect_uri=${Uri
               .encodeComponent(
-              'haclient://auth')}";
+              'https://ha-client.app/service/auth_callback.html')}";
           settingsLoaded = true;
         } catch (e) {
           completer.completeError(HAError("Error reading login details", actions: [HAErrorAction.tryAgain(type: HAErrorActionType.FULL_RELOAD), HAErrorAction.loginAgain()]));
@@ -98,16 +99,23 @@ class ConnectionManager {
 
   void _doConnect({Completer completer, bool forceReconnect}) {
     if (forceReconnect || !isConnected) {
-      _connect().timeout(connectTimeout, onTimeout: () {
+      _disconnect().then((_){
-        _disconnect().then((_) {
+        _connect().timeout(connectTimeout).then((_) {
-          if (completer != null && !completer.isCompleted) {
-            completer.completeError(HAError("Connection timeout"));
-          }
-        });
-      }).then((_) {
           completer?.complete();
         }).catchError((e) {
+          _disconnect().then((_) {
+            if (e is TimeoutException) {
+              if (connecting != null && !connecting.isCompleted) {
+                connecting.completeError(HAError("Connection timeout"));
+              }
+              completer?.completeError(HAError("Connection timeout"));
+            } else if (e is HAError) {
               completer?.completeError(e);
+            } else {
+              completer?.completeError(HAError("${e.toString()}"));
+            }
+          });
+        });
       });
     } else {
       completer?.complete();
@@ -124,6 +132,7 @@ class ConnectionManager {
       connecting = Completer();
       _disconnect().then((_) {
         Logger.d("Socket connecting...");
+        try {
           _socket = IOWebSocketChannel.connect(
             _webSocketAPIEndpoint, pingInterval: Duration(seconds: 15));
           _socketSubscription = _socket.stream.listen(
@@ -140,11 +149,21 @@ class ConnectionManager {
                   });
                 } else if (data["type"] == "auth_ok") {
                   Logger.d("[Received] <== ${data.toString()}");
+                  Logger.d("[Connection] Subscribing to events");
+                  sendSocketMessage(
+                    type: "subscribe_events",
+                    additionalData: {"event_type": "lovelace_updated"},
+                  );
+                  sendSocketMessage(
+                    type: "subscribe_events",
+                    additionalData: {"event_type": "state_changed"},
+                  ).whenComplete((){
                     _messageResolver["auth"]?.complete();
                     _messageResolver.remove("auth");
                     if (_token != null) {
                       if (!connecting.isCompleted) connecting.complete();
                     }
+                  });
                 } else if (data["type"] == "auth_invalid") {
                   Logger.d("[Received] <== ${data.toString()}");
                   _messageResolver["auth"]?.completeError(HAError("${data["message"]}", actions: [HAErrorAction.loginAgain()]));
@@ -158,6 +177,9 @@ class ConnectionManager {
               onDone: () => _handleSocketClose(connecting),
               onError: (e) => _handleSocketError(e, connecting)
           );
+        } catch(exeption) {
+          connecting.completeError(HAError("${exeption.toString()}"));
+        }
       });
       return connecting.future;
     }
@@ -194,13 +216,14 @@ class ConnectionManager {
       }
       _messageResolver.remove("${data["id"]}");
     } else if (data["type"] == "event") {
-      if ((data["event"] != null) && (data["event"]["event_type"] == "state_changed")) {
+      if (data["event"] != null) {
+        if (data["event"]["event_type"] == "state_changed") {
           Logger.d("[Received] <== ${data['type']}.${data["event"]["event_type"]}: ${data["event"]["data"]["entity_id"]}");
           onStateChangeCallback(data["event"]["data"]);
-      } else if (data["event"] != null) {
+        } else if (data["event"]["event_type"] == "lovelace_updated") {
-        Logger.w("Unhandled event type: ${data["event"]["event_type"]}");
+          Logger.d("[Received] <== ${data['type']}.${data["event"]["event_type"]}: $data");
-      } else {
+          onLovelaceUpdatedCallback();
-        Logger.e("Event is null: $data");
+        }  
       }
     } else {
       Logger.d("[Received unhandled] <== ${data.toString()}");
@@ -209,38 +232,24 @@ class ConnectionManager {
 
   void _handleSocketClose(Completer connectionCompleter) {
     Logger.d("Socket disconnected.");
+    _disconnect().then((_) {
       if (!connectionCompleter.isCompleted) {
         isConnected = false;
         connectionCompleter.completeError(HAError("Disconnected", actions: [HAErrorAction.reconnect()]));
-    } else {
+      }
-      _disconnect().then((_) {
-        Timer(Duration(seconds: 5), () {
-          Logger.d("Trying to reconnect...");
-          _connect().catchError((e) {
-            isConnected = false;
       eventBus.fire(ShowErrorEvent(HAError("Unable to connect to Home Assistant")));  
     });
-        });
-      });
-    }
   }
 
   void _handleSocketError(e, Completer connectionCompleter) {
     Logger.e("Socket stream Error: $e");
+    _disconnect().then((_) {
       if (!connectionCompleter.isCompleted) {
         isConnected = false;
-      connectionCompleter.completeError(HAError("Unable to connect to Home Assistant"));
+        connectionCompleter.completeError(HAError("Disconnected", actions: [HAErrorAction.reconnect()]));
-    } else {
+      }
-      _disconnect().then((_) {
-        Timer(Duration(seconds: 5), () {
-          Logger.d("Trying to reconnect...");
-          _connect().catchError((e) {
-            isConnected = false;
       eventBus.fire(ShowErrorEvent(HAError("Unable to connect to Home Assistant")));  
     });
-        });
-      });
-    }
   }
 
   Future _authenticate() {
@@ -329,13 +338,13 @@ class ConnectionManager {
     _messageResolver[callbackName] = _completer;
     String rawMessage = json.encode(dataObject);
     if (!isConnected) {
-      _connect().timeout(connectTimeout, onTimeout: (){
+      _connect().timeout(connectTimeout).then((_) {
-        _completer.completeError(HAError("No connection to Home Assistant", actions: [HAErrorAction.reconnect()]));
-      }).then((_) {
         Logger.d("[Sending] ==> ${auth ? "type="+dataObject['type'] : rawMessage}");
         _socket.sink.add(rawMessage);
       }).catchError((e) {
-        _completer.completeError(e);
+        if (!_completer.isCompleted) {
+          _completer.completeError(HAError("No connection to Home Assistant", actions: [HAErrorAction.reconnect()]));
+        }
       });
     } else {
       Logger.d("[Sending] ==> ${auth ? "type="+dataObject['type'] : rawMessage}");
@@ -348,7 +357,7 @@ class ConnectionManager {
     _currentMessageId += 1;
   }
 
-  Future callService({@required String domain, @required String service, String entityId, Map data}) {
+  Future callService({@required String domain, @required String service, entityId, Map data}) {
     eventBus.fire(NotifyServiceCallEvent(domain, service, entityId));
     Logger.d("Service call: $domain.$service, $entityId, $data");
     Completer completer = Completer();
@@ -363,12 +372,12 @@ class ConnectionManager {
       sendHTTPPost(
         endPoint: "/api/services/$domain/$service",
         data: json.encode(serviceData)
-      ).then((data) => completer.complete(data)).catchError((e) => completer.completeError(HAError("${e["message"]}")));
+      ).then((data) => completer.complete(data)).catchError((e) => completer.completeError(HAError(e.toString())));
       //return sendSocketMessage(type: "call_service", additionalData: {"domain": domain, "service": service, "service_data": serviceData});
     else
       sendHTTPPost(
           endPoint: "/api/services/$domain/$service"
-      ).then((data) => completer.complete(data)).catchError((e) => completer.completeError(HAError("${e["message"]}")));
+      ).then((data) => completer.complete(data)).catchError((e) => completer.completeError(HAError(e.toString())));
       //return sendSocketMessage(type: "call_service", additionalData: {"domain": domain, "service": service});
     return completer.future;
   }
@@ -414,7 +423,7 @@ class ConnectionManager {
         completer.complete(response.body);
       } else {
         Logger.d("[Received] <== HTTP ${response.statusCode}: ${response.body}");
-        completer.completeError({"code": response.statusCode, "message": "${response.body}"});
+        completer.completeError(response);
       }
     }).catchError((e) {
       completer.completeError(e);

lib/managers/location_manager.class.dart

@@ -27,7 +27,6 @@ class LocationManager {
     _isRunning = prefs.getBool("location-enabled") ?? false;
     if (_isRunning) {
       await _startLocationService();
-      updateDeviceLocation(false);
     }
   }
 
@@ -83,8 +82,8 @@ class LocationManager {
         int delay = i*delayFactor;
         Logger.d("Scheduling location update task #$i for every ${interval.inMinutes} minutes in $delay minutes...");
         await workManager.Workmanager.registerPeriodicTask(
-          "$backgroundTaskId$n",
+          "$backgroundTaskId$i",
-          "haClientLocationTracking",
+          "haClientLocationTracking-0$i",
           tag: backgroundTaskTag,
           inputData: {
             "webhookId": webhookId,
@@ -96,8 +95,8 @@ class LocationManager {
           backoffPolicy: workManager.BackoffPolicy.linear,
           backoffPolicyDelay: interval,
           constraints: workManager.Constraints(
-            networkType: workManager.NetworkType.connected
+            networkType: workManager.NetworkType.connected,
-          )
+          ),
         );
       }
     }
@@ -105,17 +104,12 @@ class LocationManager {
 
   _stopLocationService() async {
     Logger.d("Canceling previous schedule if any...");
-    await workManager.Workmanager.cancelByTag(backgroundTaskTag);
+    await workManager.Workmanager.cancelAll();
   }
 
-  updateDeviceLocation(bool force) async {
+  updateDeviceLocation() async {
-    if (!force && !_isRunning) {
-      Logger.d("[Foreground location] Not enabled. Aborting.");
-      return;
-    }
     Logger.d("[Foreground location] Started");
-    //Logger.d("[Foreground location] Forcing Android location manager...");
+    Geolocator geolocator = Geolocator();
-    Geolocator geolocator = Geolocator()..forceAndroidLocationManager = true;
     var battery = Battery();
     String webhookId = ConnectionManager().webhookId;
     String httpWebHost = ConnectionManager().httpWebHost;
@@ -154,15 +148,19 @@ class LocationManager {
 }
 
 void updateDeviceLocationIsolate() {
-  workManager.Workmanager.executeTask((backgroundTask, data) {
+  workManager.Workmanager.executeTask((backgroundTask, data) async {
     //print("[Background $backgroundTask] Started");
-    Geolocator geolocator = Geolocator()..forceAndroidLocationManager = true;
+    Geolocator geolocator = Geolocator();
     var battery = Battery();
-    int batteryLevel = 100;
     String webhookId = data["webhookId"];
     String httpWebHost = data["httpWebHost"];
+    //String logData = '==> ${DateTime.now()} [Background $backgroundTask]:';
+    //print("[Background $backgroundTask] Getting path for log file...");
+    //final logFileDirectory = await getExternalStorageDirectory();
+    //print("[Background $backgroundTask] Opening log file...");
+    //File logFile = File('${logFileDirectory.path}/ha-client-background-log.txt');
+    //print("[Background $backgroundTask] Log file path: ${logFile.path}");
     if (webhookId != null && webhookId.isNotEmpty) {
-        //print("[Background $backgroundTask] hour=$battery");
       String url = "$httpWebHost/api/webhook/$webhookId";
       Map<String, String> headers = {};
       headers["Content-Type"] = "application/json";
@@ -171,42 +169,69 @@ void updateDeviceLocationIsolate() {
         "data": {
           "gps": [],
           "gps_accuracy": 0,
-            "battery": batteryLevel
+          "battery": 100
         }
       };
       //print("[Background $backgroundTask] Getting battery level...");
-        battery.batteryLevel.then((val) => data["data"]["battery"] = val).whenComplete((){
+      int batteryLevel;
-          //print("[Background $backgroundTask] Getting device location...");
+      try {
-          geolocator.getCurrentPosition(desiredAccuracy: LocationAccuracy.high, locationPermissionLevel: GeolocationPermission.locationAlways).then((location) {
+        batteryLevel = await battery.batteryLevel;
-            //print("[Background $backgroundTask] Got location: ${location.latitude} ${location.longitude}");
+        //print("[Background $backgroundTask] Got battery level: $batteryLevel");
-            if (location != null) {
+      } catch(e) {
+        //print("[Background $backgroundTask] Error getting battery level: $e. Setting zero");
+        batteryLevel = 0;
+        //logData += 'Battery: error, $e';
+      }
+      if (batteryLevel != null) {
+        data["data"]["battery"] = batteryLevel;
+        //logData += 'Battery: success, $batteryLevel';
+      }/* else {
+        logData += 'Battery: error, level is null';
+      }*/
+      Position location;
+      try {
+        location = await geolocator.getCurrentPosition(desiredAccuracy: LocationAccuracy.high, locationPermissionLevel: GeolocationPermission.locationAlways);
+        if (location != null && location.latitude != null) {
+          //logData += ' || Location: success, ${location.latitude} ${location.longitude} (${location.timestamp})';
           data["data"]["gps"] = [location.latitude, location.longitude];
           data["data"]["gps_accuracy"] = location.accuracy;
-              //print("[Background $backgroundTask] Sending data home...");
+          try {
-              http.post(
+            http.Response response = await http.post(
                 url,
                 headers: headers,
                 body: json.encode(data)
             );
+            /*if (response.statusCode >= 200 && response.statusCode < 300) {
+              logData += ' || Post: success, ${response.statusCode}';
+            } else {
+              logData += ' || Post: error, ${response.statusCode}';
+            }*/
+          } catch(e) {
+            //logData += ' || Post: error, $e';
           }
-          }).catchError((e) {
+        }/* else {
-            //print("[Background $backgroundTask] Error getting current location: ${e.toString()}. Trying last known...");
+          logData += ' || Location: error, location is null';
-            geolocator.getLastKnownPosition(desiredAccuracy: LocationAccuracy.medium).then((location){
+        }*/
-              //print("[Background $backgroundTask] Got last known location: ${location.latitude} ${location.longitude}");
+      } catch (e) {
-              if (location != null) {
+        //print("[Background $backgroundTask] Location error: $e");
-                data["data"]["gps"] = [location.latitude, location.longitude];
+        //logData += ' || Location: error, $e';
-                data["data"]["gps_accuracy"] = location.accuracy;
-                //print("[Background $backgroundTask] Sending data home...");
-                http.post(
-                  url,
-                  headers: headers,
-                  body: json.encode(data)
-                );
       }
-            });
+    }/* else {
-          });
+      logData += 'Not configured';
-        });
+    }*/
+    //print("[Background $backgroundTask] Writing log data...");
+    /*try {
+      var fileMode;
+      if (logFile.existsSync() && logFile.lengthSync() < 5000000) {
+        fileMode = FileMode.append;
+      } else {
+        fileMode = FileMode.write;
       }
-    return Future.value(true);
+      await logFile.writeAsString('$logData\n', mode: fileMode);
+    } catch (e) {
+      print("[Background $backgroundTask] Error writing log: $e");
+    }
+    print("[Background $backgroundTask] Finished.");*/
+    return true;
   });
 }

lib/managers/mobile_app_integration_manager.class.dart

@@ -2,9 +2,11 @@ part of '../main.dart';
 
 class MobileAppIntegrationManager {
 
+  static const INTEGRATION_VERSION = 3;
+
   static final _appRegistrationData = {
-    "app_version": "$appVersion",
     "device_name": "",
+    "app_version": "$appVersion",
     "manufacturer": DeviceInfoManager().manufacturer,
     "model": DeviceInfoManager().model,
     "os_version": DeviceInfoManager().osVersion,
@@ -22,6 +24,7 @@ class MobileAppIntegrationManager {
       Logger.d("Mobile app was not registered yet or need to be reseted. Registering...");
       var registrationData = Map.from(_appRegistrationData);
       registrationData.addAll({
+        "device_id": "${DeviceInfoManager().unicDeviceId}",
         "app_id": "ha_client",
         "app_name": "$appName",
         "os_name": DeviceInfoManager().osName,
@@ -34,9 +37,11 @@ class MobileAppIntegrationManager {
       ).then((response) {
         Logger.d("Processing registration responce...");
         var responseObject = json.decode(response);
+        ConnectionManager().webhookId = responseObject["webhook_id"];
+        ConnectionManager().appIntegrationVersion = INTEGRATION_VERSION;
         SharedPreferences.getInstance().then((prefs) {
           prefs.setString("app-webhook-id", responseObject["webhook_id"]);
-          ConnectionManager().webhookId = responseObject["webhook_id"];
+          prefs.setInt('app-integration-version', INTEGRATION_VERSION);
 
           completer.complete();
           eventBus.fire(ShowPopupDialogEvent(
@@ -65,11 +70,21 @@ class MobileAppIntegrationManager {
           includeAuthHeader: false,
           data: json.encode(updateData)
       ).then((response) {
-        if (response == null || response.isEmpty) {
+        var registrationData;
-          Logger.d("No registration data in response. MobileApp integration was removed");
+        try {
+          registrationData = json.decode(response);
+        } catch (e) {
+          registrationData = null;
+        }
+        if (registrationData == null || registrationData.isEmpty) {
+          Logger.d("No registration data in response. MobileApp integration was removed or broken");
           _askToRegisterApp();
         } else {
-          Logger.d("App registration works fine");
+          if (INTEGRATION_VERSION > ConnectionManager().appIntegrationVersion) {
+            Logger.d('App registration needs to be updated');
+            _askToRemoveAndRegisterApp();
+          } else {
+            Logger.d('App registration works fine');
             if (showOkDialog) {
               eventBus.fire(ShowPopupDialogEvent(
                   title: "All good",
@@ -79,9 +94,10 @@ class MobileAppIntegrationManager {
               ));
             }
           }
+        }
         completer.complete();
       }).catchError((e) {
-        if (e['code'] != null && e['code'] == 410) {
+        if (e is http.Response && e.statusCode == 410) {
           Logger.e("MobileApp integration was removed");
           _askToRegisterApp();
         } else {
@@ -105,10 +121,22 @@ class MobileAppIntegrationManager {
     }
   }
 
+  static void _askToRemoveAndRegisterApp() {
+    eventBus.fire(ShowPopupDialogEvent(
+      title: "Mobile app integration needs to be updated",
+      body: "You need to update HA Client integration to continue using notifications and location tracking. Please remove 'Mobile App' integration for this device from your Home Assistant and restart Home Assistant. Then go back to HA Client to create app integration again.",
+      positiveText: "Ok",
+      negativeText: "Report an issue",
+      onNegative: () {
+        Launcher.launchURL("https://github.com/estevez-dev/ha_client/issues/new");
+      },
+    ));
+  }
+
   static void _askToRegisterApp() {
     eventBus.fire(ShowPopupDialogEvent(
-      title: "App integration was removed",
+      title: "App integration is broken",
-      body: "Looks like app integration was removed from your Home Assistant. HA Client needs to be registered on your Home Assistant server to make it possible to use notifications and other useful stuff.",
+      body: "Looks like app integration was removed from your Home Assistant or it needs to be updated. HA Client needs to be registered on your Home Assistant server to make it possible to use notifications and location tracking. Please remove 'Mobile App' integration for this device from your Home Assistant before registering and restart Home Assistant. Then go back here.",
       positiveText: "Register now",
       negativeText: "Cancel",
       onPositive: () {

lib/managers/startup_user_messages_manager.class.dart

@@ -9,12 +9,12 @@ class StartupUserMessagesManager {
     return _instance;
   }
 
-  StartupUserMessagesManager._internal() {}
+  StartupUserMessagesManager._internal();
 
   bool _supportAppDevelopmentMessageShown;
   bool _whatsNewMessageShown;
   static final _supportAppDevelopmentMessageKey = "user-message-shown-support-development_3";
-  static final _whatsNewMessageKey = "user-message-shown-whats-new-706";
+  static final _whatsNewMessageKey = "user-message-shown-whats-new-894";
 
   void checkMessagesToShow() async {
     SharedPreferences prefs = await SharedPreferences.getInstance();

lib/managers/theme_manager.dart

@@ -0,0 +1,272 @@
+part of '../main.dart';
+
+enum AppTheme {darkTheme, defaultTheme, haTheme}
+
+class HAClientTheme {
+
+  static const TextTheme textTheme = TextTheme(
+    display1: TextStyle(fontSize: 34, fontWeight: FontWeight.normal),
+    display2: TextStyle(fontSize: 34, fontWeight: FontWeight.normal),
+    headline: TextStyle(fontSize: 24, fontWeight: FontWeight.normal),
+    title: TextStyle(fontSize: 20, fontWeight: FontWeight.w700),
+    subhead: TextStyle(fontSize: 16, fontWeight: FontWeight.normal),
+    body1: TextStyle(fontSize: 15, fontWeight: FontWeight.normal),
+    body2: TextStyle(fontSize: 15, fontWeight: FontWeight.w500),
+    subtitle: TextStyle(fontSize: 15, fontWeight: FontWeight.w500),
+    caption: TextStyle(fontSize: 12, fontWeight: FontWeight.normal),
+    overline: TextStyle(
+      fontSize: 10,
+      fontWeight: FontWeight.normal,
+      letterSpacing: 1,
+    ),
+    button: TextStyle(fontSize: 14, fontWeight: FontWeight.w500),
+  );
+
+  static const offEntityStates = [
+    EntityState.off,
+    EntityState.closed,
+    "below_horizon",
+    "default",
+    EntityState.idle,
+    EntityState.alarm_disarmed,
+  ];
+
+  static const onEntityStates = [
+    EntityState.on,
+    "auto",
+    EntityState.active,
+    EntityState.playing,
+    EntityState.paused,
+    "above_horizon",
+    EntityState.home,
+    EntityState.open,
+    EntityState.cleaning,
+    EntityState.returning,
+    "cool",
+    EntityState.alarm_arming,
+    EntityState.alarm_disarming,
+    EntityState.alarm_pending,
+  ];
+
+  static const disabledEntityStates = [
+    EntityState.unavailable,
+    EntityState.unknown,
+  ];
+
+  static const alarmEntityStates = [
+    EntityState.alarm_armed_away,
+    EntityState.alarm_armed_custom_bypass,
+    EntityState.alarm_armed_home,
+    EntityState.alarm_armed_night,
+    EntityState.alarm_triggered,
+    "heat",
+  ];
+
+  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 final HAClientTheme _instance = HAClientTheme
+      ._internal();
+
+  factory HAClientTheme() {
+    return _instance;
+  }
+
+  HAClientTheme._internal();
+
+  ThemeData getThemeData(AppTheme theme) {
+    switch (theme) {
+      case AppTheme.darkTheme:
+        return darkTheme;
+        break;
+      case AppTheme.defaultTheme:
+        return defaultTheme;
+        break;
+      case AppTheme.haTheme:
+        return homeAssistantTheme;
+        break;
+      default:
+        return defaultTheme;
+    }
+  }
+
+  final ThemeData defaultTheme = ThemeData.from(
+    colorScheme: ColorScheme(
+      primary: Color.fromRGBO(112, 154, 193, 1),
+      primaryVariant: Color.fromRGBO(68, 115, 158, 1),
+      secondary: Color.fromRGBO(253, 216, 53, 1),
+      secondaryVariant: Color.fromRGBO(222, 181, 2, 1),
+      background: Color.fromRGBO(250, 250, 250, 1),
+      surface: Colors.white,
+      error: Colors.red,
+      onPrimary: Colors.white,
+      onSecondary: Colors.black87,
+      onBackground: Colors.black87,
+      onSurface: Colors.black87,
+      onError: Colors.white,
+      brightness: Brightness.light
+    ),
+    textTheme: ThemeData.light().textTheme.copyWith(
+      display1: textTheme.display1.copyWith(color: Colors.black54),
+      display2: textTheme.display2.copyWith(color: Colors.redAccent),
+      headline: textTheme.headline.copyWith(color: Colors.black87),
+      title: textTheme.title.copyWith(color: Colors.black87),
+      subhead: textTheme.subhead.copyWith(color: Colors.black54),
+      body1: textTheme.body1.copyWith(color: Colors.black87),
+      body2: textTheme.body2.copyWith(color: Colors.black87),
+      subtitle: textTheme.subtitle.copyWith(color: Colors.black45),
+      caption: textTheme.caption.copyWith(color: Colors.black45),
+      overline: textTheme.overline.copyWith(color: Colors.black26),
+      button: textTheme.button.copyWith(color: Colors.white),
+    )
+  );
+
+  final ThemeData homeAssistantTheme = ThemeData.from(
+    colorScheme: ColorScheme(
+      primary: Color.fromRGBO(2, 165, 238, 1),
+      primaryVariant: Color.fromRGBO(68, 115, 158, 1),
+      secondary: Color.fromRGBO(253, 216, 53, 1),
+      secondaryVariant: Color.fromRGBO(222, 181, 2, 1),
+      background: Color.fromRGBO(250, 250, 250, 1),
+      surface: Colors.white,
+      error: Colors.red,
+      onPrimary: Colors.white,
+      onSecondary: Colors.black87,
+      onBackground: Colors.black87,
+      onSurface: Colors.black87,
+      onError: Colors.white,
+      brightness: Brightness.light
+    ),
+    textTheme: ThemeData.light().textTheme.copyWith(
+      display1: textTheme.display1.copyWith(color: Colors.black54),
+      display2: textTheme.display2.copyWith(color: Colors.redAccent),
+      headline: textTheme.headline.copyWith(color: Colors.black87),
+      title: textTheme.title.copyWith(color: Colors.black87),
+      subhead: textTheme.subhead.copyWith(color: Colors.black54),
+      body1: textTheme.body1.copyWith(color: Colors.black87),
+      body2: textTheme.body2.copyWith(color: Colors.black87),
+      subtitle: textTheme.subtitle.copyWith(color: Colors.black45),
+      caption: textTheme.caption.copyWith(color: Colors.black45),
+      overline: textTheme.overline.copyWith(color: Colors.black26),
+      button: textTheme.button.copyWith(color: Colors.white),
+    )
+  );
+
+  final ThemeData darkTheme = ThemeData.from(
+    colorScheme: ColorScheme(
+      primary: Color.fromRGBO(112, 154, 193, 1),
+      primaryVariant: Color.fromRGBO(68, 115, 158, 1),
+      secondary: Color.fromRGBO(253, 216, 53, 1),
+      secondaryVariant: Color.fromRGBO(222, 181, 2, 1),
+      background: Color.fromRGBO(47, 49, 54, 1),
+      surface: Color.fromRGBO(54, 57, 63, 1),
+      error: Color.fromRGBO(183, 109, 109, 1),
+      onPrimary: Colors.white,
+      onSecondary: Colors.black87,
+      onBackground: Color.fromRGBO(220, 221, 222, 1),
+      onSurface: Colors.white,
+      onError: Colors.white,
+      brightness: Brightness.dark
+    ),
+    textTheme: textTheme
+  );
+
+  Color getOnStateColor(BuildContext context) {
+    return Theme.of(context).colorScheme.secondary;
+  }
+
+  Color getOffStateColor(BuildContext context) {
+    return Theme.of(context).colorScheme.primaryVariant;
+  }
+
+  Color getDisabledStateColor(BuildContext context) {
+    return Theme.of(context).disabledColor;
+  }
+
+  Color getAlertStateColor(BuildContext context) {
+    return Theme.of(context).colorScheme.error;
+  }
+
+  Color getColorByEntityState(String state, BuildContext context) {
+    if (onEntityStates.contains(state)) {
+      return getOnStateColor(context);
+    } else if (disabledEntityStates.contains(state)) {
+      return getDisabledStateColor(context);
+    } else if (alarmEntityStates.contains(state)) {
+      return getAlertStateColor(context);
+    } else {
+      return getOffStateColor(context);
+    }
+  }
+
+  Color getGreenGaugeColor() {
+    return Colors.green;
+  }
+
+  Color getYellowGaugeColor() {
+    return Colors.yellow;
+  }
+
+  Color getRedGaugeColor() {
+    return Colors.red;
+  }
+
+  TextStyle getLinkTextStyle(BuildContext context) {
+    ThemeData theme = Theme.of(context);
+    return theme.textTheme.body1.copyWith(
+      color: Colors.blue,
+      decoration: TextDecoration.underline
+    );
+  }
+
+  TextStyle getActionTextStyle(BuildContext context) {
+    ThemeData theme = Theme.of(context);
+    return theme.textTheme.subhead.copyWith(
+      color: Colors.blue
+    );
+  }
+
+  Color getBadgeColor(String entityDomain) {
+    return badgeColors[entityDomain] ??
+        badgeColors["default"];
+  }
+
+  Color getOnBadgeTextColor() {
+    return Colors.white;
+  }
+
+  charts.Color chartHistoryStateColor(String state, int id, BuildContext context) {
+    Color c = getColorByEntityState(state, context);
+    if (c != null) {
+      return charts.Color(
+          r: c.red,
+          g: c.green,
+          b: c.blue,
+          a: c.alpha
+      );
+    } else {
+      double r = id.toDouble() % 10;
+      return charts.MaterialPalette.getOrderedPalettes(10)[r.round()].shadeDefault;
+    }
+  }
+
+  Color historyStateColor(String state, int id, BuildContext context) {
+    Color c = getColorByEntityState(state, context);
+    if (c != null) {
+      return c;
+    } else {
+      if (id > -1) {
+        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 getOnStateColor(context);
+      }
+    }
+  }
+
+}

lib/pages/entity.page.dart

@@ -12,61 +12,52 @@ class EntityViewPage extends StatefulWidget {
 class _EntityViewPageState extends State<EntityViewPage> {
   StreamSubscription _refreshDataSubscription;
   StreamSubscription _stateSubscription;
-  Entity entity;
+  Entity _entity;
-  Entity forwardToMainPage;
-  bool _popScheduled = false;
 
   @override
   void initState() {
     super.initState();
     _stateSubscription = eventBus.on<StateChangedEvent>().listen((event) {
       if (event.entityId == widget.entityId) {
-        entity = HomeAssistant().entities.get(widget.entityId);
         Logger.d("[Entity page] State change event handled: ${event.entityId}");
-        setState(() {});
+        setState(() {
+          _getEntity();
+        });
       }
     });
     _refreshDataSubscription = eventBus.on<RefreshDataFinishedEvent>().listen((event) {
-      entity = HomeAssistant().entities.get(widget.entityId);
+      Logger.d("[Entity page] Refresh data event handled");
-      setState(() {});
+      setState(() {
+        _getEntity();
       });
-    entity = HomeAssistant().entities.get(widget.entityId);
+    });
+    _getEntity();
+  }
+
+  _getEntity() {
+    _entity = HomeAssistant().entities.get(widget.entityId);
   }
 
   @override
   Widget build(BuildContext context) {
-    Widget body;
+    String entityNameToDisplay = '${(_entity?.displayName ?? widget.entityId) ?? ''}';
-    if (MediaQuery.of(context).size.width >= Sizes.tabletMinWidth) {
-      if (!_popScheduled) {
-        _popScheduled = true;
-        _popAfterBuild();
-      }
-      body = PageLoadingIndicator();
-    } else {
-      body = EntityPageLayout(entity: entity);
-    }
     return new Scaffold(
       appBar: new AppBar(
         leading: IconButton(icon: Icon(Icons.arrow_back), onPressed: (){
           Navigator.pop(context);
         }),
-        title: new Text("${entity.displayName}"),
+        title: new Text(entityNameToDisplay),
       ),
-      body: body,
+      body: _entity == null ? PageLoadingError(
+        errorText: 'Entity is not available $entityNameToDisplay',
+      ) : EntityPageLayout(entity: _entity),
     );
   }
 
-  _popAfterBuild() async {
-    forwardToMainPage = entity;
-    await Future.delayed(Duration(milliseconds: 300));
-    Navigator.of(context).pop();
-  }
-
   @override
   void dispose(){
     if (_stateSubscription != null) _stateSubscription.cancel();
     if (_refreshDataSubscription != null) _refreshDataSubscription.cancel();
-    eventBus.fire(ShowEntityPageEvent(entity: forwardToMainPage));
     super.dispose();
   }
 }

lib/pages/fullscreen.page.dart

@@ -0,0 +1,18 @@
+part of '../main.dart';
+
+class FullScreenPage extends StatelessWidget {
+
+  final Widget child;
+
+  const FullScreenPage({Key key, this.child}) : super(key: key);
+
+  @override
+  Widget build(BuildContext context) {
+    return Container(
+      color: Colors.black,
+      child: Center(
+        child: this.child,
+      ),
+    );
+  }
+}

lib/pages/integration_settings.page.dart

@@ -1,200 +0,0 @@
-part of '../main.dart';
-
-class IntegrationSettingsPage extends StatefulWidget {
-  IntegrationSettingsPage({Key key, this.title}) : super(key: key);
-
-  final String title;
-
-  @override
-  _IntegrationSettingsPageState createState() => new _IntegrationSettingsPageState();
-}
-
-class _IntegrationSettingsPageState extends State<IntegrationSettingsPage> {
-
-  int _locationInterval = LocationManager().defaultUpdateIntervalMinutes;
-  bool _locationTrackingEnabled = false;
-  bool _wait = false;
-
-  @override
-  void initState() {
-    super.initState();
-    _loadSettings();
-
-  }
-
-  _loadSettings() async {
-    SharedPreferences prefs = await SharedPreferences.getInstance();
-    await prefs.reload();
-    SharedPreferences.getInstance().then((prefs) {
-      setState(() {
-        _locationTrackingEnabled = prefs.getBool("location-enabled") ?? false;
-        _locationInterval = prefs.getInt("location-interval") ?? LocationManager().defaultUpdateIntervalMinutes;
-        if (_locationInterval % 5 != 0) {
-          _locationInterval = 5 * (_locationInterval ~/ 5);
-        }
-      });
-    });
-  }
-
-  void incLocationInterval() {
-    if (_locationInterval < 720) {
-      setState(() {
-        _locationInterval = _locationInterval + 5;
-      });
-    }
-  }
-
-  void decLocationInterval() {
-    if (_locationInterval > 5) {
-      setState(() {
-        _locationInterval = _locationInterval - 5;
-      });
-    }
-  }
-
-  restart() {
-    eventBus.fire(ShowPopupDialogEvent(
-      title: "Are you sure you want to restart Home Assistant?",
-      body: "This will restart your Home Assistant server.",
-      positiveText: "Sure. Make it so",
-      negativeText: "What?? No!",
-      onPositive: () {
-        ConnectionManager().callService(domain: "homeassistant", service: "restart");
-      },
-    ));
-  }
-
-  stop() {
-    eventBus.fire(ShowPopupDialogEvent(
-      title: "Are you sure you want to STOP Home Assistant?",
-      body: "This will STOP your Home Assistant server. It means that your web interface as well as HA Client will not work untill you'll find a way to start your server using ssh or something.",
-      positiveText: "Sure. Make it so",
-      negativeText: "What?? No!",
-      onPositive: () {
-        ConnectionManager().callService(domain: "homeassistant", service: "stop");
-      },
-    ));
-  }
-
-  updateRegistration() {
-    MobileAppIntegrationManager.checkAppRegistration(showOkDialog: true);
-  }
-
-  resetRegistration() {
-    eventBus.fire(ShowPopupDialogEvent(
-      title: "Waaaait",
-      body: "If you don't whant to have duplicate integrations and entities in your HA for your current device, first you need to remove MobileApp integration from Integration settings in HA and restart server.",
-      positiveText: "Done it already",
-      negativeText: "Ok, I will",
-      onPositive: () {
-        MobileAppIntegrationManager.checkAppRegistration(showOkDialog: true, forceRegister: true);
-      },
-    ));
-  }
-
-  _switchLocationTrackingState(bool state) async {
-    if (state) {
-      await LocationManager().updateDeviceLocation(true);
-    }
-    await LocationManager().setSettings(_locationTrackingEnabled, _locationInterval);
-    setState(() {
-      _wait = false;
-    });
-  }
-
-  @override
-  Widget build(BuildContext context) {
-    return new Scaffold(
-      appBar: new AppBar(
-        leading: IconButton(icon: Icon(Icons.arrow_back), onPressed: (){
-          Navigator.pop(context);
-        }),
-        title: new Text(widget.title),
-      ),
-      body: ListView(
-        scrollDirection: Axis.vertical,
-        padding: const EdgeInsets.all(20.0),
-        children: <Widget>[
-                Text("Location tracking", style: TextStyle(fontSize: Sizes.largeFontSize-2)),
-                Container(height: Sizes.rowPadding,),
-                InkWell(
-                  onTap: () => Launcher.launchURLInCustomTab(context: context, url: "http://ha-client.homemade.systems/docs#location-tracking"),
-                  child: Text(
-                    "Please read documentation!",
-                    style: TextStyle(
-                      color: Colors.blue,
-                      fontSize: 16,
-                      decoration: TextDecoration.underline
-                    )
-                  ),
-                ),
-                Container(height: Sizes.rowPadding,),
-                Row(
-                  children: <Widget>[
-                    Text("Enable device location tracking"),
-                    Switch(
-                      value: _locationTrackingEnabled,
-                      onChanged: _wait ? null : (value) {
-                        setState(() {
-                          _locationTrackingEnabled = value;
-                          _wait = true;
-                        });
-                        _switchLocationTrackingState(value);
-                      },
-                    ),
-                  ],
-                ),
-                Container(height: Sizes.rowPadding,),
-                Text("Location update interval in minutes:"),
-                Row(
-                  mainAxisAlignment: MainAxisAlignment.center,
-                  mainAxisSize: MainAxisSize.max,
-                  children: <Widget>[
-                    //Expanded(child: Container(),),
-                    FlatButton(
-                      padding: EdgeInsets.all(0.0),
-                      child: Text("-", style: TextStyle(fontSize: Sizes.largeFontSize)),
-                      onPressed: () => decLocationInterval(),
-                    ),
-                    Text("$_locationInterval", style: TextStyle(fontSize: Sizes.largeFontSize)),
-                    FlatButton(
-                      padding: EdgeInsets.all(0.0),
-                      child: Text("+", style: TextStyle(fontSize: Sizes.largeFontSize)),
-                      onPressed: () => incLocationInterval(),
-                    ),
-                  ],
-                ),
-                Divider(),
-                Text("Integration status", style: TextStyle(fontSize: Sizes.largeFontSize-2)),
-                Container(height: Sizes.rowPadding,),
-                Text("${HomeAssistant().userName}'s ${DeviceInfoManager().model}, ${DeviceInfoManager().osName} ${DeviceInfoManager().osVersion}"),
-                Container(height: 6.0,),
-                Text("Here you can manually check if HA Client integration with your Home Assistant works fine. As mobileApp integration in Home Assistant is still in development, this is not 100% correct check."),
-                //Divider(),
-                Row(
-                  mainAxisSize: MainAxisSize.max,
-                  children: <Widget>[
-                    RaisedButton(
-                        color: Colors.blue,
-                        onPressed: () => updateRegistration(),
-                        child: Text("Check integration", style: TextStyle(color: Colors.white))
-                    ),
-                    Container(width: 10.0,),
-                    RaisedButton(
-                        color: Colors.redAccent,
-                        onPressed: () => resetRegistration(),
-                        child: Text("Reset integration", style: TextStyle(color: Colors.white))
-                    )
-                  ],
-                ),
-              ]
-      ),
-    );
-  }
-
-  @override
-  void dispose() {
-    LocationManager().setSettings(_locationTrackingEnabled, _locationInterval);
-    super.dispose();
-  }
-}

lib/pages/main/main.page.dart

@@ -1,4 +1,4 @@
-part of '../main.dart';
+part of '../../main.dart';
 
 class MainPage extends StatefulWidget {
   MainPage({Key key, this.title}) : super(key: key);
@@ -9,10 +9,10 @@ class MainPage extends StatefulWidget {
   _MainPageState createState() => new _MainPageState();
 }
 
-class _MainPageState extends ReceiveShareState<MainPage> with WidgetsBindingObserver, TickerProviderStateMixin {
+class _MainPageState extends State<MainPage> with WidgetsBindingObserver, TickerProviderStateMixin {
 
-  StreamSubscription<List<PurchaseDetails>> _subscription;
   StreamSubscription _stateSubscription;
+  StreamSubscription _lovelaceSubscription;
   StreamSubscription _settingsSubscription;
   StreamSubscription _serviceCallSubscription;
   StreamSubscription _showEntityPageSubscription;
@@ -21,22 +21,16 @@ class _MainPageState extends ReceiveShareState<MainPage> with WidgetsBindingObse
   StreamSubscription _showPopupDialogSubscription;
   StreamSubscription _showPopupMessageSubscription;
   StreamSubscription _reloadUISubscription;
+  StreamSubscription _fullReloadSubscription;
   StreamSubscription _showPageSubscription;
+  BottomInfoBarController _bottomInfoBarController;
   int _previousViewCount;
   bool _showLoginButton = false;
   bool _preventAppRefresh = false;
-  String _savedSharedText;
-  Entity _entityToShow;
 
   @override
   void initState() {
-    final Stream purchaseUpdates =
-        InAppPurchaseConnection.instance.purchaseUpdatedStream;
-    _subscription = purchaseUpdates.listen((purchases) {
-      _handlePurchaseUpdates(purchases);
-    });
     super.initState();
-    enableShareReceiving();
     WidgetsBinding.instance.addObserver(this);
 
     _firebaseMessaging.configure(
@@ -54,6 +48,8 @@ class _MainPageState extends ReceiveShareState<MainPage> with WidgetsBindingObse
         }
     );
 
+    _bottomInfoBarController = BottomInfoBarController();
+
     _firebaseMessaging.requestNotificationPermissions(const IosNotificationSettings(sound: true, badge: true, alert: true));
 
     // initialise the plugin. app_icon needs to be a added as a drawable resource to the Android head project
@@ -77,12 +73,6 @@ class _MainPageState extends ReceiveShareState<MainPage> with WidgetsBindingObse
     _fullLoad();
   }
 
-  @override void receiveShare(Share shared) {
-    if (shared.mimeType == ShareType.TYPE_PLAIN_TEXT) {
-      _savedSharedText = shared.text;
-    }
-  }
-
   Future onSelectNotification(String payload) async {
     if (payload != null) {
       Logger.d('Notification clicked: ' + payload);
@@ -104,48 +94,42 @@ class _MainPageState extends ReceiveShareState<MainPage> with WidgetsBindingObse
     );
   }
 
-  void _fullLoad() async {
+  void _fullLoad() {
-    _showInfoBottomBar(progress: true,);
+    _bottomInfoBarController.showInfoBottomBar(progress: true,);
     _subscribe().then((_) {
       ConnectionManager().init(loadSettings: true, forceReconnect: true).then((__){
-        _fetchData();
+        SharedPreferences.getInstance().then((prefs) {
+          HomeAssistant().lovelaceDashboardUrl = prefs.getString('lovelace_dashboard_url') ?? HomeAssistant.DEFAULT_DASHBOARD;
+          _fetchData(useCache: true);
           LocationManager();
           StartupUserMessagesManager().checkMessagesToShow();
+        });
       }, onError: (e) {
         _setErrorState(e);
       });
     });
   }
 
-  void _quickLoad() {
+  void _quickLoad({bool uiOnly: false}) {
-    _hideBottomBar();
+    _bottomInfoBarController.showInfoBottomBar(progress: true,);
-    _showInfoBottomBar(progress: true,);
     ConnectionManager().init(loadSettings: false, forceReconnect: false).then((_){
-      _fetchData();
+      _fetchData(useCache: false, uiOnly: uiOnly);
-      LocationManager().updateDeviceLocation(false);
-      //StartupUserMessagesManager().checkMessagesToShow();
     }, onError: (e) {
       _setErrorState(e);
     });
   }
 
-  _fetchData() async {
+  _fetchData({useCache: false, uiOnly: false}) async {
-    if (_savedSharedText != null && !HomeAssistant().isNoEntities) {
+    if (useCache && !uiOnly) {
-      Logger.d("Got shared text: $_savedSharedText");
+      HomeAssistant().fetchDataFromCache().then((_) {
-      Navigator.pushNamed(context, "/play-media", arguments: {"url": _savedSharedText});
+        setState((){});  
-      _savedSharedText = null;
+      });
-    }
-    await HomeAssistant().fetchData().then((_) {
-      _hideBottomBar();
-      int currentViewCount = HomeAssistant().ui?.views?.length ?? 0;
-      if (_previousViewCount != currentViewCount) {
-        Logger.d("Views count changed ($_previousViewCount->$currentViewCount). Creating new tabs controller.");
-        _viewsTabController = TabController(vsync: this, length: currentViewCount);
-        _previousViewCount = currentViewCount;
-      }
-      if (_entityToShow != null) {
-        _entityToShow = HomeAssistant().entities.get(_entityToShow.entityId);
     }
+    await HomeAssistant().fetchData(uiOnly).then((_) {
+      setState((){
+        _bottomInfoBarController.hideBottomBar();
+      });
+      HomeAssistant().saveCache();
     }).catchError((e) {
       if (e is HAError) {
         _setErrorState(e);
@@ -161,40 +145,37 @@ class _MainPageState extends ReceiveShareState<MainPage> with WidgetsBindingObse
     Logger.d("$state");
     if (state == AppLifecycleState.resumed && ConnectionManager().settingsLoaded && !_preventAppRefresh) {
       _quickLoad();
-    }
+    } else if (state == AppLifecycleState.paused && ConnectionManager().settingsLoaded && !_preventAppRefresh) {
-  }
+      //HomeAssistant().saveCache();
-
-  void _handlePurchaseUpdates(purchase) {
-    if (purchase is List<PurchaseDetails>) {
-      if (purchase[0].status == PurchaseStatus.purchased) {
-        eventBus.fire(ShowPopupMessageEvent(
-            title: "Thanks a lot!",
-            body: "Thank you for supporting HA Client development!",
-            buttonText: "Ok"
-        ));
-      } else {
-        Logger.d("Purchase change handler: ${purchase[0].status}");
-      }
-    } else {
-      Logger.e("Something wrong with purchase handling. Got: $purchase");
     }
   }
 
   Future _subscribe() {
     Completer completer = Completer();
+
     if (_stateSubscription == null) {
       _stateSubscription = eventBus.on<StateChangedEvent>().listen((event) {
         if (event.needToRebuildUI) {
-          Logger.d("New entity. Need to rebuild UI");
+          Logger.d("Need to rebuild UI");
           _quickLoad();
         } else {
           setState(() {});
         }
       });
     }
+    if (_lovelaceSubscription == null) {
+      _lovelaceSubscription = eventBus.on<LovelaceChangedEvent>().listen((event) {
+        _quickLoad();
+      });
+    }
     if (_reloadUISubscription == null) {
       _reloadUISubscription = eventBus.on<ReloadUIEvent>().listen((event){
-        _quickLoad();
+        _quickLoad(uiOnly: true);
+      });
+    }
+    if (_fullReloadSubscription == null) {
+      _fullReloadSubscription = eventBus.on<FullReloadEvent>().listen((event){
+        _fullLoad();
       });
     }
     if (_showPopupDialogSubscription == null) {
@@ -243,7 +224,7 @@ class _MainPageState extends ReceiveShareState<MainPage> with WidgetsBindingObse
 
     if (_showErrorSubscription == null) {
       _showErrorSubscription = eventBus.on<ShowErrorEvent>().listen((event){
-        _showErrorBottomBar(event.error);
+        _bottomInfoBarController.showErrorBottomBar(event.error);
       });
     }
 
@@ -256,6 +237,7 @@ class _MainPageState extends ReceiveShareState<MainPage> with WidgetsBindingObse
           _showOAuth();
         } else {
           _preventAppRefresh = false;
+          Navigator.of(context).pop();
         }
       });
     }
@@ -269,18 +251,16 @@ class _MainPageState extends ReceiveShareState<MainPage> with WidgetsBindingObse
 
   void _showOAuth() {
     _preventAppRefresh = true;
-    Launcher.launchURLInCustomTab(
+    Navigator.of(context).pushNamed("/auth", arguments: {"url": ConnectionManager().oauthUrl});
-      url: ConnectionManager().oauthUrl
-    );
   }
 
   _setErrorState(HAError e) {
     if (e == null) {
-      _showErrorBottomBar(
+      _bottomInfoBarController.showErrorBottomBar(
           HAError("Unknown error")
       );
     } else {
-      _showErrorBottomBar(e);
+      _bottomInfoBarController.showErrorBottomBar(e);
     }
   }
 
@@ -321,20 +301,20 @@ class _MainPageState extends ReceiveShareState<MainPage> with WidgetsBindingObse
     );
   }
 
-  void _notifyServiceCalled(String domain, String service, String entityId) {
+  void _notifyServiceCalled(String domain, String service, entityId) {
-    _showInfoBottomBar(
+    _bottomInfoBarController.showInfoBottomBar(
         message: "Calling $domain.$service",
         duration: Duration(seconds: 4)
     );
   }
 
   void _showEntityPage(String entityId) {
-    setState(() {
+    Navigator.push(
-      _entityToShow = HomeAssistant().entities.get(entityId);
+      context,
-      if (_entityToShow != null) {
+      MaterialPageRoute(
-        _mainScrollController?.jumpTo(0);
+        builder: (context) => EntityViewPage(entityId: entityId),
-      }
+      )
-    });
+    );
     /*if (_entityToShow!= null && MediaQuery.of(context).size.width < Sizes.tabletMinWidth) {
       Navigator.push(
           context,
@@ -374,11 +354,10 @@ class _MainPageState extends ReceiveShareState<MainPage> with WidgetsBindingObse
           accountName: Text(HomeAssistant().userName),
           accountEmail: Text(HomeAssistant().locationName ?? ""),
           currentAccountPicture: CircleAvatar(
+            backgroundColor: Theme.of(context).backgroundColor,
             child: Text(
               HomeAssistant().userAvatarText,
-              style: TextStyle(
+              style: Theme.of(context).textTheme.display1
-                  fontSize: 32.0
-              ),
             ),
           ),
         )
@@ -387,41 +366,19 @@ class _MainPageState extends ReceiveShareState<MainPage> with WidgetsBindingObse
       HomeAssistant().panels.forEach((Panel panel) {
         if (!panel.isHidden) {
           menuItems.add(
-              new ListTile(
+              panel.getMenuItemWidget(context)
-                  leading: Icon(MaterialDesignIcons.getIconDataFromIconName(panel.icon)),
-                  title: Row(
-                    crossAxisAlignment: CrossAxisAlignment.start,
-                    children: <Widget>[
-                      Text("${panel.title}"),
-                      Container(width: 4.0,),
-                      panel.isWebView ? Text("WEB", style: TextStyle(fontSize: 8.0, color: Colors.black45),) : Container(width: 1.0,)
-                    ],
-                  ),
-                  onTap: () {
-                    Navigator.of(context).pop();
-                    panel.handleOpen(context);
-                  }
-              )
           );
         }
       });
     }
     menuItems.addAll([
       Divider(),
-      ListTile(
-        leading: Icon(MaterialDesignIcons.getIconDataFromIconName("mdi:server-network")),
-        title: Text("Connection settings"),
-        onTap: () {
-          Navigator.of(context).pop();
-          Navigator.of(context).pushNamed('/connection-settings');
-        },
-      ),
       ListTile(
         leading: Icon(MaterialDesignIcons.getIconDataFromIconName("mdi:cellphone-settings-variant")),
-        title: Text("Integration settings"),
+        title: Text("App settings"),
         onTap: () {
           Navigator.of(context).pop();
-          Navigator.of(context).pushNamed('/integration-settings');
+          Navigator.of(context).pushNamed('/app-settings');
         },
       )
     ]);
@@ -458,29 +415,36 @@ class _MainPageState extends ReceiveShareState<MainPage> with WidgetsBindingObse
         title: Text("Help"),
         onTap: () {
           Navigator.of(context).pop();
-          Launcher.launchURL("http://ha-client.homemade.systems/docs");
+          Launcher.launchURL("http://ha-client.app/docs");
         },
       ),
       new ListTile(
         leading: Icon(MaterialDesignIcons.getIconDataFromIconName("mdi:discord")),
-        title: Text("Join Discord channel"),
+        title: Text("Contacts/Discussion"),
         onTap: () {
           Navigator.of(context).pop();
-          Launcher.launchURL("https://discord.gg/AUzEvwn");
+          Launcher.launchURL("https://discord.gg/nd6FZQ");
         },
       ),
+      new ListTile(
+        title: Text("What's new?"),
+        onTap: () {
+          Navigator.of(context).pop();
+          Navigator.of(context).pushNamed('/whats-new');
+        }
+      ),
       new AboutListTile(
           aboutBoxChildren: <Widget>[
             GestureDetector(
               onTap: () {
                 Navigator.of(context).pop();
-                Launcher.launchURL("http://ha-client.homemade.systems/");
+                Launcher.launchURL("http://ha-client.app/");
               },
               child: Text(
-                "ha-client.homemade.systems",
+                "ha-client.app",
-                style: TextStyle(
+                style: Theme.of(context).textTheme.body1.copyWith(
                   color: Colors.blue,
-                    decoration: TextDecoration.underline
+                  decoration: TextDecoration.underline,
                 ),
               ),
             ),
@@ -490,13 +454,13 @@ class _MainPageState extends ReceiveShareState<MainPage> with WidgetsBindingObse
             GestureDetector(
               onTap: () {
                 Navigator.of(context).pop();
-                Launcher.launchURLInCustomTab(context: context, url: "http://ha-client.homemade.systems/terms_and_conditions");
+                Launcher.launchURLInCustomTab(context: context, url: "http://ha-client.app/terms_and_conditions");
               },
               child: Text(
                 "Terms and Conditions",
-                style: TextStyle(
+                style: Theme.of(context).textTheme.body1.copyWith(
                   color: Colors.blue,
-                    decoration: TextDecoration.underline
+                  decoration: TextDecoration.underline,
                 ),
               ),
             ),
@@ -506,13 +470,13 @@ class _MainPageState extends ReceiveShareState<MainPage> with WidgetsBindingObse
             GestureDetector(
               onTap: () {
                 Navigator.of(context).pop();
-                Launcher.launchURLInCustomTab(context: context, url: "http://ha-client.homemade.systems/privacy_policy");
+                Launcher.launchURLInCustomTab(context: context, url: "http://ha-client.app/privacy_policy");
               },
               child: Text(
                 "Privacy Policy",
-                style: TextStyle(
+                style: Theme.of(context).textTheme.body1.copyWith(
                   color: Colors.blue,
-                    decoration: TextDecoration.underline
+                  decoration: TextDecoration.underline,
                 ),
               ),
             )
@@ -528,119 +492,19 @@ class _MainPageState extends ReceiveShareState<MainPage> with WidgetsBindingObse
     );
   }
 
-  void _hideBottomBar() {
-    //_scaffoldKey?.currentState?.hideCurrentSnackBar();
-    setState(() {
-      _showBottomBar = false;
-    });
-  }
-
-  Widget _bottomBarAction;
-  bool _showBottomBar = false;
-  String _bottomBarText;
-  bool _bottomBarProgress;
-  Color _bottomBarColor;
-  Timer _bottomBarTimer;
-
-  void _showInfoBottomBar({String message, bool progress: false, Duration duration}) {
-    _bottomBarTimer?.cancel();
-    _bottomBarAction = Container(height: 0.0, width: 0.0,);
-    _bottomBarColor = Colors.grey.shade50;
-    setState(() {
-      _bottomBarText = message;
-      _bottomBarProgress = progress;
-      _showBottomBar = true;
-    });
-    if (duration != null) {
-      _bottomBarTimer = Timer(duration, () {
-        _hideBottomBar();
-      });
-    }
-  }
-
-  void _showErrorBottomBar(HAError error) {
-    TextStyle textStyle = TextStyle(
-        color: Colors.blue,
-        fontSize: Sizes.nameFontSize
-    );
-    _bottomBarColor = Colors.red.shade100;
-    List<Widget> actions = [];
-    error.actions.forEach((HAErrorAction action) {
-      switch (action.type) {
-        case HAErrorActionType.FULL_RELOAD: {
-          actions.add(FlatButton(
-            child: Text("${action.title}", style: textStyle),
-            onPressed: () {
-              _fullLoad();
-            },
-          ));
-          break;
-        }
-
-        case HAErrorActionType.QUICK_RELOAD: {
-          actions.add(FlatButton(
-            child: Text("${action.title}", style: textStyle),
-            onPressed: () {
-              _quickLoad();
-            },
-          ));
-          break;
-        }
-
-        case HAErrorActionType.RELOGIN: {
-          actions.add(FlatButton(
-            child: Text("${action.title}", style: textStyle),
-            onPressed: () {
-              ConnectionManager().logout().then((_) => _fullLoad());
-            },
-          ));
-          break;
-        }
-
-        case HAErrorActionType.URL: {
-          actions.add(FlatButton(
-            child: Text("${action.title}", style: textStyle),
-            onPressed: () {
-              Launcher.launchURLInCustomTab(context: context, url: "${action.url}");
-            },
-          ));
-          break;
-        }
-
-        case HAErrorActionType.OPEN_CONNECTION_SETTINGS: {
-          actions.add(FlatButton(
-            child: Text("${action.title}", style: textStyle),
-            onPressed: () {
-              Navigator.pushNamed(context, '/connection-settings');
-            },
-          ));
-          break;
-        }
-      }
-    });
-    if (actions.isNotEmpty) {
-      _bottomBarAction = Row(
-        mainAxisSize: MainAxisSize.min,
-        children: actions,
-        mainAxisAlignment: MainAxisAlignment.end,
-      );
-    } else {
-      _bottomBarAction = Container(height: 0.0, width: 0.0,);
-    }
-    setState(() {
-      _bottomBarProgress = false;
-      _bottomBarText = "${error.message}";
-      _showBottomBar = true;
-    });
-  }
-
   final GlobalKey<ScaffoldState> _scaffoldKey = new GlobalKey<ScaffoldState>();
-  final ScrollController _mainScrollController = ScrollController();
 
   Widget _buildScaffoldBody(bool empty) {
     List<PopupMenuItem<String>> serviceMenuItems = [];
     List<PopupMenuItem<String>> mediaMenuItems = [];
 
+    int currentViewCount = HomeAssistant().ui?.views?.length ?? 0;
+    if (_previousViewCount != currentViewCount) {
+      Logger.d("Views count changed ($_previousViewCount->$currentViewCount). Creating new tabs controller.");
+      _viewsTabController = TabController(vsync: this, length: currentViewCount);
+      _previousViewCount = currentViewCount;
+    }
+
     serviceMenuItems.add(PopupMenuItem<String>(
       child: new Text("Reload"),
       value: "reload",
@@ -656,15 +520,15 @@ class _MainPageState extends ReceiveShareState<MainPage> with WidgetsBindingObse
     Widget mediaMenuIcon;
     int playersCount = 0;
     if (!empty && !HomeAssistant().entities.isEmpty) {
-      List<Entity> activePlayers = HomeAssistant().entities.getByDomains(domains: ["media_player"], stateFiler: [EntityState.paused, EntityState.playing, EntityState.idle]);
+      List<Entity> activePlayers = HomeAssistant().entities.getByDomains(includeDomains: ["media_player"], stateFiler: [EntityState.paused, EntityState.playing, EntityState.idle]);
       playersCount = activePlayers.length;
       mediaMenuItems.addAll(
           activePlayers.map((entity) => PopupMenuItem<String>(
             child: Text(
                 "${entity.displayName}",
-              style: TextStyle(
+              style: Theme.of(context).textTheme.body1.copyWith(
-                color: EntityColor.stateColor(entity.state)
+                color: HAClientTheme().getColorByEntityState(entity.state, context)
-              ),
+              )
             ),
             value: "${entity.entityId}",
           )).toList()
@@ -693,7 +557,12 @@ class _MainPageState extends ReceiveShareState<MainPage> with WidgetsBindingObse
                 shape: BoxShape.circle,
               ),
               child: Center(
-                child: Text("$playersCount", style: TextStyle(fontSize: 12)),
+                child: Text(
+                  "$playersCount",
+                  style: Theme.of(context).textTheme.caption.copyWith(
+                    color: Colors.white
+                  )
+                ),
               ),
             ),
           )
@@ -711,7 +580,7 @@ class _MainPageState extends ReceiveShareState<MainPage> with WidgetsBindingObse
                 mainAxisAlignment: MainAxisAlignment.center,
                 children: <Widget>[
                   FlatButton(
-                    child: Text("Login with Home Assistant", style: TextStyle(fontSize: 16.0, color: Colors.white)),
+                    child: Text("Login with Home Assistant", style: Theme.of(context).textTheme.button),
                     color: Colors.blue,
                     onPressed: () => _fullLoad(),
                   )
@@ -729,28 +598,7 @@ class _MainPageState extends ReceiveShareState<MainPage> with WidgetsBindingObse
         );
       }
     } else {
-      if (_entityToShow != null && MediaQuery.of(context).size.width >= Sizes.tabletMinWidth) {
+      mainScrollBody = HomeAssistant().ui.build(context, _viewsTabController);
-        mainScrollBody = Flex(
-          direction: Axis.horizontal,
-          children: <Widget>[
-            Expanded(
-              child: HomeAssistant().buildViews(context, _viewsTabController),
-            ),
-            Container(
-              width: Sizes.mainPageScreenSeparatorWidth,
-              color: Colors.blue,
-            ),
-            ConstrainedBox(
-              constraints: BoxConstraints.tightFor(width: Sizes.entityPageMaxWidth),
-              child: EntityPageLayout(entity: _entityToShow, showClose: true,),
-            )
-          ],
-        );
-      } else if (_entityToShow != null) {
-        mainScrollBody = EntityPageLayout(entity: _entityToShow, showClose: true,);
-      } else {
-        mainScrollBody = HomeAssistant().buildViews(context, _viewsTabController);
-      }
     }
 
     return NestedScrollView(
@@ -787,7 +635,9 @@ class _MainPageState extends ReceiveShareState<MainPage> with WidgetsBindingObse
                           context: context,
                           items: serviceMenuItems
                       ).then((String val) {
+                        HomeAssistant().lovelaceDashboardUrl = HomeAssistant.DEFAULT_DASHBOARD;
                         if (val == "reload") {
+                          
                           _quickLoad();
                         } else if (val == "logout") {
                           HomeAssistant().logout().then((_) {
@@ -804,7 +654,7 @@ class _MainPageState extends ReceiveShareState<MainPage> with WidgetsBindingObse
                   _scaffoldKey.currentState.openDrawer();
                 },
               ),
-              bottom: (empty || _entityToShow != null) ? null : TabBar(
+              bottom: empty ? null : TabBar(
                 controller: _viewsTabController,
                 tabs: buildUIViewTabs(),
                 isScrollable: true,
@@ -814,7 +664,6 @@ class _MainPageState extends ReceiveShareState<MainPage> with WidgetsBindingObse
           ];
         },
         body: mainScrollBody,
-        controller: _mainScrollController,
     );
   }
 
@@ -822,80 +671,25 @@ class _MainPageState extends ReceiveShareState<MainPage> with WidgetsBindingObse
 
   @override
   Widget build(BuildContext context) {
-    Widget bottomBar;
-    if (_showBottomBar) {
-      List<Widget> bottomBarChildren = [];
-      if (_bottomBarText != null) {
-        bottomBarChildren.add(
-            Padding(
-              padding: EdgeInsets.fromLTRB(
-                  Sizes.leftWidgetPadding, Sizes.rowPadding, 0.0,
-                  Sizes.rowPadding),
-              child: Text(
-                "$_bottomBarText",
-                textAlign: TextAlign.left,
-                softWrap: true,
-              ),
-            )
-
-        );
-      }
-      if (_bottomBarProgress) {
-        bottomBarChildren.add(
-          CollectionScaleTransition(
-            children: <Widget>[
-              Icon(Icons.stop, size: 10.0, color: EntityColor.stateColor(EntityState.on),),
-              Icon(Icons.stop, size: 10.0, color: EntityColor.stateColor(EntityState.unavailable),),
-              Icon(Icons.stop, size: 10.0, color: EntityColor.stateColor(EntityState.off),),
-            ],
-          ),
-        );
-      }
-      if (bottomBarChildren.isNotEmpty) {
-        bottomBar = Container(
-          color: _bottomBarColor,
-          child: Row(
-            mainAxisSize: MainAxisSize.max,
-            children: <Widget>[
-              Expanded(
-                child: Column(
-                  crossAxisAlignment: _bottomBarProgress ? CrossAxisAlignment.center : CrossAxisAlignment.start,
-                  mainAxisSize: MainAxisSize.min,
-                  children: bottomBarChildren,
-                ),
-              ),
-              _bottomBarAction
-            ],
-          ),
-        );
-      }
-    }
-    // This method is rerun every time setState is called.
     if (HomeAssistant().isNoViews) {
         return Scaffold(
             key: _scaffoldKey,
             primary: false,
             drawer: _buildAppDrawer(),
-          bottomNavigationBar: bottomBar,
+            bottomNavigationBar: BottomInfoBar(
+              controller: _bottomInfoBarController,
+            ),
             body: _buildScaffoldBody(true)
         );
       } else {
-      return WillPopScope(
+        return Scaffold(
-        child: Scaffold(
           key: _scaffoldKey,
           drawer: _buildAppDrawer(),
           primary: false,
-          bottomNavigationBar: bottomBar,
+          bottomNavigationBar: BottomInfoBar(
-          body: _buildScaffoldBody(false)
+            controller: _bottomInfoBarController,
           ),
-        onWillPop: () {
+          body: _buildScaffoldBody(false)
-          if (_entityToShow != null) {
-            eventBus.fire(ShowEntityPageEvent());
-            return Future.value(false);
-          } else {
-            return Future.value(true);
-          }
-        },
         );
       }
   }
@@ -903,8 +697,11 @@ class _MainPageState extends ReceiveShareState<MainPage> with WidgetsBindingObse
   @override
   void dispose() {
     WidgetsBinding.instance.removeObserver(this);
+    //final flutterWebviewPlugin = new FlutterWebviewPlugin();
+    //flutterWebviewPlugin.dispose();
     _viewsTabController?.dispose();
     _stateSubscription?.cancel();
+    _lovelaceSubscription?.cancel();
     _settingsSubscription?.cancel();
     _serviceCallSubscription?.cancel();
     _showPopupDialogSubscription?.cancel();
@@ -912,11 +709,9 @@ class _MainPageState extends ReceiveShareState<MainPage> with WidgetsBindingObse
     _showEntityPageSubscription?.cancel();
     _showErrorSubscription?.cancel();
     _startAuthSubscription?.cancel();
-    _subscription?.cancel();
     _showPageSubscription?.cancel();
+    _fullReloadSubscription?.cancel();
     _reloadUISubscription?.cancel();
-    //TODO disconnect
-    //widget.homeAssistant?.disconnect();
     super.dispose();
   }
 }

lib/pages/play_media.page.dart

@@ -57,9 +57,8 @@ class _PlayMediaPageState extends State<PlayMediaPage> {
         _loaded = false;
       });
     } else {
-      _isMediaExtractorExist = HomeAssistant().services.containsKey("media_extractor");
+      _isMediaExtractorExist = HomeAssistant().isComponentEnabled("media_extractor");
-      //_useMediaExtractor = _isMediaExtractorExist;
+      _players = HomeAssistant().entities.getByDomains(includeDomains: ["media_player"]);
-      _players = HomeAssistant().entities.getByDomains(domains: ["media_player"]);
       setState(() {
         if (_players.isNotEmpty) {
           _loaded = true;
@@ -135,7 +134,9 @@ class _PlayMediaPageState extends State<PlayMediaPage> {
       if (_validationMessage.isNotEmpty) {
         children.add(Text(
           "$_validationMessage",
-          style: TextStyle(color: Colors.red)
+          style: Theme.of(context).textTheme.body1.copyWith(
+            color: Theme.of(context).errorColor
+          )
         ));
       }
       children.addAll(<Widget>[
@@ -193,7 +194,7 @@ class _PlayMediaPageState extends State<PlayMediaPage> {
                 },
                 child: Text(
                   "How?",
-                  style: TextStyle(
+                  style: Theme.of(context).textTheme.body1.copyWith(
                     color: Colors.blue,
                     decoration: TextDecoration.underline
                   ),

lib/pages/purchase.page.dart

@@ -62,7 +62,7 @@ class _PurchasePageState extends State<PurchasePage> {
     }
   }
 
-  Widget _buildProducts() {
+  List<Widget> _buildProducts() {
     List<Widget> productWidgets = [];
     for (ProductDetails product in _products) {
       productWidgets.add(
@@ -72,10 +72,7 @@ class _PurchasePageState extends State<PurchasePage> {
           purchased: _purchases.any((purchase) { return purchase.productID == product.id;}),)
       );
     }
-    return ListView(
+    return productWidgets;
-        scrollDirection: Axis.vertical,
-        children: productWidgets
-      );
   }
 
   void _buyProduct(ProductDetails product) {
@@ -87,12 +84,28 @@ class _PurchasePageState extends State<PurchasePage> {
 
   @override
   Widget build(BuildContext context) {
-    Widget body;
+    List<Widget> body;
     if (!_loaded) {
-      body = _error.isEmpty ? PageLoadingIndicator() : PageLoadingError(errorText: _error);
+      body = [_error.isEmpty ? PageLoadingIndicator() : PageLoadingError(errorText: _error)];
     } else {
       body = _buildProducts();
     }
+    body.add(
+      Card(
+        child: Container(
+          height: 80,
+          child: InkWell(
+            child: Image.network('https://www.paypalobjects.com/en_US/i/btn/btn_donateCC_LG.gif'),
+            onTap: () {
+              Launcher.launchURLInCustomTab(
+                context: context,
+                url: 'https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=ARWGETZD2D83Q&source=url'
+              );
+            },
+          )
+        ),
+      )
+    );
     return new Scaffold(
       appBar: new AppBar(
         leading: IconButton(icon: Icon(Icons.arrow_back), onPressed: (){
@@ -100,7 +113,10 @@ class _PurchasePageState extends State<PurchasePage> {
         }),
         title: new Text(widget.title),
       ),
-      body: body,
+      body: ListView(
+        scrollDirection: Axis.vertical,
+        children: body
+      ),
     );
   }
   

lib/pages/settings.page.dart

@@ -1,228 +0,0 @@
-part of '../main.dart';
-
-class ConnectionSettingsPage extends StatefulWidget {
-  ConnectionSettingsPage({Key key, this.title}) : super(key: key);
-
-  final String title;
-
-  @override
-  _ConnectionSettingsPageState createState() => new _ConnectionSettingsPageState();
-}
-
-class _ConnectionSettingsPageState extends State<ConnectionSettingsPage> {
-  String _hassioDomain = "";
-  String _newHassioDomain = "";
-  String _hassioPort = "";
-  String _newHassioPort = "";
-  String _socketProtocol = "wss";
-  String _newSocketProtocol = "wss";
-  String _longLivedToken = "";
-  String _newLongLivedToken = "";
-  bool _useLovelace = true;
-  bool _newUseLovelace = true;
-
-  String oauthUrl;
-  bool useOAuth = false;
-
-  @override
-  void initState() {
-    super.initState();
-    _loadSettings();
-
-  }
-
-  _loadSettings() async {
-    SharedPreferences prefs = await SharedPreferences.getInstance();
-    final storage = new FlutterSecureStorage();
-
-    try {
-      useOAuth = prefs.getBool("oauth-used") ?? true;
-    } catch (e) {
-      useOAuth = true;
-    }
-
-    if (!useOAuth) {
-      try {
-        _longLivedToken = _newLongLivedToken =
-        await storage.read(key: "hacl_llt");
-      } catch (e) {
-        _longLivedToken = _newLongLivedToken = "";
-        await storage.delete(key: "hacl_llt");
-      }
-    }
-
-    setState(() {
-      _hassioDomain = _newHassioDomain = prefs.getString("hassio-domain")?? "";
-      _hassioPort = _newHassioPort = prefs.getString("hassio-port") ?? "";
-      _socketProtocol = _newSocketProtocol = prefs.getString("hassio-protocol") ?? 'wss';
-      try {
-        _useLovelace = _newUseLovelace = prefs.getBool("use-lovelace") ?? true;
-      } catch (e) {
-        _useLovelace = _newUseLovelace = true;
-      }
-    });
-  }
-
-  bool _checkConfigChanged() {
-    return (
-      (_newHassioPort != _hassioPort) ||
-      (_newHassioDomain != _hassioDomain) ||
-      (_newSocketProtocol != _socketProtocol) ||
-      (_newUseLovelace != _useLovelace) ||
-      (_newLongLivedToken != _longLivedToken));
-
-  }
-
-  _saveSettings() async {
-    _newHassioDomain = _newHassioDomain.trim();
-    if (_newHassioDomain.indexOf("http") == 0 && _newHassioDomain.indexOf("//") > 0) {
-      _newHassioDomain = _newHassioDomain.split("//")[1];
-    }
-    _newHassioDomain = _newHassioDomain.split("/")[0];
-    SharedPreferences prefs = await SharedPreferences.getInstance();
-    final storage = new FlutterSecureStorage();
-    if (_newLongLivedToken.isNotEmpty) {
-      _newLongLivedToken = _newLongLivedToken.trim();
-      prefs.setBool("oauth-used", false);
-      await storage.write(key: "hacl_llt", value: _newLongLivedToken);
-    } else if (!useOAuth) {
-      await storage.delete(key: "hacl_llt");
-    }
-    prefs.setString("hassio-domain", _newHassioDomain);
-    if (_newHassioPort == null || _newHassioPort.isEmpty) {
-      _newHassioPort = _newSocketProtocol == "wss" ? "443" : "80";
-    } else {
-      _newHassioPort = _newHassioPort.trim();
-    }
-    prefs.setString("hassio-port", _newHassioPort);
-    prefs.setString("hassio-protocol", _newSocketProtocol);
-    prefs.setString("hassio-res-protocol", _newSocketProtocol == "wss" ? "https" : "http");
-    prefs.setBool("use-lovelace", _newUseLovelace);
-  }
-
-  @override
-  Widget build(BuildContext context) {
-    return new Scaffold(
-      appBar: new AppBar(
-        leading: IconButton(icon: Icon(Icons.arrow_back), onPressed: (){
-          Navigator.pop(context);
-        }),
-        title: new Text(widget.title),
-        actions: <Widget>[
-          IconButton(
-            icon: Icon(Icons.check),
-            onPressed: (){
-              if (_checkConfigChanged()) {
-                Logger.d("Settings changed. Saving...");
-                _saveSettings().then((r) {
-                  Navigator.pop(context);
-                  eventBus.fire(SettingsChangedEvent(true));
-                });
-              } else {
-                Logger.d("Settings was not changed");
-                Navigator.pop(context);
-              }
-            }
-          )
-        ],
-      ),
-      body: ListView(
-        scrollDirection: Axis.vertical,
-        padding: const EdgeInsets.all(20.0),
-        children: <Widget>[
-          Text(
-              "Connection settings",
-              style: TextStyle(
-                color: Colors.black45,
-                fontSize: 20.0
-              ),
-          ),
-          new Row(
-            children: [
-              Text("Use ssl (HTTPS)"),
-              Switch(
-                value: (_newSocketProtocol == "wss"),
-                onChanged: (value) {
-                  setState(() {
-                    _newSocketProtocol = value ? "wss" : "ws";
-                  });
-                },
-              )
-            ],
-          ),
-          new TextField(
-            decoration: InputDecoration(
-              labelText: "Home Assistant domain or ip address"
-            ),
-            controller: TextEditingController.fromValue(TextEditingValue(text: _newHassioDomain)),
-            onChanged: (value) {
-              _newHassioDomain = value;
-            }
-          ),
-          new TextField(
-            decoration: InputDecoration(
-              labelText: "Home Assistant port (default is 8123)"
-            ),
-            controller: TextEditingController.fromValue(TextEditingValue(text: _newHassioPort)),
-            onChanged: (value) {
-              _newHassioPort = value;
-            }
-          ),
-          new Text(
-            "Try ports 80 and 443 if default is not working and you don't know why.",
-            style: TextStyle(color: Colors.grey),
-          ),
-          Padding(
-            padding: EdgeInsets.only(top: 20.0),
-            child: Text(
-              "UI",
-              style: TextStyle(
-                  color: Colors.black45,
-                  fontSize: 20.0
-              ),
-            ),
-          ),
-          new Row(
-            children: [
-              Text("Use Lovelace UI"),
-              Switch(
-                value: _newUseLovelace,
-                onChanged: (value) {
-                  setState(() {
-                    _newUseLovelace = value;
-                  });
-                },
-              )
-            ],
-          ),
-          Text(
-            "Authentication settings",
-            style: TextStyle(
-                color: Colors.black45,
-                fontSize: 20.0
-            ),
-          ),
-          Container(height: 10.0,),
-          Text(
-            "You can leave this field blank to make app generate new long-lived token automatically by asking you to login to your Home Assistant. Use this field only if you still want to use manually generated long-lived token. Leave it blank if you don't understand what we are talking about.",
-            style: TextStyle(color: Colors.redAccent),
-          ),
-          new TextField(
-              decoration: InputDecoration(
-                  labelText: "Long-lived token"
-              ),
-              controller: TextEditingController.fromValue(TextEditingValue(text: _newLongLivedToken)),
-              onChanged: (value) {
-                _newLongLivedToken = value;
-              }
-          ),
-        ],
-      ),
-    );
-  }
-
-  @override
-  void dispose() {
-    super.dispose();
-  }
-}

lib/pages/settings/app_settings.page.dart

@@ -0,0 +1,104 @@
+part of '../../main.dart';
+
+enum AppSettingsSection {menu, connectionSettings, integrationSettings, lookAndFeel}
+
+class AppSettingsPage extends StatefulWidget {
+  final AppSettingsSection showSection;
+
+  AppSettingsPage({Key key, this.showSection: AppSettingsSection.menu}) : super(key: key);
+
+  @override
+  _AppSettingsPageState createState() => new _AppSettingsPageState();
+}
+
+class _AppSettingsPageState extends State<AppSettingsPage> {
+
+  var _currentSection;
+
+  @override
+  void initState() {
+    super.initState();
+    _currentSection = widget.showSection;
+  }
+
+  Widget _buildMenuItem(BuildContext context, IconData icon,String title, AppSettingsSection section) {
+    return ListTile(
+      title: Text(title, style: Theme.of(context).textTheme.subhead),
+      leading: Icon(icon),
+      trailing: Icon(Icons.keyboard_arrow_right),
+      onTap: () {
+        setState(() {
+          _currentSection = section;
+        });
+      },
+    );
+  }
+
+  Widget _buildMenu(BuildContext context) {
+    return ListView(
+      children: <Widget>[
+        _buildMenuItem(context, MaterialDesignIcons.getIconDataFromIconName('mdi:network'), 'Connection settings', AppSettingsSection.connectionSettings),
+        _buildMenuItem(context, MaterialDesignIcons.getIconDataFromIconName('mdi:cellphone-android'), 'Integration settings', AppSettingsSection.integrationSettings),
+        _buildMenuItem(context, MaterialDesignIcons.getIconDataFromIconName('mdi:brush'), 'Look and feel', AppSettingsSection.lookAndFeel),
+      ],
+    );
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    Widget section;
+    String title;
+    switch (_currentSection) {
+      case AppSettingsSection.menu: {
+        section = _buildMenu(context);
+        title = 'App settings';
+        break;
+      }
+      case AppSettingsSection.connectionSettings: {
+        section = ConnectionSettingsPage();
+        title = 'App settings - Connection';
+        break;
+      }
+      case AppSettingsSection.integrationSettings: {
+        section = IntegrationSettingsPage();
+        title = 'App settings - Integration';
+        break;
+      }
+      case AppSettingsSection.lookAndFeel: {
+        section = LookAndFeelSettingsPage();
+        title = 'App settings - Look&Feel';
+        break;
+      }
+      default:
+        title = ':(';
+        section = PageLoadingIndicator();
+    }
+    return WillPopScope(
+      child: Scaffold(
+        appBar: new AppBar(
+          leading: IconButton(icon: Icon(Icons.arrow_back), onPressed: (){
+            if (_currentSection == AppSettingsSection.menu) {
+              Navigator.pop(context);
+            } else {
+              setState(() {
+                _currentSection = AppSettingsSection.menu;
+              });
+            }
+          }),
+          title: Text(title),
+        ),
+        body: section
+      ),
+      onWillPop: () {
+        if (_currentSection == AppSettingsSection.menu) {
+          return Future.value(true);
+        } else {
+          setState(() {
+            _currentSection = AppSettingsSection.menu;
+          });
+          return Future.value(false);
+        }
+      },
+    );
+  }
+}

lib/pages/settings/connection_settings.part.dart

@@ -0,0 +1,192 @@
+part of '../../main.dart';
+
+class ConnectionSettingsPage extends StatefulWidget {
+  ConnectionSettingsPage({Key key, this.title}) : super(key: key);
+
+  final String title;
+
+  @override
+  _ConnectionSettingsPageState createState() => new _ConnectionSettingsPageState();
+}
+
+class _ConnectionSettingsPageState extends State<ConnectionSettingsPage> {
+  String _hassioDomain = "";
+  String _newHassioDomain = "";
+  String _hassioPort = "";
+  String _newHassioPort = "";
+  String _socketProtocol = "wss";
+  String _newSocketProtocol = "wss";
+  String _longLivedToken = "";
+  String _newLongLivedToken = "";
+
+  String oauthUrl;
+  bool useOAuth = false;
+
+  @override
+  void initState() {
+    super.initState();
+    _loadSettings();
+
+  }
+
+  _loadSettings() async {
+    SharedPreferences prefs = await SharedPreferences.getInstance();
+    final storage = new FlutterSecureStorage();
+
+    try {
+      useOAuth = prefs.getBool("oauth-used") ?? true;
+    } catch (e) {
+      useOAuth = true;
+    }
+
+    if (!useOAuth) {
+      try {
+        _longLivedToken = _newLongLivedToken =
+        await storage.read(key: "hacl_llt");
+      } catch (e) {
+        _longLivedToken = _newLongLivedToken = "";
+        await storage.delete(key: "hacl_llt");
+      }
+    }
+
+    setState(() {
+      _hassioDomain = _newHassioDomain = prefs.getString("hassio-domain")?? "";
+      _hassioPort = _newHassioPort = prefs.getString("hassio-port") ?? "";
+      _socketProtocol = _newSocketProtocol = prefs.getString("hassio-protocol") ?? 'wss';
+    });
+  }
+
+  bool _checkConfigChanged() {
+    return (
+      (_newHassioPort != _hassioPort) ||
+      (_newHassioDomain != _hassioDomain) ||
+      (_newSocketProtocol != _socketProtocol) ||
+      (_newLongLivedToken != _longLivedToken));
+
+  }
+
+  _saveSettings() async {
+    _newHassioDomain = _newHassioDomain.trim();
+    if (_newHassioDomain.startsWith("http") && _newHassioDomain.indexOf("//") > 0) {
+      _newHassioDomain.startsWith("https") ? _newSocketProtocol = "wss" : _newSocketProtocol = "ws";
+      _newHassioDomain = _newHassioDomain.split("//")[1];
+    }
+    _newHassioDomain = _newHassioDomain.split("/")[0];
+    if (_newHassioDomain.contains(":")) {
+      List<String> domainAndPort = _newHassioDomain.split(":");
+      _newHassioDomain = domainAndPort[0];
+      _newHassioPort = domainAndPort[1];
+    }
+    SharedPreferences prefs = await SharedPreferences.getInstance();
+    final storage = new FlutterSecureStorage();
+    if (_newLongLivedToken.isNotEmpty) {
+      _newLongLivedToken = _newLongLivedToken.trim();
+      prefs.setBool("oauth-used", false);
+      await storage.write(key: "hacl_llt", value: _newLongLivedToken);
+    } else if (!useOAuth) {
+      await storage.delete(key: "hacl_llt");
+    }
+    prefs.setString("hassio-domain", _newHassioDomain);
+    if (_newHassioPort == null || _newHassioPort.isEmpty) {
+      _newHassioPort = _newSocketProtocol == "wss" ? "443" : "80";
+    } else {
+      _newHassioPort = _newHassioPort.trim();
+    }
+    prefs.setString("hassio-port", _newHassioPort);
+    prefs.setString("hassio-protocol", _newSocketProtocol);
+    prefs.setString("hassio-res-protocol", _newSocketProtocol == "wss" ? "https" : "http");
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return ListView(
+      scrollDirection: Axis.vertical,
+      padding: const EdgeInsets.all(20.0),
+      children: <Widget>[
+        Text(
+            "Connection settings",
+            style: Theme.of(context).textTheme.headline,
+        ),
+        new Row(
+          children: [
+            Text("Use ssl (HTTPS)"),
+            Switch(
+              value: (_newSocketProtocol == "wss"),
+              onChanged: (value) {
+                setState(() {
+                  _newSocketProtocol = value ? "wss" : "ws";
+                });
+              },
+            )
+          ],
+        ),
+        new TextField(
+          decoration: InputDecoration(
+            labelText: "Home Assistant domain or ip address"
+          ),
+          controller: TextEditingController.fromValue(TextEditingValue(text: _newHassioDomain)),
+          onChanged: (value) {
+            _newHassioDomain = value;
+          }
+        ),
+        new TextField(
+          decoration: InputDecoration(
+            labelText: "Home Assistant port (default is 8123)"
+          ),
+          controller: TextEditingController.fromValue(TextEditingValue(text: _newHassioPort)),
+          onChanged: (value) {
+            _newHassioPort = value;
+          }
+        ),
+        new Text(
+          "Try ports 80 and 443 if default is not working and you don't know why.",
+          style: Theme.of(context).textTheme.caption,
+        ),
+        Text(
+          "Authentication settings",
+          style: Theme.of(context).textTheme.headline,
+        ),
+        Container(height: 10.0,),
+        Text(
+          "You can leave this field blank to make app generate new long-lived token automatically by asking you to login to your Home Assistant. Use this field only if you still want to use manually generated long-lived token. Leave it blank if you don't understand what we are talking about.",
+          style: Theme.of(context).textTheme.body1.copyWith(
+            color: Colors.redAccent
+          ),
+        ),
+        new TextField(
+            decoration: InputDecoration(
+                labelText: "Long-lived token"
+            ),
+            controller: TextEditingController.fromValue(TextEditingValue(text: _newLongLivedToken)),
+            onChanged: (value) {
+              _newLongLivedToken = value;
+            }
+        ),
+        Container(
+          height: Sizes.rowPadding,
+        ),
+        RaisedButton(
+          child: Text('Apply', style: Theme.of(context).textTheme.button),
+          color: Theme.of(context).primaryColorDark,
+          onPressed: () {
+            if (_checkConfigChanged()) {
+              Logger.d("Settings changed. Saving...");
+              _saveSettings().then((r) {
+                Navigator.pop(context);
+                eventBus.fire(SettingsChangedEvent(true));
+              });
+            } else {
+              Logger.d("Settings was not changed");
+              Navigator.pop(context);
+            }
+          },
+        )
+      ],
+    );
+  }
+
+  @override
+  void dispose() {
+    super.dispose();
+  }
+}

lib/pages/settings/integration_settings.part.dart

@@ -0,0 +1,194 @@
+part of '../../main.dart';
+
+class IntegrationSettingsPage extends StatefulWidget {
+  IntegrationSettingsPage({Key key, this.title}) : super(key: key);
+
+  final String title;
+
+  @override
+  _IntegrationSettingsPageState createState() => new _IntegrationSettingsPageState();
+}
+
+class _IntegrationSettingsPageState extends State<IntegrationSettingsPage> {
+
+  int _locationInterval = LocationManager().defaultUpdateIntervalMinutes;
+  bool _locationTrackingEnabled = false;
+  bool _wait = false;
+
+  @override
+  void initState() {
+    super.initState();
+    _loadSettings();
+
+  }
+
+  _loadSettings() async {
+    SharedPreferences prefs = await SharedPreferences.getInstance();
+    await prefs.reload();
+    SharedPreferences.getInstance().then((prefs) {
+      setState(() {
+        _locationTrackingEnabled = prefs.getBool("location-enabled") ?? false;
+        _locationInterval = prefs.getInt("location-interval") ?? LocationManager().defaultUpdateIntervalMinutes;
+        if (_locationInterval % 5 != 0) {
+          _locationInterval = 5 * (_locationInterval ~/ 5);
+        }
+      });
+    });
+  }
+
+  void incLocationInterval() {
+    if (_locationInterval < 720) {
+      setState(() {
+        _locationInterval = _locationInterval + 5;
+      });
+    }
+  }
+
+  void decLocationInterval() {
+    if (_locationInterval > 5) {
+      setState(() {
+        _locationInterval = _locationInterval - 5;
+      });
+    }
+  }
+
+  restart() {
+    eventBus.fire(ShowPopupDialogEvent(
+      title: "Are you sure you want to restart Home Assistant?",
+      body: "This will restart your Home Assistant server.",
+      positiveText: "Sure. Make it so",
+      negativeText: "What?? No!",
+      onPositive: () {
+        ConnectionManager().callService(domain: "homeassistant", service: "restart");
+      },
+    ));
+  }
+
+  stop() {
+    eventBus.fire(ShowPopupDialogEvent(
+      title: "Are you sure you want to STOP Home Assistant?",
+      body: "This will STOP your Home Assistant server. It means that your web interface as well as HA Client will not work untill you'll find a way to start your server using ssh or something.",
+      positiveText: "Sure. Make it so",
+      negativeText: "What?? No!",
+      onPositive: () {
+        ConnectionManager().callService(domain: "homeassistant", service: "stop");
+      },
+    ));
+  }
+
+  updateRegistration() {
+    MobileAppIntegrationManager.checkAppRegistration(showOkDialog: true);
+  }
+
+  resetRegistration() {
+    eventBus.fire(ShowPopupDialogEvent(
+      title: "Waaaait",
+      body: "If you don't whant to have duplicate integrations and entities in your HA for your current device, first you need to remove MobileApp integration from Integration settings in HA and restart server.",
+      positiveText: "Done it already",
+      negativeText: "Ok, I will",
+      onPositive: () {
+        MobileAppIntegrationManager.checkAppRegistration(showOkDialog: true, forceRegister: true);
+      },
+    ));
+  }
+
+  _switchLocationTrackingState(bool state) async {
+    if (state) {
+      await LocationManager().updateDeviceLocation();
+    }
+    await LocationManager().setSettings(_locationTrackingEnabled, _locationInterval);
+    setState(() {
+      _wait = false;
+    });
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return ListView(
+      scrollDirection: Axis.vertical,
+      padding: const EdgeInsets.all(20.0),
+      children: <Widget>[
+              Text("Location tracking", style: Theme.of(context).textTheme.title),
+              Container(height: Sizes.rowPadding,),
+              InkWell(
+                onTap: () => Launcher.launchURLInCustomTab(context: context, url: "http://ha-client.app/docs#location-tracking"),
+                child: Text(
+                  "Please read documentation!",
+                  style: Theme.of(context).textTheme.subhead.copyWith(
+                    color: Colors.blue,
+                    decoration: TextDecoration.underline
+                  )
+                ),
+              ),
+              Container(height: Sizes.rowPadding,),
+              Row(
+                children: <Widget>[
+                  Text("Enable device location tracking"),
+                  Switch(
+                    value: _locationTrackingEnabled,
+                    onChanged: _wait ? null : (value) {
+                      setState(() {
+                        _locationTrackingEnabled = value;
+                        _wait = true;
+                      });
+                      _switchLocationTrackingState(value);
+                    },
+                  ),
+                ],
+              ),
+              Container(height: Sizes.rowPadding,),
+              Text("Location update interval in minutes:"),
+              Row(
+                mainAxisAlignment: MainAxisAlignment.center,
+                mainAxisSize: MainAxisSize.max,
+                children: <Widget>[
+                  //Expanded(child: Container(),),
+                  FlatButton(
+                    padding: EdgeInsets.all(0.0),
+                    child: Text("-", style: Theme.of(context).textTheme.title),
+                    onPressed: () => decLocationInterval(),
+                  ),
+                  Text("$_locationInterval", style: Theme.of(context).textTheme.title),
+                  FlatButton(
+                    padding: EdgeInsets.all(0.0),
+                    child: Text("+", style: Theme.of(context).textTheme.title),
+                    onPressed: () => incLocationInterval(),
+                  ),
+                ],
+              ),
+              Divider(),
+              Text("Integration status", style: Theme.of(context).textTheme.title),
+              Container(height: Sizes.rowPadding,),
+              Text(
+                "${HomeAssistant().userName}'s ${DeviceInfoManager().model}, ${DeviceInfoManager().osName} ${DeviceInfoManager().osVersion}",
+                style: Theme.of(context).textTheme.subtitle,
+                ),
+              Container(height: 6.0,),
+              Text("Here you can manually check if HA Client integration with your Home Assistant works fine. As mobileApp integration in Home Assistant is still in development, this is not 100% correct check."),
+              //Divider(),
+              Row(
+                mainAxisSize: MainAxisSize.max,
+                children: <Widget>[
+                  RaisedButton(
+                      color: Colors.blue,
+                      onPressed: () => updateRegistration(),
+                      child: Text("Check integration", style: Theme.of(context).textTheme.button)
+                  ),
+                  Container(width: 10.0,),
+                  RaisedButton(
+                      color: Colors.redAccent,
+                      onPressed: () => resetRegistration(),
+                      child: Text("Reset integration", style: Theme.of(context).textTheme.button)
+                  )
+                ],
+              ),
+            ]
+        );
+  }
+
+  @override
+  void dispose() {
+    LocationManager().setSettings(_locationTrackingEnabled, _locationInterval);
+    super.dispose();
+  }
+}

lib/pages/settings/lookandfeel_settings.part.dart

@@ -0,0 +1,79 @@
+part of '../../main.dart';
+
+class LookAndFeelSettingsPage extends StatefulWidget {
+  LookAndFeelSettingsPage({Key key, this.title}) : super(key: key);
+
+  final String title;
+
+  @override
+  _LookAndFeelSettingsPageState createState() => new _LookAndFeelSettingsPageState();
+}
+
+class _LookAndFeelSettingsPageState extends State<LookAndFeelSettingsPage> {
+
+  AppTheme _currentTheme;
+  bool _changed = false;
+
+  @override
+  void initState() {
+    super.initState();
+    _loadSettings();
+  }
+
+  _loadSettings() async {
+    SharedPreferences prefs = await SharedPreferences.getInstance();
+    await prefs.reload();
+    SharedPreferences.getInstance().then((prefs) {
+      setState(() {
+        _currentTheme = AppTheme.values[prefs.getInt("app-theme") ?? AppTheme.defaultTheme];
+      });
+    });
+  }
+
+  _saveSettings(AppTheme theme) {
+    SharedPreferences.getInstance().then((prefs) {
+      prefs.setInt('app-theme', theme.index);
+      setState(() {
+        _currentTheme = theme;
+        eventBus.fire(ChangeThemeEvent(_currentTheme));
+      });
+    });
+  }
+
+  Map appThemeName = {
+    AppTheme.defaultTheme: 'Default',
+    AppTheme.haTheme: 'Home Assistant theme',
+    AppTheme.darkTheme: 'Dark theme'
+  };
+
+  @override
+  Widget build(BuildContext context) {
+    return ListView(
+      scrollDirection: Axis.vertical,
+      padding: const EdgeInsets.all(20.0),
+      children: <Widget>[
+          Text("Application theme:", style: Theme.of(context).textTheme.body2),
+          Container(height: Sizes.rowPadding),
+          DropdownButton<AppTheme>(
+            value: _currentTheme,
+            iconSize: 30.0,
+            isExpanded: true,
+            style: Theme.of(context).textTheme.title,
+            //hint: Text("Select ${caption.toLowerCase()}"),
+            items: AppTheme.values.map((value) {
+              return new DropdownMenuItem<AppTheme>(
+                value: value,
+                child: Text('${appThemeName[value]}'),
+              );
+            }).toList(),
+            onChanged: (theme) => _saveSettings(theme),
+          )
+        ]
+      );
+  }
+
+  @override
+  void dispose() {
+    super.dispose();
+  }
+}

lib/pages/whats_new.page.dart

@@ -24,7 +24,7 @@ class _WhatsNewPageState extends State<WhatsNewPage> {
       error = "";
     });
     http.Response response;
-    response = await http.get("http://ha-client.homemade.systems/service/whats_new_0.7.0.md");
+    response = await http.get("http://ha-client.app/service/whats_new_0.8.5.md");
     if (response.statusCode == 200) {
       setState(() {
         data = response.body;

lib/pages/widgets/bottom_info_bar.dart

@@ -0,0 +1,210 @@
+part of '../../main.dart';
+
+class BottomInfoBarController {
+
+  Function show;
+  Function hide;
+
+  String bottomBarText;
+  bool bottomBarProgress;
+  bool bottomBarErrorColor;
+  Timer _bottomBarTimer;
+  bool initialState = false;
+
+  List<HAErrorAction> actions = [];
+
+  void hideBottomBar() {
+    _bottomBarTimer?.cancel();
+    if (hide == null) {
+      initialState = false;
+    } else {
+      hide();
+    }
+  }
+
+  void showInfoBottomBar({String message, bool progress: false, Duration duration}) {
+    _bottomBarTimer?.cancel();
+    actions.clear();
+    bottomBarErrorColor = false;
+    bottomBarText = message;
+    bottomBarProgress = progress;
+    if (show == null) {
+      initialState = true;
+    } else {
+      show();
+    }
+    if (duration != null) {
+      _bottomBarTimer = Timer(duration, () {
+        hideBottomBar();
+      });
+    }
+  }
+
+  void showErrorBottomBar(HAError error) {
+    actions.clear();
+    actions.addAll(error.actions);
+    bottomBarErrorColor = true;
+    bottomBarProgress = false;
+    bottomBarText = "${error.message}";
+    if (show == null) {
+      initialState = true;
+    } else {
+      show();
+    }
+  }
+
+}
+
+class BottomInfoBar extends StatefulWidget {
+
+  final BottomInfoBarController controller;
+
+  const BottomInfoBar({Key key, this.controller}) : super(key: key);
+  
+  @override
+  State<StatefulWidget> createState() {
+    return new _BottomInfoBarState();
+  }
+
+}
+
+class _BottomInfoBarState extends State<BottomInfoBar> {
+
+  bool _show;
+
+  @override
+  void initState() {
+    _show = widget.controller.initialState;
+    widget.controller.show = () {
+      setState(() {
+        _show = true;
+      });
+    };
+    widget.controller.hide = () {
+      setState(() {
+        _show = false;
+      });
+    };
+    super.initState();
+  }
+
+
+  @override
+  Widget build(BuildContext context) {
+    if (!_show) {
+      return Container(width: 0, height: 0,);
+    } else {
+      Widget bottomBar;
+      List<Widget> bottomBarChildren = [];
+      Widget actionsWidget;
+      TextStyle textStyle = Theme.of(context).textTheme.button.copyWith(
+        decoration: TextDecoration.underline
+      );
+      List<Widget> actions = [];
+      widget.controller.actions.forEach((HAErrorAction action) {
+        switch (action.type) {
+          case HAErrorActionType.FULL_RELOAD: {
+            actions.add(FlatButton(
+              child: Text("${action.title}", style: textStyle),
+              onPressed: () {
+                eventBus.fire(FullReloadEvent());
+              },
+            ));
+            break;
+          }
+
+          case HAErrorActionType.QUICK_RELOAD: {
+            actions.add(FlatButton(
+              child: Text("${action.title}", style: textStyle),
+              onPressed: () {
+                eventBus.fire(ReloadUIEvent());
+              },
+            ));
+            break;
+          }
+
+          case HAErrorActionType.RELOGIN: {
+            actions.add(FlatButton(
+              child: Text("${action.title}", style: textStyle),
+              onPressed: () {
+                ConnectionManager().logout().then((_) => eventBus.fire(FullReloadEvent()));
+              },
+            ));
+            break;
+          }
+
+          case HAErrorActionType.URL: {
+            actions.add(FlatButton(
+              child: Text("${action.title}", style: textStyle),
+              onPressed: () {
+                Launcher.launchURLInCustomTab(context: context, url: "${action.url}");
+              },
+            ));
+            break;
+          }
+
+          case HAErrorActionType.OPEN_CONNECTION_SETTINGS: {
+            actions.add(FlatButton(
+              child: Text("${action.title}", style: textStyle),
+              onPressed: () {
+                Navigator.pushNamed(context, '/connection-settings');
+              },
+            ));
+            break;
+          }
+        }
+      });
+      if (actions.isNotEmpty) {
+        actionsWidget = Row(
+          mainAxisSize: MainAxisSize.min,
+          children: actions,
+          mainAxisAlignment: MainAxisAlignment.end,
+        );
+      } else {
+        actionsWidget = Container(height: 0.0, width: 0.0,);
+      }
+
+      if (widget.controller.bottomBarText != null) {
+        bottomBarChildren.add(
+            Padding(
+              padding: EdgeInsets.fromLTRB(
+                  Sizes.leftWidgetPadding, Sizes.rowPadding, 0.0,
+                  Sizes.rowPadding),
+              child: Text(
+                "${widget.controller.bottomBarText}",
+                textAlign: TextAlign.left,
+                softWrap: true,
+              ),
+            )
+
+        );
+      }
+      if (widget.controller.bottomBarProgress) {
+        bottomBarChildren.add(
+          LinearProgressIndicator(),
+        );
+      }
+      if (bottomBarChildren.isNotEmpty) {
+        bottomBar = Container(
+          color: widget.controller.bottomBarErrorColor ? Theme.of(context).errorColor : Theme.of(context).primaryColorLight,
+          child: Row(
+            mainAxisSize: MainAxisSize.max,
+            children: <Widget>[
+              Expanded(
+                child: Column(
+                  crossAxisAlignment: widget.controller.bottomBarProgress ? CrossAxisAlignment.center : CrossAxisAlignment.start,
+                  mainAxisSize: MainAxisSize.min,
+                  children: bottomBarChildren,
+                ),
+              ),
+              actionsWidget
+            ],
+          ),
+        );
+      } else {
+        bottomBar = Container(height: 0,);
+      }
+      return bottomBar;
+    }
+  } 
+}

lib/pages/widgets/last_updated.dart

@@ -10,8 +10,7 @@ class LastUpdatedWidget extends StatelessWidget {
       child: Text(
         '${entityModel.entityWrapper.entity.lastUpdated}',
         textAlign: TextAlign.left,
-        style: TextStyle(
+        style: Theme.of(context).textTheme.caption
-            fontSize: Sizes.smallFontSize, color: Colors.black26),
       ),
     );
   }

lib/pages/widgets/page_loading_error.dart

@@ -23,7 +23,7 @@ class PageLoadingError extends StatelessWidget {
                     size: 48.0
                 )
             ),
-            Text(this.errorText, style: TextStyle(color: Colors.black45))
+            Text(this.errorText, style: Theme.of(context).textTheme.subtitle)
           ],
         )
       ],

lib/pages/widgets/page_loading_indicator.dart

@@ -14,7 +14,7 @@ class PageLoadingIndicator extends StatelessWidget {
                 padding: EdgeInsets.only(top: 40.0, bottom: 20.0),
                 child: CircularProgressIndicator()
             ),
-            Text("Loading...", style: TextStyle(color: Colors.black45))
+            Text("Loading...", style: Theme.of(context).textTheme.subtitle)
           ],
         )
       ],

lib/pages/widgets/product_purchase.widget.dart

@@ -40,10 +40,7 @@ class ProductPurchase extends StatelessWidget {
                       children: <Widget>[
                         Text(
                           "${product.title}",
-                          style: TextStyle(
+                          style: Theme.of(context).textTheme.body2,
-                              fontWeight: FontWeight.bold,
-                              fontSize: 16.0
-                          ),
                         ),
                         Container(height: Sizes.rowPadding,),
                         Text(
@@ -53,7 +50,9 @@ class ProductPurchase extends StatelessWidget {
                           softWrap: true,
                         ),
                         Container(height: Sizes.rowPadding,),
-                        Text("${product.price} $period", style: TextStyle(color: priceColor)),
+                        Text("${product.price} $period", style: Theme.of(context).textTheme.body1.copyWith(
+                          color: priceColor
+                        )),
                       ],
                     )
                 ),
@@ -61,7 +60,7 @@ class ProductPurchase extends StatelessWidget {
               Expanded(
                 flex: 2,
                 child: RaisedButton(
-                  child: Text(this.purchased ? buttonTextInactive : buttonText, style: TextStyle(color: Colors.white)),
+                  child: Text(this.purchased ? buttonTextInactive : buttonText, style: Theme.of(context).textTheme.button),
                   color: Colors.blue,
                   onPressed: this.purchased ? null : () => this.onBuy(this.product),
                 ),

lib/pages/zha_page.dart

@@ -0,0 +1,90 @@
+part of '../main.dart';
+
+class ZhaPage extends StatefulWidget {
+  ZhaPage({Key key}) : super(key: key);
+
+  @override
+  _ZhaPageState createState() => new _ZhaPageState();
+}
+
+class _ZhaPageState extends State<ZhaPage> {
+
+  List data = [];
+  String error = "";
+
+  @override
+  void initState() {
+    super.initState();
+    _loadData();
+  }
+
+  _loadData() async {
+    setState(() {
+      data.clear();
+      error = "";
+    });
+    ConnectionManager().sendSocketMessage(
+      type: 'zha_map/devices'
+    ).then((response){
+      setState(() {
+        data = response['devices'];
+      });
+    }).catchError((e){
+      setState(() {
+        error = '$e';
+      });
+    });
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    Widget body;
+    if (error.isNotEmpty) {
+      body = PageLoadingError(errorText: error,);
+    } else if (data.isEmpty) {
+      body = PageLoadingIndicator();
+    } else {
+      List<Widget> devicesListWindet = [];
+      data.forEach((device) {
+        devicesListWindet.add(
+          Card(
+            child: Column(
+              mainAxisSize: MainAxisSize.min,
+              children: <Widget>[
+                CardHeader(
+                  name: '${device['ieee']}',
+                  subtitle: Text('${device['manufacturer']}'),
+                ),
+                Text('${device['device_type']}'),
+                Text('model: ${device['model']}'),
+                Text('offline: ${device['offline']}'),
+                Text('neighbours: ${device['neighbours'].length}'),
+                Text('raw: $device'),
+              ],
+            ),
+          )
+        );
+      });
+      body = ListView(
+        children: devicesListWindet
+      );
+    }
+    return new Scaffold(
+      appBar: new AppBar(
+        leading: IconButton(icon: Icon(Icons.arrow_back), onPressed: (){
+          Navigator.pop(context);
+        }),
+        actions: <Widget>[
+          IconButton(
+            icon: Icon(Icons.refresh),
+            onPressed: () => _loadData(),
+          )
+        ],
+        // Here we take the value from the MyHomePage object that was created by
+        // the App.build method, and use it to set our appbar title.
+        title: new Text('ZHA'),
+      ),
+      body: body
+    );
+  }
+}

lib/panels/panel_class.dart

@@ -11,7 +11,7 @@ class Panel {
   };
 
   final String id;
-  final String type;
+  final String componentName;
   final String title;
   final String urlPath;
   final Map config;
@@ -19,34 +19,61 @@ class Panel {
   bool isHidden = true;
   bool isWebView = false;
 
-  Panel({this.id, this.type, this.title, this.urlPath, this.icon, this.config}) {
+  Panel({this.id, this.componentName, this.title, this.urlPath, this.icon, this.config}) {
     if (icon == null || !icon.startsWith("mdi:")) {
-      icon = Panel.iconsByComponent[type];
+      icon = Panel.iconsByComponent[componentName];
     }
-    isHidden = (type == 'lovelace' || type == 'kiosk' || type == 'states' || type == 'profile' || type == 'developer-tools');
+    isHidden = (componentName == 'kiosk' || componentName == 'states' || componentName == 'profile' || componentName == 'developer-tools');
-    isWebView = (type != 'config');
+    isWebView = (componentName != 'config' && componentName != 'lovelace' && !componentName.startsWith('haclient'));
   }
 
   void handleOpen(BuildContext context) {
-    if (type == "config") {
+    if (componentName == "config") {
       Navigator.of(context).push(
           MaterialPageRoute(
             builder: (context) => PanelPage(title: "$title", panel: this),
           )
       );
+    } else if (componentName.startsWith('haclient')) {
+      Navigator.of(context).pushNamed(urlPath);
+    } else if (componentName == 'lovelace') {
+      HomeAssistant().lovelaceDashboardUrl = this.urlPath;
+      HomeAssistant().autoUi = false;
+      SharedPreferences.getInstance().then((prefs) {
+        prefs.setString('lovelace_dashboard_url', this.urlPath);
+        eventBus.fire(ReloadUIEvent());
+      });
     } else {
-      Launcher.launchURLInCustomTab(url: "${ConnectionManager().httpWebHost}/$urlPath");
+      Launcher.launchAuthenticatedWebView(context: context, url: "${ConnectionManager().httpWebHost}/$urlPath", title: "${this.title}");
     }
   }
 
+  Widget getMenuItemWidget(BuildContext context) {
+    return ListTile(
+        leading: Icon(MaterialDesignIcons.getIconDataFromIconName(this.icon)),
+        title: Row(
+          crossAxisAlignment: CrossAxisAlignment.start,
+          children: <Widget>[
+            Text("${this.title}"),
+            Container(width: 4.0,),
+            isWebView ? Text("webview", style: Theme.of(context).textTheme.overline) : Container(width: 1.0,)
+          ],
+        ),
+        onTap: () {
+          Navigator.of(context).pop();
+          this.handleOpen(context);
+        }
+    );
+  }
+
   Widget getWidget() {
-    switch (type) {
+    switch (componentName) {
       case "config": {
         return ConfigPanelWidget();
       }
 
       default: {
-        return Text("Unsupported panel component: $type");
+        return Text("Unsupported panel component: $componentName");
       }
     }
   }