Merge pull request #796 from bwssytems/FeaturesfFor5.0

Features for 5.0

Fixes #749  No Login Feedback - No Password reset enhancement question
Fixes #717  Having to often repeat command enhancement question
Fixes #768  Hue Items error with ha-bridge-5.0.0rc2 bug question
Fixes #782  getting server error 500 out of nowhere enhancement question
Fixes #779  Allow custom hue-bridgeid? enhancement question
Fixes #450  Unable to edit on ipad enhancement question
Fixes #336  Fibaro support enhancement help wanted
Fixes #560  How to run Fibaro Scene in HA-Bridge? enhancement question
Fixes #737  2 HA-Bridge instances: UpnpListener encountered an error sending upnp notify packet. IP: 239.255.255.250 with message: Operation not permitted enhancement question
Fixes #761  Philips Hue app update - bridge update required enhancement question
Fixes #747  Issue with MQTT messages - intermittent success enhancement question
Fixes #722  Long time no operation causes failure of the first operation of home assistant devices enhancement question
Fixes #671  action taking place only on the second time i ask to do it enhancement question
Fixes #381  Resize Target Item Field enhancement question
Fixes #705  Item Delete Button deletes multiple items bug question
Fixes #327  Add Color or Raw Info enhancement question
Fixes #704  Rename "Clear Device" to "Clear" enhancement
Fixes #713  Room and basic color (especially limitless/milight) support enhancement

.gitattributes

@@ -1,5 +1,5 @@
 # Auto detect text files and perform LF normalization
-* text=auto
+text=auto
 
 # Custom for Visual Studio
 *.cs     diff=csharp

.gitignore

@@ -12,3 +12,5 @@ data
 /.settings/
 /start.bat
 /.classpath
+
+sftp-config\.json

README.md

@@ -1,7 +1,45 @@
 # ha-bridge
-Emulates Philips Hue api to other home automation gateways such as an Amazon Echo.  The Bridge handles basic commands such as "On", "Off" and "brightness" commands of the hue protocol.  This bridge can control most devices that have a distinct API.
+Emulates Philips Hue API to other home automation gateways such as an Amazon Echo or other systems that support Philips Hue.  The Bridge handles basic commands such as "On", "Off" and "brightness" commands of the hue protocol.  This bridge can control most devices that have a distinct API.
 
-In the cases of systems that require authorization and/or have API's that cannot be handled in the current method, a module may need to be built. The Harmony Hub is such a module and so is the Nest module. The Bridge has helpers to build devices for the gateway for the Logitech Harmony Hub, Vera, Vera Lite or Vera Edge, Nest and the ability to proxy all of your real Hue bridges behind this bridge.
+Here are some diagrams to put this software in perspective.
+
+The Echo Path looks like this:
+```
+                     +------------------------+    +------------------------+
++-------------+      | H A +------------------|    | A +------------------+ |
+| Amazon Echo |----->| U P | ha-bridge core   |--->| P | Device to control| |
++-------------+      | E I +------------------|    | I +------------------+ |
+                     +------------------------+    +------------------------+
+```
+The Google Home Path looks like this:
+```
+                     +------------------------+    +------------------------+
++-------------+      | H A +------------------|    | A +------------------+ |
+| Google Home |----->| U P | ha-bridge core   |--->| P | Device to control| |
++-------------+      | E I +------------------|    | I +------------------+ |
+                     +------------------------+    +------------------------+
+```
+THe Harmony Hub Path looks like this:
+```
+                     +------------------------+    +------------------------+
++-------------+      | H A +------------------|    | A +------------------+ |
+| Harmony Hub |----->| U P | ha-bridge core   |--->| P | Device to control| |
++-------------+      | E I +------------------|    | I +------------------+ |
+                     +------------------------+    +------------------------+
+```
+**SECURITY RISK: If you are unsure on how this software operates and what it exposes to your network, please make sure you understand that it can allow root access to your system. It is best practice to not open this to the Internet through your router as there are no security protocols in place to protect the system. The License agreement states specifically that you use this at your own risk.**
+
+**ATTENTION: This requires a physical Amazon Echo, Dot or Tap and does not work with prototype devices built using the Alexa Voice Service e.g. Amazon's Alexa AVS Sample App and Sam Machin's AlexaPi. The AVS version does not have any capability for Hue Bridge discovery!**
+
+**NOTE: This software does require the user to have knowledge on how processes run on Linux or Windows with java. Also, an understanding of networking basics will help as well. This system receives upnp udp multicast packets from devices to be found, so that is something to understand. Please make sure you have all your devices use static IP addresses from your router. Most all questions have been answered already. PLEASE USE GOOGLE TO FIND YOUR ANSWERS!**
+
+**NOTE: This software does not control Philips Hue devices directly. A physical Philips Hue Hub is required for that, by which the ha-bridge can then proxy all of your real Hue bridges behind this bridge.**
+
+**ISSUE: Google Home now seems to not support local connection to Philips Hue Hubs and requires that it connect to meethue.com. Since the ha-bridge only emulates the local API, and is not associated with Philips, this method will not work. If you have an older Google Home application, this may still work. YMMV.**
+
+**FAQ: Please look here for the current FAQs! https://github.com/bwssytems/ha-bridge/wiki/HA-Bridge-FAQs**
+
+In the cases of systems that require authorization and/or have APIs that cannot be handled in the current method, a module may need to be built. The Harmony Hub is such a module and so is the Nest module. The Bridge has helpers to build devices for the gateway for the Logitech Harmony Hub, Vera, Vera Lite or Vera Edge, Nest, Somfy Tahoma and the ability to proxy all of your real Hue bridges behind this bridge.
 
 Alternatively the Bridge supports custom calls as well using http/https/udp and tcp such as the LimitlessLED/MiLight bulbs using the UDP protocol. Binary data is supported with UDP/TCP.
 
@@ -20,13 +58,31 @@ Then locate the jar and start the server with:
 
 ATTENTION: This requires JDK 1.8 to run
 
+ATTENTION: Due to port 80 being the default, Linux restricts this to super user. Use the instructions below.
+
 ```
-java -jar ha-bridge-W.X.Y.jar
+java -jar ha-bridge-5.0.0.jar
 ```
 ### Automation on Linux systems
-To have this conigured and running automatically ther eare a few resources to use. One is using Docker and a docker containerahs been built for this and can be gotten here: https://github.com/aptalca/docker-ha-bridge
+To have this configured and running automatically there are a few resources to use. One is using Docker and a docker container has been built for this and can be gotten here: https://github.com/aptalca/docker-ha-bridge
 
-For next gen Linux systems, here is a systemctl unit file that you can install. Here is a link on how to do this: https://www.digitalocean.com/community/tutorials/how-to-use-systemctl-to-manage-systemd-services-and-units
+Create the directory and make sure that ha-bridge-5.0.0.jar is in your /home/pi/habridge directory.
+```
+pi@raspberrypi:~ $ mkdir habridge
+pi@raspberrypi:~ $ cd habridge
+
+pi@raspberrypi:~/habridge $ wget https://github.com/bwssytems/ha-bridge/releases/download/v5.0.0/ha-bridge-5.0.0.jar
+```
+
+#### System Control Setup on a pi (preferred)
+For next gen Linux systems (this includes the Raspberry Pi), here is a systemctl unit file that you can install. Here is a link on how to do this: https://www.digitalocean.com/community/tutorials/how-to-use-systemctl-to-manage-systemd-services-and-units
+
+Start here to create the habridge.service unit file:
+```
+pi@raspberrypi:~ $ cd /etc/systemd/system
+pi@raspberrypi:~ $ sudo nano habridge.service
+```
+Copy the text below into the editor nano.
 ```
 [Unit]
 Description=HA Bridge
@@ -35,89 +91,284 @@ After=network.target
 
 [Service]
 Type=simple
-ExecStart=/usr/bin/java -jar -Dconfig.file=/home/pi/amazon-echo/data/habridge.config /home/pi/amazon-echo/ha-bridge-2.0.0.jar
+WorkingDirectory=/home/pi/habridge
+ExecStart=/usr/bin/java -jar -Dconfig.file=/home/pi/habridge/data/habridge.config /home/pi/habridge/ha-bridge-5.0.0.jar
 
 [Install]
 WantedBy=multi-user.target
 ```
+Save the file in the editor by hitting CTL-X and then saying Y to update and save.
+
+Reload the system control config:
+```
+pi@raspberrypi:~ $ sudo systemctl daemon-reload
+```
+To start the bridge:
+```
+pi@raspberrypi:~ $ sudo systemctl start habridge.service
+```
+To start the service at boot, use the `enable` command:
+```
+pi@raspberrypi:~ $ sudo systemctl enable habridge.service
+```
+To look at the log, the output goes into the system log at `/var/log/syslog':
+```
+pi@raspberrypi:~ $ tail -f /var/log/syslog
+```
+#### Basic script setup to run the bridge on a pi.
+
+*NOTE ON RC.LOCAL*: Due to the way network subsystem is brought up on the pi, it uses the new systemctl to start services. The old style runlevel setup, which rc.local is part of does not get the benefit of knowing if the network has been fully realized. Starting ha-bridge from rc.local on next gen systems will cause unexpected results and issues with discovering registered devices. 
+
+Edit the shell script for starting:
+```
+pi@raspberrypi:~/habridge $ nano starthabridge.sh
+```
+Then cut and past this, modify any locations that are not correct
+```
+cd /home/pi/habridge
+rm /home/pi/habridge/habridge-log.txt
+nohup java -jar -Dconfig.file=/home/pi/habridge/data/habridge.config /home/pi/habridge/ha-bridge-5.0.0.jar > /home/pi/habridge/habridge-log.txt 2>&1 &
+
+chmod 777 /home/pi/habridge/habridge-log.txt
+```
+Exit and save the file with ctrl-X and follow the prompts and then execute on the command line:
+```
+pi@raspberrypi:~/habridge $ chmod u+x starthabridge.sh
+```
+Then execute the script:
+```
+pi@raspberrypi:~/habridge $ ./starthabridge.sh
+```
+You should now be running the bridge. Check for errors:
+```
+pi@raspberrypi:~/habridge $ tail -f habridge-log.txt
+```
+## Run ha-bridge alongside web server already on port 80
+These examples will help you proxy your current webserver requests to the ha-bridge running on a different port, such as 8080.
+
+### Apache Example
+
+Reverse proxy with Apache on Ubuntu linux:
+
+Enable the required Apache modules: 
+
+`a2enmod proxy proxy_http headers`
+
+Added the following lines to my Apache config file “000-default”
+
+```
+<VirtualHost *:80>
+	ProxyPass         /api  http://localhost:8080/api nocanon
+	ProxyPassReverse  /api  http://localhost:8080/api
+	ProxyRequests     Off
+	AllowEncodedSlashes NoDecode
+
+	# Local reverse proxy authorization override
+	# Most unix distribution deny proxy by default (ie /etc/apache2/mods-enabled/proxy.conf in Ubuntu)
+	<Proxy http://localhost:8080/api*>
+		  Order deny,allow
+		  Allow from all
+	</Proxy>
+
+….. (the rest of the VirtualHost config section) …..
+</VirtualHost>
+```
+
+Restart apache for the changes to take effect. 
+
+`service apache2 restart`
+
+### lighthttpd Example
+```
+server.modules   += ( "mod_proxy" )
+proxy.server = ( 
+	"/api" =>
+        (
+                ( "host" => "127.0.0.1",
+                  "port" => "8080"
+                )
+        )
+)
+```
+### nginx Example
+```
+location /api/ {
+    proxy_pass http://127.0.0.1:8080/api;
+}
+```
 ## Available Arguments
-Arguments are now deprecated. The ha-bridge will use the old -D arguments and populate the configuration screen, Brisge Control Tab, which can now be saved to a file and will not be needed. There is only one optional argument that overrides and that is the location of the configuration file. The default is the relative path "data/habridge.config".
+Arguments are now deprecated. The ha-bridge will use the old -D arguments and populate the configuration screen, Bridge Control Tab, which can now be saved to a file and will not be needed. There is only one optional argument that overrides and that is the location of the configuration file. The default is the relative path "data/habridge.config".
+### -Djava.net.preferIPv4Stack=true
+This will guarantee that the ha-bridge will not use an IPV6 address. This cannot be automatically set inside the code.
+```
+java -jar -Djava.net.preferIPv4Stack=true ha-bridge-W.X.Y.jar
+```
 ### -Dconfig.file=`<filepath>`
 The default location for the configuration file to contain the settings for the bridge is the relative path from where the bridge is started in "data/habridge.config". If you would like a different filename or directory, specify -Dconfig.file=`<directory>/<filename>` explicitly. The command line example:
 ```
 java -jar -Dconfig.file=/home/me/data/myhabridge.config ha-bridge-W.X.Y.jar
 ```
 ### -Dserver.port=`<port number>`
-The default port number for the bridge is 8080. To override what the default or what is in the configuration file for this parameter, specify -Dserver.port=`<port number>` explicitly. This is especially helpful if you are running the ha-bridge for the first time and have another application on port 8080. The command line example:
+The default port number for the bridge is 80. To override what the default or what is in the configuration file for this parameter, specify -Dserver.port=`<port number>` explicitly. This is especially helpful if you are running the ha-bridge for the first time and have another application on port 80. The command line example:
 ```
 java -jar -Dserver.port=80 ha-bridge-W.X.Y.jar
 ```
+Note: if using with a Google Home device, port 80 *must* be used.
 
+### -Dserver.ip=`<ip address>`
+The default ip address for the bridge to listen on is all interfaces (0.0.0.0). To override what the default or what is in the configuration file for this parameter, specify -Dserver.ip=`<ip address>` explicitly. This is especially helpful if you are running the ha-bridge for the first time and have another application on that utilizes the default interface. The command line example:
+```
+java -jar -Dserver.ip=192.168.1.1 ha-bridge-W.X.Y.jar
+```
+### -Dsecurity.key=`<Your Key To Encrypt Security Data>`
+This option is very important to set if you will be using username/passwords to secure the ha-bridge. The ha-bridge needs to encrypt the settings in the config file and to make sure they are secured specifically to you is to provide this key. Otherwise a default key is used and it is available in the code on github for the ha-bridge here, so not very secure in that sense. **It is very important provide this if you are using username/password.** To override the default, specify -Dsecurity.key=`<Your Key To Encrypt Security Data>` explicitly on the command line. This is will prevent any issues if your config file gets hacked. The command line example:
+```
+java -jar -Dsecurity.key=Xfawer354WertSdf321234asd ha-bridge-W.X.Y.jar
+```
+### -Dexec.garden=`<The path to your scripts and program directory>`
+This sets a directory of your choosing to have a walled area for what can be executed by the Exec Command type. This is a good feature to use if you use the capabilities of executing a script or program from the ha-bridge. The default is not set which allows any program or script to be called and anyone with access to the your system could create an exec command call and execute it from the API. This is will prevent any issues if your system gets hacked.  To override the default, specify -Dexec.garden=`<The path to your scripts and program directory>` explicitly on the command line. The command line example:
+```
+java -jar -Dexec.garden=C:\Users\John\bin
+```
 ## HA Bridge Usage and Configuration
 This section will cover the basics of configuration and where this configuration can be done. This requires that you have started your bridge process and then have pointed your
-favorite web interface by going to the http://<my ip address>:<port> or http://localhost:<port> with port you have assigned. The default quick link is http://localhost:8080 for yoru reference.
+favorite web interface by going to the http://<my ip address>:<port> or http://localhost:<port> with port you have assigned. The default quick link is http://localhost for your reference.
 ### The Bridge Devices Tab
 This screen allows you to see your devices you have configured for the ha-bridge to present to a controller, such as an Amazon Echo/Dot. It gives you a count of devices as there have been reports that the Echo only supports a limited number, but has been growing as of late, YMMV. You can test each device from this page as this calls the ha-bridge just as a controller would, i.e. the Echo. This is useful to make sure your configuration for each device is correct and for trouble shooting. You can also manages your devices as well by editing and making a new device copy as well as deleting it.
 
 At the bottom of the screen is the "Bridge Device DB Backup" which can be accessed with clicking on the `+` to expand this frame. Here you can backup and restore configurations that you have saved. These configs can be named or by clicking the `Backup Device DB' button will create a backup and name it for you. You can manage these backups by restoring them or deleting them.
+#### Renumber Devices
+This changes the numbering of the added devices to start at 1 and goes up from there. It was originally intended for a conversion from the previous system version that used large numbers and was not necessary. This also allows the system to try and number sequentially. If you use this button, you will need to re-discover your devices as their ID's will have changed.
+#### Link
+If this is present, you have enabled the ue link button feature for the ha-bridge. If you want a new system to recognize the ha-bridge, you will need to press this button when you are doign a discovery.
 ### The Bridge Control Tab
 This is where all of the configuration occurs for what ports and IP's the bridge runs on. It also contains the configurations for target devices so that Helper Tabs for configuration can be added as well as the connection information to control those devices.
 #### Bridge server
 This field is used to test the bridge server with the UPNP IP Address and to make sure that the bridge is responding.
 #### Bridge Control Buttons
 These buttons are for managing the bridge. The Save button is enabled when there is a change to the configuration. The Bridge Reinitialize button will recycle the internal running of the bridge in the java process. The Stop button will stop the java process. The Refresh button will refresh the page and settings.
+#### The Security Dialog
+This is where you can set the different security settings for the ha-bridge. There are two settings, one for enabling Hue like operation to secure the Hue API with the internally generated user for the calls that are done after the link button. The other is to secure the hue API with a username/password that is created as well. The other fields are to add and delete users and to set and change passwords for those users. If there are no users in the system, the system will not require a username/password to operate.
 #### Configuration Path and File
 The default location for the configuration file to contain the settings for the bridge is the relative path from where the bridge is started in "data/habridge.config". If you would like a different filename or directory, specify `<directory>/<filename>` explicitly.
 #### Device DB Path and File
 The default location for the db to contain the devices as they are added is "data/devices.db". If you would like a different filename or directory, specify `<directory>/<filename>  explicitly.
 #### UPNP IP Address
 The server defaults to the first available address on the host if this is not given. This default may NOT be the correct IP that is your public IP for your host on the network. It is best to set this parameter to not have discovery issues. Replace this value with the server ipv4 address you would like to use as the address that any upnp device will call after discovery. 
+#### Use UPNP Address Interface
+The server tries to bind to all interfaces to respond to UPNP request. Setting this to `true` will make the binding to the interface that has the `UPNP IP Address`. The default is to be all interfaces which is set as false.
+#### Web Server IP Address
+The server defaults to all interfaces on the machine (0.0.0.0). Replace this value with the server ipv4 address you would like to use as the address that will bind to a specific ip address on an interface if you would like. This is only necessary if you want to isolate how access is handled to the web UI. 
 #### Web Server Port
-The server defaults to running on port 8080. To override what the default is, specify a different number.
+The server defaults to running on port 80. To override what the default is, specify a different number. ATTENTION: If you want to use any of the apps made for the Hue to control this bridge, you should keep this port set to 80.
 #### UPNP Response Port
 The upnp response port that will be used. The default is 50000.  
 #### Vera Names and IP Addresses
-Provide IP Addresses of your Veras that you want to utilize with the bridge. Also, give a meaningful name to each one so it is easy to decipher in the helper tab. When these names and IP's are given, the bridge will be able to control the devices or scenes by the call it receives and send it to the target Vera and devce/scene you configure. 
+Provide IP Addresses of your Veras that you want to utilize with the bridge. Also, give a meaningful name to each one so it is easy to decipher in the helper tab. When these names and IP's are given, the bridge will be able to control the devices or scenes by the call it receives and send it to the target Vera and device/scene you configure.
+#### Fibaro Names and IP Addresses
+Provide IP Addresses of your Fibaros that you want to utilize with the bridge. Also, give a meaningful name to each one so it is easy to decipher in the helper tab. When these names and IP's are given, the bridge will be able to control the devices or scenes by the call it receives and send it to the target Fibaro and device/scene you configure.
 #### Harmony Names and IP Addresses
-Provide IP Addresses of your Harmony Hubs that you want to utilize with the bridge. Also, give a meaningful name to each one so it is easy to decipher in the helper tab. When these names and IP's are given, the bridge will be able to control the activity or buttons by the call it receives and send it to the target Harmony Hub and activity/button you configure. 
-#### Harmony Username
-The user name of the MyHarmony.com account for the Harmony Hub. This needs to be given if you are using the Harmony Hub features.
-#### Harmony Password
-The password for the user name of the MyHarmony.com account for the Harmony Hub. This needs to be given if you are using the Harmony Hub Features.
+Provide IP Addresses of your Harmony Hubs that you want to utilize with the bridge. Also, give a meaningful name to each one so it is easy to decipher in the helper tab. When these names and IP's are given, the bridge will be able to control the activity or buttons by the call it receives and send it to the target Harmony Hub and activity/button you configure. Also, an option of webhook can be called when the activity changes on the harmony hub that will send an HTTP GET call to the the address of your choosing. This can contain the replacement variables of ${activity.id} and/or ${activity.label}. Example : http://192.168.0.1/activity/${activity.id}/${activity.label} OR http://hook?a=${activity.label}
 #### Hue Names and IP Addresses
 Provide IP Addresses of your Hue Bridges that you want to proxy through the bridge. Also, give a meaningful name to each one so it is easy to decipher in the helper tab. When these names and IP's are given, the bridge will passthru the call it receives to the target Hue and device you configure.
+
+Don't forget - You will need to push the link button when you got to the Hue Tab the first time after the process comes up.  (The user name is not persistent when the process comes up.)
+#### HAL Names and IP Addresses
+Provide IP Addresses of your HAL Systems that you want to utilize with the bridge. Also, give a meaningful name to each one so it is easy to decipher in the helper tab. When these names and IP's are given, the bridge will be able to control the devices or scenes by the call it receives and send it to the target HAL and device/scene you configure. 
+#### MQTT Client IDs and IP Addresses	
+Provide Client ID and IP Addresses and ports of your MQTT Brokers that you want to utilize with the bridge. Also, you can provide the username and password if you have secured your MQTT broker which is optional. When these Client ID and IP's are given, the bridge will be able to publish MQTT messages by the call it receives and send it to the target MQTT Broker you configure. The MQTT Messages Tab will become available to help you build messages.
+#### Home Assistant Names and IP Addresses
+Provide IP Addresses and ports of your Home Assistant that you want to utilize with the bridge. Also, give a meaningful name to each one so it is easy to decipher in the helper tab. When these names and IP's are given, the bridge will be able to control the devices or scenes by the call it receives and send it to the target Home Assistant and device/scene you configure. 
+#### Domoticz Names and IP Addresses
+Provide IP Addresses of your Domoticz Systems that you want to utilize with the bridge. Also, give a meaningful name to each one so it is easy to decipher in the helper tab. When these names and IP's are given, the bridge will be able to control the devices or scenes by the call it receives and send it to the target Domoticz and device/scene you configure. 
+#### Somfy Tahoma Names and IP Addresses
+Provide user name and password used to login to www.tahomalink.com.  This needs to be provided if you're using the Somfy Tahoma features (for connecting to IO Homecontrol used by Velux among others). There is no need to give any IP address or host information as this contacts your cloud account.  *Note:* you have to 'turn on' a window to open it, and 'turn off' to close.
 #### Nest Username
 The user name of the home.nest.com account for the Nest user. This needs to be given if you are using the Nest features. There is no need to give any ip address or host information as this contacts your cloud account.
 #### Nest Password
 The password for the user name of the home.nest.com account for the Nest user. This needs to be given if you are using the Nest features.
-#### Nest Temp Farenheit
-This setting allows the value being sent into the bridge to be interpreted as Farenheit or Celsius. The default is to have Farenheit.
+#### Nest Temp Fahrenheit
+This setting allows the value being sent into the bridge to be interpreted as Fahrenheit or Celsius. The default is to have Fahrenheit.
+#### LIFX Support
+This setting will have the ha-bridge look for LIFX devices on your network. Since this is broadcast based, there is no other info needed.
+#### Emulate Hue Hub Version
+This setting is used to set the version that the ha-bridge will return in the hub version field. The default is 9999999999 which should work to be higher than the versions that are being used.
+#### Emulate MAC
+This setting is in bridge-id, uuid, etc. in ha-bridge hue config replies. Leave blank unless needed as it is mainly a tool to keep a config to a specific set of devices whtn the ha-bridge is moved to another machine
 #### Button Press/Call Item Loop Sleep Interval (ms)
-This setting is the time used in between button presses when there is multple buttons in a button device. It also controls the time between multiple items in a custom device call. This is defaulted to 100ms and the number represnts milliseonds (1000 milliseconds = 1 second).
+This setting is the time used in between button presses when there is multiple buttons in a button device. It also controls the time between multiple items in a custom device call. This is defaulted to 100ms and the number represents milliseconds (1000 milliseconds = 1 second).
 #### Log Messages to Buffer
 This controls how many log messages will be kept and displayed on the log tab. This does not affect what is written to the standard output for logging. The default is 512. Changing this will incur more memory usage of the process.
-#### UPNP Strict Handling
-Upnp has been set to be very specific as to respond as a Hue. There may be a need to make this response a little more open for other devices that may want to find the ha-bridge. The default is to be strict which is set as true.
 #### Trace UPNP Calls
 Turn on tracing for upnp discovery messages to the log. The default is false.
+#### My Echo URL
+This sets the URL that is used in the menu bar to ge to your echo. For certain countries, this needs to be set to a different URL.
 
 At the bottom of the screen is the "Bridge Settings Backup" which can be accessed with clicking on the `+` to expand this frame. Here you can backup and restore configurations that you have saved. These configs can be named or by clicking the `Backup Settings' button will create a backup and name it for you. You can manage these backups by restoring them or deleting them.
 ### The Logs Tab
 This screen displays the last 512 or number of rows defined in the config screen of the log so you don't have to go to the output of your process. The `Update Log` button refreshes the log as this screen does not auto refresh. FYI, when the trace upnp setting is turned on in the configuration, the messages will show here.
 
-The bottom part of the Logs Screen has configuration to change the logging levels as it is running. The ROOT is the basic setting and will turn on only top level logging. To set logging at a lower level, select the `Show All Loggers` checkbox and then you can set the explicit level on each of the processes components. The most helpful logger would be setting DBUG for com.bwssystems.HABridge.hue.HueMulator component. Changing this and then selecting the `Update Log Levels` button applies the new log settings. 
+The bottom part of the Logs Screen has configuration to change the logging levels as it is running. The ROOT is the basic setting and will turn on only top level logging. To set logging at a lower level, select the `Show All Loggers` checkbox and then you can set the explicit level on each of the processes components. The most helpful logger would be setting DEBUG for com.bwssystems.HABridge.hue.HueMulator component. Changing this and then selecting the `Update Log Levels` button applies the new log settings. 
 ### Bridge Device Additions
-You must configure devices before you will have any thing for the Echo or other contoller that is connected to the ha-bridge to receive.
+You must configure devices before you will have anything for the Echo or other controller that is connected to the ha-bridge to receive.
 #### Helpers
-The easy way to get devices configured is with the use of the helpers for the Vera or Harmony, Nest and Hue to create devices that the bridge will present.
+The easy way to get devices configured is with the use of the helpers for the Vera or Harmony, Nest, Hue and others to create devices that the bridge will present.
 
-For the Helpers, each item being presented from the target system has a button such as `Generate Bridge Device`, `Build A Button` or specific tasks such as `Temp` for thermostats that is used to create the specific device parameters and give it a name in the "Add a Bridge Device..." area below. The next thing to check is the name for the bridge device that it is something that makes sense especially if you usign the ha-bridge with an Echo as this is what the Echo will interpret as the device you want. Then select the `Add Bridge Device` button to finalize it.
+For the Helpers, each item being presented from the target system has a button such as `Build Item`, `Build A Button` or specific tasks such as `Temp` for thermostats that is used to create the specific device parameters. The build action buttons will put you into the edit screen. The next thing to check is the name for the bridge device that it is something that makes sense especially if you using the ha-bridge with an Echo or Google Home as this is what the Echo or Google Home will interpret as the device you want. Also, you can go back to any helper tab and click a build action button to add another item for a multi-command. After you are done in the edit tab, click the `Add Bridge Device` to finish that selection setup. 
 
 The helper tabs will also show you what you have already configured for that target type. Click on the `+` and you will see them and be able to delete them.
-#### The Manual Add Tab
+#### The Add/Edit Tab
 Another way to add a device is through the Manual Add Tab. This allows you to manually enter the name, the on and off URLs and select if there are custom handling with the type of call that can be made. This allows for control of anything that has a distinct request that can be executed so you are not limited to the Vera, Harmony, Nest or other Hue.
 
-The format of these can be the default HTTP request which executes the URLs formatted as http://<your stuff here> as a GET. Other options to this are to select the HTTP Verb and add the data type and add a body that is passed with the request. Secure https is supported as well, just use https://<your secure call here>. When using POST and PUT, you have the ability to specify the body that will be sent with the request as well as the application type for the http call.
+There is a new format for the on/dim/off URL areas. The new editor handles the intricacies of the components, but is broken down here for explanation.
+
+It is imperative when adding a line by hand that you hit the ```Add``` button at the end of the line before adding or updating the whole entry.
+
+```Update Bridge Device``` Button is for editing a current bridge device entry.
+
+```Add Bridge Device``` Button is to ccreate a new bridge device entry.
+
+```Clear``` Button is used to clear the contents of the entry on the screen.
+
+```Change Edit Mode``` Button is used to swithc back to a pure editor for the on/off/dim/color lines within the device entry.
+
+Here are the fields that can be put into the call item:
+
+Json Type | field name | What | Use
+----------|------------|------|-----
+String or JsonElement | item | This is the payload that will be called for devices | Required
+Integer | count | This is how many times this items will be executed | Optional
+Integer | delay | This is how long we will wait until the next call after | Optional
+String | type | This is the type of device we are executing | Required
+String | filterIPs | This is used filter on the IPs given in the list | Optional
+String | httpVerb | This is the http command if given, default is GET | Optional
+String | httpBody | Send this Body with a PUT or POST | Optional
+String | httpHeaders | Send these headers with the http call | Optional
+String | contentType | Define the type of content in the body | Optional
+
+Example from device.db:
+```
+[{"item":<a String that is quoted or another JSON object>,"type":"<atype>"."count":X."delay":X."filterIPs":"<comma separated list of IP addresses that are valid>"."httpVerb":"<GET,PUT,POST>","httpBody":"<body info>","httpHeaders":[{"name":"header name","value":"header value"},{"name":"another header","value":"another value"}],"contentType":"<http content type i.e application/json>"},{"item":<another item>,"type":"<aType>"}]
+```
+
+The format of the example is in JSON where the JSON tags equate to the UI labels of the On Items/Dim Items/Off Items. i.e.: JSON item = UI Target Item, JSON type = UI Type, etc... 
+
+The Add/Edit tab will show you the fields to fill in for the above in a form, when you have completed putting in the things you want, make sure to hit the `Add` button at the right.
+ 
+The format of the item can be the default HTTP request which executes the URLs formatted as `http://<your stuff here>` as a GET. Other options to this are to select the HTTP Verb and add the data type and add a body that is passed with the request. Secure https is supported as well, just use `https://<your secure call here>`. When using POST and PUT, you have the ability to specify the body that will be sent with the request as well as the application type for the http call.
+
+The valid device types are: "custom", "veraDevice", "veraScene", "harmonyActivity", "harmonyButton", "nestHomeAway", "nestThermoSet", "hueDevice", "halDevice", 
+	"halButton", "halHome", "halThermoSet", "mqttMessage", "cmdDevice", "hassDevice", "tcpDevice", "udpDevice", "httpDevice", "domoticzDevice", "somfyDevice"
+
+Filter Ip example:
+```
+Turn on Lights in Bedroom 1 (http://api.call.here/1) - Restricted to Echo 1 (10.1.1.1)
+Turn on Lights in Bedroom 2 (http://api.call.here/2) - Restricted to Echo 2 (10.2.2.2)
+Turn on Lights in Bedroom 3 (http://api.call.here/3) - Restricted to Echo 3 (10.3.3.3)
+
+Device: "Lights"
+On URL: [{"item":"http://api.call.here/1", "httpVerb":"POST", "httpBody":"value1=1&value2=2","type":"httpDevice","filterIPs":"10.1.1.1"},{"item":"http://api.call.here/2", "httpVerb":"POST", "httpBody":"value1=1&value2=2","type":"httpDevice","filterIPs":"10.2.2.2"},{"item":"http://api.call.here/3", "httpVerb":"POST", "httpBody":"value1=1&value2=2","type":"httpDevice","filterIPs":"10.3.3.3"}]
+```
 
 Headers can be added as well using a Json construct [{"name":"header type name","value":"the header value"}] with the format example:
 ```
@@ -125,99 +376,135 @@ Headers can be added as well using a Json construct [{"name":"header type name",
 {"name":"Pragma","value":"no-cache"}]
 ```
 
-Another option that is detected by the bridge is to use UDP or TCP direct calls such as udp://<ip_address>:<port>/<your stuff here> to send a UDP request. TCP calls are handled the same way as tcp://<ip_address>:<port>/<your stuff here>. If your data for the UDP or TCP request is formatted as "0x00F009B9" lexical hex format, the bridge will convert the data into a binary stream to send.
+Another option that is detected by the bridge is to use UDP or TCP direct calls such as `udp://<ip_address>:<port>/<your stuff here>` to send a UDP request. TCP calls are handled the same way as `tcp://<ip_address>:<port>/<your stuff here>`. If your data for the UDP or TCP request is formatted as "0x00F009B9" lexical hex format, the bridge will convert the data into a binary stream to send.
 
-You can also use the value replacement constructs within these statements. Such as using the expressions ${intensity.percent} for 0-100 or ${intensity.byte} for 0-255 for straight pass through of the value or items that require special calculated values using ${intensity.math()} i.e. "${intensity.math(X/4)}".
+You can also use the value replacement constructs within these statements. Such as using the expressions "${time.format(Java time format string)}" for inserting a date/time stamp, ${intensity.percent} or ${intensity.percent.hex} for 0-100 or ${intensity.decimal_percent} for 0.00-1.00 or ${intensity.byte} or ${intensity.byte.hex} for 0-255 for straight pass through of the value or items that require special calculated values using ${intensity.math()} i.e. "${intensity.math(X/4)}" or "${intensity.math(X/4).hex}". See Value Passing Controls Below.
 Examples:
 ```
-GET
-http://192.168.1.1:8180/set/this/value/${intensity.percent}
 
-PUT
-http://192.168.1.1:8280/set/this
-ContentBody: {"someValue":"${intensity..byte}"}
+[{"item":"http://192.168.1.1:8180/set/this/value/${intensity.percent}","type":"httpDevice","httpVerb":"GET"}]
 
-udp://192.168.1.1:5000/0x45${intensity.percent}55
+
+[{"item":"http://192.168.1.1:8280/set/this","type":"httpDevice","httpVerb":"PUT","httpBody":{"someValue":"${intensity.byte}"}}]
+
+[{"item":"udp://192.168.1.1:5000/0x45${intensity.percent}55","type":"udpDevice"}]
+
+[{"item":"udp://192.168.2.2:6000/fireoffthismessage\n","type":"udpDevice"}]
+
+[{"item":"tcp://192.168.3.3:9000/sendthismessage","type":"tcpDevice"}]
+
+[{"item":"tcp://192.168.4.4:10000/0x435f12dd${intensity.math((X -4)*50)}438c","type":"tcpDevice"}]
+
+[{"item":"tcp://192.168.5.5:110000/0x","type":"tcpDevice"}]
 ```
 
 #### Multiple Call Construct
-Also available is the ability to specify multiple commands in the On URL, Dim URL and Off URL areas by adding Json constructs listed here.
+Also available is the ability to specify multiple commands in the On URL, Dim URL and Off URL areas by adding Json constructs listed here. This is only for the types of tcp, udp, http, https or a new exec type. Also within the item format you can specify delay in milliseconds and count per item. These new parameters work on device buttons for the Harmony as well.
 Format Example in the URL areas:
 ```
-[{"item":"http://192.168.1.1:8180/do/this/thing"},
-{"item":"http://192.168.1.1:8180/do/the/next/thing"},
-"item":"http://192.168.1.1:8180/do/another/thing"}]
+[{"item":"http://192.168.1.1:8180/do/this/thing","type":"httpDevice"},
+{"item":"http://192.168.1.1:8180/do/the/next/thing","delay":1000,"count":2,"type":"httpDevice"},
+{"item":"http://192.168.1.1:8180/do/another/thing","type":"httpDevice"}]
 
 
-[{"item":"udp://192.168.1.1:5000/0x450555"},
-{"item":"udp://192.168.1.1:5000/0x45${intensity.percent}55"}]
+[{"item":"udp://192.168.1.1:5000/0x450555","type":"udpDevice"},
+{"item":"udp://192.168.1.1:5000/0x45${intensity.percent}55","type":"udpDevice"}]
 
-[{"item":"udp://192.168.1.1:5000/0x450555"},
-{"item":"http://192.168.1.1:8180/do/this/thing"},
-{"item":"tcp://192.168.2.1/sendthisdata"},
-{"item":"https://192.168.12.1/do/this/secure/thing"}]
+[{"item":"udp://192.168.1.1:5000/0x450555","type":"udpDevice"},
+{"item":"http://192.168.1.1:8180/do/this/thing","type":"httpDevice"},
+{"item":"tcp://192.168.2.1/sendthisdata","type":"tcpDevice"},
+{"item":"https://192.168.12.1/do/this/secure/thing","type":"httpDevice"},
+{"item":"exec://notepad.exe","type":"cmdDevice"}]
 ```
 #### Script or Command Execution
-The release as of v2.0.0 will no support the execution of a local script or program. This will blindly fire off a process to run and is bound by the privileges of the java process.
+The release as of v2.0.0 will now support the execution of a local script or program. This will blindly fire off a process to run and is bound by the privileges of the java process.
 
 To configure this type of manual add, you will need to select the Device type of "Execute Script/Program".
 
 In the URL areas, the format of the execution is just providing what command line you would like to run, or using the multiple call item construct described above.
 ```
-notepad.exe
+[{"item":"exec://C:\\Users\\John\\Documents\\Applications\\putty.exe 192.168.1.1","type":"cmdDevice"},{"item":"exec://notepad.exe","type":"cmdDevice"}]
 
-OR
+[{"item":"/home/pi/scripts/dothisscript.sh","type":"cmdDevice"}]
+```
+#### Value Passing Controls
+There are multiple replacement constructs available to be put into any of the calls except Harmony items, Net Items and HAL items. These constructs are: "${time.format(Java time format string)}", "${intensity.percent}", "${intensity.percent.hex}", "${intensity.decimal_percent}", "${intensity.byte}", "${intensity.byte.hex}", "${intensity.math(using X in your calc)}" and "${intensity.math(using X in your calc).hex}".
 
-[{"item":"C:\\Users\\John\\Documents\\Applications\\putty.exe 192.168.1.1"},
-{"item":"notepad.exe"}]
+You can control items that require special calculated values using ${intensity.math(<your expression using "X" as the value to operate on>)} i.e. "${intensity.math(X/4)}".
 
-OR
+For the items that want to have a date time put into the message, utilize ${time.format(yyyy-MM-ddTHH:mm:ssXXX)} where "yyyy-MM-ddTHH:mm:ssXXX" can be any format from the Java SimpleDateFormat documented here: https://docs.oracle.com/javase/8/docs/api/java/text/SimpleDateFormat.html
 
-/home/me/startsomething.sh
+Also, device data can be inserted into your payloads by the use of "${device.name}", "${device.id}", "${device.uniqueid}", "${device.targetDevice}", "${device.mapId}", "${device.mapType}", "${device.deviceType}", "${device.requesterAddress}", "${device.description}" and "${device.comments}". These work just like the dimming value replacements.
+e.g.
+```
+[{"item":"http://192.168.1.201:3480/data_request?id=action&output_format=json&DeviceNum=10&serviceId=urn:upnp-org:serviceId:Dimming1&action=SetLoadLevelTarget&newLoadlevelTarget=${intensity.math(X/4)}","type":"httpDevice"}]
+
+[{"item":"udp://192.168.1.1:5000/0x45${intensity.percent}55","type":"udpDevice"}]
+
+[{"item":"tcp://192.168.1.1:5000/This is the intensity real value ${intensity.byte}","type":"tcpDevice"}]
+
+[{"item":{"clientId":"TestClient","topic":"Yep","message":"This is the time ${time.format(yyyy-MM-ddTHH:mm:ssXXX)}"},"type":"mqttDevice"}]
 
 ```
 
-Also, you may want to use the REST API's listed below to configure your devices.
+Also, you may want to use the REST APIs listed below to configure your devices.
 ## Ask Alexa
 After this Tell Alexa: "Alexa, discover my devices". If there is an issue you can go to the `Menu / Settings / Connected Home` for the echo on the mobile app or your browser and have Alexa forget all devices and then do the discovery again.
 
 Then you can say "Alexa, Turn on the office light" or whatever name you have given your configured devices.  
 
-Here is the table of items to use to tell Alexa what you want to do:
+Here is the table of items to use to tell Alexa what you want to do, this has changed over time due to Amazon reserving words for skills:
 
 To do this... |	Say this...
 --------------|------------
-ON Commands | 
- | Alexa, turn on `<Device Name>`
- | Alexa, start `<Device Name>`
- | Alexa, unlock `<Device Name>`
- | Alexa, open `<Device Name>`
- | Alexa, boot up `<Device Name>`
- | Alexa, run `<Device Name>`
- | Alexa, arm `<Device Name>`
-OFF Commands | 
- | Alexa, turn off `<Device Name>`
- | Alexa, stop `<Device Name>` (this one is tricky to get right)
- | Alexa, stop running `<Device Name>` (also very tricky)
- | Alexa, lock `<Device Name>`
- | Alexa, close `<Device Name>`
- | Alexa, shutdown `<Device Name>`
- | Alexa, shut `<Device Name>`
- | Alexa, disarm `<Device Name>`
-DIM Commands | 
- | Alexa, brighten `<Device Name>` to `<Position>`
- | Alexa, dim `<Device Name> to <Position>`
- | Alexa, raise `<Device Name>` to `<Position>`
- | Alexa, lower `<Device Name>` to `<Position>`
- | Alexa, set `<Device Name>` to `<Position>`
- | Alexa, turn up `<Device Name>` to `<Position>`
- | Alexa, turn down `<Device Name>` to `<Position>`
+ON Commands | Alexa, turn on `<Device Name>`
+OFF Commands | Alexa, turn off `<Device Name>`
+DIM Commands | Alexa, brighten `<Device Name>` to `<Position>`
+DIM Commands| Alexa, dim `<Device Name>` to `<Position>`
+DIM Commands| Alexa, brighten `<Device Name>`
+DIM Commands| Alexa, dim `<Device Name>`
+DIM Commands| Alexa, set `<Device Name>` to `<Position>`
 
-To see what Alexa thinks you said, you can check in the home page for your alexa.
+To see what Alexa thinks you said, you can check in the home page for your Alexa.
 
 To view or remove devices that Alexa knows about, you can use the mobile app `Menu / Settings / Connected Home` or go to http://echo.amazon.com/#cards.
+
+## Google Assistant
+Google Home is supported as of v3.2.0 and forward, but only if the bridge is running on port 80.
+
+**ISSUE: Google Home now seems to not support local connection to Philips Hue Hubs and requires that it connect to meethue.com. Since the ha-bridge only emulates the local API, and is not associated with Philips, this method will not work. If you have an older Google Home application, this may still work. YMMV.**
+
+Use the Google Home app on a phone to add new "home control" devices by going into `Settings / Home Control / +`
+as described [here](https://support.google.com/googlehome/answer/7124115?hl=en&ref_topic=7125624#homecontrol).
+Click on `Philips Hue` under the `Add new` section. If ha-bridge is on the same network as the
+phone as well as the Home device, then the app should quickly pass through the pairing step and
+populate with all of the devices. If instead it takes you to a Philips Hue login page, this means
+that the bridge was not properly discovered.
+
+Then you can say "OK Google, Turn on the office light" or whatever name you have given your configured devices.
+
+The Google Assistant can also group lights into rooms as described in the main [help article](https://support.google.com/googlehome/answer/7072090?hl=en&ref_topic=7029100).
+
+Here is the table of items to use to tell Google what you want to do. Note that either "OK Google"
+or "Hey Google" can be used as a trigger.
+ 
+To do this: | Say "Hey Google", then...
+------------|--------------------------
+To turn on/off a light | "Turn on <light name>"
+Dim a light | "Dim the <light name>"
+Brighten a light | "Brighten the <light name>"
+Set a light brightness to a certain percentage | "Set <light name> to 50%"
+Dim/Brighten lights by a certain percentage | "Dim/Brighten <light name> by 50%"
+Turn on/off all lights in room | "Turn on/off lights in <room name>" 
+Turn on/off all lights | "Turn on/off all of the lights"
+
+To see what Home thinks you said, you can ask "Hey Google, What did I say?" or check the history in the app.
+
+New or removed devices are picked up automatically as soon as they are added/removed from ha-bridge.
+No re-discovery step is necessary.
+
 ## Configuration REST API Usage
-This section will describe the REST api available for configuration. The REST body examples are all formatted for easy reading, the actual body usage should be like this:
+This section will describe the REST API available for configuration. The REST body examples are all formatted for easy reading, the actual body usage should be like this:
 ```
 {"var1":"value1","var2":"value2","var3:"value3"}
 ```
@@ -226,7 +513,7 @@ These calls can be accomplished with a REST tool using the following URLs and HT
 ### Add a device 
 Add a new device to the HA Bridge configuration. There is a basic examples and then three alternate examples for the add. Please note that dimming is supported as well as custom value based on the dimming number given from the echo. This is under the Dimming and Value example.
 ```
-POST http://host:8080/api/devices
+POST http://host/api/devices
 ```
 #### Body Arguments
 Name |	Type |	Description | Required
@@ -249,19 +536,19 @@ contentBodyOff | string | This is the content body that you would like to send w
 {
 "name" : "bedroom light",
 "deviceType" : "switch",
-  "onUrl" : "http://192.168.1.201:3480/data_request?id=action&output_format=json&serviceId=urn:upnp-org:serviceId:SwitchPower1&action=SetTarget&newTargetValue=1&DeviceNum=41",
-  "offUrl" : "http://192.168.1.201:3480/data_request?id=action&output_format=json&serviceId=urn:upnp-org:serviceId:SwitchPower1&action=SetTarget&newTargetValue=0&DeviceNum=41"
+  "onUrl" : "[{\"item\":\"http://192.168.1.201:3480/data_request?id=action&output_format=json&serviceId=urn:upnp-org:serviceId:SwitchPower1&action=SetTarget&newTargetValue=1&DeviceNum=41\",\"type\":\"veraDevice\"}]",
+  "offUrl" : "[{\"item\":\"http://192.168.1.201:3480/data_request?id=action&output_format=json&serviceId=urn:upnp-org:serviceId:SwitchPower1&action=SetTarget&newTargetValue=0&DeviceNum=41\",\"type\":\"veraDevice\"}]"
 }
 ```
 #### Dimming Control Example
-Dimming is also supported by using the expressions ${intensity.percent} for 0-100 or ${intensity.byte} for 0-255 for straight pass trhough of the value.
+Dimming is also supported by using the expressions ${intensity.percent} for 0-100 or ${intensity.decimal_percent} for 0.00-1.00 or ${intensity.byte} for 0-255 for straight pass through of the value.
 e.g.
 ```
 {
     "name": "entry light",
     "deviceType": "switch",
-    "offUrl": "http://192.168.1.201:3480/data_request?id=action&output_format=json&serviceId=urn:upnp-org:serviceId:SwitchPower1&action=SetTarget&newTargetValue=0&DeviceNum=31",
-    "onUrl": "http://192.168.1.201:3480/data_request?id=action&output_format=json&DeviceNum=31&serviceId=urn:upnp-org:serviceId:Dimming1&action=SetLoadLevelTarget&newLoadlevelTarget=${intensity.percent}"
+    "offUrl": "[{\"item\":\"http://192.168.1.201:3480/data_request?id=action&output_format=json&serviceId=urn:upnp-org:serviceId:SwitchPower1&action=SetTarget&newTargetValue=0&DeviceNum=31\",\"type\":\"veraDevice\"}]",
+    "onUrl": "[{\"item\":\"http://192.168.1.201:3480/data_request?id=action&output_format=json&DeviceNum=31&serviceId=urn:upnp-org:serviceId:Dimming1&action=SetLoadLevelTarget&newLoadlevelTarget=${intensity.percent}\",\"type\":\"veraDevice\"}]"
 }
 ```
 See the echo's documentation for the dimming phrase.
@@ -273,8 +560,8 @@ e.g.
 {
     "name": "Thermostat,
     "deviceType": "custom",
-    "offUrl": "http://192.168.1.201:3480/data_request?id=action&output_format=json&serviceId=urn:upnp-org:serviceId:SwitchPower1&action=SetTarget&newTargetValue=0&DeviceNum=10",
-    "onUrl": "http://192.168.1.201:3480/data_request?id=action&output_format=json&DeviceNum=10&serviceId=urn:upnp-org:serviceId:Dimming1&action=SetLoadLevelTarget&newLoadlevelTarget=${intensity.math(X/4)}"
+    "offUrl": "[{\"item\":\"http://192.168.1.201:3480/data_request?id=action&output_format=json&serviceId=urn:upnp-org:serviceId:SwitchPower1&action=SetTarget&newTargetValue=0&DeviceNum=10\",\"type\":\"veraDevice\"}]",
+    "onUrl": "[{\"item\":\"http://192.168.1.201:3480/data_request?id=action&output_format=json&DeviceNum=10&serviceId=urn:upnp-org:serviceId:Dimming1&action=SetLoadLevelTarget&newLoadlevelTarget=${intensity.math(X/4)}\",\"type\":\"veraDevice\"}]"
 }
 ```
 See the echo's documentation for the dimming phrase.
@@ -286,12 +573,8 @@ e.g:
 {
     "name": "test device",
     "deviceType": "custom",
-    "offUrl": "http://192.168.1.201:3480/data_request?id=action&output_format=json&serviceId=urn:upnp-org:serviceId:SwitchPower1&action=SetTarget&newTargetValue=0&DeviceNum=31",
-    "onUrl": "http://192.168.1.201:3480/data_request?id=action&output_format=json&DeviceNum=31&serviceId=urn:upnp-org:serviceId:Dimming1&action=SetLoadLevelTarget&newLoadlevelTarget=${intensity.percent}",
-  "httpVerb":"POST",
-  "contentType" : "application/json",
-  "contentBody" : "{\"fooBar\":\"baz_on\"}"
-  "contentBodyOff" : "{\"fooBar\":\"baz_off\"}"
+    "offUrl": "[{\"item\":\"http://192.168.1.201:3480/data_request?id=action&output_format=json&serviceId=urn:upnp-org:serviceId:SwitchPower1&action=SetTarget&newTargetValue=0&DeviceNum=31\",\"httpVerb\":\"POST\",\"contentType\" : \"application/json\",\"httpBody\" : \"{\"fooBar\":\"baz_off\"}]",
+    "onUrl": "[{\"item\":\"http://192.168.1.201:3480/data_request?id=action&output_format=json&DeviceNum=31&serviceId=urn:upnp-org:serviceId:Dimming1&action=SetLoadLevelTarget&newLoadlevelTarget=${intensity.percent}\",\"type\":\"httpDevice\",\"httpVerb\":\"POST\",\"contentType\" : \"application/json\",\"httpBody\" : \"{\"fooBar\":\"baz_on\"}]"
 }
 ```
 #### Custom Usage URLs Example
@@ -300,8 +583,8 @@ Anything that takes an action as a result of an HTTP request will probably work
 {
   "name": "night mode",
   "deviceType": ""custom",
-  "offUrl": "http://192.168.1.201:3480/data_request?id=lu_action&serviceId=urn:micasaverde-com:serviceId:HomeAutomationGateway1&action=SetHouseMode&Mode=1",
-  "onUrl": "http://192.168.1.201:3480/data_request?id=lu_action&serviceId=urn:micasaverde-com:serviceId:HomeAutomationGateway1&action=SetHouseMode&Mode=3"
+  "offUrl": "[{\"item\":\"http://192.168.1.201:3480/data_request?id=lu_action&serviceId=urn:micasaverde-com:serviceId:HomeAutomationGateway1&action=SetHouseMode&Mode=1\",\"type\":\"httpDevice\"}]",
+  "onUrl": "[{\"item\":\"http://192.168.1.201:3480/data_request?id=lu_action&serviceId=urn:micasaverde-com:serviceId:HomeAutomationGateway1&action=SetHouseMode&Mode=3\",\"type\":\"httpDevice\"}]"
 }
 ```
 Here is a UDP example that can send binary data.
@@ -309,8 +592,8 @@ Here is a UDP example that can send binary data.
 {
   "name": "UDPPacket",
   "deviceType": "custom",
-  "offUrl": "udp://192.168.1.1:8899/0x460055",
-  "onUrl": "udp://192.168.1.1:8899/0x450055"
+  "offUrl": "[{\"item\":\"udp://192.168.1.1:8899/0x460055\",\"type\":\"udpDevice\"}]",
+  "onUrl": "[{\"item\":\"udp://192.168.1.1:8899/0x450055\",\"type\":\"udpDevice\"}]"
 }
 ```
 #### Response
@@ -335,14 +618,16 @@ contentBodyOff | string | This is the content body that you would like to send w
 "id" : "12345",
 "name" : "bedroom light",
 "deviceType" : "switch",
-  "onUrl" : "http://192.168.1.201:3480/data_request?id=action&output_format=json&serviceId=urn:upnp-org:serviceId:SwitchPower1&action=SetTarget&newTargetValue=1&DeviceNum=41",
-  "offUrl" : "http://192.168.1.201:3480/data_request?id=action&output_format=json&serviceId=urn:upnp-org:serviceId:SwitchPower1&action=SetTarget&newTargetValue=0&DeviceNum=41"
+  "onUrl" : [{"item":"http://192.168.1.201:3480/data_request?id=action&output_format=json&serviceId=urn:upnp-org:serviceId:SwitchPower1&action=SetTarget&newTargetValue=1&DeviceNum=41","type":"veraDevice"}],
+  "offUrl" : [{"item":"http://192.168.1.201:3480/data_request?id=action&output_format=json&serviceId=urn:upnp-org:serviceId:SwitchPower1&action=SetTarget&newTargetValue=0&DeviceNum=41","type":"veraDevice"}]
 }
 ```
 ### Update a Device 
-Update an existing device using it's ID that was given when the device was created and the update could contain any of the fields that are used and shown in the previous examples when adding a device. 
+Update an existing device using its ID that was given when the device was created and the update could contain any of the fields that are used and shown in the previous examples when adding a device. 
+
+**Note: You must supply all fields of the device in return as this is a replacement update for the given id.**
 ```
-POST http://host:port/api/devices/<id>
+PUT http://host:port/api/devices/<id>
 ```
 #### Body Arguments
 Name |	Type |	Description | Required
@@ -354,7 +639,7 @@ mapType | string | This identifies what type of source item was used from the he
 deviceType | string | This identifies what type of device entry this is. It is used by the system and should be the values of "switch", "scene", "custom", "activity", "button", "thermo", "passthru", "exec", "UDP", "TCP" or "custom". | Required
 targetDevice | string | A name given to the target when there are multiples of a given type in the configuration | Optional
 onUrl | string | This is the URL or Data Description that is executed for an "on" request. | Required
-dimUrl | string | This is the URL or Data Description that is executed for an "on" request when a intensity value is sent. | Optional
+dimUrl | string | This is the URL or Data Description that is executed for an "on" request when an intensity value is sent. | Optional
 offUrl | string | This is the URL or Data Description that is executed for an "off" request. | Optional
 headers | string | This is a header or list of headers that is used for http/https calls when given. | Optional
 httpVerb | string | This is used for "custom" calls that the user would like to execute. The values can only be "GET, "PUT", "POST". | Optional
@@ -367,8 +652,8 @@ contentBodyOff | string | This is the content body that you would like to send w
 "id" : "6789",
 "name" : "table light",
 "deviceType" : "switch",
-  "onUrl" : "http://192.168.1.201:3480/data_request?id=action&output_format=json&serviceId=urn:upnp-org:serviceId:SwitchPower1&action=SetTarget&newTargetValue=1&DeviceNum=41",
-  "offUrl" : "http://192.168.1.201:3480/data_request?id=action&output_format=json&serviceId=urn:upnp-org:serviceId:SwitchPower1&action=SetTarget&newTargetValue=0&DeviceNum=41"
+  "onUrl" : "[{\"item\":\"http://192.168.1.201:3480/data_request?id=action&output_format=json&serviceId=urn:upnp-org:serviceId:SwitchPower1&action=SetTarget&newTargetValue=1&DeviceNum=41\",\"type\":\"veraDevice\"}]",
+  "offUrl" : "[{\"item\":\"http://192.168.1.201:3480/data_request?id=action&output_format=json&serviceId=urn:upnp-org:serviceId:SwitchPower1&action=SetTarget&newTargetValue=0&DeviceNum=41\",\"type\":\"veraDevice\"}]"
 }
 ```
 #### Response
@@ -377,8 +662,8 @@ contentBodyOff | string | This is the content body that you would like to send w
 "id" : "6789",
 "name" : "table light",
 "deviceType" : "switch",
-  "onUrl" : "http://192.168.1.201:3480/data_request?id=action&output_format=json&serviceId=urn:upnp-org:serviceId:SwitchPower1&action=SetTarget&newTargetValue=1&DeviceNum=41",
-  "offUrl" : "http://192.168.1.201:3480/data_request?id=action&output_format=json&serviceId=urn:upnp-org:serviceId:SwitchPower1&action=SetTarget&newTargetValue=0&DeviceNum=41"
+  "onUrl" : [{"item":"http://192.168.1.201:3480/data_request?id=action&output_format=json&serviceId=urn:upnp-org:serviceId:SwitchPower1&action=SetTarget&newTargetValue=1&DeviceNum=41","type":"veraDevice"}],
+  "offUrl" : [{"item":"http://192.168.1.201:3480/data_request?id=action&output_format=json&serviceId=urn:upnp-org:serviceId:SwitchPower1&action=SetTarget&newTargetValue=0&DeviceNum=41","type":"veraDevice"}]
 }
 ```
 ### Get All Devices 
@@ -393,15 +678,15 @@ Individual entries are the same as a single device but in json list format.
 "id" : "12345",
 "name" : "bedroom light",
 "deviceType" : "switch",
-  "onUrl" : "http://192.168.1.201:3480/data_request?id=action&output_format=json&serviceId=urn:upnp-org:serviceId:SwitchPower1&action=SetTarget&newTargetValue=1&DeviceNum=41",
-  "offUrl" : "http://192.168.1.201:3480/data_request?id=action&output_format=json&serviceId=urn:upnp-org:serviceId:SwitchPower1&action=SetTarget&newTargetValue=0&DeviceNum=41"
+  "onUrl" : [{"item":"http://192.168.1.201:3480/data_request?id=action&output_format=json&serviceId=urn:upnp-org:serviceId:SwitchPower1&action=SetTarget&newTargetValue=1&DeviceNum=41","type":"veraDevice"}],
+  "offUrl" : [{"item":"http://192.168.1.201:3480/data_request?id=action&output_format=json&serviceId=urn:upnp-org:serviceId:SwitchPower1&action=SetTarget&newTargetValue=0&DeviceNum=41","type":"veraDevice"}]
 }
 {
 "id" : "6789",
 "name" : "table light",
 "deviceType" : "switch",
-  "onUrl" : "http://192.168.1.201:3480/data_request?id=action&output_format=json&serviceId=urn:upnp-org:serviceId:SwitchPower1&action=SetTarget&newTargetValue=1&DeviceNum=41",
-  "offUrl" : "http://192.168.1.201:3480/data_request?id=action&output_format=json&serviceId=urn:upnp-org:serviceId:SwitchPower1&action=SetTarget&newTargetValue=0&DeviceNum=41"
+  "onUrl" : [{"item":"http://192.168.1.201:3480/data_request?id=action&output_format=json&serviceId=urn:upnp-org:serviceId:SwitchPower1&action=SetTarget&newTargetValue=1&DeviceNum=41","type":"veraDevice"}],
+  "offUrl" : [{"item":"http://192.168.1.201:3480/data_request?id=action&output_format=json&serviceId=urn:upnp-org:serviceId:SwitchPower1&action=SetTarget&newTargetValue=0&DeviceNum=41","type":"veraDevice"}]
 }]
 ```
 ### Get a Specific Device 
@@ -416,8 +701,8 @@ The response is the same layout as defined in the add device response.
 "id" : "6789",
 "name" : "table light",
 "deviceType" : "switch",
-  "onUrl" : "http://192.168.1.201:3480/data_request?id=action&output_format=json&serviceId=urn:upnp-org:serviceId:SwitchPower1&action=SetTarget&newTargetValue=1&DeviceNum=41",
-  "offUrl" : "http://192.168.1.201:3480/data_request?id=action&output_format=json&serviceId=urn:upnp-org:serviceId:SwitchPower1&action=SetTarget&newTargetValue=0&DeviceNum=41"
+  "onUrl" : [{"item":"http://192.168.1.201:3480/data_request?id=action&output_format=json&serviceId=urn:upnp-org:serviceId:SwitchPower1&action=SetTarget&newTargetValue=1&DeviceNum=41","type":"veraDevice"}],
+  "offUrl" : [{"item":"http://192.168.1.201:3480/data_request?id=action&output_format=json&serviceId=urn:upnp-org:serviceId:SwitchPower1&action=SetTarget&newTargetValue=0&DeviceNum=41","type":"veraDevice"}]
 }
 ```
 ### Delete a Specific Device 
@@ -430,7 +715,7 @@ This call returns a null json "{}".
 ### Get HA Bridge Version 
 Get current version of the HA bridge software. 
 ```
-GET http://host:port/api/devices/habridge/version
+GET http://host:port/system/habridge/version
 ```
 #### Response
 Name |	Type |	Description
@@ -580,7 +865,7 @@ Show the Harmony Hub's current activity.
 GET http://host:port/api/devices/harmony/show
 ```
 #### Response
-Only listing the relevant fields that are needed for identity of an activity. TThe example below is representative of an activity.
+Only listing the relevant fields that are needed for identity of an activity. The example below is representative of an activity.
 
 Name |	Type |	Description
 -----|-------|-------------
@@ -621,7 +906,7 @@ The example below is representative of some HUE device responses.
 
 Name |	Type |	Description
 -----|-------|-------------
-device | HUE lights object | The HUE light detail descriptor, see api for lights response below.
+device | HUE lights object | The HUE light detail descriptor, see API for lights response below.
 huedeviceid | string | The id of the actual passthru HUE light id.
 hueaddress | string | The address of the target HUE bridge.
 huename | string | A name given to the target HUE bridge.
@@ -630,7 +915,7 @@ huename | string | A name given to the target HUE bridge.
 [{"device":{"state":{"on":true,"bri":254,"hue":4444,"sat":254,"effect":"none","ct":0,"alert":"none","colormode":"hs","reachable":true,"xy":[0.0,0.0]},"type":"Extended color light","name":"Hue Lamp 1","modelid":"LCT001","uniqueid":"00:17:88:01:00:d4:12:08-0a","swversion":"65003148"},"huedeviceid":"1","hueaddress":"192.168.0.118:8000","huename":"HueEmul"},{"device":{"state":{"on":true,"bri":254,"hue":23536,"sat":144,"effect":"none","ct":201,"alert":"none","colormode":"hs","reachable":true,"xy":[0.346,0.3568]},"type":"Extended color light","name":"Hue Lamp 2","modelid":"LCT001","uniqueid":"00:17:88:01:00:d4:12:08-0b","swversion":"65003148"},"huedeviceid":"2","hueaddress":"192.168.0.118:8000","huename":"HueEmul"},{"device":{"state":{"on":true,"bri":254,"hue":65136,"sat":254,"effect":"none","ct":201,"alert":"none","colormode":"hs","reachable":true,"xy":[0.346,0.3568]},"type":"Extended color light","name":"Hue Lamp 3","modelid":"LCT001","uniqueid":"00:17:88:01:00:d4:12:08-0c","swversion":"65003148"},"huedeviceid":"3","hueaddress":"192.168.0.118:8000","huename":"HueEmul"}]
 ```
 ## HUE REST API usage
-This section will describe the REST api available for controlling the bridge based off of the HUE API. This Bridge does not support the full HUE API, only the calls that are supported with the HA Bridge are shown. The REST body examples are all formatted for easy reading, the actual body usage should be like this:
+This section will describe the REST API available for controlling the bridge based off of the HUE API. This Bridge does not support the full HUE API, only the calls that are supported with the HA Bridge are shown. The REST body examples are all formatted for easy reading, the actual body usage should be like this:
 ```
 {"var1":"value1","var2":"value2","var3:"value3"}
 ```
@@ -739,12 +1024,12 @@ A response to a successful PUT request contains confirmation of the arguments pa
 ]
 ```
 ### Update bridge internal light state
-Allows the user to set the internal state of the light on and off, modify the brightness. This is not a HUE API call and is special to the bridge as it keeps track of the state changes to the light from the api. It is intended to allow you to sync the bridge state with your HA system state.
+Allows the user to set the internal state of the light on and off, modify the brightness. This is not a HUE API call and is special to the bridge as it keeps track of the state changes to the light from the API. It is intended to allow you to sync the bridge state with your HA system state.
 ```
 PUT	http://host:port/api/<username>/lights/<id>/bridgeupdatestate
 ```
 #### Body arguments
-These are examples that can be used in the control of items iwthin the bridge, but for HUE passthru devices, the complete state object is sent.
+These are examples that can be used in the control of items within the bridge, but for HUE passthru devices, the complete state object is sent.
 Name |	Type |	Description	 
 -----|-------|-------------
 on |	bool |	On/Off state of the light. On=true, Off=false. Optional
@@ -862,7 +1147,7 @@ rules |	object |	A collection of all rules and their attributes. This is not giv
 ## UPNP Emulation of HUE
 This section will discuss the UPNP implementation of this bridge based as much as can be for the HUE.
 ### UPNP listening
-The HA Bridge default UPNP listner is started on port 1900 on the upnp multicast address of 239.255.255.250. All ethernet interfaces that are active are bound to and the repsonse port is set to the one given on the command line above or the default of 50000.
+The HA Bridge default UPNP listener is started on port 1900 on the upnp multicast address of 239.255.255.250. All ethernet interfaces that are active are bound to and the response port is set to the one given on the command line above or the default of 50000.
 
 The listener will respond to the following body packet that contain the following minimal information:
 
@@ -876,22 +1161,50 @@ ST: upnp:rootdevice\r\n
 ST: ssdp:all\r\n
 ```
 
-If this criteria is met, the following response is provided to the calling application:
+If this criteria is met, the following three responses are provided to the calling application:
 
 ```
-HTTP/1.1 200 OK\r\n
-CACHE-CONTROL: max-age=86400\r\n
-EXT:\r\n
-LOCATION: http://192.168.1.1:8080/description.xml\r\n
-SERVER: FreeRTOS/6.0.5, UPnP/1.0, IpBridge/0.1\r\n 
-ST: urn:schemas-upnp-org:device:basic:1\r\n
-"USN: uuid:Socket-1_0-221438K0100073::urn:schemas-upnp-org:device:basic:1\r\n\r\n
+HTTP/1.1 200 OK
+HOST: 239.255.255.250:1900
+CACHE-CONTROL: max-age=100
+EXT:
+LOCATION: http://192.168.1.1:80/description.xml
+SERVER: Linux/3.14.0 UPnP/1.0 IpBridge/1.15.0
+hue-bridgeid: 001E06FFFE123456
+ST: upnp:rootdevice
+USN: uuid:2f402f80-da50-11e1-9b23-001e06123456::upnp:rootdevice
 ```
+```
+HTTP/1.1 200 OK
+HOST: 239.255.255.250:1900
+CACHE-CONTROL: max-age=100
+EXT:
+LOCATION: http://192.168.1.1:80/description.xml
+SERVER: Linux/3.14.0 UPnP/1.0 IpBridge/1.15.0
+hue-bridgeid: 001E06FFFE123456
+ST: uuid:2f402f80-da50-11e1-9b23-001e06123456
+USN: uuid:2f402f80-da50-11e1-9b23-001e06123456
+```
+```
+HTTP/1.1 200 OK
+HOST: 239.255.255.250:1900
+CACHE-CONTROL: max-age=100
+EXT:
+LOCATION: http://192.168.1.1:80/description.xml
+SERVER: Linux/3.14.0 UPnP/1.0 IpBridge/1.15.0
+hue-bridgeid: 001E06FFFE123456
+ST: urn:schemas-upnp-org:device:basic:1
+USN: uuid:2f402f80-da50-11e1-9b23-001e06123456
+```
+ 
+Note that `192.168.1.1` and `12345` are replaced with the actual IP address and last 6 digits of the MAC address, respectively.
+
+
 ### UPNP description service
-The bridge provides the description service which is used by the calling app to interogate access details after it has decided the upnp multicast repsonse is the correct device.
+The bridge provides the description service which is used by the calling app to interrogate access details after it has decided the upnp multicast response is the correct device.
 #### Get Description
 ```
-GET http://host:8080/description.xml
+GET http://host:80/description.xml
 ```
 #### Response
 ```
@@ -901,18 +1214,18 @@ GET http://host:8080/description.xml
 	<major>1</major>\n
 	<minor>0</minor>\n
 	</specVersion>\n
-	<URLBase>http://192.168.1.1:8080/</URLBase>\n
+	<URLBase>http://192.168.1.1:80/</URLBase>\n
 	<device>\n
 		<deviceType>urn:schemas-upnp-org:device:Basic:1</deviceType>\n
-		<friendlyName>HA-Bridge (192.168.1.1)</friendlyName>\n
+		<friendlyName>Philips hue (192.168.1.1)</friendlyName>\n
 		<manufacturer>Royal Philips Electronics</manufacturer>\n
-		<manufacturerURL>http://www.bwssystems.com</manufacturerURL>\n
-		<modelDescription>Hue Emulator for HA bridge</modelDescription>\n
-		<modelName>Philips hue bridge 2012</modelName>\n
-		<modelNumber>929000226503</modelNumber>\n
-		<modelURL>http://www.bwssystems.com/apps.html</modelURL>\n
+		<manufacturerURL>http://www.philips.com</manufacturerURL>\n
+		<modelDescription>Philips hue Personal Wireless Lighting</modelDescription>\n"
+		<modelName>Philips hue bridge 2015</modelName>\n
+		<modelNumber>BSB002</modelNumber>\n
+		<modelURL>http://www.meethue.com</modelURL>\n
 		<serialNumber>0017880ae670</serialNumber>\n
-		<UDN>uuid:88f6698f-2c83-4393-bd03-cd54a9f8595</UDN>\n
+		<UDN>uuid:2f402f80-da50-11e1-9b23-001788102201</UDN>\n
 		<serviceList>\n
 			<service>\n
 				<serviceType>(null)</serviceType>\n
@@ -942,13 +1255,8 @@ GET http://host:8080/description.xml
 	</device>\n
 </root>\n
 ```
-## Debugging
-To turn on debugging for the bridge, use the following extra parm in the command line:
-```
--Dorg.slf4j.simpleLogger.defaultLogLevel=DEBUG
-```
 ## Development Mode
-To turn on development mode so that it will not need an Harmony Hub for testing, use the following extra parm in the command line and the harmony ip and login info will not be needed:
+To turn on development mode so that it will not need a Harmony Hub for testing, use the following extra parameter in the command line and the harmony ip and login info will not be needed:
 ```
 java -jar -Ddev.mode=true ha-bridge-0.X.Y.jar
-```
+```

pom.xml

@@ -5,7 +5,7 @@
 
 	<groupId>com.bwssystems.HABridge</groupId>
 	<artifactId>ha-bridge</artifactId>
-	<version>2.0.0</version>
+	<version>5.0.0</version>
 	<packaging>jar</packaging>
 
 	<name>HA Bridge</name>
@@ -15,6 +15,7 @@
 		<java.version>1.8</java.version>
         <maven.compiler.source>1.8</maven.compiler.source>
         <maven.compiler.target>1.8</maven.compiler.target>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
 	</properties>
 
 	<repositories>
@@ -22,13 +23,17 @@
 	    	<id>jitpack.io</id>
 		    <url>https://jitpack.io</url>
 		</repository>
+	    <repository>
+	        <id>Eclipse Paho Repo</id>
+	        <url>https://repo.eclipse.org/content/repositories/paho-releases/</url>
+	    </repository>
 	</repositories>
 
 	<dependencies>
 		<dependency>
 		    <groupId>com.github.bwssytems</groupId>
 		    <artifactId>harmony-java-client</artifactId>
-		    <version>1.0.8</version>
+		    <version>1.1.5</version>
 		    <exclusions>
 		       <exclusion> 
 		          <groupId>org.slf4j</groupId>
@@ -43,7 +48,7 @@
         <dependency>
             <groupId>com.github.bwssytems</groupId>
             <artifactId>nest-controller</artifactId>
-            <version>1.0.8</version>
+            <version>1.0.14</version>
 		    <exclusions>
 		       <exclusion> 
 		          <groupId>org.slf4j</groupId>
@@ -58,7 +63,7 @@
 		<dependency>
 		    <groupId>com.sparkjava</groupId>
 		    <artifactId>spark-core</artifactId>
-		    <version>2.3</version>
+		    <version>2.7.1</version>
 		    <exclusions>
 		    	<exclusion>
 		    		<artifactId>slf4j-simple</artifactId>
@@ -89,18 +94,8 @@
         <dependency>
             <groupId>com.google.code.gson</groupId>
             <artifactId>gson</artifactId>
-            <version>2.2.4</version>
+            <version>2.6.2</version>
         </dependency>
-        <dependency>
-            <groupId>com.fasterxml.jackson.core</groupId>
-            <artifactId>jackson-databind</artifactId>
-            <version>2.6.0</version>
-        </dependency>
-		<dependency>
-		  <groupId>com.cedarsoftware</groupId>
-		  <artifactId>json-io</artifactId>
-		  <version>4.1.6</version>
-		</dependency>
 		<dependency>
 		  <groupId>net.java.dev.eval</groupId>
 		  <artifactId>eval</artifactId>
@@ -116,6 +111,26 @@
 		  <artifactId>smack-core</artifactId>
 		  <version>4.0.7</version>
 		</dependency>
+	    <dependency>
+	        <groupId>org.eclipse.paho</groupId>
+	        <artifactId>org.eclipse.paho.client.mqttv3</artifactId>
+	        <version>1.1.0</version>
+	    </dependency>
+		<dependency>
+		    <groupId>junit</groupId>
+		    <artifactId>junit</artifactId>
+		    <version>4.11</version>
+		</dependency>
+		<dependency>
+		  <groupId>com.github.bwssytems</groupId>
+		  <artifactId>lifx-sdk-java</artifactId>
+		  <version>2.1.6</version>
+		</dependency>
+		<dependency>
+		  <groupId>org.apache.commons</groupId>
+		  <artifactId>commons-lang3</artifactId>
+		  <version>3.5</version>
+		</dependency>
 	</dependencies>
 
 	<build>
@@ -139,7 +154,7 @@
 			<plugin>
 				<groupId>org.apache.maven.plugins</groupId>
 				<artifactId>maven-shade-plugin</artifactId>
-				<version>2.3</version>
+				<version>2.4.3</version>
 				<executions>
 					<execution>
 						<phase>package</phase>
@@ -193,6 +208,12 @@
 										<include>**</include>
 									</includes>
 								</filter>
+								<filter>
+									<artifact>org.eclipse.paho:org.eclipse.paho.client.mqttv3</artifact>
+									<includes>
+										<include>**</include>
+									</includes>
+								</filter>
 							</filters>
 							<transformers>
 								<transformer
@@ -206,4 +227,4 @@
 			</plugin>
 		</plugins>
 	</build>
-</project>
+</project>

src/main/java/com/bwssystems/HABridge/BridgeControlDescriptor.java

@@ -3,6 +3,7 @@ package com.bwssystems.HABridge;
 public class BridgeControlDescriptor {
 	private boolean reinit;
 	private boolean stop;
+	private boolean linkButton;
 
 	public BridgeControlDescriptor() {
 		super();
@@ -22,4 +23,12 @@ public class BridgeControlDescriptor {
 	public void setStop(boolean stop) {
 		this.stop = stop;
 	}
+
+	public boolean isLinkButton() {
+		return linkButton;
+	}
+
+	public void setLinkButton(boolean linkButton) {
+		this.linkButton = linkButton;
+	}
 }

src/main/java/com/bwssystems/HABridge/BridgeSecurity.java

@@ -0,0 +1,356 @@
+package com.bwssystems.HABridge;
+
+import java.io.IOException;
+import java.io.UnsupportedEncodingException;
+import java.security.GeneralSecurityException;
+import java.util.Base64;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Set;
+import java.util.StringTokenizer;
+import java.util.UUID;
+import java.util.Map.Entry;
+
+import javax.crypto.Cipher;
+import javax.crypto.SecretKey;
+import javax.crypto.SecretKeyFactory;
+import javax.crypto.spec.PBEKeySpec;
+import javax.crypto.spec.PBEParameterSpec;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.bwssystems.HABridge.api.hue.HueError;
+import com.bwssystems.HABridge.api.hue.HueErrorResponse;
+import com.bwssystems.HABridge.api.hue.WhitelistEntry;
+import com.google.gson.Gson;
+import com.google.gson.JsonSyntaxException;
+
+import spark.Request;
+
+public class BridgeSecurity {
+	private static final Logger log = LoggerFactory.getLogger(BridgeSecurity.class);
+	private static final String USER_SESSION_ID = "user";
+	private static final String DEPRACATED_INTERNAL_USER = "thehabridgeuser";
+	private static final String TEST_USER_TYPE = "test_ha_bridge";
+    private static final byte[] SALT = {
+            (byte) 0xde, (byte) 0x33, (byte) 0x10, (byte) 0x12,
+            (byte) 0xde, (byte) 0x33, (byte) 0x10, (byte) 0x12,
+        };
+	private char[] habridgeKey;
+	private String execGarden;
+    private BridgeSecurityDescriptor securityDescriptor;
+	private boolean settingsChanged;
+
+	public BridgeSecurity(char[] theKey, String theExecGarden) {
+		habridgeKey = theKey;
+		execGarden = theExecGarden;
+		securityDescriptor = null;
+		settingsChanged = false;
+	}
+
+	public void setSecurityData(String theData) {
+		String anError = null;
+		if(theData != null && !theData.isEmpty()) {
+			try {
+				securityDescriptor = new Gson().fromJson(decrypt(theData), BridgeSecurityDescriptor.class);
+			} catch (JsonSyntaxException e) {
+				anError = e.getMessage();
+			} catch (GeneralSecurityException e) {
+				anError = e.getMessage();
+			} catch (IOException e) {
+				anError = e.getMessage();
+			}
+			if(anError != null)
+				log.warn("Cound not get security data, using default security (none): " + anError);
+		}
+		
+		if(theData == null || anError != null) {
+			securityDescriptor = new BridgeSecurityDescriptor();
+		}
+	}
+
+	public String getSecurityDescriptorData() throws UnsupportedEncodingException, GeneralSecurityException {
+		return encrypt(new Gson().toJson(securityDescriptor));
+	}
+	
+	public boolean isUseLinkButton() {
+		return securityDescriptor.isUseLinkButton();
+	}
+
+	public String setPassword(User aUser) throws IOException {
+		String error = null;
+		if(aUser != null) {
+			error = aUser.validate();
+			if(error == null) {
+				if(securityDescriptor.getUsers() != null) {
+					User theUser = securityDescriptor.getUsers().get(aUser.getUsername());
+					if(theUser != null) {
+						theUser.setPassword(aUser.getPassword());
+						theUser.setPassword2(null);
+						settingsChanged = true;
+					}
+					else
+						error = "User not found";
+				}
+				else
+					error = "User not found";
+			}
+		}
+		else
+			error = "invalid user object given";
+		
+		return error;
+	}
+
+	public String addUser(User aUser) throws IOException {
+		String error = null;
+		if(aUser != null) {
+			error = aUser.validate();
+			if(error == null) {
+				if(securityDescriptor.getUsers() == null)
+					securityDescriptor.setUsers(new HashMap<String, User>());
+				if(securityDescriptor.getUsers().get(aUser.getUsername()) == null) {
+					securityDescriptor.getUsers().put(aUser.getUsername(), aUser);
+					settingsChanged = true;
+				}
+				else
+					error = "Invalid request";
+			}
+		}
+		else
+			error = "invalid user object given";
+		
+		return error;
+	}
+
+	public String delUser(User aUser) throws IOException {
+		String error = null;
+		if(aUser != null) {
+				if(securityDescriptor.getUsers() != null) {
+				if(securityDescriptor.getUsers().get(aUser.getUsername()) != null) {
+					securityDescriptor.getUsers().remove(aUser.getUsername());
+					settingsChanged = true;
+				}
+				else
+					error = "User not found";
+				}
+		}
+		else
+			error = "invalid user object given";
+		
+		return error;
+	}
+
+	public String getExecGarden() {
+		return execGarden;
+	}
+	public void setUseLinkButton(boolean useThis) {
+		securityDescriptor.setUseLinkButton(useThis);
+		settingsChanged = true;
+	}
+
+	public boolean isSecureHueApi() {
+		return securityDescriptor.isSecureHueApi();
+	}
+	
+	public void setSecureHueApi(boolean theState) {
+		securityDescriptor.setSecureHueApi(theState);
+	}
+	public SecurityInfo getSecurityInfo() {
+		SecurityInfo theInfo = new SecurityInfo();
+		theInfo.setUseLinkButton(isUseLinkButton());
+		theInfo.setSecureHueApi(isSecureHueApi());
+		theInfo.setSecure(isSecure());
+		return theInfo;
+	}
+	public LoginResult validatePassword(User targetUser) throws IOException {
+		LoginResult result = new LoginResult();
+		if(targetUser != null && targetUser.getUsername() != null) {
+			if(securityDescriptor.getUsers() != null && securityDescriptor.getUsers().get(targetUser.getUsername()) != null) {
+				User theUser = securityDescriptor.getUsers().get(targetUser.getUsername());
+				if(theUser.getPassword() != null) {
+					theUser.setPassword2(targetUser.getPassword());
+					if(theUser.validatePassword()) {
+						theUser.setPassword2(null);
+						result.setUser(targetUser);
+					}
+					else
+						result.setError("user or password not correct");
+				} else {
+					result.setError("input password is not set....");
+				}
+			}
+			else
+				result.setError("user or password not correct");
+		}
+		else
+			result.setError("input user not given");
+		return result;
+	}
+	
+	public boolean isSecure() {
+		return securityDescriptor.isSecure();
+	}
+
+	public boolean isSettingsChanged() {
+		return settingsChanged;
+	}
+
+	public void setSettingsChanged(boolean settingsChanged) {
+		this.settingsChanged = settingsChanged;
+	}
+	public Map<String, WhitelistEntry> getWhitelist() {
+		return securityDescriptor.getWhitelist();
+	}
+
+	public HueError[] validateWhitelistUser(String aUser, String userDescription, boolean strict) {
+		String validUser = null;
+		boolean found = false;
+		if (aUser != null && !aUser.equalsIgnoreCase("undefined") && !aUser.equalsIgnoreCase("null")
+				&& !aUser.equalsIgnoreCase("") && !aUser.equals(DEPRACATED_INTERNAL_USER)) {
+			if (securityDescriptor.getWhitelist() != null) {
+				Set<String> theUserIds = securityDescriptor.getWhitelist().keySet();
+				Iterator<String> userIterator = theUserIds.iterator();
+				while (userIterator.hasNext()) {
+					validUser = userIterator.next();
+					if (validUser.equals(aUser)) {
+						found = true;
+						log.debug("validateWhitelistUser: found a user <" + aUser + ">");
+					}
+				}
+			}
+
+			if(!found && !strict) {
+				log.debug("validateWhitelistUser: a user was not found and it is not strict rules <" + aUser + "> being created");
+				newWhitelistUser(aUser, userDescription);
+				
+				found = true;
+			}
+		}
+		
+		if (!found) {
+			log.debug("validateWhitelistUser: a user was not found and strict rules is set to: " + strict + "for user <" + aUser + ">");
+			return HueErrorResponse.createResponse("1", "/api/" + aUser == null ? "" : aUser, "unauthorized user", null, null, null).getTheErrors();
+		}
+
+		return null;
+	}
+	
+	private void newWhitelistUser(String aUser, String userDescription) {
+		if (securityDescriptor.getWhitelist() == null) {
+			securityDescriptor.setWhitelist(new HashMap<>());
+		}
+		if(userDescription == null)
+			userDescription = "auto insert user";
+		
+		securityDescriptor.getWhitelist().put(aUser, WhitelistEntry.createEntry(userDescription));
+		setSettingsChanged(true);
+	}
+
+	public String createWhitelistUser(String userDescription) {
+		String aUser = getNewUserID();
+		newWhitelistUser(aUser, userDescription);
+		return aUser;
+	}
+
+	public void convertWhitelist(Map<String, WhitelistEntry> whitelist) {
+		securityDescriptor.setWhitelist(whitelist);
+	}
+
+	private String getNewUserID() {
+		UUID uid = UUID.randomUUID();
+		StringTokenizer st = new StringTokenizer(uid.toString(), "-");
+		String newUser = "";
+		while (st.hasMoreTokens()) {
+			newUser = newUser + st.nextToken();
+		}
+
+		return newUser;
+	}
+	
+	public void removeTestUsers() {
+		if (securityDescriptor.getWhitelist() != null) {
+			Object anUser = securityDescriptor.getWhitelist().remove(DEPRACATED_INTERNAL_USER);
+			if(anUser != null)
+				setSettingsChanged(true);
+
+		    Iterator<Entry<String, WhitelistEntry>> it = securityDescriptor.getWhitelist().entrySet().iterator();
+		    while (it.hasNext()) {
+		        Map.Entry<String, WhitelistEntry> pair = it.next();
+		        if(pair.getValue().getName().equals(TEST_USER_TYPE)) {
+			        it.remove(); // avoids a ConcurrentModificationException
+					setSettingsChanged(true);
+		        }
+		    }
+		}
+	}
+
+	private String encrypt(String property) throws GeneralSecurityException, UnsupportedEncodingException {
+        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("PBEWithMD5AndDES");
+        SecretKey key = keyFactory.generateSecret(new PBEKeySpec(habridgeKey));
+        Cipher pbeCipher = Cipher.getInstance("PBEWithMD5AndDES");
+        pbeCipher.init(Cipher.ENCRYPT_MODE, key, new PBEParameterSpec(SALT, 20));
+        return base64Encode(pbeCipher.doFinal(property.getBytes("UTF-8")));
+    }
+
+    private static String base64Encode(byte[] bytes) {
+        return Base64.getEncoder().encodeToString(bytes);
+    }
+
+    private String decrypt(String property) throws GeneralSecurityException, IOException {
+        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("PBEWithMD5AndDES");
+        SecretKey key = keyFactory.generateSecret(new PBEKeySpec(habridgeKey));
+        Cipher pbeCipher = Cipher.getInstance("PBEWithMD5AndDES");
+        pbeCipher.init(Cipher.DECRYPT_MODE, key, new PBEParameterSpec(SALT, 20));
+        return new String(pbeCipher.doFinal(base64Decode(property)), "UTF-8");
+    }
+
+    private static byte[] base64Decode(String property) throws IOException {
+        return Base64.getDecoder().decode(property);
+    }
+
+    public void addAuthenticatedUser(Request request, User u) {
+		request.session().attribute(USER_SESSION_ID, u);
+		
+	}
+
+	public void removeAuthenticatedUser(Request request) {
+		request.session().removeAttribute(USER_SESSION_ID);
+		
+	}
+
+	public User getAuthenticatedUser(Request request) {
+		User theUser = request.session().attribute(USER_SESSION_ID);
+		if(theUser == null) {
+			String authHeader = request.headers("Authorization");
+			if(authHeader != null) {
+			    byte[] authData;
+				try {
+					authData = base64Decode(authHeader.substring(6));
+				} catch (IOException e1) {
+					// TODO Auto-generated catch block
+					return theUser;
+				}
+			    String[] credentials = new String(authData).split(":");
+			    String username = credentials[0];
+			    String password = credentials[1];
+			    theUser = new User();
+			    theUser.setUsername(username);
+			    theUser.setPassword(password);
+			    LoginResult theResult = null;
+				try {
+					theResult = validatePassword(theUser);
+				} catch (IOException e) {
+					// TODO Auto-generated catch block
+					return null;
+				}
+				if(theResult != null && theResult.getError() == null) {
+					addAuthenticatedUser(request, theUser);
+				}
+			}
+		}
+		return theUser;
+	}
+}

src/main/java/com/bwssystems/HABridge/BridgeSecurityDescriptor.java

@@ -0,0 +1,70 @@
+package com.bwssystems.HABridge;
+
+import java.util.Map;
+import com.bwssystems.HABridge.api.hue.WhitelistEntry;
+
+public class BridgeSecurityDescriptor {
+	private Map<String, User> users;
+	private boolean useLinkButton;
+	private String execGarden;
+	private boolean secureHueApi;
+	private Map<String, WhitelistEntry> whitelist;
+
+	public BridgeSecurityDescriptor() {
+		super();
+		this.setUseLinkButton(false);
+	}
+
+	public Map<String, User> getUsers() {
+		return users;
+	}
+
+	public void setUsers(Map<String, User> users) {
+		this.users = users;
+	}
+
+	public boolean isUseLinkButton() {
+		return useLinkButton;
+	}
+
+	public void setUseLinkButton(boolean useLinkButton) {
+		this.useLinkButton = useLinkButton;
+	}
+
+	public String getExecGarden() {
+		return execGarden;
+	}
+
+	public void setExecGarden(String execGarden) {
+		this.execGarden = execGarden;
+	}
+
+	public boolean isSecureHueApi() {
+		return secureHueApi;
+	}
+
+	public void setSecureHueApi(boolean secureHueApi) {
+		this.secureHueApi = secureHueApi;
+	}
+	public Map<String, WhitelistEntry> getWhitelist() {
+		return whitelist;
+	}
+	public void setWhitelist(Map<String, WhitelistEntry> whitelist) {
+		this.whitelist = whitelist;
+	}
+
+	public boolean isSecure() {
+		boolean secureFlag = false;
+		if(users != null && !users.isEmpty()) {
+			for (Map.Entry<String, User> entry : users.entrySet())
+			{
+				if(entry.getValue().getPassword() != null && !entry.getValue().getPassword().isEmpty()) {
+					secureFlag = true;
+					break;
+				}
+			}
+		}
+		return secureFlag;
+		
+	}
+}

src/main/java/com/bwssystems/HABridge/BridgeSettings.java

@@ -1,6 +1,7 @@
 package com.bwssystems.HABridge;
 
 import java.io.IOException;
+import java.io.UnsupportedEncodingException;
 import java.net.InetAddress;
 import java.net.NetworkInterface;
 import java.net.SocketException;
@@ -9,24 +10,44 @@ import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.nio.file.StandardOpenOption;
+import java.nio.file.attribute.PosixFilePermission;
+import java.security.GeneralSecurityException;
+import java.text.SimpleDateFormat;
+import java.util.Date;
 import java.util.Enumeration;
+import java.util.HashSet;
+import java.util.Set;
 
 import org.apache.http.conn.util.InetAddressUtils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import com.bwssystems.util.BackupHandler;
-import com.bwssystems.util.JsonTransformer;
+import com.bwssystems.HABridge.util.BackupHandler;
+import com.bwssystems.HABridge.util.JsonTransformer;
 import com.google.gson.Gson;
 
 public class BridgeSettings extends BackupHandler {
+	private static final Logger log = LoggerFactory.getLogger(BridgeSettings.class);
 	private BridgeSettingsDescriptor theBridgeSettings;
 	private BridgeControlDescriptor bridgeControl;
+	private BridgeSecurity bridgeSecurity;
+    private static SimpleDateFormat dateFormat = new SimpleDateFormat("yyyyMMdd'T'HHmmss");
 	
 	public BridgeSettings() {
 		super();
 		bridgeControl = new BridgeControlDescriptor();
 		theBridgeSettings = new BridgeSettingsDescriptor();
+		bridgeSecurity = null;
+		String theKey = System.getProperty("security.key");
+		if(theKey == null)
+			theKey = "IWantMyPasswordsToBeAbleToBeDecodedPleaseSeeTheReadme";
+		String execGarden = System.getProperty("exec.garden");
+		bridgeSecurity = new BridgeSecurity(theKey.toCharArray(), execGarden);
+		String ipV6Stack = System.getProperty("ipV6Stack");
+        if(ipV6Stack == null || !ipV6Stack.equalsIgnoreCase("true")) {
+        	System.setProperty("java.net.preferIPv4Stack" , "true");
+        }
+
 	}
 	public BridgeControlDescriptor getBridgeControl() {
 		return bridgeControl;
@@ -34,13 +55,19 @@ public class BridgeSettings extends BackupHandler {
 	public BridgeSettingsDescriptor getBridgeSettingsDescriptor() {
 		return theBridgeSettings;
 	}
+	public BridgeSecurity getBridgeSecurity() {
+		return bridgeSecurity;
+	}
+	 public static String getCurrentDate() {
+		 return dateFormat.format(new Date());
+	 }
+	
 	public void buildSettings() {
-        Logger log = LoggerFactory.getLogger(BridgeSettings.class);
-        InetAddress address = null;
         String addressString = null;
         String theVeraAddress = null;
+        String theFibaroAddress = null;
+        String theSomfyAddress = null;
         String theHarmonyAddress = null;
-
         String configFileProperty = System.getProperty("config.file");
         if(configFileProperty == null) {
         	Path filePath = Paths.get(Configuration.CONFIG_FILE);
@@ -48,6 +75,8 @@ public class BridgeSettings extends BackupHandler {
         		configFileProperty = Configuration.CONFIG_FILE;
         }
         String serverPortOverride = System.getProperty("server.port");
+        String serverIpOverride = System.getProperty("server.ip");
+        String upnpStrictOverride = System.getProperty("upnp.strict", "true");
         if(configFileProperty != null)
         {
         	log.info("reading from config file: " + configFileProperty);
@@ -63,6 +92,7 @@ public class BridgeSettings extends BackupHandler {
         	theBridgeSettings.setServerPort(System.getProperty("server.port", Configuration.DEFAULT_WEB_PORT));
         	theBridgeSettings.setUpnpConfigAddress(System.getProperty("upnp.config.address"));
         	theBridgeSettings.setUpnpDeviceDb(System.getProperty("upnp.device.db"));
+        	theBridgeSettings.setUpnpGroupDb(System.getProperty("upnp.group.db"));
         	theBridgeSettings.setUpnpResponsePort(System.getProperty("upnp.response.port", Configuration.UPNP_RESPONSE_PORT));
 	        
 	        theVeraAddress = System.getProperty("vera.address");
@@ -80,6 +110,22 @@ public class BridgeSettings extends BackupHandler {
 		        }
 	        }
 	        theBridgeSettings.setVeraAddress(theVeraList);
+	        
+	        theFibaroAddress = System.getProperty("fibaro.address");
+        	IpList theFibaroList = null;
+	        if(theFibaroAddress != null) {
+		        try {
+		        	theFibaroList = new Gson().fromJson(theFibaroAddress, IpList.class);
+		        } catch (Exception e) {
+		        	try {
+		        		theFibaroList = new Gson().fromJson("{devices:[{name:default,ip:" + theFibaroAddress + "}]}", IpList.class);
+		        	} catch (Exception et) {
+		    	        log.error("Cannot parse fibaro.address, not set with message: " + e.getMessage(), e);
+		    	        theFibaroList = null;
+		        	}
+		        }
+	        }
+	        theBridgeSettings.setFibaroAddress(theFibaroList);
 
 	        theHarmonyAddress = System.getProperty("harmony.address");
 	        IpList theHarmonyList = null;	
@@ -96,8 +142,23 @@ public class BridgeSettings extends BackupHandler {
 		        }
 	        }
 	        theBridgeSettings.setHarmonyAddress(theHarmonyList);
-	        theBridgeSettings.setHarmonyUser(System.getProperty("harmony.user"));
-	        theBridgeSettings.setHarmonyPwd(System.getProperty("harmony.pwd"));
+
+			theSomfyAddress = System.getProperty("somfy.address");
+			IpList theSomfyList = null;
+			if(theSomfyAddress != null) {
+				try {
+					theSomfyList = new Gson().fromJson(theSomfyAddress, IpList.class);
+				} catch (Exception e) {
+					try {
+						theSomfyList = new Gson().fromJson("{devices:[{name:default,ip:" + theSomfyAddress + "}]}", IpList.class);
+					} catch (Exception et) {
+						log.error("Cannot parse somfy.address, not set with message: " + e.getMessage(), e);
+						theSomfyList = null;
+					}
+				}
+			}
+			theBridgeSettings.setSomfyAddress(theSomfyList);
+
 	        theBridgeSettings.setUpnpStrict(Boolean.parseBoolean(System.getProperty("upnp.strict", "true")));
 	        theBridgeSettings.setTraceupnp(Boolean.parseBoolean(System.getProperty("trace.upnp", "false")));
 	        theBridgeSettings.setButtonsleep(Integer.parseInt(System.getProperty("button.sleep", Configuration.DEFAULT_BUTTON_SLEEP)));
@@ -105,35 +166,19 @@ public class BridgeSettings extends BackupHandler {
 	        theBridgeSettings.setNestpwd(System.getProperty("nest.pwd"));
         }
 
-        if(theBridgeSettings.getUpnpConfigAddress() == null || theBridgeSettings.getUpnpConfigAddress().equals("")) {
-	        try {
-	        	log.info("Getting an IP address for this host....");
-				Enumeration<NetworkInterface> ifs =	NetworkInterface.getNetworkInterfaces();
-	
-				while (ifs.hasMoreElements() && addressString == null) {
-					NetworkInterface xface = ifs.nextElement();
-					Enumeration<InetAddress> addrs = xface.getInetAddresses();
-					String name = xface.getName();
-					int IPsPerNic = 0;
-	
-					while (addrs.hasMoreElements() && IPsPerNic == 0) {
-						address = addrs.nextElement();
-						if (InetAddressUtils.isIPv4Address(address.getHostAddress())) {
-							log.debug(name + " ... has IPV4 addr " + address);
-							if(!name.equalsIgnoreCase(Configuration.LOOP_BACK_INTERFACE)|| !address.getHostAddress().equalsIgnoreCase(Configuration.LOOP_BACK_ADDRESS)) {
-								IPsPerNic++;
-								addressString = address.getHostAddress();
-								log.info("Adding " + addressString + " from interface " + name + " as our default upnp config address.");
-							}
-						}
-					} 
-				}
-			} catch (SocketException e) {
-		        log.error("Cannot get ip address of this host, Exiting with message: " + e.getMessage(), e);
-		        return;
-			}
-	        
-	        theBridgeSettings.setUpnpConfigAddress(addressString);
+        if(theBridgeSettings.getUpnpConfigAddress() == null || theBridgeSettings.getUpnpConfigAddress().trim().equals("") || theBridgeSettings.getUpnpConfigAddress().trim().equals("0.0.0.0")) {
+        	addressString = checkIpAddress(null, true);
+        	if(addressString != null) {
+        		theBridgeSettings.setUpnpConfigAddress(addressString);
+        		log.info("Adding " + addressString + " as our default upnp config address.");
+        	}
+        	else
+		        log.error("Cannot get ip address of this host.");
+        }
+        else {
+        	addressString = checkIpAddress(theBridgeSettings.getUpnpConfigAddress(), false);
+        	if(addressString == null)
+        		log.warn("The upnp config address, " + theBridgeSettings.getUpnpConfigAddress() + ", does not match any known IP's on this host.");
         }
         
         if(theBridgeSettings.getUpnpResponsePort() == null)
@@ -144,20 +189,41 @@ public class BridgeSettings extends BackupHandler {
         
         if(theBridgeSettings.getUpnpDeviceDb() == null)
         	theBridgeSettings.setUpnpDeviceDb(Configuration.DEVICE_DB_DIRECTORY);
+
+        if(theBridgeSettings.getUpnpGroupDb() == null)
+        	theBridgeSettings.setUpnpGroupDb(Configuration.GROUP_DB_DIRECTORY);
         
-        if(theBridgeSettings.getNumberoflogmessages() == null)
-        	theBridgeSettings.setNumberoflogmessages(Configuration.NUMBER_OF_LOG_MESSAGES);
-        
-        if(theBridgeSettings.getButtonsleep() <= 0)
+        if(theBridgeSettings.getNumberoflogmessages() == null || theBridgeSettings.getNumberoflogmessages() <= 0)
+        	theBridgeSettings.setNumberoflogmessages(new Integer(Configuration.NUMBER_OF_LOG_MESSAGES));
+
+        if(theBridgeSettings.getButtonsleep() == null || theBridgeSettings.getButtonsleep() < 0)
         	theBridgeSettings.setButtonsleep(Integer.parseInt(Configuration.DEFAULT_BUTTON_SLEEP));
 
         theBridgeSettings.setVeraconfigured(theBridgeSettings.isValidVera());
+        theBridgeSettings.setFibaroconfigured(theBridgeSettings.isValidFibaro());
         theBridgeSettings.setHarmonyconfigured(theBridgeSettings.isValidHarmony());
         theBridgeSettings.setNestConfigured(theBridgeSettings.isValidNest());
         theBridgeSettings.setHueconfigured(theBridgeSettings.isValidHue());
-        if(serverPortOverride != null)
+        theBridgeSettings.setHalconfigured(theBridgeSettings.isValidHal());
+        theBridgeSettings.setMqttconfigured(theBridgeSettings.isValidMQTT());
+        theBridgeSettings.setHassconfigured(theBridgeSettings.isValidHass());
+        theBridgeSettings.setDomoticzconfigured(theBridgeSettings.isValidDomoticz());
+		theBridgeSettings.setSomfyconfigured(theBridgeSettings.isValidSomfy());
+        // Lifx is either configured or not, so it does not need an update.
+       if(serverPortOverride != null)
         	theBridgeSettings.setServerPort(serverPortOverride);
+        if(serverIpOverride != null)
+        	theBridgeSettings.setWebaddress(serverIpOverride);
+        if(upnpStrictOverride != null)
+        	theBridgeSettings.setUpnpStrict(Boolean.parseBoolean(upnpStrictOverride));
 		setupParams(Paths.get(theBridgeSettings.getConfigfile()), ".cfgbk", "habridge.config-");
+		
+		bridgeSecurity.setSecurityData(theBridgeSettings.getSecurityData());
+		if(theBridgeSettings.getWhitelist() != null) {
+			bridgeSecurity.convertWhitelist(theBridgeSettings.getWhitelist());
+			theBridgeSettings.removeWhitelist();
+			updateConfigFile();
+		}
 	}
 
 	public void loadConfig() {
@@ -171,42 +237,62 @@ public class BridgeSettings extends BackupHandler {
 
 	private void _loadConfig(Path aPath) {
 		String jsonContent = configReader(aPath);
-		BridgeSettingsDescriptor aBridgeSettings = new Gson().fromJson(jsonContent, BridgeSettingsDescriptor.class);
-		theBridgeSettings.setButtonsleep(aBridgeSettings.getButtonsleep());
-		theBridgeSettings.setUpnpConfigAddress(aBridgeSettings.getUpnpConfigAddress());
-		theBridgeSettings.setServerPort(aBridgeSettings.getServerPort());
-		theBridgeSettings.setUpnpResponsePort(aBridgeSettings.getUpnpResponsePort());
-		theBridgeSettings.setUpnpDeviceDb(aBridgeSettings.getUpnpDeviceDb());
-		theBridgeSettings.setVeraAddress(aBridgeSettings.getVeraAddress());
-		theBridgeSettings.setHarmonyAddress(aBridgeSettings.getHarmonyAddress());
-		theBridgeSettings.setHarmonyUser(aBridgeSettings.getHarmonyUser());
-		theBridgeSettings.setHarmonyPwd(aBridgeSettings.getHarmonyPwd());
-		theBridgeSettings.setUpnpStrict(aBridgeSettings.isUpnpStrict());
-		theBridgeSettings.setTraceupnp(aBridgeSettings.isTraceupnp());
-		theBridgeSettings.setNestuser(aBridgeSettings.getNestuser());
-		theBridgeSettings.setNestpwd(aBridgeSettings.getNestpwd());
-		theBridgeSettings.setVeraconfigured(aBridgeSettings.isValidVera());
-		theBridgeSettings.setHarmonyconfigured(aBridgeSettings.isValidHarmony());
-		theBridgeSettings.setNestConfigured(aBridgeSettings.isValidNest());
-		theBridgeSettings.setNumberoflogmessages(aBridgeSettings.getNumberoflogmessages());
-		theBridgeSettings.setFarenheit(aBridgeSettings.isFarenheit());
-		theBridgeSettings.setHueaddress(aBridgeSettings.getHueaddress());
-		theBridgeSettings.setHueconfigured(aBridgeSettings.isValidHue());
+		if(jsonContent == null)
+			return;
+		try {
+			theBridgeSettings = new Gson().fromJson(jsonContent, BridgeSettingsDescriptor.class);
+		} catch (Exception e) {
+			log.warn("Issue loading values from file: " + aPath.toUri().toString() + ", Gson convert failed.");
+			theBridgeSettings = new BridgeSettingsDescriptor();
+			theBridgeSettings.setConfigfile(aPath.toString());
+		}
     }
 
 	public void save(BridgeSettingsDescriptor newBridgeSettings) {
-        Logger log = LoggerFactory.getLogger(BridgeSettings.class);
         log.debug("Save HA Bridge settings.");
 		Path configPath = Paths.get(theBridgeSettings.getConfigfile());
     	JsonTransformer aRenderer = new JsonTransformer();
+    	if(bridgeSecurity.isSettingsChanged()) {
+    		try {
+				newBridgeSettings.setSecurityData(bridgeSecurity.getSecurityDescriptorData());
+			} catch (UnsupportedEncodingException e) {
+				log.warn("could not get encoded security data: " + e.getMessage());
+				return;
+			} catch (GeneralSecurityException e) {
+				log.warn("could not get encoded security data: " + e.getMessage());
+				return;
+			}
+    		bridgeSecurity.setSettingsChanged(false);
+    	}
     	String  jsonValue = aRenderer.render(newBridgeSettings);
     	configWriter(jsonValue, configPath);
     	_loadConfig(configPath);
     }
     
 
-	private void configWriter(String content, Path filePath) {
-        Logger log = LoggerFactory.getLogger(BridgeSettings.class);
+	public void updateConfigFile() {
+        log.debug("Save HA Bridge settings.");
+		Path configPath = Paths.get(theBridgeSettings.getConfigfile());
+    	JsonTransformer aRenderer = new JsonTransformer();
+    	if(bridgeSecurity.isSettingsChanged()) {
+    		try {
+				theBridgeSettings.setSecurityData(bridgeSecurity.getSecurityDescriptorData());
+			} catch (UnsupportedEncodingException e) {
+				log.warn("could not get encoded security data: " + e.getMessage());
+				return;
+			} catch (GeneralSecurityException e) {
+				log.warn("could not get encoded security data: " + e.getMessage());
+				return;
+			}
+    		bridgeSecurity.setSettingsChanged(false);
+    	}
+    	String  jsonValue = aRenderer.render(theBridgeSettings);
+    	configWriter(jsonValue, configPath);
+    	_loadConfig(configPath);
+    }
+    
+
+	private synchronized void configWriter(String content, Path filePath) {
 		if(Files.exists(filePath) && !Files.isWritable(filePath)){
 			log.error("Error file is not writable: " + filePath);
 			return;
@@ -223,10 +309,25 @@ public class BridgeSettings extends BackupHandler {
 		try {
 			Path target = null;
 			if(Files.exists(filePath)) {
-				target = FileSystems.getDefault().getPath(filePath.getParent().toString(), "habridge.config.old");
+				target = FileSystems.getDefault().getPath(filePath.getParent().toString(), "habridge.config.old." + getCurrentDate());
 				Files.move(filePath, target);
 			}
 			Files.write(filePath, content.getBytes(), StandardOpenOption.CREATE);
+
+			// set attributes to be for user only
+	        // using PosixFilePermission to set file permissions
+	        Set<PosixFilePermission> perms = new HashSet<PosixFilePermission>();
+	        // add owners permission 
+	        perms.add(PosixFilePermission.OWNER_READ);
+	        perms.add(PosixFilePermission.OWNER_WRITE);
+	        
+	        try {
+	        	String osName = System.getProperty("os.name");
+	        	if(osName.toLowerCase().indexOf("win") < 0)
+	        		Files.setPosixFilePermissions(filePath, perms);
+	        } catch(UnsupportedOperationException e) {
+	        	log.info("Cannot set permissions for config file on this system as it is not supported. Continuing");
+	        }
 			if(target != null)
 				Files.delete(target);
 		} catch (IOException e) {
@@ -235,15 +336,12 @@ public class BridgeSettings extends BackupHandler {
 	}
 	
 	private String configReader(Path filePath) {
-        Logger log = LoggerFactory.getLogger(BridgeSettings.class);
-
 		String content = null;
 		if(Files.notExists(filePath) || !Files.isReadable(filePath)){
 			log.warn("Error reading the file: " + filePath + " - Does not exist or is not readable. continuing...");
 			return null;
 		}
 
-		
 		try {
 			content = new String(Files.readAllBytes(filePath));
 		} catch (IOException e) {
@@ -252,4 +350,40 @@ public class BridgeSettings extends BackupHandler {
 		
 		return content;
 	}
+	
+	private String checkIpAddress(String ipAddress, boolean checkForLocalhost) {
+		Enumeration<NetworkInterface> ifs =	null;
+		try {
+			ifs =	NetworkInterface.getNetworkInterfaces();
+		} catch(SocketException e) {
+	        log.error("checkIpAddress cannot get ip address of this host, Exiting with message: " + e.getMessage(), e);
+	        return null;			
+		}
+		
+		String addressString = null;
+        InetAddress address = null;
+		while (ifs.hasMoreElements() && addressString == null) {
+			NetworkInterface xface = ifs.nextElement();
+			Enumeration<InetAddress> addrs = xface.getInetAddresses();
+			String name = xface.getName();
+			int IPsPerNic = 0;
+
+			while (addrs.hasMoreElements() && IPsPerNic == 0) {
+				address = addrs.nextElement();
+				if (InetAddressUtils.isIPv4Address(address.getHostAddress())) {
+					log.debug(name + " ... has IPV4 addr " + address);
+					if(checkForLocalhost && (!name.equalsIgnoreCase(Configuration.LOOP_BACK_INTERFACE) || !address.getHostAddress().equalsIgnoreCase(Configuration.LOOP_BACK_ADDRESS))) {
+						IPsPerNic++;
+						addressString = address.getHostAddress();
+						log.debug("checkIpAddress found " + addressString + " from interface " + name);
+					}
+					else if(ipAddress != null && ipAddress.equalsIgnoreCase(address.getHostAddress())){
+						addressString = ipAddress;
+						IPsPerNic++;
+					}
+				}
+			}
+		}
+		return addressString;
+	}
 }

src/main/java/com/bwssystems/HABridge/BridgeSettingsDescriptor.java

@@ -1,39 +1,141 @@
 package com.bwssystems.HABridge;
 
 import java.util.List;
+import java.util.Map;
+import com.google.gson.annotations.Expose;
+import com.google.gson.annotations.SerializedName;
+
+import com.bwssystems.HABridge.api.hue.HueConstants;
+import com.bwssystems.HABridge.api.hue.WhitelistEntry;
 
 public class BridgeSettingsDescriptor {
+	@SerializedName("upnpconfigaddress")
+	@Expose
 	private String upnpconfigaddress;
+	@SerializedName("useupnpiface")
+	@Expose
+	private boolean useupnpiface;
+	@SerializedName("serverport")
+	@Expose
 	private Integer serverport;
+	@SerializedName("upnpresponseport")
+	@Expose
 	private Integer upnpresponseport;
+	@SerializedName("upnpdevicedb")
+	@Expose
 	private String upnpdevicedb;
+	@SerializedName("upnpgroupdb")
+	@Expose
+	private String upnpgroupdb;
+	@SerializedName("veraaddress")
+	@Expose
 	private IpList veraaddress;
+	@SerializedName("fibaroaddress")
+	@Expose
+	private IpList fibaroaddress;
+	@SerializedName("harmonyaddress")
+	@Expose
 	private IpList harmonyaddress;
-	private String harmonyuser;
-	private String harmonypwd;
+	@SerializedName("buttonsleep")
+	@Expose
 	private Integer buttonsleep;
-	private boolean upnpstrict;
+	@SerializedName("traceupnp")
+	@Expose
 	private boolean traceupnp;
+	@SerializedName("nestuser")
+	@Expose
 	private String nestuser;
+	@SerializedName("nestpwd")
+	@Expose
 	private String nestpwd;
-	private boolean veraconfigured;
-	private boolean harmonyconfigured;
-	private boolean nestconfigured;
+	@SerializedName("farenheit")
+	@Expose
 	private boolean farenheit;
+	@SerializedName("configfile")
+	@Expose
 	private String configfile;
+	@SerializedName("numberoflogmessages")
+	@Expose
 	private Integer numberoflogmessages;
+	@SerializedName("hueaddress")
+	@Expose
 	private IpList hueaddress;
+	@SerializedName("haladdress")
+	@Expose
+	private IpList haladdress;
+	@SerializedName("whitelist")
+	@Expose
+	private Map<String, WhitelistEntry> whitelist;
+	@SerializedName("myechourl")
+	@Expose
+	private String myechourl;
+	@SerializedName("webaddress")
+	@Expose
+	private String webaddress;
+	@SerializedName("mqttaddress")
+	@Expose
+	private IpList mqttaddress;
+	@SerializedName("hassaddress")
+	@Expose
+	private IpList hassaddress;
+	@SerializedName("domoticzaddress")
+	@Expose
+	private IpList domoticzaddress;
+	@SerializedName("somfyaddress")
+	@Expose
+	private IpList somfyaddress;
+	@SerializedName("hubversion")
+	@Expose
+	private String hubversion;
+	@SerializedName("hubmac")
+	@Expose
+	private String hubmac;
+	@SerializedName("securityData")
+	@Expose
+	private String securityData;
+
+	
+	private boolean settingsChanged;
+	private boolean veraconfigured;
+	private boolean fibaroconfigured;
+	private boolean harmonyconfigured;
 	private boolean hueconfigured;
+	private boolean nestconfigured;
+	private boolean halconfigured;
+	private boolean mqttconfigured;
+	private boolean hassconfigured;
+	private boolean domoticzconfigured;
+	private boolean somfyconfigured;
+	private boolean lifxconfigured;
+
+	// Deprecated settings
+	private String haltoken;
+	private boolean upnpstrict;
 	
 	public BridgeSettingsDescriptor() {
 		super();
 		this.upnpstrict = true;
+		this.useupnpiface = false;
 		this.traceupnp = false;
 		this.nestconfigured = false;
 		this.veraconfigured = false;
+		this.fibaroconfigured = false;
+		this.somfyconfigured = false;
 		this.harmonyconfigured = false;
 		this.hueconfigured = false;
+		this.halconfigured = false;
+		this.mqttconfigured = false;
+		this.hassconfigured = false;
+		this.domoticzconfigured = false;
+		this.somfyconfigured = false;
+		this.lifxconfigured = false;
 		this.farenheit = true;
+		this.securityData = null;
+		this.settingsChanged = false;
+		this.myechourl = "alexa.amazon.com/spa/index.html#cards";
+		this.webaddress = "0.0.0.0";
+		this.hubversion = HueConstants.HUB_VERSION;
+		this.hubmac = null;
 	}
 	public String getUpnpConfigAddress() {
 		return upnpconfigaddress;
@@ -41,6 +143,12 @@ public class BridgeSettingsDescriptor {
 	public void setUpnpConfigAddress(String upnpConfigAddress) {
 		this.upnpconfigaddress = upnpConfigAddress;
 	}
+	public boolean isUseupnpiface() {
+		return useupnpiface;
+	}
+	public void setUseupnpiface(boolean useupnpiface) {
+		this.useupnpiface = useupnpiface;
+	}
 	public Integer  getServerPort() {
 		return serverport;
 	}
@@ -65,30 +173,36 @@ public class BridgeSettingsDescriptor {
 	public void setUpnpDeviceDb(String upnpDeviceDb) {
 		this.upnpdevicedb = upnpDeviceDb;
 	}
+	public String getUpnpGroupDb() {
+		return upnpgroupdb;
+	}
+	public void setUpnpGroupDb(String upnpGroupDb) {
+		this.upnpgroupdb = upnpGroupDb;
+	}
 	public IpList getVeraAddress() {
 		return veraaddress;
 	}
+	public IpList getFibaroAddress() {
+		return fibaroaddress;
+	}
+	public IpList getSomfyAddress() {
+		return somfyaddress;
+	}
 	public void setVeraAddress(IpList veraAddress) {
 		this.veraaddress = veraAddress;
 	}
+	public void setFibaroAddress(IpList fibaroAddress) {
+		this.fibaroaddress = fibaroAddress;
+	}
+	public void setSomfyAddress(IpList somfyAddress) {
+		this.somfyaddress = somfyAddress;
+	}
 	public IpList getHarmonyAddress() {
 		return harmonyaddress;
 	}
 	public void setHarmonyAddress(IpList harmonyaddress) {
 		this.harmonyaddress = harmonyaddress;
 	}
-	public String getHarmonyUser() {
-		return harmonyuser;
-	}
-	public void setHarmonyUser(String harmonyuser) {
-		this.harmonyuser = harmonyuser;
-	}
-	public String getHarmonyPwd() {
-		return harmonypwd;
-	}
-	public void setHarmonyPwd(String harmonypwd) {
-		this.harmonypwd = harmonypwd;
-	}
 	public boolean isUpnpStrict() {
 		return upnpstrict;
 	}
@@ -116,9 +230,21 @@ public class BridgeSettingsDescriptor {
 	public boolean isVeraconfigured() {
 		return veraconfigured;
 	}
+	public boolean isFibaroconfigured() {
+		return fibaroconfigured;
+	}
+	public boolean isSomfyconfigured() {
+		return somfyconfigured;
+	}
 	public void setVeraconfigured(boolean veraconfigured) {
 		this.veraconfigured = veraconfigured;
 	}
+	public void setFibaroconfigured(boolean fibaroconfigured) {
+		this.fibaroconfigured = fibaroconfigured;
+	}
+	public void setSomfyconfigured(boolean somfyconfigured) {
+		this.somfyconfigured = somfyconfigured;
+	}
 	public boolean isHarmonyconfigured() {
 		return harmonyconfigured;
 	}
@@ -167,6 +293,108 @@ public class BridgeSettingsDescriptor {
 	public void setHueconfigured(boolean hueconfigured) {
 		this.hueconfigured = hueconfigured;
 	}
+	public IpList getHaladdress() {
+		return haladdress;
+	}
+	public void setHaladdress(IpList haladdress) {
+		this.haladdress = haladdress;
+	}
+	public String getHaltoken() {
+		return haltoken;
+	}
+	public void setHaltoken(String haltoken) {
+		this.haltoken = haltoken;
+	}
+	public boolean isHalconfigured() {
+		return halconfigured;
+	}
+	public void setHalconfigured(boolean halconfigured) {
+		this.halconfigured = halconfigured;
+	}
+	public Map<String, WhitelistEntry> getWhitelist() {
+		return whitelist;
+	}
+	protected void removeWhitelist() {
+		whitelist = null;
+	}
+	public boolean isSettingsChanged() {
+		return settingsChanged;
+	}
+	public void setSettingsChanged(boolean settingsChanged) {
+		this.settingsChanged = settingsChanged;
+	}
+	public String getMyechourl() {
+		return myechourl;
+	}
+	public void setMyechourl(String myechourl) {
+		this.myechourl = myechourl;
+	}
+	public String getWebaddress() {
+		return webaddress;
+	}
+	public void setWebaddress(String webaddress) {
+		this.webaddress = webaddress;
+	}
+	public IpList getMqttaddress() {
+		return mqttaddress;
+	}
+	public void setMqttaddress(IpList mqttaddress) {
+		this.mqttaddress = mqttaddress;
+	}
+	public boolean isMqttconfigured() {
+		return mqttconfigured;
+	}
+	public void setMqttconfigured(boolean mqttconfigured) {
+		this.mqttconfigured = mqttconfigured;
+	}
+	public IpList getHassaddress() {
+		return hassaddress;
+	}
+	public void setHassaddress(IpList hassaddress) {
+		this.hassaddress = hassaddress;
+	}
+	public boolean isHassconfigured() {
+		return hassconfigured;
+	}
+	public void setHassconfigured(boolean hassconfigured) {
+		this.hassconfigured = hassconfigured;
+	}
+	public String getHubversion() {
+		return hubversion;
+	}
+	public void setHubversion(String hubversion) {
+		this.hubversion = hubversion;
+	}
+	public String getHubmac() {
+		return hubmac;
+	}
+	public void setHubmac(String hubmac) {
+		this.hubmac = hubmac;
+	}
+	public IpList getDomoticzaddress() {
+		return domoticzaddress;
+	}
+	public void setDomoticzaddress(IpList domoticzaddress) {
+		this.domoticzaddress = domoticzaddress;
+	}
+	public boolean isDomoticzconfigured() {
+		return domoticzconfigured;
+	}
+	public void setDomoticzconfigured(boolean domoticzconfigured) {
+		this.domoticzconfigured = domoticzconfigured;
+	}
+	public boolean isLifxconfigured() {
+		return lifxconfigured;
+	}
+	public void setLifxconfigured(boolean lifxconfigured) {
+		this.lifxconfigured = lifxconfigured;
+	}
+	public String getSecurityData() {
+		return securityData;
+	}
+	public void setSecurityData(String securityData) {
+		this.securityData = securityData;
+	}
 	public Boolean isValidVera() {
 		if(this.getVeraAddress() == null || this.getVeraAddress().getDevices().size() <= 0)
 			return false;
@@ -175,16 +403,20 @@ public class BridgeSettingsDescriptor {
 			return false;
 		return true;
 	}
+	public Boolean isValidFibaro() {
+		if(this.getFibaroAddress() == null || this.getFibaroAddress().getDevices().size() <= 0)
+			return false;
+		List<NamedIP> devicesList = this.getFibaroAddress().getDevices();
+		if(devicesList.get(0).getIp().contains(Configuration.DEFAULT_ADDRESS))
+			return false;
+		return true;
+	}
 	public Boolean isValidHarmony() {
 		if(this.getHarmonyAddress() == null || this.getHarmonyAddress().getDevices().size() <= 0)
 			return false;		
 		List<NamedIP> devicesList = this.getHarmonyAddress().getDevices();
 		if(devicesList.get(0).getIp().contains(Configuration.DEFAULT_ADDRESS))
 			return false;
-		if(this.getHarmonyPwd() == null || this.getHarmonyPwd().equals(""))
-			return false;
-		if(this.getHarmonyUser() == null || this.getHarmonyUser().equals(""))
-			return false;
 		return true;
 	}
 	public Boolean isValidNest() {
@@ -202,4 +434,62 @@ public class BridgeSettingsDescriptor {
 			return false;
 		return true;
 	}
+	public Boolean isValidHal() {
+		if(this.getHaladdress() == null || this.getHaladdress().getDevices().size() <= 0)
+			return false;		
+		List<NamedIP> devicesList = this.getHaladdress().getDevices();
+		if(devicesList.get(0).getIp().contains(Configuration.DEFAULT_ADDRESS))
+			return false;
+		if(devicesList.get(0).getPassword() == null || devicesList.get(0).getPassword().trim().isEmpty()) {
+			if(this.getHaltoken() == null || this.getHaltoken().equals(""))
+				return false;
+		}
+		return true;
+	}
+	public Boolean isValidMQTT() {
+		if(this.getMqttaddress() == null || this.getMqttaddress().getDevices().size() <= 0)
+			return false;		
+		List<NamedIP> devicesList = this.getMqttaddress().getDevices();
+		if(devicesList.get(0).getIp().contains(Configuration.DEFAULT_ADDRESS))
+			return false;
+		return true;
+	}
+	public Boolean isValidHass() {
+		if(this.getHassaddress() == null || this.getHassaddress().getDevices().size() <= 0)
+			return false;		
+		List<NamedIP> devicesList = this.getHassaddress().getDevices();
+		if(devicesList.get(0).getIp().contains(Configuration.DEFAULT_ADDRESS))
+			return false;
+		return true;
+	}
+	public Boolean isValidDomoticz() {
+		if(this.getDomoticzaddress() == null || this.getDomoticzaddress().getDevices().size() <= 0)
+			return false;		
+		List<NamedIP> devicesList = this.getDomoticzaddress().getDevices();
+		if(devicesList.get(0).getIp().contains(Configuration.DEFAULT_ADDRESS))
+			return false;
+		return true;
+	}
+	public Boolean isValidSomfy() {
+		if(this.getSomfyAddress() == null || this.getSomfyAddress().getDevices().size() <= 0)
+			return false;
+		List<NamedIP> devicesList = this.getSomfyAddress().getDevices();
+		if(devicesList.get(0).getIp().contains(Configuration.DEFAULT_ADDRESS))
+			return false;
+		return true;
+	}
+	public Boolean isValidLifx() {
+		return this.isLifxconfigured();
+	}
+	public void updateHue(NamedIP aHue) {
+		int indexHue = -1;
+		for( int i = 0; i < hueaddress.getDevices().size(); i++) {
+			if(hueaddress.getDevices().get(i).getName().equals(aHue.getName()))
+				indexHue = i;
+		}
+		if(indexHue >= 0) {
+			hueaddress.getDevices().set(indexHue, aHue);
+			this.setSettingsChanged(true);
+		}
+	}
 }

src/main/java/com/bwssystems/HABridge/Configuration.java

@@ -2,14 +2,16 @@ package com.bwssystems.HABridge;
 
 public class Configuration {
 	public final static String DEVICE_DB_DIRECTORY = "data/device.db"; 
+	public final static String GROUP_DB_DIRECTORY = "data/group.db"; 
 	public final static String UPNP_RESPONSE_PORT = "50000";
 	public final static String DEFAULT_ADDRESS = "1.1.1.1";
 	public final static String LOOP_BACK_ADDRESS = "127.0.0.1";
 	public final static String LOOP_BACK_INTERFACE = "lo";
-	public final static String DEFAULT_WEB_PORT = "8080";
+	public final static String DEFAULT_WEB_PORT = "80";
 	public final static String DEFAULT_BUTTON_SLEEP = "100";
 	public static final int UPNP_DISCOVERY_PORT = 1900;
 	public static final String UPNP_MULTICAST_ADDRESS = "239.255.255.250";
 	public static final String CONFIG_FILE = "data/habridge.config";
 	public static final int NUMBER_OF_LOG_MESSAGES = 512;
+	public static final long UPNP_NOTIFY_TIMEOUT = 20000;
 }

src/main/java/com/bwssystems/HABridge/DeviceMapTypes.java

@@ -0,0 +1,91 @@
+package com.bwssystems.HABridge;
+
+import java.util.ArrayList;
+
+public class DeviceMapTypes {
+
+	public final static String[] CUSTOM_DEVICE = { "custom", "Custom"};
+	public final static String[] VERA_DEVICE = { "veraDevice", "Vera Device"};
+	public final static String[] VERA_SCENE = { "veraScene", "Vera Scene"};
+	public final static String[] FIBARO_DEVICE = { "fibaroDevice", "Fibaro Device"};
+	public final static String[] FIBARO_SCENE = { "fibaroScene", "Fibaro Scene"};
+	public final static String[] HARMONY_ACTIVITY = { "harmonyActivity", "Harmony Activity"};
+	public final static String[] HARMONY_BUTTON = { "harmonyButton", "Harmony Button"};
+	public final static String[] NEST_HOMEAWAY = { "nestHomeAway", "Nest Home Status"};
+	public final static String[] NEST_THERMO_SET = { "nestThermoSet", "Nest Thermostat"};
+	public final static String[] HUE_DEVICE = { "hueDevice", "Hue Device"};
+	public final static String[] HAL_DEVICE = { "halDevice", "HAL Device"};
+	public final static String[] HAL_BUTTON = { "halButton", "HAL Button"};
+	public final static String[] HAL_HOME = { "halHome", "HAL Home Status"};
+	public final static String[] HAL_THERMO_SET = { "halThermoSet", "HAL Thermostat"};
+	public final static String[] MQTT_MESSAGE = { "mqttMessage", "MQTT Message"};
+	public final static String[] EXEC_DEVICE_COMPAT = { "exec", "Execute Script/Program"};
+	public final static String[] CMD_DEVICE = { "cmdDevice", "Execute Command/Script/Program"};
+	public final static String[] HASS_DEVICE = { "hassDevice", "HomeAssistant Device"};
+	public final static String[] TCP_DEVICE = { "tcpDevice", "TCP Device"};
+	public final static String[] TCP_DEVICE_COMPAT = { "TCP", "TCP Device"};
+	public final static String[] UDP_DEVICE = { "udpDevice", "UDP Device"};
+	public final static String[] UDP_DEVICE_COMPAT = { "UDP", "UDP Device"};
+	public final static String[] HTTP_DEVICE = { "httpDevice", "HTTP Device"};
+	public final static String[] DOMOTICZ_DEVICE = { "domoticzDevice", "Domoticz Device"};
+	public final static String[] SOMFY_DEVICE = { "somfyDevice", "Somfy Device"};
+	public final static String[] LIFX_DEVICE = { "lifxDevice", "LIFX Device"};
+
+	public final static int typeIndex = 0;
+	public final static int displayIndex = 1;
+
+	ArrayList<String[]> deviceMapTypes;
+	
+	public DeviceMapTypes() {
+		super();
+		deviceMapTypes = new ArrayList<String[]>();
+		deviceMapTypes.add(CMD_DEVICE);
+		deviceMapTypes.add(DOMOTICZ_DEVICE);
+		deviceMapTypes.add(HAL_DEVICE);
+		deviceMapTypes.add(HAL_HOME);
+		deviceMapTypes.add(HAL_THERMO_SET);
+		deviceMapTypes.add(HAL_BUTTON);
+		deviceMapTypes.add(HARMONY_ACTIVITY);
+		deviceMapTypes.add(HARMONY_BUTTON);
+		deviceMapTypes.add(HASS_DEVICE);
+		deviceMapTypes.add(HTTP_DEVICE);
+		deviceMapTypes.add(HUE_DEVICE);
+		deviceMapTypes.add(LIFX_DEVICE);
+		deviceMapTypes.add(MQTT_MESSAGE);
+		deviceMapTypes.add(NEST_HOMEAWAY);
+		deviceMapTypes.add(NEST_THERMO_SET);
+		deviceMapTypes.add(SOMFY_DEVICE);
+		deviceMapTypes.add(TCP_DEVICE);
+		deviceMapTypes.add(UDP_DEVICE);
+		deviceMapTypes.add(VERA_DEVICE);
+		deviceMapTypes.add(VERA_SCENE);
+		deviceMapTypes.add(FIBARO_DEVICE);
+		deviceMapTypes.add(FIBARO_SCENE);
+		deviceMapTypes.add(SOMFY_DEVICE);
+	}
+	public static int getTypeIndex() {
+		return typeIndex;
+	}
+	public static int getDisplayIndex() {
+		return displayIndex;
+	}
+	public ArrayList<String[]> getDeviceMapTypes() {
+		return deviceMapTypes;
+	}
+	
+	public Boolean validateType(String type) {
+		if(type == null || type.trim().isEmpty())
+			return false;
+		for(String[] mapType : deviceMapTypes) {
+			if(type.trim().contentEquals(mapType[typeIndex]))
+				return true;
+		}
+		if(type.trim().contentEquals(EXEC_DEVICE_COMPAT[typeIndex]))
+			return true;
+		if(type.trim().contentEquals(TCP_DEVICE_COMPAT[typeIndex]))
+			return true;
+		if(type.trim().contentEquals(UDP_DEVICE_COMPAT[typeIndex]))
+			return true;
+		return false;
+	}
+}

src/main/java/com/bwssystems/HABridge/HABridge.java

@@ -2,16 +2,17 @@ package com.bwssystems.HABridge;
 
 import static spark.Spark.*;
 
+import java.io.IOException;
+
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import com.bwssystems.HABridge.devicemanagmeent.*;
 import com.bwssystems.HABridge.hue.HueMulator;
+import com.bwssystems.HABridge.plugins.http.HttpClientPool;
 import com.bwssystems.HABridge.upnp.UpnpListener;
 import com.bwssystems.HABridge.upnp.UpnpSettingsResource;
-import com.bwssystems.NestBridge.NestHome;
-import com.bwssystems.harmony.HarmonyHome;
-import com.bwssystems.hue.HueHome;
+import com.bwssystems.HABridge.util.UDPDatagramSender;
 
 public class HABridge {
 	
@@ -33,65 +34,112 @@ public class HABridge {
     public static void main(String[] args) {
         Logger log = LoggerFactory.getLogger(HABridge.class);
         DeviceResource theResources;
-        HarmonyHome harmonyHome;
-        NestHome nestHome;
-        HueHome hueHome;
+        HomeManager homeManager;
         HueMulator theHueMulator;
+        UDPDatagramSender udpSender;
         UpnpSettingsResource theSettingResponder;
         UpnpListener theUpnpListener;
         SystemControl theSystem;
         BridgeSettings bridgeSettings;
         Version theVersion;
-        
+    	@SuppressWarnings("unused")
+		HttpClientPool thePool;
+       
         theVersion = new Version();
+        // Singleton initialization
+        thePool = new HttpClientPool();
 
         log.info("HA Bridge (v" + theVersion.getVersion() + ") starting....");
         
         bridgeSettings = new BridgeSettings();
+    	// sparkjava config directive to set html static file location for Jetty
         while(!bridgeSettings.getBridgeControl().isStop()) {
         	bridgeSettings.buildSettings();
-            log.info("HA Bridge (v" + theVersion.getVersion() + ") initializing....");
+            bridgeSettings.getBridgeSecurity().removeTestUsers();
+            log.info("HA Bridge initializing....");
 	        // sparkjava config directive to set ip address for the web server to listen on
-	        // ipAddress("0.0.0.0"); // not used
+	        ipAddress(bridgeSettings.getBridgeSettingsDescriptor().getWebaddress());
 	        // sparkjava config directive to set port for the web server to listen on
 	        port(bridgeSettings.getBridgeSettingsDescriptor().getServerPort());
-	        // sparkjava config directive to set html static file location for Jetty
-	        staticFileLocation("/public");
+	    	staticFileLocation("/public");
+	    	initExceptionHandler((e) -> HABridge.theExceptionHandler(e, bridgeSettings.getBridgeSettingsDescriptor().getServerPort()));
+	        if(!bridgeSettings.getBridgeControl().isReinit())
+	        	init();
+	        bridgeSettings.getBridgeControl().setReinit(false);
 	        // setup system control api first
 	        theSystem = new SystemControl(bridgeSettings, theVersion);
 	        theSystem.setupServer();
-	        //setup the harmony connection if available
-	        harmonyHome = new HarmonyHome(bridgeSettings.getBridgeSettingsDescriptor());
-	        //setup the nest connection if available
-	        nestHome = new NestHome(bridgeSettings.getBridgeSettingsDescriptor());
-	        //setup the hue passtrhu configuration if available
-	        hueHome = new HueHome(bridgeSettings.getBridgeSettingsDescriptor());
-	        // setup the class to handle the resource setup rest api
-	        theResources = new DeviceResource(bridgeSettings.getBridgeSettingsDescriptor(), harmonyHome, nestHome, hueHome);
-	        // setup the class to handle the hue emulator rest api
-	        theHueMulator = new HueMulator(bridgeSettings.getBridgeSettingsDescriptor(), theResources.getDeviceRepository(), harmonyHome, nestHome, hueHome);
-	        theHueMulator.setupServer();
-	        // setup the class to handle the upnp response rest api
-	        theSettingResponder = new UpnpSettingsResource(bridgeSettings.getBridgeSettingsDescriptor());
-	        theSettingResponder.setupServer();
-	        // wait for the sparkjava initialization of the rest api classes to be complete
-	        awaitInitialization();
-	
-	        // start the upnp ssdp discovery listener
-	        theUpnpListener = new UpnpListener(bridgeSettings.getBridgeSettingsDescriptor(), bridgeSettings.getBridgeControl());
-	        if(theUpnpListener.startListening())
-	        	log.info("HA Bridge (v" + theVersion.getVersion() + ") reinitialization requessted....");
-	        else
-	        	bridgeSettings.getBridgeControl().setStop(true);
+	        // setup the UDP Datagram socket to be used by the HueMulator and the upnpListener
+	        udpSender = UDPDatagramSender.createUDPDatagramSender(bridgeSettings.getBridgeSettingsDescriptor().getUpnpResponsePort());
+	        if(udpSender == null) {
+	        	bridgeSettings.getBridgeControl().setStop(true);	        	
+	        }
+	        else {
+		        //Setup the device connection homes through the manager
+		        homeManager = new HomeManager();
+		        homeManager.buildHomes(bridgeSettings, udpSender);
+		        // setup the class to handle the resource setup rest api
+		        theResources = new DeviceResource(bridgeSettings, homeManager);
+		        // setup the class to handle the hue emulator rest api
+		        theHueMulator = new HueMulator(bridgeSettings, theResources.getDeviceRepository(), theResources.getGroupRepository(), homeManager);
+		        theHueMulator.setupServer();
+		        // wait for the sparkjava initialization of the rest api classes to be complete
+		        awaitInitialization();
 
-	        bridgeSettings.getBridgeControl().setReinit(false);
+		        if(bridgeSettings.getBridgeSettingsDescriptor().isTraceupnp())
+		        	log.info("Traceupnp: upnp config address: " + bridgeSettings.getBridgeSettingsDescriptor().getUpnpConfigAddress() + "-useIface:" +
+		        			bridgeSettings.getBridgeSettingsDescriptor().isUseupnpiface() + " on web server: " +
+		        			bridgeSettings.getBridgeSettingsDescriptor().getWebaddress() + ":" + bridgeSettings.getBridgeSettingsDescriptor().getServerPort());
+		        // setup the class to handle the upnp response rest api
+		        theSettingResponder = new UpnpSettingsResource(bridgeSettings.getBridgeSettingsDescriptor());
+		        theSettingResponder.setupServer();
+
+		        // start the upnp ssdp discovery listener
+		        theUpnpListener = null;
+		        try {
+					theUpnpListener = new UpnpListener(bridgeSettings.getBridgeSettingsDescriptor(), bridgeSettings.getBridgeControl(), udpSender);
+				} catch (IOException e) {
+					log.error("Could not initialize UpnpListener, exiting....", e);
+					theUpnpListener = null;
+				}
+		        if(theUpnpListener != null && theUpnpListener.startListening())
+		        	log.info("HA Bridge (v" + theVersion.getVersion() + ") reinitialization requessted....");
+		        else
+		        	bridgeSettings.getBridgeControl().setStop(true);
+		        if(bridgeSettings.getBridgeSettingsDescriptor().isSettingsChanged())
+		        	bridgeSettings.save(bridgeSettings.getBridgeSettingsDescriptor());
+		        log.info("Going to close all homes");
+		        homeManager.closeHomes();
+		        udpSender.closeResponseSocket();
+		        udpSender = null;
+	        }
 	        stop();
-	        nestHome.closeTheNest();
-	        nestHome = null;
-	        harmonyHome.shutdownHarmonyHubs();
-	        harmonyHome = null;
+	        if(!bridgeSettings.getBridgeControl().isStop()) {
+	        	try {
+					Thread.sleep(5000);
+				} catch (InterruptedException e) {
+					log.error("Sleep error: " + e.getMessage());
+				}
+	        }
         }
+        bridgeSettings.getBridgeSecurity().removeTestUsers();
+        if(bridgeSettings.getBridgeSecurity().isSettingsChanged())
+        	bridgeSettings.updateConfigFile();
+		try {
+			HttpClientPool.shutdown();
+			thePool = null;
+		} catch (InterruptedException e) {
+			log.warn("Error shutting down http pool: " + e.getMessage());;
+		} catch (IOException e) {
+			log.warn("Error shutting down http pool: " + e.getMessage());;
+		}
         log.info("HA Bridge (v" + theVersion.getVersion() + ") exiting....");
         System.exit(0);
     }
+    
+    private static void theExceptionHandler(Exception e, Integer thePort) {
+        Logger log = LoggerFactory.getLogger(HABridge.class);
+    	log.error("Could not start ha-bridge webservice on port [" + thePort + "] due to: " + e.getMessage());
+    	System.exit(0);
+    }
 }

src/main/java/com/bwssystems/HABridge/Home.java

@@ -0,0 +1,9 @@
+package com.bwssystems.HABridge;
+
+import com.bwssystems.HABridge.devicemanagmeent.ResourceHandler;
+import com.bwssystems.HABridge.hue.HueMulatorHandler;
+
+public interface Home extends HueMulatorHandler, ResourceHandler {
+	public Home createHome(BridgeSettings bridgeSettings);
+	public void closeHome();
+}

src/main/java/com/bwssystems/HABridge/HomeManager.java

@@ -0,0 +1,130 @@
+package com.bwssystems.HABridge;
+
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.bwssystems.HABridge.devicemanagmeent.ResourceHandler;
+import com.bwssystems.HABridge.plugins.NestBridge.NestHome;
+import com.bwssystems.HABridge.plugins.domoticz.DomoticzHome;
+import com.bwssystems.HABridge.plugins.exec.CommandHome;
+import com.bwssystems.HABridge.plugins.hal.HalHome;
+import com.bwssystems.HABridge.plugins.harmony.HarmonyHome;
+import com.bwssystems.HABridge.plugins.hass.HassHome;
+import com.bwssystems.HABridge.plugins.http.HTTPHome;
+import com.bwssystems.HABridge.plugins.hue.HueHome;
+import com.bwssystems.HABridge.plugins.lifx.LifxHome;
+import com.bwssystems.HABridge.plugins.mqtt.MQTTHome;
+import com.bwssystems.HABridge.plugins.somfy.SomfyHome;
+import com.bwssystems.HABridge.plugins.tcp.TCPHome;
+import com.bwssystems.HABridge.plugins.udp.UDPHome;
+import com.bwssystems.HABridge.plugins.vera.VeraHome;
+import com.bwssystems.HABridge.plugins.fibaro.FibaroHome;
+import com.bwssystems.HABridge.util.UDPDatagramSender;
+
+public class HomeManager {
+	private static final Logger log = LoggerFactory.getLogger(HomeManager.class);
+	Map<String, Home> homeList;
+	Map<String, Home> resourceList;
+	
+	public HomeManager() {
+		homeList = new HashMap<String, Home>();
+		resourceList = new HashMap<String, Home>();
+	}
+
+	// factory method
+	public void buildHomes(BridgeSettings bridgeSettings, UDPDatagramSender aUdpDatagramSender) {
+		Home aHome = null;
+        //setup the harmony connection if available
+		aHome = new HarmonyHome(bridgeSettings);
+		resourceList.put(DeviceMapTypes.HARMONY_ACTIVITY[DeviceMapTypes.typeIndex], aHome);
+		homeList.put(DeviceMapTypes.HARMONY_ACTIVITY[DeviceMapTypes.typeIndex], aHome);
+		resourceList.put(DeviceMapTypes.HARMONY_BUTTON[DeviceMapTypes.typeIndex], aHome);
+		homeList.put(DeviceMapTypes.HARMONY_BUTTON[DeviceMapTypes.typeIndex], aHome);
+        //setup the nest connection if available
+		aHome = new NestHome(bridgeSettings);
+		resourceList.put(DeviceMapTypes.NEST_HOMEAWAY[DeviceMapTypes.typeIndex], aHome);
+		homeList.put(DeviceMapTypes.NEST_HOMEAWAY[DeviceMapTypes.typeIndex], aHome);
+		homeList.put(DeviceMapTypes.NEST_THERMO_SET[DeviceMapTypes.typeIndex], aHome);
+        //setup the hue passtrhu configuration if available
+		aHome = new HueHome(bridgeSettings);
+		resourceList.put(DeviceMapTypes.HUE_DEVICE[DeviceMapTypes.typeIndex], aHome);
+		homeList.put(DeviceMapTypes.HUE_DEVICE[DeviceMapTypes.typeIndex], aHome);
+        //setup the hal configuration if available
+		aHome = new HalHome(bridgeSettings);
+		resourceList.put(DeviceMapTypes.HAL_DEVICE[DeviceMapTypes.typeIndex], aHome);
+		homeList.put(DeviceMapTypes.HAL_DEVICE[DeviceMapTypes.typeIndex], aHome);
+		homeList.put(DeviceMapTypes.HAL_BUTTON[DeviceMapTypes.typeIndex], aHome);
+		homeList.put(DeviceMapTypes.HAL_HOME[DeviceMapTypes.typeIndex], aHome);
+		homeList.put(DeviceMapTypes.HAL_THERMO_SET[DeviceMapTypes.typeIndex], aHome);
+        //setup the mqtt handlers if available
+		aHome = new MQTTHome(bridgeSettings);
+		resourceList.put(DeviceMapTypes.MQTT_MESSAGE[DeviceMapTypes.typeIndex], aHome);
+		homeList.put(DeviceMapTypes.MQTT_MESSAGE[DeviceMapTypes.typeIndex], aHome);
+        //setup the HomeAssistant configuration if available
+		aHome = new HassHome(bridgeSettings);
+		resourceList.put(DeviceMapTypes.HASS_DEVICE[DeviceMapTypes.typeIndex], aHome);
+		homeList.put(DeviceMapTypes.HASS_DEVICE[DeviceMapTypes.typeIndex], aHome);
+		//setup the command execution Home
+		aHome = new CommandHome(bridgeSettings);
+		homeList.put(DeviceMapTypes.EXEC_DEVICE_COMPAT[DeviceMapTypes.typeIndex], aHome);
+		homeList.put(DeviceMapTypes.CMD_DEVICE[DeviceMapTypes.typeIndex], aHome);
+		//setup the http handler Home
+		aHome = new HTTPHome(bridgeSettings);
+		homeList.put(DeviceMapTypes.HTTP_DEVICE[DeviceMapTypes.typeIndex], aHome);
+		homeList.put(DeviceMapTypes.CUSTOM_DEVICE[DeviceMapTypes.typeIndex], aHome);
+		homeList.put(DeviceMapTypes.VERA_DEVICE[DeviceMapTypes.typeIndex], aHome);
+		homeList.put(DeviceMapTypes.VERA_SCENE[DeviceMapTypes.typeIndex], aHome);
+		homeList.put(DeviceMapTypes.FIBARO_DEVICE[DeviceMapTypes.typeIndex], aHome);
+		homeList.put(DeviceMapTypes.FIBARO_SCENE[DeviceMapTypes.typeIndex], aHome);
+		//setup the tcp handler Home
+		aHome = new TCPHome(bridgeSettings);
+		homeList.put(DeviceMapTypes.TCP_DEVICE[DeviceMapTypes.typeIndex], aHome);
+		homeList.put(DeviceMapTypes.TCP_DEVICE_COMPAT[DeviceMapTypes.typeIndex], aHome);
+		//setup the udp handler Home
+		aHome = new UDPHome(bridgeSettings, aUdpDatagramSender);
+		homeList.put(DeviceMapTypes.UDP_DEVICE[DeviceMapTypes.typeIndex], aHome);
+		homeList.put(DeviceMapTypes.UDP_DEVICE_COMPAT[DeviceMapTypes.typeIndex], aHome);
+		// Setup Vera Home if available
+		aHome = new VeraHome(bridgeSettings);
+		resourceList.put(DeviceMapTypes.VERA_DEVICE[DeviceMapTypes.typeIndex], aHome);
+		resourceList.put(DeviceMapTypes.VERA_SCENE[DeviceMapTypes.typeIndex], aHome);
+		// Setup Fibaro Home if available
+		aHome = new FibaroHome(bridgeSettings);
+		resourceList.put(DeviceMapTypes.FIBARO_DEVICE[DeviceMapTypes.typeIndex], aHome);
+		resourceList.put(DeviceMapTypes.FIBARO_SCENE[DeviceMapTypes.typeIndex], aHome);
+    //setup the Domoticz configuration if available
+		aHome = new DomoticzHome(bridgeSettings);
+		homeList.put(DeviceMapTypes.DOMOTICZ_DEVICE[DeviceMapTypes.typeIndex], aHome);
+		resourceList.put(DeviceMapTypes.DOMOTICZ_DEVICE[DeviceMapTypes.typeIndex], aHome);
+		//setup the Somfy configuration if available
+		aHome = new SomfyHome(bridgeSettings);
+		homeList.put(DeviceMapTypes.SOMFY_DEVICE[DeviceMapTypes.typeIndex], aHome);
+		resourceList.put(DeviceMapTypes.SOMFY_DEVICE[DeviceMapTypes.typeIndex], aHome);
+        //setup the Lifx configuration if available
+		aHome = new LifxHome(bridgeSettings);
+		resourceList.put(DeviceMapTypes.LIFX_DEVICE[DeviceMapTypes.typeIndex], aHome);
+		homeList.put(DeviceMapTypes.LIFX_DEVICE[DeviceMapTypes.typeIndex], aHome);
+	}
+	
+	public Home findHome(String type) {
+		return homeList.get(type);
+	}
+	public ResourceHandler findResource(String type) {
+		return resourceList.get(type);
+	}
+
+	public void closeHomes() {
+		log.info("Manager close homes called....");
+		Collection<Home> theHomes = homeList.values();
+		for(Home aHome : theHomes) {
+			log.info("Closing home: " + aHome.getClass().getCanonicalName());
+			aHome.closeHome();
+		}
+		homeList.clear();
+		homeList = null;
+	}
+}

src/main/java/com/bwssystems/HABridge/LinkButtonPressed.java

@@ -0,0 +1,29 @@
+package com.bwssystems.HABridge;
+
+import java.util.Timer;
+import java.util.TimerTask;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class LinkButtonPressed extends TimerTask {
+    private static final Logger log = LoggerFactory.getLogger(LinkButtonPressed.class);
+	private BridgeControlDescriptor linkDescriptor;
+	private Timer myTimer;
+	private boolean isSilent;
+
+	public LinkButtonPressed(BridgeControlDescriptor theDescriptor, Timer aTimer, boolean keepSilent) {
+		linkDescriptor = theDescriptor;
+		myTimer = aTimer;
+		isSilent = keepSilent;
+	}
+
+	@Override
+	public void run() {
+		if(!isSilent)
+			log.info("Link button time ended....");
+		linkDescriptor.setLinkButton(false);
+		myTimer.cancel();
+	}
+
+}

src/main/java/com/bwssystems/HABridge/LinkParams.java

@@ -0,0 +1,20 @@
+package com.bwssystems.HABridge;
+
+public class LinkParams {
+	private Integer seconds;
+	private boolean silent;
+
+	public Integer getSeconds() {
+		return seconds;
+	}
+	public void setSeconds(Integer seconds) {
+		this.seconds = seconds;
+	}
+	public boolean isSilent() {
+		return silent;
+	}
+	public void setSilent(boolean silent) {
+		this.silent = silent;
+	}
+
+}

src/main/java/com/bwssystems/HABridge/LoginResult.java

@@ -0,0 +1,22 @@
+package com.bwssystems.HABridge;
+
+public class LoginResult {
+	
+	private String error;
+	
+	private User user;
+	
+	public String getError() {
+		return error;
+	}
+	public void setError(String error) {
+		this.error = error;
+	}
+	public User getUser() {
+		return user;
+	}
+	public void setUser(User user) {
+		this.user = user;
+	}
+
+}

src/main/java/com/bwssystems/HABridge/NamedIP.java

@@ -3,7 +3,12 @@ package com.bwssystems.HABridge;
 public class NamedIP {
 	private String name;
 	private String ip;
+	private String webhook;
 	private String port;
+	private String username;
+	private String password;
+	private Boolean secure;
+	
 	public String getName() {
 		return name;
 	}
@@ -16,10 +21,34 @@ public class NamedIP {
 	public void setIp(String ip) {
 		this.ip = ip;
 	}
-	public String getPort() {
+        public String getWebhook() {
+            return webhook;
+        }
+        public void setWebhook(final String webhook) {
+            this.webhook = webhook;
+        }
+        public String getPort() {
 		return port;
 	}
 	public void setPort(String port) {
 		this.port = port;
 	}
+	public String getUsername() {
+		return username;
+	}
+	public void setUsername(String username) {
+		this.username = username;
+	}
+	public String getPassword() {
+		return password;
+	}
+	public void setPassword(String password) {
+		this.password = password;
+	}
+	public Boolean getSecure() {
+		return secure;
+	}
+	public void setSecure(Boolean secure) {
+		this.secure = secure;
+	}
 }

src/main/java/com/bwssystems/HABridge/SecurityInfo.java

@@ -0,0 +1,26 @@
+package com.bwssystems.HABridge;
+
+public class SecurityInfo {
+	private boolean useLinkButton;
+	private boolean secureHueApi;
+	private boolean isSecure;
+	
+	public boolean isUseLinkButton() {
+		return useLinkButton;
+	}
+	public void setUseLinkButton(boolean useLinkButton) {
+		this.useLinkButton = useLinkButton;
+	}
+	public boolean isSecureHueApi() {
+		return secureHueApi;
+	}
+	public void setSecureHueApi(boolean secureHueApi) {
+		this.secureHueApi = secureHueApi;
+	}
+	public boolean isSecure() {
+		return isSecure;
+	}
+	public void setSecure(boolean isSecure) {
+		this.isSecure = isSecure;
+	}
+}

src/main/java/com/bwssystems/HABridge/SystemControl.java

@@ -4,6 +4,8 @@ import static spark.Spark.get;
 import static spark.Spark.options;
 import static spark.Spark.post;
 import static spark.Spark.put;
+import static spark.Spark.before;
+import static spark.Spark.halt;
 
 import java.io.IOException;
 import java.net.DatagramPacket;
@@ -12,17 +14,19 @@ import java.net.MulticastSocket;
 import java.text.DateFormat;
 import java.text.SimpleDateFormat;
 import java.util.Arrays;
+import java.util.Timer;
+import java.util.Base64;
 
 import org.apache.http.HttpStatus;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import com.bwssystems.HABridge.dao.BackupFilename;
+import com.bwssystems.HABridge.util.JsonTransformer;
+import com.bwssystems.HABridge.util.TextStringFormatter;
 import com.bwssystems.logservices.LoggerInfo;
 import com.bwssystems.logservices.LoggingForm;
 import com.bwssystems.logservices.LoggingManager;
-import com.bwssystems.util.TextStringFormatter;
-import com.bwssystems.util.JsonTransformer;
 import com.google.gson.Gson;
 
 import ch.qos.logback.classic.LoggerContext;
@@ -55,17 +59,28 @@ public class SystemControl {
 //	This function sets up the sparkjava rest calls for the hue api
     public void setupServer() {
     	log.info("System control service started....");
+		before(SYSTEM_CONTEXT + "/*", (request, response) -> {
+			if(bridgeSettings.getBridgeSecurity().isSecure()) {
+				String pathInfo = request.pathInfo();
+				if(pathInfo == null || (!pathInfo.equals(SYSTEM_CONTEXT + "/login") && !pathInfo.equals(SYSTEM_CONTEXT + "/habridge/version"))) {
+					User authUser = bridgeSettings.getBridgeSecurity().getAuthenticatedUser(request);
+					if(authUser == null) {
+						halt(401, "{\"message\":\"User not authenticated\"}");
+					}
+				}
+			}
+		});
 	    // http://ip_address:port/system/habridge/version gets the version of this bridge instance
-    	get (SYSTEM_CONTEXT + "/habridge/version", "application/json", (request, response) -> {
+    	get (SYSTEM_CONTEXT + "/habridge/version", (request, response) -> {
 	    	log.debug("Get HA Bridge version: v" + version.getVersion());
 			response.status(HttpStatus.SC_OK);
-	        return "{\"version\":\"" + version.getVersion() + "\"}";
+			response.type("application/json");
+	        return "{\"version\":\"" + version.getVersion() + "\",\"isSecure\":" + bridgeSettings.getBridgeSecurity().isSecure() + "}";
 	    });
 
 	    // http://ip_address:port/system/logmsgs gets the log messages for the bridge
-    	get (SYSTEM_CONTEXT + "/logmsgs", "application/json", (request, response) -> {
+    	get (SYSTEM_CONTEXT + "/logmsgs", (request, response) -> {
 			log.debug("Get logmsgs.");
-			response.status(HttpStatus.SC_OK);
 			String logMsgs;
 		    int count = -1;
 		    if(cyclicBufferAppender == null)
@@ -86,24 +101,202 @@ public class SystemControl {
 				}
 		    }
 		    logMsgs = logMsgs + "]";
-			response.status(200);
+			response.status(HttpStatus.SC_OK);
+			response.type("application/json");
 			return logMsgs;
 	    });
 
 	    // http://ip_address:port/system/logmgmt/loggers gets the logger info for the bridge
-    	get (SYSTEM_CONTEXT + "/logmgmt/loggers/:all", "application/json", (request, response) -> {
+    	get (SYSTEM_CONTEXT + "/logmgmt/loggers/:all", (request, response) -> {
 			log.debug("Get loggers info with showAll argument: " + request.params(":all"));
 			Boolean showAll = false;
 			if(request.params(":all").equals("true"))
 				showAll = true;
 			theLogServiceMgr.setShowAll(showAll);
 			theLogServiceMgr.init();
-			response.status(200);
+			response.status(HttpStatus.SC_OK);
+			response.type("application/json");
 			return theLogServiceMgr.getConfiguredLoggers();
 	    }, new JsonTransformer());
 
+//      http://ip_address:port/system/setpassword CORS request
+	    options(SYSTEM_CONTEXT + "/setpassword", (request, response) -> {
+	        response.status(HttpStatus.SC_OK);
+	        response.header("Access-Control-Allow-Origin", request.headers("Origin"));
+	        response.header("Access-Control-Allow-Methods", "GET, POST, PUT");
+	        response.header("Access-Control-Allow-Headers", request.headers("Access-Control-Request-Headers"));
+	        response.header("Content-Type", "text/html; charset=utf-8");
+	    	return "";
+	    });
+//      http://ip_address:port/system/setpassword which sets a password for a given user
+		post(SYSTEM_CONTEXT + "/setpassword", (request, response) -> {
+			log.debug("setpassword....");
+			String theDecodedPayload = new String(Base64.getDecoder().decode(request.body()));
+			User theUser = new Gson().fromJson(theDecodedPayload, User.class);
+			String errorMessage = bridgeSettings.getBridgeSecurity().setPassword(theUser);
+			if(errorMessage != null) {
+		        response.status(HttpStatus.SC_BAD_REQUEST);
+		        errorMessage = "{\"message\":\"" + errorMessage + "\"}";
+			} else {
+		        response.status(HttpStatus.SC_OK);
+		        bridgeSettings.save(bridgeSettings.getBridgeSettingsDescriptor());
+			}
+
+			if(errorMessage == null)
+				errorMessage = "{}";
+			response.type("application/json");
+            return errorMessage;
+        });
+
+//      http://ip_address:port/system/adduser CORS request
+	    options(SYSTEM_CONTEXT + "/adduser", (request, response) -> {
+	        response.status(HttpStatus.SC_OK);
+	        response.header("Access-Control-Allow-Origin", request.headers("Origin"));
+	        response.header("Access-Control-Allow-Methods", "GET, POST, PUT");
+	        response.header("Access-Control-Allow-Headers", request.headers("Access-Control-Request-Headers"));
+	        response.header("Content-Type", "text/html; charset=utf-8");
+	    	return "";
+	    });
+//      http://ip_address:port/system/adduser which adds a new user
+		put(SYSTEM_CONTEXT + "/adduser", (request, response) -> {
+			log.debug("adduser....");
+			String theDecodedPayload = new String(Base64.getDecoder().decode(request.body()));
+			User theUser = new Gson().fromJson(theDecodedPayload, User.class);
+			String errorMessage = theUser.validate();
+			if(errorMessage != null) {
+		        response.status(HttpStatus.SC_BAD_REQUEST);
+		        errorMessage = "{\"message\":\"" + errorMessage + "\"}";
+			} else {
+		        errorMessage = bridgeSettings.getBridgeSecurity().addUser(theUser);
+				if(errorMessage == null) {
+			        response.status(HttpStatus.SC_OK);
+			        bridgeSettings.save(bridgeSettings.getBridgeSettingsDescriptor());
+				} else {
+			        response.status(HttpStatus.SC_BAD_REQUEST);
+			        errorMessage = "{\"message\":\"" + errorMessage + "\"}";
+				}
+			}
+
+			if(errorMessage == null)
+				errorMessage = "{}";
+			response.type("application/json");
+            return errorMessage;
+        });
+
+//      http://ip_address:port/system/deluser CORS request
+	    options(SYSTEM_CONTEXT + "/deluser", (request, response) -> {
+	        response.status(HttpStatus.SC_OK);
+	        response.header("Access-Control-Allow-Origin", request.headers("Origin"));
+	        response.header("Access-Control-Allow-Methods", "GET, POST, PUT");
+	        response.header("Access-Control-Allow-Headers", request.headers("Access-Control-Request-Headers"));
+	        response.header("Content-Type", "text/html; charset=utf-8");
+	    	return "";
+	    });
+//      http://ip_address:port/system/deluser which dels a user
+		put(SYSTEM_CONTEXT + "/deluser", (request, response) -> {
+			log.debug("deluser....");
+			String theDecodedPayload = new String(Base64.getDecoder().decode(request.body()));
+			User theUser = new Gson().fromJson(theDecodedPayload, User.class);
+	        String errorMessage = bridgeSettings.getBridgeSecurity().delUser(theUser);
+			if(errorMessage != null) {
+		        response.status(HttpStatus.SC_BAD_REQUEST);
+		        errorMessage = "{\"message\":\"" + errorMessage + "\"}";
+			} else {
+		        response.status(HttpStatus.SC_OK);
+				bridgeSettings.save(bridgeSettings.getBridgeSettingsDescriptor());
+			}
+
+			if(errorMessage == null)
+				errorMessage = "{}";
+			response.type("application/json");
+            return errorMessage;
+        });
+
+//      http://ip_address:port/system/login CORS request
+	    options(SYSTEM_CONTEXT + "/login", (request, response) -> {
+	        response.status(HttpStatus.SC_OK);
+	        response.header("Access-Control-Allow-Origin", request.headers("Origin"));
+	        response.header("Access-Control-Allow-Methods", "GET, POST, PUT");
+	        response.header("Access-Control-Allow-Headers", request.headers("Access-Control-Request-Headers"));
+	        response.header("Content-Type", "text/html; charset=utf-8");
+	    	return "";
+	    });
+//      http://ip_address:port/system/login validates the login
+		post(SYSTEM_CONTEXT + "/login", (request, response) -> {
+			log.debug("login....");
+			String theDecodedPayload = new String(Base64.getDecoder().decode(request.body()));
+			User theUser = new Gson().fromJson(theDecodedPayload, User.class);
+			LoginResult result = bridgeSettings.getBridgeSecurity().validatePassword(theUser);
+			if(result.getUser() != null)
+				bridgeSettings.getBridgeSecurity().addAuthenticatedUser(request, theUser);
+	        response.status(HttpStatus.SC_OK);
+			response.type("application/json");
+            return result;
+        }, new JsonTransformer());
+
+//      http://ip_address:port/system/presslinkbutton CORS request
+	    options(SYSTEM_CONTEXT + "/presslinkbutton", (request, response) -> {
+	        response.status(HttpStatus.SC_OK);
+	        response.header("Access-Control-Allow-Origin", request.headers("Origin"));
+	        response.header("Access-Control-Allow-Methods", "GET, POST, PUT");
+	        response.header("Access-Control-Allow-Headers", request.headers("Access-Control-Request-Headers"));
+	        response.header("Content-Type", "text/html; charset=utf-8");
+	    	return "";
+	    });
+//      http://ip_address:port/system/presslinkbutton which sets the link button for device registration
+		put(SYSTEM_CONTEXT + "/presslinkbutton", (request, response) -> {
+			LinkParams linkParams = null;
+			if(!request.body().isEmpty()) {
+				linkParams = new Gson().fromJson(request.body(), LinkParams.class);
+				if(linkParams.getSeconds() <= 0)
+					linkParams.setSeconds(1);
+			}
+			else {
+				linkParams = new LinkParams();
+				linkParams.setSilent(false);
+				linkParams.setSeconds(30);
+			}
+			if(!linkParams.isSilent())
+				log.info("Link button pressed....");
+			bridgeSettings.getBridgeControl().setLinkButton(true);
+			Timer theTimer = new Timer();
+			theTimer.schedule(new LinkButtonPressed(bridgeSettings.getBridgeControl(), theTimer, linkParams.isSilent()), (linkParams.getSeconds() * 1000));
+	        response.status(HttpStatus.SC_OK);
+			response.type("application/json");
+            return "";
+        }, new JsonTransformer());
+
+	    // http://ip_address:port/system/securityinfo gets the security info for the bridge
+    	get (SYSTEM_CONTEXT + "/securityinfo", (request, response) -> {
+			log.debug("Get security info");
+	        response.status(HttpStatus.SC_OK);
+			response.type("application/json");
+			return bridgeSettings.getBridgeSecurity().getSecurityInfo();
+	    }, new JsonTransformer());
+
+//      http://ip_address:port/system/changesecurityinfo CORS request
+	    options(SYSTEM_CONTEXT + "/changesecurityinfo", (request, response) -> {
+	        response.status(HttpStatus.SC_OK);
+	        response.header("Access-Control-Allow-Origin", request.headers("Origin"));
+	        response.header("Access-Control-Allow-Methods", "GET, POST, PUT");
+	        response.header("Access-Control-Allow-Headers", request.headers("Access-Control-Request-Headers"));
+	        response.header("Content-Type", "text/html; charset=utf-8");
+	    	return "";
+	    });
+//      http://ip_address:port/system/changesecurityinfo which sets the security settings other than passwords and users
+		post(SYSTEM_CONTEXT + "/changesecurityinfo", (request, response) -> {
+			log.debug("changesecurityinfo....");
+			SecurityInfo theInfo = new Gson().fromJson(request.body(), SecurityInfo.class);
+			bridgeSettings.getBridgeSecurity().setUseLinkButton(theInfo.isUseLinkButton());
+			bridgeSettings.getBridgeSecurity().setSecureHueApi(theInfo.isSecureHueApi());
+			bridgeSettings.save(bridgeSettings.getBridgeSettingsDescriptor());
+	        response.status(HttpStatus.SC_OK);
+			response.type("application/json");
+            return bridgeSettings.getBridgeSecurity().getSecurityInfo();
+        }, new JsonTransformer());
+
 //      http://ip_address:port/system/logmgmt/update CORS request
-	    options(SYSTEM_CONTEXT + "/logmgmt/update", "application/json", (request, response) -> {
+	    options(SYSTEM_CONTEXT + "/logmgmt/update", (request, response) -> {
 	        response.status(HttpStatus.SC_OK);
 	        response.header("Access-Control-Allow-Origin", request.headers("Origin"));
 	        response.header("Access-Control-Allow-Methods", "GET, POST, PUT");
@@ -112,28 +305,28 @@ public class SystemControl {
 	    	return "";
 	    });
 //      http://ip_address:port/system/logmgmt/update which changes logging parameters for the process
-		put(SYSTEM_CONTEXT + "/logmgmt/update", "application/json", (request, response) -> {
+		put(SYSTEM_CONTEXT + "/logmgmt/update", (request, response) -> {
 			log.debug("update loggers: " + request.body());
-			response.status(200);
 			LoggerInfo updateLoggers[];
 			updateLoggers = new Gson().fromJson(request.body(), LoggerInfo[].class);
 			LoggingForm theModel = theLogServiceMgr.getModel();
 			theModel.setUpdatedLoggers(Arrays.asList(updateLoggers));
 			theLogServiceMgr.updateLogLevels();
+	        response.status(HttpStatus.SC_OK);
+			response.type("application/json");
             return theLogServiceMgr.getConfiguredLoggers();
         }, new JsonTransformer());
 
     	//      http://ip_address:port/system/settings which returns the bridge configuration settings
-		get(SYSTEM_CONTEXT + "/settings", "application/json", (request, response) -> {
+		get(SYSTEM_CONTEXT + "/settings", (request, response) -> {
 			log.debug("bridge settings requested from " + request.ip());
-
-			response.status(200);
-
+	        response.status(HttpStatus.SC_OK);
+			response.type("application/json");
             return bridgeSettings.getBridgeSettingsDescriptor();
         }, new JsonTransformer());
 		
 //      http://ip_address:port/system/settings CORS request
-	    options(SYSTEM_CONTEXT + "/settings", "application/json", (request, response) -> {
+	    options(SYSTEM_CONTEXT + "/settings", (request, response) -> {
 	        response.status(HttpStatus.SC_OK);
 	        response.header("Access-Control-Allow-Origin", request.headers("Origin"));
 	        response.header("Access-Control-Allow-Methods", "GET, POST, PUT");
@@ -142,17 +335,17 @@ public class SystemControl {
 	    	return "";
 	    });
 //      http://ip_address:port/system/settings which returns the bridge configuration settings
-		put(SYSTEM_CONTEXT + "/settings", "application/json", (request, response) -> {
+		put(SYSTEM_CONTEXT + "/settings", (request, response) -> {
 			log.debug("save bridge settings requested from " + request.ip() + " with body: " + request.body());
 			BridgeSettingsDescriptor newBridgeSettings = new Gson().fromJson(request.body(), BridgeSettingsDescriptor.class);
 			bridgeSettings.save(newBridgeSettings);
-			response.status(200);
-
+	        response.status(HttpStatus.SC_OK);
+			response.type("application/json");
             return bridgeSettings.getBridgeSettingsDescriptor();
         }, new JsonTransformer());
 		
 	    // http://ip_address:port/system/control/reinit CORS request
-	    options(SYSTEM_CONTEXT + "/control/reinit", "application/json", (request, response) -> {
+	    options(SYSTEM_CONTEXT + "/control/reinit", (request, response) -> {
 	        response.status(HttpStatus.SC_OK);
 	        response.header("Access-Control-Allow-Origin", request.headers("Origin"));
 	        response.header("Access-Control-Allow-Methods", "GET, POST, PUT");
@@ -161,12 +354,14 @@ public class SystemControl {
 	    	return "";
 	    });
 	    // http://ip_address:port/system/control/reinit sets the parameter reinit the server
-	    put(SYSTEM_CONTEXT + "/control/reinit", "application/json", (request, response) -> {
+	    put(SYSTEM_CONTEXT + "/control/reinit", (request, response) -> {
+	        response.status(HttpStatus.SC_OK);
+			response.type("application/json");
 	    	return reinit();
 	    });
 
 	    // http://ip_address:port/system/control/stop CORS request
-	    options(SYSTEM_CONTEXT + "/control/stop", "application/json", (request, response) -> {
+	    options(SYSTEM_CONTEXT + "/control/stop", (request, response) -> {
 	        response.status(HttpStatus.SC_OK);
 	        response.header("Access-Control-Allow-Origin", request.headers("Origin"));
 	        response.header("Access-Control-Allow-Methods", "GET, POST, PUT");
@@ -175,19 +370,22 @@ public class SystemControl {
 	    	return "";
 	    });
 	    // http://ip_address:port/system/control/stop sets the parameter stop the server
-	    put(SYSTEM_CONTEXT + "/control/stop", "application/json", (request, response) -> {
+	    put(SYSTEM_CONTEXT + "/control/stop", (request, response) -> {
+	        response.status(HttpStatus.SC_OK);
+			response.type("application/json");
 	    	return stop();
 	    });
 
 	    // http://ip_address:port/system/backup/available returns a list of config backup filenames
-	    get (SYSTEM_CONTEXT + "/backup/available", "application/json", (request, response) -> {
+	    get (SYSTEM_CONTEXT + "/backup/available", (request, response) -> {
         	log.debug("Get backup filenames");
           	response.status(HttpStatus.SC_OK);
+			response.type("application/json");
           	return bridgeSettings.getBackups();
         }, new JsonTransformer());
 
 	    // http://ip_address:port/system/backup/create CORS request
-	    options(SYSTEM_CONTEXT + "/backup/create", "application/json", (request, response) -> {
+	    options(SYSTEM_CONTEXT + "/backup/create", (request, response) -> {
 	        response.status(HttpStatus.SC_OK);
 	        response.header("Access-Control-Allow-Origin", request.headers("Origin"));
 	        response.header("Access-Control-Allow-Methods", "PUT");
@@ -195,16 +393,18 @@ public class SystemControl {
 	        response.header("Content-Type", "text/html; charset=utf-8");
 	    	return "";
 	    });
-    	put (SYSTEM_CONTEXT + "/backup/create", "application/json", (request, response) -> {
+    	put (SYSTEM_CONTEXT + "/backup/create", (request, response) -> {
 	    	log.debug("Create backup: " + request.body());
         	BackupFilename aFilename = new Gson().fromJson(request.body(), BackupFilename.class);
         	BackupFilename returnFilename = new BackupFilename();
         	returnFilename.setFilename(bridgeSettings.backup(aFilename.getFilename()));
+	        response.status(HttpStatus.SC_OK);
+			response.type("application/json");
 	        return returnFilename;
     	}, new JsonTransformer());
 
 	    // http://ip_address:port/system/backup/delete CORS request
-	    options(SYSTEM_CONTEXT + "/backup/delete", "application/json", (request, response) -> {
+	    options(SYSTEM_CONTEXT + "/backup/delete", (request, response) -> {
 	        response.status(HttpStatus.SC_OK);
 	        response.header("Access-Control-Allow-Origin", request.headers("Origin"));
 	        response.header("Access-Control-Allow-Methods", "POST");
@@ -212,18 +412,20 @@ public class SystemControl {
 	        response.header("Content-Type", "text/html; charset=utf-8");
 	    	return "";
 	    });
-    	post (SYSTEM_CONTEXT + "/backup/delete", "application/json", (request, response) -> {
+    	post (SYSTEM_CONTEXT + "/backup/delete", (request, response) -> {
 	    	log.debug("Delete backup: " + request.body());
         	BackupFilename aFilename = new Gson().fromJson(request.body(), BackupFilename.class);
         	if(aFilename != null)
         		bridgeSettings.deleteBackup(aFilename.getFilename());
         	else
         		log.warn("No filename given for delete backup.");
-	        return null;
+	        response.status(HttpStatus.SC_OK);
+			response.type("application/json");
+	        return "";
 	    }, new JsonTransformer());
 
 	    // http://ip_address:port/system/backup/restore CORS request
-	    options(SYSTEM_CONTEXT + "/backup/restore", "application/json", (request, response) -> {
+	    options(SYSTEM_CONTEXT + "/backup/restore", (request, response) -> {
 	        response.status(HttpStatus.SC_OK);
 	        response.header("Access-Control-Allow-Origin", request.headers("Origin"));
 	        response.header("Access-Control-Allow-Methods", "POST");
@@ -231,7 +433,7 @@ public class SystemControl {
 	        response.header("Content-Type", "text/html; charset=utf-8");
 	    	return "";
 	    });
-    	post (SYSTEM_CONTEXT + "/backup/restore", "application/json", (request, response) -> {
+    	post (SYSTEM_CONTEXT + "/backup/restore", (request, response) -> {
 	    	log.debug("Restore backup: " + request.body());
         	BackupFilename aFilename = new Gson().fromJson(request.body(), BackupFilename.class);
         	if(aFilename != null) {
@@ -240,6 +442,8 @@ public class SystemControl {
         	}
         	else
         		log.warn("No filename given for restore backup.");
+	        response.status(HttpStatus.SC_OK);
+			response.type("application/json");
 	        return bridgeSettings.getBridgeSettingsDescriptor();
 	    }, new JsonTransformer());
     }

src/main/java/com/bwssystems/HABridge/User.java

@@ -0,0 +1,65 @@
+package com.bwssystems.HABridge;
+
+import spark.utils.StringUtils;
+
+public class User {
+	private int id;
+	
+	private String username;
+	
+	private String password;
+	
+	private String password2;
+
+	public int getId() {
+		return id;
+	}
+
+	public void setId(int id) {
+		this.id = id;
+	}
+
+	public String getUsername() {
+		return username;
+	}
+
+	public void setUsername(String username) {
+		this.username = username;
+	}
+
+	public String getPassword() {
+		return password;
+	}
+
+	public void setPassword(String password) {
+		this.password = password;
+	}
+
+	public String getPassword2() {
+		return password2;
+	}
+
+	public void setPassword2(String password2) {
+		this.password2 = password2;
+	}
+	
+	public String validate() {
+		String error = null;
+		
+		if(StringUtils.isEmpty(username)) {
+			error = "You have to enter a username";
+		} else if(StringUtils.isEmpty(password)) {
+			error = "You have to enter a password";
+		} else if(!password.equals(password2)) {
+			error = "The two passwords do not match";
+		}
+		
+		return error;
+	}
+
+	public boolean validatePassword() {
+		if(password != null && password2 != null)
+			return password.equals(password2);
+		return false;
+	}
+}

src/main/java/com/bwssystems/HABridge/api/CallItem.java

@@ -1,13 +1,87 @@
 package com.bwssystems.HABridge.api;
 
-public class CallItem {
-	private String item;
+import com.google.gson.JsonElement;
 
-	public String getItem() {
+public class CallItem {
+	private JsonElement item;
+	private Integer count;
+	private Integer delay;
+	private String type;
+	private String filterIPs;
+	private String httpVerb;
+	private String httpBody;
+	private String httpHeaders;
+	private String contentType;
+
+	public String getType() {
+		return type;
+	}
+
+	public void setType(String type) {
+		this.type = type;
+	}
+
+	public String getFilterIPs() {
+		return filterIPs;
+	}
+
+	public void setFilterIPs(String filterIPs) {
+		this.filterIPs = filterIPs;
+	}
+
+	public JsonElement getItem() {
 		return item;
 	}
 
-	public void setItem(String anitem) {
-		item = anitem;
+	public void setItem(JsonElement item) {
+		this.item = item;
+	}
+
+	public Integer getCount() {
+		return count;
+	}
+
+	public void setCount(Integer count) {
+		this.count = count;
+	}
+
+	public Integer getDelay() {
+		return delay;
+	}
+
+	public void setDelay(Integer delay) {
+		this.delay = delay;
+	}
+
+	public String getHttpVerb() {
+		return httpVerb;
+	}
+
+	public void setHttpVerb(String httpVerb) {
+		this.httpVerb = httpVerb;
+	}
+
+	public String getHttpBody() {
+		return httpBody;
+	}
+
+	public void setHttpBody(String httpBody) {
+		this.httpBody = httpBody;
+	}
+
+	public String getHttpHeaders() {
+		return httpHeaders;
+	}
+
+	public void setHttpHeaders(String httpHeaders) {
+		this.httpHeaders = httpHeaders;
+	}
+
+	public String getContentType() {
+		return contentType;
+	}
+
+	public void setContentType(String contentType) {
+		this.contentType = contentType;
 	}
 }

src/main/java/com/bwssystems/HABridge/api/CallItemDeserializer.java

@@ -0,0 +1,30 @@
+package com.bwssystems.HABridge.api;
+import java.lang.reflect.Type;
+
+import com.google.gson.JsonDeserializationContext;
+import com.google.gson.JsonDeserializer;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+
+public class CallItemDeserializer implements JsonDeserializer<CallItem> {
+    @Override
+    public CallItem deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext ctx)
+    {
+    	CallItem aCallItem = new CallItem();
+        JsonObject jsonObj = json.getAsJsonObject();
+        JsonElement jsonElem;
+        jsonElem = jsonObj.get("item");
+        aCallItem.setItem(jsonElem);
+        jsonElem = jsonObj.get("delay");
+        aCallItem.setDelay(jsonElem.getAsInt());
+        jsonElem = jsonObj.get("count");
+        aCallItem.setCount(jsonElem.getAsInt());
+        jsonElem = jsonObj.get("type");
+        aCallItem.setType(jsonElem.getAsString());
+        jsonElem = jsonObj.get("filterIPs");
+        aCallItem.setFilterIPs(jsonElem.getAsString());
+        
+        return aCallItem;
+    }
+
+}

src/main/java/com/bwssystems/HABridge/api/hue/DeviceResponse.java

@@ -1,6 +1,7 @@
 package com.bwssystems.HABridge.api.hue;
 
 import com.bwssystems.HABridge.dao.DeviceDescriptor;
+import com.bwssystems.HABridge.dao.GroupDescriptor;
 
 /**
  * Created by arm on 4/14/15.
@@ -11,8 +12,11 @@ public class DeviceResponse {
     private String name;
     private String modelid;
     private String manufacturername;
+    private String luminaireuniqueid;
     private String uniqueid;
     private String swversion;
+    private String swconfigid;
+    private String productid;
 
     public DeviceState getState() {
         return state;
@@ -70,17 +74,73 @@ public class DeviceResponse {
         this.swversion = swversion;
     }
 
-    public static DeviceResponse createResponse(DeviceDescriptor device){
+    public String getSwconfigid() {
+        return swconfigid;
+    }
+
+    public void setSwconfigid(String swconfigid) {
+        this.swconfigid = swconfigid;
+    }
+    
+    public String getProductid() {
+        return productid;
+    }
+
+	public void setProductid(String productid) {
+        this.productid = productid;
+    }
+
+
+    public String getLuminaireuniqueid() {
+		return luminaireuniqueid;
+	}
+
+	public void setLuminaireuniqueid(String luminaireuniqueid) {
+		this.luminaireuniqueid = luminaireuniqueid;
+	}
+
+	public static DeviceResponse createResponse(DeviceDescriptor device){
         DeviceResponse response = new DeviceResponse();
         response.setState(device.getDeviceState());
 
         response.setName(device.getName());
-        response.setUniqueid(device.getId());
+        response.setUniqueid(device.getUniqueid());
         response.setManufacturername("Philips");
-        response.setType("Dimmable light");
-        response.setModelid("LWB004");
-        response.setSwversion("66012040");
+            
+        if (device.isColorDevice()) {
+            response.setType("Extended color light");
+            response.setModelid("LCT010");
+            response.setSwversion("1.15.2_r19181");
+            response.setSwconfigid("F921C859");
+            response.setProductid("Philips-LCT010-1-A19ECLv4");    
+        } else {
+            response.setType("Dimmable light");
+            response.setModelid("LWB007");
+            response.setSwversion("66012040");
+        }
+        
+        response.setLuminaireuniqueid(null);
 
         return response;
     }
+
+    public static DeviceResponse createResponseForVirtualLight(GroupDescriptor group){
+        DeviceResponse response = new DeviceResponse();
+        response.setState(group.getAction());
+
+        response.setName(group.getName());
+        response.setUniqueid("00:17:88:5E:D3:FF-" + String.format("%02X", Integer.parseInt(group.getId())));
+        response.setManufacturername("Philips");
+        response.setType("Extended color light");
+        response.setModelid("LCT010");
+        response.setSwversion("1.15.2_r19181");
+        response.setSwconfigid("F921C859");
+        response.setProductid("Philips-LCT010-1-A19ECLv4");    
+        
+        response.setLuminaireuniqueid(null);
+
+        return response;
+    }
+
+
 }

src/main/java/com/bwssystems/HABridge/api/hue/DeviceState.java

@@ -1,5 +1,6 @@
 package com.bwssystems.HABridge.api.hue;
 
+import java.util.ArrayList;
 import java.util.List;
 
 /**
@@ -7,15 +8,17 @@ import java.util.List;
  */
 public class DeviceState {
     private boolean on;
-    private int bri = 255;
-    private int hue;
-    private int sat;
+    private int bri;
+    private Integer hue;
+    private Integer sat;
     private String effect;
-    private int ct;
+    private List<Double> xy;
+    private Integer ct;
     private String alert;
     private String colormode;
     private boolean reachable;
-    private List<Double> xy;
+    
+//    private int transitiontime;
 
     public boolean isOn() {
         return on;
@@ -34,19 +37,21 @@ public class DeviceState {
     }
 
     public int getHue() {
-        return hue;
+        return hue != null ? hue.intValue() : 0;
     }
 
     public void setHue(int hue) {
         this.hue = hue;
+        this.colormode = "hs";
     }
 
     public int getSat() {
-        return sat;
+        return sat != null ? sat.intValue() : 0;
     }
 
     public void setSat(int sat) {
         this.sat = sat;
+        this.colormode = "hs";
     }
 
     public String getEffect() {
@@ -58,11 +63,12 @@ public class DeviceState {
     }
 
     public int getCt() {
-        return ct;
+        return ct != null ? ct.intValue() : 0;
     }
 
     public void setCt(int ct) {
         this.ct = ct;
+        this.colormode = "ct";
     }
 
     public String getAlert() {
@@ -95,8 +101,40 @@ public class DeviceState {
 
     public void setXy(List<Double> xy) {
         this.xy = xy;
+        this.colormode = "xy";
     }
+//    public int getTransitiontime() {
+//		return transitiontime;
+//	}
 
+//	public void setTransitiontime(int transitiontime) {
+//		this.transitiontime = transitiontime;
+//	}
+
+	public static DeviceState createDeviceState(boolean color) {
+    	DeviceState newDeviceState = new DeviceState();
+    	newDeviceState.fillIn(color);
+        if (color) {
+            newDeviceState.setColormode("xy");
+            newDeviceState.setHue(0);
+            newDeviceState.setSat(0);
+            newDeviceState.setCt(153);
+            ArrayList<Double> doubleArray = new ArrayList<Double>();
+            doubleArray.add(0.3146);
+            doubleArray.add(0.3303);
+            newDeviceState.setXy(doubleArray);    
+        }
+    	return newDeviceState;
+    }
+    public void fillIn(boolean color) {
+    	if(this.getAlert() == null)
+    		this.setAlert("none");
+        if (color) {
+            if(this.getEffect() == null)
+                this.setEffect("none");
+        }
+    	this.setReachable(true);
+    }
     @Override
     public String toString() {
         return "DeviceState{" +

src/main/java/com/bwssystems/HABridge/api/hue/DeviceTypes.java

@@ -0,0 +1,18 @@
+package com.bwssystems.HABridge.api.hue;
+
+public class DeviceTypes {
+	private Boolean bridge;
+	private String[] lights;
+	public Boolean getBridge() {
+		return bridge;
+	}
+	public void setBridge(Boolean bridge) {
+		this.bridge = bridge;
+	}
+	public String[] getLights() {
+		return lights;
+	}
+	public void setLights(String[] lights) {
+		this.lights = lights;
+	}
+}

src/main/java/com/bwssystems/HABridge/api/hue/GroupClassTypes.java

@@ -0,0 +1,61 @@
+package com.bwssystems.HABridge.api.hue;
+
+import java.util.ArrayList;
+
+public class GroupClassTypes {
+
+	public final static String BATHROOM = "Bathroom";
+	public final static String BEDROOM = "Bedroom";
+	public final static String CARPORT = "Carport";
+	public final static String DINING = "Dining";
+	public final static String DRIVEWAY = "Driveway";
+	public final static String FRONT_DOOR = "Front door";
+	public final static String GARAGE = "Garage";
+	public final static String GARDEN = "Garden";
+	public final static String GYM = "Gym";
+	public final static String HALLWAY = "Hallway";
+	public final static String BEDROOM_KIDS = "Kids bedroom";
+	public final static String KITCHEN = "Kitchen";
+	public final static String LIVING_ROOM = "Living room";
+	public final static String NURSERY = "Nursery";
+	public final static String OFFICE = "Office";
+	public final static String OTHER = "Other";
+	public final static String RECREATION = "Recreation";
+	public final static String TERRACE = "Terrace";
+	public final static String TOILET = "Toilet";
+	
+	ArrayList<String> groupClassTypes;
+
+	public GroupClassTypes() {
+		groupClassTypes = new ArrayList<String>();
+		groupClassTypes.add(BATHROOM);
+		groupClassTypes.add(BEDROOM);
+		groupClassTypes.add(CARPORT);
+		groupClassTypes.add(DINING);
+		groupClassTypes.add(DRIVEWAY);
+		groupClassTypes.add(FRONT_DOOR);
+		groupClassTypes.add(GARAGE);
+		groupClassTypes.add(GARDEN);
+		groupClassTypes.add(GYM);
+		groupClassTypes.add(HALLWAY);
+		groupClassTypes.add(BEDROOM_KIDS);
+		groupClassTypes.add(KITCHEN);
+		groupClassTypes.add(LIVING_ROOM);
+		groupClassTypes.add(NURSERY);
+		groupClassTypes.add(OFFICE);
+		groupClassTypes.add(OTHER);
+		groupClassTypes.add(RECREATION);
+		groupClassTypes.add(TERRACE);
+		groupClassTypes.add(TOILET);
+	}
+
+	public Boolean validateType(String type) {
+		if(type == null || type.trim().isEmpty())
+			return false;
+		for(String classType : groupClassTypes) {
+			if(type.trim().contentEquals(classType))
+				return true;
+		}
+		return false;
+	}
+}

src/main/java/com/bwssystems/HABridge/api/hue/GroupResponse.java

@@ -0,0 +1,126 @@
+package com.bwssystems.HABridge.api.hue;
+
+import java.util.Map;
+
+import com.bwssystems.HABridge.dao.GroupDescriptor;
+import com.google.gson.annotations.SerializedName;
+
+public class GroupResponse {
+    @SerializedName("action")
+	private DeviceState action;
+    @SerializedName("lights")
+	private String[] lights;
+    @SerializedName("name")
+	private String name;
+    @SerializedName("type")
+	private String type;
+    @SerializedName("class")
+    String class_name;
+    @SerializedName("state")
+    private GroupState state;
+
+	public DeviceState getAction() {
+		return action;
+	}
+	public void setAction(DeviceState action) {
+		this.action = action;
+	}
+
+	public GroupState getState() {
+		return state;
+	}
+	public void setState(GroupState state) {
+		this.state = state;
+	}
+
+	public String[] getLights() {
+		return lights;
+	}
+	public void setLights(String[] lights) {
+		this.lights = lights;
+	}
+	public String getName() {
+		return name;
+	}
+	public void setName(String name) {
+		this.name = name;
+	}
+	
+	 public String getType() {
+		return type;
+	}
+	public void setType(String type) {
+		this.type = type;
+	}
+	public String getClass_name() {
+		return class_name;
+	}
+	public void setClass_name(String class_name) {
+		this.class_name = class_name;
+	}
+	
+	public static GroupResponse createDefaultGroupResponse(Map<String, DeviceResponse> deviceList) {
+		String[] theList = new String[deviceList.size()];
+		Boolean all_on = true;
+		Boolean any_on = false;
+		int i = 0;
+		for (Map.Entry<String, DeviceResponse> device : deviceList.entrySet()) {
+			if (Integer.parseInt(device.getKey()) >= 10000) { // don't show fake lights for other groups
+				continue;
+			}
+		    theList[i] = device.getKey();
+		    Boolean is_on = device.getValue().getState().isOn();
+		    if (is_on)
+		    	any_on = true;
+		    else
+		    	all_on = false;
+		    i++;
+		}
+		GroupResponse theResponse = new GroupResponse();
+		theResponse.setAction(DeviceState.createDeviceState(true));
+		theResponse.setState(new GroupState(all_on, any_on));
+		theResponse.setName("Group 0");
+		theResponse.setLights(theList);
+		theResponse.setType("LightGroup");
+		return theResponse;
+	}
+
+	public static GroupResponse createResponse(GroupDescriptor group, Map<String, DeviceResponse> lights){
+        GroupResponse response = new GroupResponse();
+        Boolean all_on = true;
+		Boolean any_on = false;
+		String[] groupLights = null; 
+		if (lights == null) {
+			all_on = false;
+			groupLights = group.getLights();
+		} else {
+			for (DeviceResponse light : lights.values()) {
+		    Boolean is_on = light.getState().isOn();
+		    if (is_on)
+		    	any_on = true;
+		    else
+		    	all_on = false;
+			}	
+
+			// group.getLights() is not filtered by requester, lights is
+			// we want the filtered version but keep the order from group.getLights()
+			groupLights = new String[lights.size()];
+			int i = 0;
+			for (String light : group.getLights()) {
+				if (lights.keySet().contains(light)) {
+					groupLights[i] = light;
+					i++;
+				}
+			}
+		}
+		
+        response.setState(new GroupState(all_on, any_on));
+        response.setAction(group.getAction());
+        response.setName(group.getName());
+        response.setType(group.getGroupType());
+        response.setLights(groupLights);
+        response.setClass_name(group.getGroupClass());
+
+        return response;
+    }
+}

src/main/java/com/bwssystems/HABridge/api/hue/GroupState.java

@@ -0,0 +1,35 @@
+package com.bwssystems.HABridge.api.hue;
+
+/**
+ * Created by Florian Foerderreuther on 07/23/17
+ */
+public class GroupState {
+    private boolean all_on;
+    private boolean any_on;
+    
+    public boolean isAllOn() {
+        return all_on;
+    }
+
+    public boolean isAnyOn() {
+        return any_on;
+    }
+
+    public void setState(boolean all_on, boolean any_on) {
+        this.all_on = all_on;
+        this.any_on = any_on;
+    }
+
+    public GroupState(boolean all_on, boolean any_on) {
+        this.all_on = all_on;
+        this.any_on = any_on;   
+    }
+
+    @Override
+    public String toString() {
+        return "GroupState{" +
+                "all_on=" + all_on +
+                ", any_on=" + any_on +
+                '}';
+    }
+}

src/main/java/com/bwssystems/HABridge/api/hue/HueApiResponse.java

@@ -12,15 +12,15 @@ import com.google.gson.JsonObject;
 public class HueApiResponse {
     private Map<String, DeviceResponse> lights;
     private Map<String, JsonObject> scenes;
-    private Map<String, JsonObject> groups;
+    private Map<String, GroupResponse> groups;
     private Map<String, JsonObject> schedules;
     private Map<String, JsonObject> sensors;
     private Map<String, JsonObject> rules;
     private HueConfig config;
 
-    public HueApiResponse(String name, String ipaddress, String devicetype, String userid) {
+    public HueApiResponse(String name, String ipaddress, Map<String, WhitelistEntry> awhitelist, String emulateHubVersion, boolean isLinkButtonPressed, String emulateMAC) {
 		super();
-		this.setConfig(HueConfig.createConfig(name, ipaddress, devicetype, userid));
+		this.setConfig(HueConfig.createConfig(name, ipaddress, awhitelist, emulateHubVersion, isLinkButtonPressed, emulateMAC));
 		this.setRules(new HashMap<>());
 		this.setSensors(new HashMap<>());
 		this.setSchedules(new HashMap<>());
@@ -44,11 +44,11 @@ public class HueApiResponse {
 		this.scenes = scenes;
 	}
 
-	public Map<String, JsonObject> getGroups() {
+	public Map<String, GroupResponse> getGroups() {
 		return groups;
 	}
 
-	public void setGroups(Map<String, JsonObject> groups) {
+	public void setGroups(Map<String, GroupResponse> groups) {
 		this.groups = groups;
 	}
 

src/main/java/com/bwssystems/HABridge/api/hue/HueConfig.java

@@ -6,7 +6,6 @@ import java.net.SocketException;
 import java.net.UnknownHostException;
 import java.text.SimpleDateFormat;
 import java.util.Date;
-import java.util.HashMap;
 import java.util.Map;
 import java.util.TimeZone;
 
@@ -29,19 +28,23 @@ public class HueConfig
 	private String localtime;
 	private String timezone;
 	private String zigbeechannel;
+	private String modelid;
+	private String bridgeid;
+	private Boolean factorynew;
+	private String replacesbridgeid;
 	private Map<String, WhitelistEntry> whitelist;
 
-	public static HueConfig createConfig(String name, String ipaddress, String devicetype, String userid) {
+	public static HueConfig createConfig(String name, String ipaddress, Map<String, WhitelistEntry> awhitelist, String emulateHubVersion, boolean isLinkButtonPressed, String emulateMAC) {
 		HueConfig aConfig = new HueConfig();
 	    SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss");
 	    SimpleDateFormat dateFormatGmt = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss");
 		dateFormatGmt.setTimeZone(TimeZone.getTimeZone("UTC"));
 		aConfig.setMac(HueConfig.getMacAddress(ipaddress));
-		aConfig.setApiversion("1.4.0");
+		aConfig.setApiversion(HueConstants.API_VERSION);
 		aConfig.setPortalservices(false);
 		aConfig.setGateway(ipaddress);
-		aConfig.setSwversion("01005215");
-		aConfig.setLinkbutton(false);
+		aConfig.setSwversion(emulateHubVersion);
+		aConfig.setLinkbutton(isLinkButtonPressed);
 		aConfig.setIpaddress(ipaddress);
 		aConfig.setProxyport(0);
 		aConfig.setSwupdate(Swupdate.createSwupdate());
@@ -53,8 +56,10 @@ public class HueConfig
 		aConfig.setLocaltime(dateFormat.format(new Date()));
 		aConfig.setTimezone(TimeZone.getDefault().getID());
 		aConfig.setZigbeechannel("6");
-		Map<String, WhitelistEntry> awhitelist = new HashMap<>();
-		awhitelist.put(userid, WhitelistEntry.createEntry(devicetype));
+		aConfig.setBridgeid(HuePublicConfig.createConfig(name, ipaddress, emulateHubVersion, emulateMAC).getHueBridgeIdFromMac());
+		aConfig.setModelid(HueConstants.MODEL_ID);
+		aConfig.setFactorynew(false);
+		aConfig.setReplacesbridgeid(null);
 		aConfig.setWhitelist(awhitelist);
 
 		return aConfig;
@@ -235,4 +240,36 @@ public class HueConfig
 	public void setZigbeechannel(String zigbeechannel) {
 		this.zigbeechannel = zigbeechannel;
 	}
+
+	public String getModelid() {
+		return modelid;
+	}
+
+	public void setModelid(String modelid) {
+		this.modelid = modelid;
+	}
+
+	public String getBridgeid() {
+		return bridgeid;
+	}
+
+	public void setBridgeid(String bridgeid) {
+		this.bridgeid = bridgeid;
+	}
+
+	public Boolean getFactorynew() {
+		return factorynew;
+	}
+
+	public void setFactorynew(Boolean factorynew) {
+		this.factorynew = factorynew;
+	}
+
+	public String getReplacesbridgeid() {
+		return replacesbridgeid;
+	}
+
+	public void setReplacesbridgeid(String replacesbridgeid) {
+		this.replacesbridgeid = replacesbridgeid;
+	}
 }

src/main/java/com/bwssystems/HABridge/api/hue/HueConstants.java

@@ -0,0 +1,8 @@
+package com.bwssystems.HABridge.api.hue;
+
+public class HueConstants {
+	public final static String HUB_VERSION = "9999999999";
+	public final static String API_VERSION = "1.19.0";
+	public final static String MODEL_ID = "BSB002";
+	public final static String UUID_PREFIX = "2f402f80-da50-11e1-9b23-";
+}

src/main/java/com/bwssystems/HABridge/api/hue/HueError.java

@@ -0,0 +1,19 @@
+package com.bwssystems.HABridge.api.hue;
+
+public class HueError {
+	
+	private HueErrorDetails error;
+
+	public HueError(HueErrorDetails error) {
+		super();
+		this.error = error;
+	}
+
+	public HueErrorDetails getError() {
+		return error;
+	}
+
+	public void setError(HueErrorDetails error) {
+		this.error = error;
+	}
+}

src/main/java/com/bwssystems/HABridge/api/hue/HueErrorDetails.java

@@ -0,0 +1,56 @@
+package com.bwssystems.HABridge.api.hue;
+
+public class HueErrorDetails {
+	private String type;
+	private String address;
+	private String description;
+	private String method_name;
+	private String resource_name;
+	private String value;
+	public HueErrorDetails(String type, String address, String description, String method_name, String resource_name,
+			String value) {
+		super();
+		this.type = type;
+		this.address = address;
+		this.description = description;
+		this.method_name = method_name;
+		this.resource_name = resource_name;
+		this.value = value;
+	}
+	public String getType() {
+		return type;
+	}
+	public void setType(String type) {
+		this.type = type;
+	}
+	public String getAddress() {
+		return address;
+	}
+	public void setAddress(String address) {
+		this.address = address;
+	}
+	public String getDescription() {
+		return description;
+	}
+	public void setDescription(String description) {
+		this.description = description;
+	}
+	public String getMethod_name() {
+		return method_name;
+	}
+	public void setMethod_name(String method_name) {
+		this.method_name = method_name;
+	}
+	public String getResource_name() {
+		return resource_name;
+	}
+	public void setResource_name(String resource_name) {
+		this.resource_name = resource_name;
+	}
+	public String getValue() {
+		return value;
+	}
+	public void setValue(String value) {
+		this.value = value;
+	}
+}

src/main/java/com/bwssystems/HABridge/api/hue/HueErrorResponse.java

@@ -0,0 +1,32 @@
+package com.bwssystems.HABridge.api.hue;
+
+import java.util.ArrayList;
+
+public class HueErrorResponse {
+	private ArrayList<HueError> theErrors;
+
+	public static HueErrorResponse createResponse(String type, String address, String description, String method_name, String resource_name, String value) {
+		HueErrorResponse theErrorResp = new HueErrorResponse();
+		theErrorResp.addError(new HueError(new HueErrorDetails(type, address, description, method_name, resource_name, value)));
+		return theErrorResp;
+	}
+	public HueErrorResponse() {
+		super();
+		theErrors = new ArrayList<HueError>();
+	}
+
+	public void addError(HueError anError) {
+		theErrors.add(anError);
+	}
+	
+	public HueError[] getTheErrors() {
+		HueError theList[] = new HueError[theErrors.size()];
+		theList = theErrors.toArray(theList);
+		return theList;
+	}
+
+	public void setTheErrors(ArrayList<HueError> theErrors) {
+		this.theErrors = theErrors;
+	}
+
+}

src/main/java/com/bwssystems/HABridge/api/hue/HuePublicConfig.java

@@ -0,0 +1,156 @@
+package com.bwssystems.HABridge.api.hue;
+
+import java.net.InetAddress;
+import java.net.NetworkInterface;
+import java.net.SocketException;
+import java.net.UnknownHostException;
+import java.util.StringTokenizer;
+
+
+public class HuePublicConfig
+{
+	private String name;
+	private String apiversion;
+	private String swversion;
+	private String mac;
+	private String bridgeid;
+	private String replacesbridgeid;
+	private Boolean factorynew;
+	private String modelid;
+
+	public static HuePublicConfig createConfig(String name, String ipaddress, String emulateHubVersion, String emulateMAC) {
+		HuePublicConfig aConfig = new HuePublicConfig();
+		aConfig.setMac(HuePublicConfig.getMacAddress(ipaddress, emulateMAC));
+		aConfig.setApiversion(HueConstants.API_VERSION);
+		aConfig.setSwversion(emulateHubVersion);
+		aConfig.setName(name);
+		aConfig.setBridgeid(aConfig.getHueBridgeIdFromMac());
+		aConfig.setModelid(HueConstants.MODEL_ID);
+		aConfig.setFactorynew(false);
+		aConfig.setReplacesbridgeid(null);
+
+		return aConfig;
+	}
+
+	private static String getMacAddress(String addr, String aMAC)
+	{
+		InetAddress ip;
+		StringBuilder sb = new StringBuilder();
+		if(aMAC == null || aMAC.trim().length() <= 0) {
+			try {
+					
+				ip = InetAddress.getByName(addr);
+				
+				NetworkInterface network = NetworkInterface.getByInetAddress(ip);
+					
+				byte[] mac = network.getHardwareAddress();
+					
+				for (int i = 0; i < mac.length; i++) {
+					sb.append(String.format("%02X%s", mac[i], (i < mac.length - 1) ? ":" : ""));		
+				}
+					
+			} catch (UnknownHostException e) {
+				
+				sb.append("00:00:88:00:bb:ee");
+				
+			} catch (SocketException e){
+					
+				sb.append("00:00:88:00:bb:ee");
+					
+			} catch (Exception e){
+				
+				sb.append("00:00:88:00:bb:ee");
+				
+			}
+		}
+		else {
+			sb.append(aMAC.trim());
+		}
+		    
+		return sb.toString();
+	}
+
+	public String getSNUUIDFromMac()
+	{
+    	StringTokenizer st = new StringTokenizer(this.getMac(), ":");
+    	String bridgeUUID = "";
+    	while(st.hasMoreTokens()) {
+    		bridgeUUID = bridgeUUID + st.nextToken();
+    	}
+    	bridgeUUID = bridgeUUID.toLowerCase();
+		return bridgeUUID.toLowerCase();
+	}
+
+	protected String getHueBridgeIdFromMac()
+	{
+		String cleanMac = this.getSNUUIDFromMac();
+    	String bridgeId = cleanMac.substring(0, 6) + "FFFE" + cleanMac.substring(6);
+		return bridgeId.toUpperCase();
+	}
+	
+	public String getMac() {
+		return mac;
+	}
+
+	public void setMac(String mac) {
+		this.mac = mac;
+	}
+
+	public String getSwversion() {
+		return swversion;
+	}
+
+	public void setSwversion(String swversion) {
+		this.swversion = swversion;
+	}
+
+	public String getName() {
+		return name;
+	}
+
+	public void setName(String name) {
+		this.name = name;
+	}
+
+
+	public String getApiversion() {
+		return apiversion;
+	}
+
+	public void setApiversion(String apiversion) {
+		this.apiversion = apiversion;
+	}
+
+
+	public String getModelid() {
+		return modelid;
+	}
+
+	public void setModelid(String modelid) {
+		this.modelid = modelid;
+	}
+
+	public String getBridgeid() {
+		return bridgeid;
+	}
+
+	public void setBridgeid(String bridgeid) {
+		this.bridgeid = bridgeid;
+	}
+
+	public Boolean getFactorynew() {
+		return factorynew;
+	}
+
+	public void setFactorynew(Boolean factorynew) {
+		this.factorynew = factorynew;
+	}
+
+	public String getReplacesbridgeid() {
+		return replacesbridgeid;
+	}
+
+	public void setReplacesbridgeid(String replacesbridgeid) {
+		this.replacesbridgeid = replacesbridgeid;
+	}
+}

src/main/java/com/bwssystems/HABridge/api/hue/StateChangeBody.java

@@ -0,0 +1,136 @@
+package com.bwssystems.HABridge.api.hue;
+
+// import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Created by arm on 4/14/15.
+ */
+public class StateChangeBody {
+    private boolean on;
+    private int bri;
+    private int hue;
+    private int sat;
+    private String effect;
+    private int ct;
+    private String alert;
+    private List<Double> xy;
+    private int transitiontime;
+    private int bri_inc;
+    private int hue_inc;
+    private int sat_inc;
+    private List<Double> xy_inc;
+    private int ct_inc;
+
+    public boolean isOn() {
+        return on;
+    }
+
+    public void setOn(boolean on) {
+        this.on = on;
+    }
+
+    public int getBri() {
+        return bri;
+    }
+
+    public void setBri(int bri) {
+        this.bri = bri;
+    }
+
+    public int getHue() {
+        return hue;
+    }
+
+    public void setHue(int hue) {
+        this.hue = hue;
+    }
+
+    public int getSat() {
+        return sat;
+    }
+
+    public void setSat(int sat) {
+        this.sat = sat;
+    }
+
+    public String getEffect() {
+        return effect;
+    }
+
+    public void setEffect(String effect) {
+        this.effect = effect;
+    }
+
+    public int getCt() {
+        return ct;
+    }
+
+    public void setCt(int ct) {
+        this.ct = ct;
+    }
+
+    public String getAlert() {
+        return alert;
+    }
+
+    public void setAlert(String alert) {
+        this.alert = alert;
+    }
+
+    public List<Double> getXy() {
+        return xy;
+    }
+
+    public void setXy(List<Double> xy) {
+        this.xy = xy;
+    }
+
+	public int getTransitiontime() {
+		return transitiontime;
+	}
+
+	public void setTransitiontime(int transitiontime) {
+		this.transitiontime = transitiontime;
+	}
+
+	public int getBri_inc() {
+		return bri_inc;
+	}
+
+	public void setBri_inc(int bri_inc) {
+		this.bri_inc = bri_inc;
+	}
+
+	public int getHue_inc() {
+		return hue_inc;
+	}
+
+	public void setHue_inc(int hue_inc) {
+		this.hue_inc = hue_inc;
+	}
+
+	public int getSat_inc() {
+		return sat_inc;
+	}
+
+	public void setSat_inc(int sat_inc) {
+		this.sat_inc = sat_inc;
+	}
+
+	public List<Double> getXy_inc() {
+		return xy_inc;
+	}
+
+	public void setXy_inc(List<Double> xy_inc) {
+		this.xy_inc = xy_inc;
+	}
+
+	public int getCt_inc() {
+		return ct_inc;
+	}
+
+	public void setCt_inc(int ct_inc) {
+		this.ct_inc = ct_inc;
+	}
+}

src/main/java/com/bwssystems/HABridge/api/hue/Swupdate.java

@@ -3,20 +3,36 @@ package com.bwssystems.HABridge.api.hue;
 
 public class Swupdate
 {
+	private Integer updatestate;
+	private Boolean checkforupdate;
+	private DeviceTypes devicetypes;
 	private String text;
 	private Boolean notify;
-	private Integer updatestate;
 	private String url;
 
 	public static Swupdate createSwupdate() {
 		Swupdate aSwupdate = new Swupdate();
+		aSwupdate.setUpdatestate(0);
+		aSwupdate.setCheckforupdate(false);
+		aSwupdate.setDevicetypes(new DeviceTypes());
 		aSwupdate.setNotify(false);
 		aSwupdate.setText("");
-		aSwupdate.setUpdatestate(0);
 		aSwupdate.setUrl("");
 		return aSwupdate;
 	}
 	
+	public Boolean getCheckforupdate() {
+		return checkforupdate;
+	}
+	public void setCheckforupdate(Boolean checkforupdate) {
+		this.checkforupdate = checkforupdate;
+	}
+	public DeviceTypes getDevicetypes() {
+		return devicetypes;
+	}
+	public void setDevicetypes(DeviceTypes devicetypes) {
+		this.devicetypes = devicetypes;
+	}
 	public String getText() {
 		return text;
 	}

src/main/java/com/bwssystems/HABridge/dao/DeviceDescriptor.java

@@ -11,6 +11,9 @@ public class DeviceDescriptor{
 	@SerializedName("id")
 	@Expose
 	private String id;
+	@SerializedName("uniqueid")
+	@Expose
+	private String uniqueid;
 	@SerializedName("name")
 	@Expose
     private String name;
@@ -35,6 +38,9 @@ public class DeviceDescriptor{
     @SerializedName("onUrl")
     @Expose
     private String onUrl;
+    @SerializedName("colorUrl")
+    @Expose
+    private String colorUrl;
     @SerializedName("headers")
     @Expose
     private String headers;
@@ -50,7 +56,29 @@ public class DeviceDescriptor{
     @SerializedName("contentBodyOff")
     @Expose
     private String contentBodyOff;
-
+    @SerializedName("contentBodyDim")
+    @Expose
+    private String contentBodyDim;
+    @SerializedName("inactive")
+    @Expose
+    private boolean inactive;
+    @SerializedName("noState")
+    @Expose
+    private boolean noState;
+    @SerializedName("offState")
+    @Expose
+    private boolean offState;
+    @SerializedName("requesterAddress")
+    @Expose
+    private String requesterAddress;
+    @SerializedName("description")
+    @Expose
+    private String description;
+    @SerializedName("comments")
+    @Expose
+    private String comments;
+    @SerializedName("deviceState")
+    @Expose
     private DeviceState deviceState;
     
     public String getName() {
@@ -117,6 +145,14 @@ public class DeviceDescriptor{
         this.onUrl = onUrl;
     }
 
+    public String getColorUrl() {
+        return colorUrl;
+    }
+
+    public void setColorUrl(String colorUrl) {
+        this.colorUrl = colorUrl;
+    }
+
     public String getId() {
         return id;
     }
@@ -125,6 +161,14 @@ public class DeviceDescriptor{
         this.id = id;
     }
 
+	public String getUniqueid() {
+		return uniqueid;
+	}
+
+	public void setUniqueid(String uniqueid) {
+		this.uniqueid = uniqueid;
+	}
+
 	public String getHeaders() {
 		return headers;
 	}
@@ -165,7 +209,17 @@ public class DeviceDescriptor{
 		this.contentBodyOff = contentBodyOff;
 	}
 
+	public String getContentBodyDim() {
+		return contentBodyDim;
+	}
+
+	public void setContentBodyDim(String contentBodyDim) {
+		this.contentBodyDim = contentBodyDim;
+	}
+
 	public DeviceState getDeviceState() {
+		if(deviceState == null)
+			deviceState = DeviceState.createDeviceState(this.isColorDevice());
 		return deviceState;
 	}
 
@@ -173,4 +227,88 @@ public class DeviceDescriptor{
 		this.deviceState = deviceState;
 	}
 
-}
+	public boolean isInactive() {
+		return inactive;
+	}
+
+	public void setInactive(boolean inactive) {
+		this.inactive = inactive;
+	}
+
+	public boolean isNoState() {
+		return noState;
+	}
+
+	public void setNoState(boolean noState) {
+		this.noState = noState;
+	}
+
+	public boolean isOffState() {
+		return offState;
+	}
+
+	public void setOffState(boolean offState) {
+		this.offState = offState;
+	}
+
+	public String getRequesterAddress() {
+		return requesterAddress;
+	}
+
+	public void setRequesterAddress(String requesterAddress) {
+		this.requesterAddress = requesterAddress;
+	}
+
+	public String getDescription() {
+		return description;
+	}
+
+	public void setDescription(String description) {
+		this.description = description;
+	}
+
+	public String getComments() {
+		return comments;
+	}
+
+	public void setComments(String comments) {
+		this.comments = comments;
+	}
+
+	public boolean containsType(String aType) {
+		if(aType == null)
+			return false;
+		
+		if(this.mapType != null && this.mapType.contains(aType))
+			return true;
+		
+		if(this.deviceType != null && this.deviceType.contains(aType))
+			return true;
+		
+		if(this.onUrl != null && this.onUrl.contains(aType))
+			return true;
+		
+		if(this.dimUrl != null && this.dimUrl.contains(aType))
+			return true;
+		
+		if(this.offUrl != null && this.offUrl.contains(aType))
+			return true;
+
+		if(this.colorUrl != null && this.colorUrl.contains(aType))
+			return true;
+		
+		return false;
+	}
+
+	public boolean isColorDevice() {
+        boolean color = true;
+        if ((deviceType == null || !deviceType.trim().equals("passthru")) && (colorUrl == null || colorUrl.trim().equals(""))) {
+            color = false;
+        } else if (deviceType != null && deviceType.trim().equals("passthru")) {
+            if (deviceState != null && (deviceState.getColormode() == null || deviceState.getColormode().equals(""))) {
+                color = false;
+            }
+        }
+        return color;
+	}
+}

src/main/java/com/bwssystems/HABridge/dao/DeviceRepository.java

@@ -2,6 +2,7 @@ package com.bwssystems.HABridge.dao;
 
 
 import java.io.IOException;
+import java.math.BigInteger;
 import java.nio.file.FileSystems;
 import java.nio.file.Files;
 import java.nio.file.Path;
@@ -9,18 +10,29 @@ import java.nio.file.Paths;
 import java.nio.file.StandardOpenOption;
 import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.Iterator;
 import java.util.Map;
-import java.util.Random;
+
+import javax.xml.bind.DatatypeConverter;
+
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import com.bwssystems.HABridge.DeviceMapTypes;
+import com.bwssystems.HABridge.api.CallItem;
+import com.bwssystems.HABridge.api.hue.DeviceResponse;
 import com.bwssystems.HABridge.dao.DeviceDescriptor;
-import com.bwssystems.util.BackupHandler;
-import com.bwssystems.util.JsonTransformer;
+import com.bwssystems.HABridge.plugins.hue.HueHome;
+import com.bwssystems.HABridge.util.BackupHandler;
+import com.bwssystems.HABridge.util.JsonTransformer;
 import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;
+import com.google.gson.JsonSyntaxException;
 
+import java.util.Collection;
 import java.util.List;
+import java.util.Arrays;
+
 /*
  * This is an in memory list to manage the configured devices and saves the list as a JSON string to a file for later  
  * loading.
@@ -29,7 +41,7 @@ public class DeviceRepository extends BackupHandler {
 	private Map<String, DeviceDescriptor> devices;
     private Path repositoryPath;
 	private Gson gson;
-    final private Random random = new Random();
+    private Integer nextId;
     private Logger log = LoggerFactory.getLogger(DeviceRepository.class);
 	
     public DeviceRepository(String deviceDb) {
@@ -41,6 +53,7 @@ public class DeviceRepository extends BackupHandler {
 		repositoryPath = null;
 		repositoryPath = Paths.get(deviceDb);
 		setupParams(repositoryPath, ".bk", "device.db-");
+		nextId = 0;
 		_loadRepository(repositoryPath);
 	}
     
@@ -56,7 +69,11 @@ public class DeviceRepository extends BackupHandler {
 		{
 			DeviceDescriptor list[] = gson.fromJson(jsonContent, DeviceDescriptor[].class);
 			for(int i = 0; i < list.length; i++) {
+				list[i].setDeviceState(null);
 				put(list[i].getId(), list[i]);
+				if(Integer.decode(list[i].getId()) > nextId) {
+					nextId = Integer.decode(list[i].getId());
+				}
 			}
 		}    	
     }
@@ -66,11 +83,85 @@ public class DeviceRepository extends BackupHandler {
 		return list;
 	}
 
-	public List<DeviceDescriptor> findByDeviceType(String aType) {
-		List<DeviceDescriptor> list = new ArrayList<DeviceDescriptor>(devices.values());
+	public List<DeviceDescriptor> findActive() {
+		List<DeviceDescriptor> list = new ArrayList<DeviceDescriptor>();
+		for(DeviceDescriptor aDevice : new ArrayList<DeviceDescriptor>(devices.values())) {
+			if(!aDevice.isInactive())
+				list.add(aDevice);
+		}
 		return list;
 	}
-	
+
+	public List<DeviceDescriptor> findAllByRequester(String anAddress) {
+		List<DeviceDescriptor> list = new ArrayList<DeviceDescriptor>(devices.values());
+		return findAllByRequester(anAddress, list);
+	}
+
+	private List<DeviceDescriptor> findAllByRequester(String anAddress, Collection<DeviceDescriptor> list) {
+		List<DeviceDescriptor> theReturnList = new ArrayList<DeviceDescriptor>();
+		Iterator<DeviceDescriptor> anIterator = list.iterator();
+		DeviceDescriptor theDevice;
+		String theRequesterAddress;
+
+		HashMap<String,String > addressMap;
+		while (anIterator.hasNext()) {
+			theDevice = anIterator.next();
+			theRequesterAddress = theDevice.getRequesterAddress();
+			addressMap = new HashMap<String, String>();
+			if(theRequesterAddress != null) {
+				if (theRequesterAddress.contains(",")) {
+					String[] theArray = theRequesterAddress.split(",");
+					for (String v : theArray) {
+						addressMap.put(v.trim(), v.trim());
+					}
+				} else
+					addressMap.put(theRequesterAddress, theRequesterAddress);
+			}
+			if (theRequesterAddress == null || theRequesterAddress.length() == 0 || addressMap.containsKey(anAddress))
+				theReturnList.add(theDevice);
+		}
+		return theReturnList;
+	}
+
+	public Map<String, DeviceResponse> findAllByGroupWithState(String[] lightsInGroup, String anAddress, HueHome myHueHome, Gson aGsonBuilder) {
+		return findAllByGroupWithState(lightsInGroup, anAddress, myHueHome, aGsonBuilder, false);
+	}
+
+	public Map<String, DeviceResponse> findAllByGroupWithState(String[] lightsInGroup, String anAddress, HueHome myHueHome, Gson aGsonBuilder, boolean ignoreAddress) {
+		Map<String, DeviceResponse> deviceResponseMap = new HashMap<String, DeviceResponse>();
+		Map<String, DeviceDescriptor> lights = new HashMap<String, DeviceDescriptor>(devices);
+		lights.keySet().retainAll(Arrays.asList(lightsInGroup));
+		for (DeviceDescriptor light : (ignoreAddress ? lights.values() : findAllByRequester(anAddress, lights.values()))) {
+			DeviceResponse deviceResponse = null;
+			if(!light.isInactive()) {
+				if (light.containsType(DeviceMapTypes.HUE_DEVICE[DeviceMapTypes.typeIndex])) {
+					CallItem[] callItems = null;
+					try {
+						if(light.getOnUrl() != null)
+							callItems = aGsonBuilder.fromJson(light.getOnUrl(), CallItem[].class);
+					} catch(JsonSyntaxException e) {
+						log.warn("Could not decode Json for url items to get Hue state for device: " + light.getName());
+						callItems = null;
+					}
+
+					for (int i = 0; callItems != null && i < callItems.length; i++) {
+						if((callItems[i].getType() != null && callItems[i].getType().equals(DeviceMapTypes.HUE_DEVICE[DeviceMapTypes.typeIndex])) ||
+									(callItems[i].getItem() != null && callItems[i].getItem().getAsString() != null && callItems[i].getItem().getAsString().contains("hueName"))) {
+							deviceResponse = myHueHome.getHueDeviceInfo(callItems[i], light);
+							i = callItems.length;
+						}
+					}
+				}
+				
+				if (deviceResponse == null) {
+					deviceResponse = DeviceResponse.createResponse(light);
+				}
+				deviceResponseMap.put(light.getId(), deviceResponse);	
+			}
+		}
+		return (deviceResponseMap.size() == 0) ? null : deviceResponseMap;
+	}
+
 	public DeviceDescriptor findOne(String id) {
     	return devices.get(id);	
     }
@@ -84,8 +175,17 @@ public class DeviceRepository extends BackupHandler {
 		for(int i = 0; i < descriptors.length; i++) {
 	        if(descriptors[i].getId() != null && descriptors[i].getId().length() > 0)
 	        	devices.remove(descriptors[i].getId());
-	        else
-	        	descriptors[i].setId(String.valueOf(random.nextInt(Integer.MAX_VALUE)));
+	        else {
+	        	nextId++;
+	        	descriptors[i].setId(String.valueOf(nextId));
+	        }
+	        if(descriptors[i].getUniqueid() == null || descriptors[i].getUniqueid().length() == 0) {
+	        	BigInteger bigInt = BigInteger.valueOf(Integer.decode(descriptors[i].getId()));
+	        	byte[] theBytes = bigInt.toByteArray();
+	        	String hexValue = DatatypeConverter.printHexBinary(theBytes);
+
+	        	descriptors[i].setUniqueid("00:17:88:5E:D3:" + hexValue + "-" + hexValue);
+	        }
 	        put(descriptors[i].getId(), descriptors[i]);
 	        theNames = theNames + " " + descriptors[i].getName() + ", ";
 		}
@@ -94,6 +194,28 @@ public class DeviceRepository extends BackupHandler {
         log.debug("Save device(s): " + theNames);
     }
     
+	public void renumber() {
+		List<DeviceDescriptor> list = new ArrayList<DeviceDescriptor>(devices.values());
+		Iterator<DeviceDescriptor> deviceIterator = list.iterator();
+		Map<String, DeviceDescriptor> newdevices = new HashMap<String, DeviceDescriptor>();;
+		nextId = 0;
+        log.debug("Renumber devices.");
+		while(deviceIterator.hasNext()) {
+        	nextId++;
+			DeviceDescriptor theDevice = deviceIterator.next();
+        	theDevice.setId(String.valueOf(nextId));
+        	BigInteger bigInt = BigInteger.valueOf(nextId);
+        	byte[] theBytes = bigInt.toByteArray();
+        	String hexValue = DatatypeConverter.printHexBinary(theBytes);
+       	
+        	theDevice.setUniqueid("00:17:88:5E:D3:" + hexValue + "-" + hexValue);
+	        newdevices.put(theDevice.getId(), theDevice);
+		}
+        devices = newdevices;
+    	String  jsonValue = gson.toJson(findAll());
+        repositoryWriter(jsonValue, repositoryPath);
+    }
+    
 	public String delete(DeviceDescriptor aDescriptor) {
         if (aDescriptor != null) {
         	devices.remove(aDescriptor.getId());

src/main/java/com/bwssystems/HABridge/dao/GroupDescriptor.java

@@ -0,0 +1,147 @@
+package com.bwssystems.HABridge.dao;
+
+import com.bwssystems.HABridge.api.hue.DeviceState;
+import com.google.gson.annotations.Expose;
+import com.google.gson.annotations.SerializedName;
+import com.bwssystems.HABridge.api.hue.GroupState;
+
+/*
+ * Object to handle the device configuration
+ */
+public class GroupDescriptor{
+	@SerializedName("id")
+	@Expose
+	private String id;
+	@SerializedName("name")
+	@Expose
+    private String name;
+    @SerializedName("groupType")
+	@Expose
+    private String groupType;
+    @SerializedName("groupClass")
+	@Expose
+    private String groupClass;
+    @SerializedName("requesterAddress")
+    @Expose
+    private String requesterAddress;
+    @SerializedName("inactive")
+    @Expose
+    private boolean inactive;
+	@SerializedName("description")
+    @Expose
+    private String description;
+    @SerializedName("comments")
+    @Expose
+    private String comments;
+    
+    private DeviceState action;
+    private GroupState groupState;
+    
+    @SerializedName("lights")
+    @Expose
+    private String[] lights;
+    @SerializedName("exposeAsLight")
+    @Expose
+    private String exposeAsLight;
+    
+    
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public String getGroupType() {
+        return groupType;
+    }
+
+    public void setGroupType(String groupType) {
+        this.groupType = groupType;
+    }
+
+    public String getGroupClass() {
+        return groupClass;
+    }
+
+    public void setGroupClass(String groupClass) {
+        this.groupClass = groupClass;
+    }
+
+    public String getId() {
+        return id;
+    }
+
+    public void setId(String id) {
+        this.id = id;
+    }
+
+	public GroupState getGroupState() {
+		if(groupState == null)
+			groupState = new GroupState(false,false);
+		return groupState;
+	}
+
+	public void setGroupState(GroupState groupState) {
+		this.groupState = groupState;
+	}
+
+	public DeviceState getAction() {
+		if(action == null)
+			action = DeviceState.createDeviceState(true);
+		return action;
+	}
+
+	public void setAction(DeviceState action) {
+		this.action = action;
+	}
+
+	public boolean isInactive() {
+		return inactive;
+	}
+
+	public void setInactive(boolean inactive) {
+		this.inactive = inactive;
+	}
+
+	public String getRequesterAddress() {
+		return requesterAddress;
+	}
+
+	public void setRequesterAddress(String requesterAddress) {
+		this.requesterAddress = requesterAddress;
+	}
+
+	public String getDescription() {
+		return description;
+	}
+
+	public void setDescription(String description) {
+		this.description = description;
+	}
+
+	public String getComments() {
+		return comments;
+	}
+
+	public void setComments(String comments) {
+		this.comments = comments;
+	}
+
+	public String[] getLights() {
+		return lights;
+	}
+
+	public void setLights(String[] lights) {
+		this.lights = lights;
+	}
+
+	public void setExposeAsLight(String exposeFor) {
+		this.exposeAsLight = exposeFor;
+	}
+
+	public String getExposeAsLight() {
+		return exposeAsLight;
+	}
+}

src/main/java/com/bwssystems/HABridge/dao/GroupRepository.java

@@ -0,0 +1,220 @@
+package com.bwssystems.HABridge.dao;
+
+
+import java.io.IOException;
+import java.nio.file.FileSystems;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.bwssystems.HABridge.dao.GroupDescriptor;
+import com.bwssystems.HABridge.util.BackupHandler;
+import com.bwssystems.HABridge.util.JsonTransformer;
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+
+import java.util.List;
+/*
+ * This is an in memory list to manage the configured groups and saves the list as a JSON string to a file for later  
+ * loading.
+ */
+public class GroupRepository extends BackupHandler {
+	private Map<String, GroupDescriptor> groups;
+    private Path repositoryPath;
+	private Gson gson;
+    private Integer nextId;
+    private Logger log = LoggerFactory.getLogger(GroupRepository.class);
+	
+    public GroupRepository(String groupDb) {
+		super();
+		gson =
+                new GsonBuilder()
+                .excludeFieldsWithoutExposeAnnotation()
+                .create();
+        nextId = 0;
+		try {
+			repositoryPath = null;
+			repositoryPath = Paths.get(groupDb);
+			setupParams(repositoryPath, ".bk", "group.db-");
+			_loadRepository(repositoryPath);
+		} catch (Exception ex) {
+			groups = new HashMap<String, GroupDescriptor>();
+		}
+	}
+    
+    public void loadRepository() {
+    	if(repositoryPath != null)
+    		_loadRepository(repositoryPath);
+    }
+	private void _loadRepository(Path aPath){
+		String jsonContent = repositoryReader(aPath);
+		groups = new HashMap<String, GroupDescriptor>();
+		
+		if(jsonContent != null)
+		{
+			GroupDescriptor list[] = gson.fromJson(jsonContent, GroupDescriptor[].class);
+			for(int i = 0; i < list.length; i++) {
+				list[i].setGroupState(null);
+				put(list[i].getId(), list[i]);
+				if(Integer.decode(list[i].getId()) > nextId) {
+					nextId = Integer.decode(list[i].getId());
+				}
+			}
+		}    	
+    }
+    
+	public List<GroupDescriptor> findAll() {
+		List<GroupDescriptor> list = new ArrayList<GroupDescriptor>(groups.values());
+		return list;
+	}
+
+	public List<GroupDescriptor> findActive() {
+		List<GroupDescriptor> list = new ArrayList<GroupDescriptor>();
+		for(GroupDescriptor aGroup : new ArrayList<GroupDescriptor>(groups.values())) {
+			if(!aGroup.isInactive())
+				list.add(aGroup);
+		}
+		return list;
+	}
+
+	public List<GroupDescriptor> findAllByRequester(String anAddress) {
+		List<GroupDescriptor> list = new ArrayList<GroupDescriptor>(groups.values());
+		List<GroupDescriptor> theReturnList = new ArrayList<GroupDescriptor>();
+		Iterator<GroupDescriptor> anIterator = list.iterator();
+		GroupDescriptor theGroup;
+		String theRequesterAddress;
+
+		HashMap<String,String > addressMap;
+		while (anIterator.hasNext()) {
+			theGroup = anIterator.next();
+			theRequesterAddress = theGroup.getRequesterAddress();
+			addressMap = new HashMap<String, String>();
+			if(theRequesterAddress != null) {
+				if (theRequesterAddress.contains(",")) {
+					String[] theArray = theRequesterAddress.split(",");
+					for (String v : theArray) {
+						addressMap.put(v.trim(), v.trim());
+					}
+				} else
+					addressMap.put(theRequesterAddress, theRequesterAddress);
+			}
+			if (theRequesterAddress == null || theRequesterAddress.length() == 0 || addressMap.containsKey(anAddress))
+				theReturnList.add(theGroup);
+		}
+		return theReturnList;
+	}
+
+	public List<GroupDescriptor> findVirtualLights(String anAddress) {
+		List<GroupDescriptor> list = new ArrayList<GroupDescriptor>();
+		for (GroupDescriptor group : groups.values()) {
+			String expose = group.getExposeAsLight();
+			if (expose != null && expose.contains(anAddress)) {
+				list.add(group);
+			}
+		}
+		return list;
+	}
+
+	public GroupDescriptor findOne(String id) {
+    	return groups.get(id);	
+    }
+    
+	private void put(String id, GroupDescriptor aDescriptor) {
+        groups.put(id, aDescriptor);
+    }
+    
+    public void save() {
+    	save(groups.values().toArray(new GroupDescriptor[0]));
+    }
+
+	public void save(GroupDescriptor[] descriptors) {
+		String theNames = "";
+		for(int i = 0; i < descriptors.length; i++) {
+	        if(descriptors[i].getId() != null && descriptors[i].getId().length() > 0)
+	        	groups.remove(descriptors[i].getId());
+	        else {
+	        	nextId++;
+	        	descriptors[i].setId(String.valueOf(nextId));
+	        }
+	        
+	        put(descriptors[i].getId(), descriptors[i]);
+	        theNames = theNames + " " + descriptors[i].getName() + ", ";
+		}
+    	String  jsonValue = gson.toJson(findAll());
+        repositoryWriter(jsonValue, repositoryPath);
+        log.debug("Save group(s): " + theNames);
+    }
+
+    public Integer getNewId() {
+    	return nextId + 1;
+    }
+
+    public String delete(GroupDescriptor aDescriptor) {
+        if (aDescriptor != null) {
+        	groups.remove(aDescriptor.getId());
+        	JsonTransformer aRenderer = new JsonTransformer();
+        	String  jsonValue = aRenderer.render(findAll());
+            repositoryWriter(jsonValue, repositoryPath);
+            return "Group with id '" + aDescriptor.getId() + "' deleted";
+        } else {
+            return "Group not found";
+        }
+
+    }
+	
+	private void repositoryWriter(String content, Path filePath) {
+		if(Files.exists(filePath) && !Files.isWritable(filePath)){
+			log.error("Error file is not writable: " + filePath);
+			return;
+		}
+		
+		if(Files.notExists(filePath.getParent())) {
+			try {
+				Files.createDirectories(filePath.getParent());
+			} catch (IOException e) {
+				log.error("Error creating the directory: " + filePath + " message: " + e.getMessage(), e);
+			}
+		}
+
+		try {
+			Path target = null;
+			if(Files.exists(filePath)) {
+				target = FileSystems.getDefault().getPath(filePath.getParent().toString(), "group.db.old");
+				Files.move(filePath, target);
+			}
+			Files.write(filePath, content.getBytes(), StandardOpenOption.CREATE);
+			if(target != null)
+				Files.delete(target);
+		} catch (IOException e) {
+			log.error("Error writing the file: " + filePath + " message: " + e.getMessage(), e);
+		}
+	}
+	
+	private String repositoryReader(Path filePath) {
+
+		String content = null;
+		if(Files.notExists(filePath) || !Files.isReadable(filePath)){
+			log.warn("Error reading the file: " + filePath + " - Does not exist or is not readable. continuing...");
+			return null;
+		}
+
+		
+		try {
+			content = new String(Files.readAllBytes(filePath));
+		} catch (IOException e) {
+			log.error("Error reading the file: " + filePath + " message: " + e.getMessage(), e);
+		}
+		
+		return content;
+	}
+
+
+}

src/main/java/com/bwssystems/HABridge/devicemanagmeent/DeviceResource.java

@@ -1,9 +1,11 @@
 package com.bwssystems.HABridge.devicemanagmeent;
 
 import static spark.Spark.get;
+import static spark.Spark.halt;
 import static spark.Spark.options;
 import static spark.Spark.post;
 import static spark.Spark.put;
+import static spark.Spark.before;
 import static spark.Spark.delete;
 
 import java.util.Arrays;
@@ -15,19 +17,20 @@ import org.apache.http.HttpStatus;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import com.bwssystems.HABridge.BridgeSettingsDescriptor;
+import com.bwssystems.HABridge.BridgeSettings;
+import com.bwssystems.HABridge.DeviceMapTypes;
+import com.bwssystems.HABridge.HomeManager;
+import com.bwssystems.HABridge.User;
+import com.bwssystems.HABridge.api.CallItem;
 import com.bwssystems.HABridge.dao.BackupFilename;
 import com.bwssystems.HABridge.dao.DeviceDescriptor;
 import com.bwssystems.HABridge.dao.DeviceRepository;
+import com.bwssystems.HABridge.dao.GroupRepository;
 import com.bwssystems.HABridge.dao.ErrorMessage;
-import com.bwssystems.NestBridge.NestHome;
-import com.bwssystems.harmony.HarmonyHome;
-import com.bwssystems.hue.HueHome;
-import com.bwssystems.luupRequests.Device;
-import com.bwssystems.luupRequests.Scene;
-import com.bwssystems.util.JsonTransformer;
-import com.bwssystems.vera.VeraHome;
+import com.bwssystems.HABridge.util.JsonTransformer;
 import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import com.google.gson.JsonSyntaxException;
 
 /**
 	spark core server for bridge configuration
@@ -36,43 +39,40 @@ public class DeviceResource {
     private static final String API_CONTEXT = "/api/devices";
     private static final Logger log = LoggerFactory.getLogger(DeviceResource.class);
     private DeviceRepository deviceRepository;
-    private VeraHome veraHome;
-    private HarmonyHome myHarmonyHome;
-    private NestHome nestHome;
-    private HueHome hueHome;
+    private GroupRepository groupRepository;
+    private HomeManager homeManager;
+    private BridgeSettings bridgeSettings;
+	private Gson aGsonHandler;
     private static final Set<String> supportedVerbs = new HashSet<>(Arrays.asList("get", "put", "post"));
 
-	public DeviceResource(BridgeSettingsDescriptor theSettings, HarmonyHome theHarmonyHome, NestHome aNestHome, HueHome aHueHome) {
-		this.deviceRepository = new DeviceRepository(theSettings.getUpnpDeviceDb());
-
-		if(theSettings.isValidVera())
-			this.veraHome = new VeraHome(theSettings);
-		else
-			this.veraHome = null;
-		
-		if(theSettings.isValidHarmony())
-			this.myHarmonyHome = theHarmonyHome;
-		else
-			this.myHarmonyHome = null;
-		
-		if(theSettings.isValidNest())
-			this.nestHome = aNestHome;
-		else
-			this.nestHome = null;
-
-		if(theSettings.isValidHue())
-			this.hueHome = aHueHome;
-		else
-			this.hueHome = null;
-        setupEndpoints();
+	public DeviceResource(BridgeSettings theSettings, HomeManager aHomeManager) {
+		bridgeSettings = theSettings;
+		this.deviceRepository = new DeviceRepository(bridgeSettings.getBridgeSettingsDescriptor().getUpnpDeviceDb());
+		this.groupRepository = new GroupRepository(bridgeSettings.getBridgeSettingsDescriptor().getUpnpGroupDb());
+		homeManager = aHomeManager;
+		aGsonHandler = new GsonBuilder().create();
+		setupEndpoints();
 	}
 
 	public DeviceRepository getDeviceRepository() {
 		return deviceRepository;
 	}
 
+	public GroupRepository getGroupRepository() {
+		return groupRepository;
+	}
+
     private void setupEndpoints() {
     	log.info("HABridge device management service started.... ");
+		before(API_CONTEXT + "/*", (request, response) -> {
+			// This never gets called as the HueMulator class covers this path. This is here for backup
+			if(bridgeSettings.getBridgeSecurity().isSecure()) {
+					User authUser = bridgeSettings.getBridgeSecurity().getAuthenticatedUser(request);
+					if(authUser == null) {
+						halt(401, "{\"message\":\"User not authenticated\"}");
+					}
+			}
+		});
 	    // http://ip_address:port/api/devices CORS request
 	    options(API_CONTEXT, "application/json", (request, response) -> {
 	        response.status(HttpStatus.SC_OK);
@@ -91,14 +91,54 @@ public class DeviceResource {
 	    	else {
 	    		devices = new Gson().fromJson("[" + request.body() + "]", DeviceDescriptor[].class);
 	    	}
+			@SuppressWarnings("unused")
+			CallItem[] callItems = null;
+			String errorMessage = null;
 	    	for(int i = 0; i < devices.length; i++) {
 		    	if(devices[i].getContentBody() != null ) {
 		            if (devices[i].getContentType() == null || devices[i].getHttpVerb() == null || !supportedVerbs.contains(devices[i].getHttpVerb().toLowerCase())) {
 		            	response.status(HttpStatus.SC_BAD_REQUEST);
-						log.debug("Bad http verb in create a Device(s): " + request.body());
-						return new ErrorMessage("Bad http verb in create a Device(s): " + request.body() + " ");
+		            	errorMessage = "Bad http verb in create device(s) for name: " + devices[i].getName() + " with verb: " + devices[i].getHttpVerb();
+						log.debug(errorMessage);
+						return new ErrorMessage(errorMessage);
 		            }
 		        }
+				try {
+					if(devices[i].getOnUrl() != null && !devices[i].getOnUrl().isEmpty())
+						callItems = aGsonHandler.fromJson(devices[i].getOnUrl(), CallItem[].class);
+				} catch(JsonSyntaxException e) {
+	            	response.status(HttpStatus.SC_BAD_REQUEST);
+	            	errorMessage = "Bad on URL JSON in create device(s) for name: " + devices[i].getName() + " with on URL: " + devices[i].getOnUrl();
+					log.debug(errorMessage);
+					return new ErrorMessage(errorMessage);
+				}
+				try {
+					if(devices[i].getDimUrl() != null && !devices[i].getDimUrl().isEmpty())
+						callItems = aGsonHandler.fromJson(devices[i].getDimUrl(), CallItem[].class);
+				} catch(JsonSyntaxException e) {
+	            	response.status(HttpStatus.SC_BAD_REQUEST);
+	            	errorMessage = "Bad dim URL JSON in create device(s) for name: " + devices[i].getName() + " with dim URL: " + devices[i].getDimUrl();
+					log.debug(errorMessage);
+					return new ErrorMessage(errorMessage);
+				}
+				try {
+					if(devices[i].getOffUrl() != null && !devices[i].getOffUrl().isEmpty())
+						callItems = aGsonHandler.fromJson(devices[i].getOffUrl(), CallItem[].class);
+				} catch(JsonSyntaxException e) {
+	            	response.status(HttpStatus.SC_BAD_REQUEST);
+	            	errorMessage = "Bad off URL JSON in create device(s) for name: " + devices[i].getName() + " with off URL: " + devices[i].getOffUrl();
+					log.debug(errorMessage);
+					return new ErrorMessage(errorMessage);
+				}
+				try {
+					if(devices[i].getColorUrl() != null && !devices[i].getColorUrl().isEmpty())
+						callItems = aGsonHandler.fromJson(devices[i].getColorUrl(), CallItem[].class);
+				} catch(JsonSyntaxException e) {
+	            	response.status(HttpStatus.SC_BAD_REQUEST);
+	            	errorMessage = "Bad color URL JSON in create device(s) for name: " + devices[i].getName() + " with color URL: " + devices[i].getColorUrl();
+					log.debug(errorMessage);
+					return new ErrorMessage(errorMessage);
+				}
 	    	}
 
 	    	deviceRepository.save(devices);
@@ -182,84 +222,111 @@ public class DeviceResource {
 
     	get (API_CONTEXT + "/vera/devices", "application/json", (request, response) -> {
 	    	log.debug("Get vera devices");
-	        if(veraHome == null){
-				response.status(HttpStatus.SC_NOT_FOUND);
-				return new ErrorMessage("A Vera is not available.");
-	        }
-	        List<Device> theDevices = veraHome.getDevices();
-	        if(theDevices == null) {
-	        	response.status(HttpStatus.SC_SERVICE_UNAVAILABLE);
-	        	return new ErrorMessage("A Vera request failed to get devices. Check your Vera IP addresses.");
-	        }
-	        else
-	        	response.status(HttpStatus.SC_OK);
-	        return theDevices;
+        	response.status(HttpStatus.SC_OK);
+	        return homeManager.findResource(DeviceMapTypes.VERA_DEVICE[DeviceMapTypes.typeIndex]).getItems(DeviceMapTypes.VERA_DEVICE[DeviceMapTypes.typeIndex]);
 	    }, new JsonTransformer());
 
     	get (API_CONTEXT + "/vera/scenes", "application/json", (request, response) -> {
 	    	log.debug("Get vera scenes");
-	        if(veraHome == null){
-				response.status(HttpStatus.SC_NOT_FOUND);
-				return new ErrorMessage("A Vera is not available.");
-	        }
-	        List<Scene> theScenes = veraHome.getScenes();
-	        if(theScenes == null) {
-	        	response.status(HttpStatus.SC_SERVICE_UNAVAILABLE);
-	        	return new ErrorMessage("A Vera is not available and failed to get scenes. Check your Vera IP addresses.");
-	        }
-	        else
-	        	response.status(HttpStatus.SC_OK);
-	        return theScenes;
+	        response.status(HttpStatus.SC_OK);
+	        return homeManager.findResource(DeviceMapTypes.VERA_DEVICE[DeviceMapTypes.typeIndex]).getItems(DeviceMapTypes.VERA_SCENE[DeviceMapTypes.typeIndex]);
+	    }, new JsonTransformer());
+    	
+    	get (API_CONTEXT + "/fibaro/devices", "application/json", (request, response) -> {
+	    	log.debug("Get fibaro devices");
+        	response.status(HttpStatus.SC_OK);
+	        return homeManager.findResource(DeviceMapTypes.FIBARO_DEVICE[DeviceMapTypes.typeIndex]).getItems(DeviceMapTypes.FIBARO_DEVICE[DeviceMapTypes.typeIndex]);
+	    }, new JsonTransformer());
+
+    	get (API_CONTEXT + "/fibaro/scenes", "application/json", (request, response) -> {
+	    	log.debug("Get fibaro scenes");
+	        response.status(HttpStatus.SC_OK);
+	        return homeManager.findResource(DeviceMapTypes.FIBARO_DEVICE[DeviceMapTypes.typeIndex]).getItems(DeviceMapTypes.FIBARO_SCENE[DeviceMapTypes.typeIndex]);
 	    }, new JsonTransformer());
 
     	get (API_CONTEXT + "/harmony/activities", "application/json", (request, response) -> {
 	    	log.debug("Get harmony activities");
-	      	if(myHarmonyHome == null) {
-				response.status(HttpStatus.SC_NOT_FOUND);
-				return new ErrorMessage("A Harmony is not available.");	      		
-	      	}
 	      	response.status(HttpStatus.SC_OK);
-	      	return myHarmonyHome.getActivities();
+	      	return homeManager.findResource(DeviceMapTypes.HARMONY_ACTIVITY[DeviceMapTypes.typeIndex]).getItems(DeviceMapTypes.HARMONY_ACTIVITY[DeviceMapTypes.typeIndex]);
 	    }, new JsonTransformer());
 
     	get (API_CONTEXT + "/harmony/show", "application/json", (request, response) -> {
 	    	log.debug("Get harmony current activity");
-	      	if(myHarmonyHome == null) {
-	      		response.status(HttpStatus.SC_NOT_FOUND);
-	      		return new ErrorMessage("A Harmony is not available.");	
-	      	}
-	      	response.status(HttpStatus.SC_OK);
-      		return myHarmonyHome.getCurrentActivities();
+      		return homeManager.findResource(DeviceMapTypes.HARMONY_ACTIVITY[DeviceMapTypes.typeIndex]).getItems("current_activity");
 	    }, new JsonTransformer());
 
     	get (API_CONTEXT + "/harmony/devices", "application/json", (request, response) -> {
 	    	log.debug("Get harmony devices");
-	      	if(myHarmonyHome == null) {
-				response.status(HttpStatus.SC_NOT_FOUND);
-				return new ErrorMessage("A Harmony is not available.");		      		
-	      	}
 	      	response.status(HttpStatus.SC_OK);
-	      	return myHarmonyHome.getDevices();
+	      	return homeManager.findResource(DeviceMapTypes.HARMONY_BUTTON[DeviceMapTypes.typeIndex]).getItems(DeviceMapTypes.HARMONY_BUTTON[DeviceMapTypes.typeIndex]);
 	    }, new JsonTransformer());
 
     	get (API_CONTEXT + "/nest/items", "application/json", (request, response) -> {
 	    	log.debug("Get nest items");
-	      	if(nestHome == null) {
-				response.status(HttpStatus.SC_NOT_FOUND);
-				return new ErrorMessage("A Nest is not available.");
-	      	}
 	      	response.status(HttpStatus.SC_OK);
-	      	return nestHome.getItems();
+	      	return homeManager.findResource(DeviceMapTypes.NEST_HOMEAWAY[DeviceMapTypes.typeIndex]).getItems(DeviceMapTypes.NEST_HOMEAWAY[DeviceMapTypes.typeIndex]);
 	    }, new JsonTransformer());
 
     	get (API_CONTEXT + "/hue/devices", "application/json", (request, response) -> {
 	    	log.debug("Get hue items");
-	      	if(hueHome == null) {
-				response.status(HttpStatus.SC_NOT_FOUND);
-				return new ErrorMessage("A Hue is not available.");
-	      	}
 	      	response.status(HttpStatus.SC_OK);
-	      	return hueHome.getDevices();
+	      	return homeManager.findResource(DeviceMapTypes.HUE_DEVICE[DeviceMapTypes.typeIndex]).getItems(DeviceMapTypes.HUE_DEVICE[DeviceMapTypes.typeIndex]);
+	    }, new JsonTransformer());
+
+    	get (API_CONTEXT + "/hal/devices", "application/json", (request, response) -> {
+	    	log.debug("Get hal items");
+	      	response.status(HttpStatus.SC_OK);
+	      	return homeManager.findResource(DeviceMapTypes.HAL_DEVICE[DeviceMapTypes.typeIndex]).getItems(DeviceMapTypes.HAL_DEVICE[DeviceMapTypes.typeIndex]);
+	    }, new JsonTransformer());
+
+    	get (API_CONTEXT + "/mqtt/devices", "application/json", (request, response) -> {
+	    	log.debug("Get MQTT brokers");
+	      	response.status(HttpStatus.SC_OK);
+	      	return homeManager.findResource(DeviceMapTypes.MQTT_MESSAGE[DeviceMapTypes.typeIndex]).getItems(DeviceMapTypes.MQTT_MESSAGE[DeviceMapTypes.typeIndex]);
+	    }, new JsonTransformer());
+
+    	get (API_CONTEXT + "/hass/devices", "application/json", (request, response) -> {
+	    	log.debug("Get HomeAssistant Clients");
+	      	response.status(HttpStatus.SC_OK);
+	      	return homeManager.findResource(DeviceMapTypes.HASS_DEVICE[DeviceMapTypes.typeIndex]).getItems(DeviceMapTypes.HASS_DEVICE[DeviceMapTypes.typeIndex]);
+	    }, new JsonTransformer());
+
+    	get (API_CONTEXT + "/domoticz/devices", "application/json", (request, response) -> {
+	    	log.debug("Get Domoticz Clients");
+	      	response.status(HttpStatus.SC_OK);
+	      	return homeManager.findResource(DeviceMapTypes.DOMOTICZ_DEVICE[DeviceMapTypes.typeIndex]).getItems(DeviceMapTypes.DOMOTICZ_DEVICE[DeviceMapTypes.typeIndex]);
+	    }, new JsonTransformer());
+
+    	get (API_CONTEXT + "/lifx/devices", "application/json", (request, response) -> {
+	    	log.debug("Get LIFX devices");
+	      	response.status(HttpStatus.SC_OK);
+	      	return homeManager.findResource(DeviceMapTypes.LIFX_DEVICE[DeviceMapTypes.typeIndex]).getItems(DeviceMapTypes.LIFX_DEVICE[DeviceMapTypes.typeIndex]);
+	    }, new JsonTransformer());
+
+		get (API_CONTEXT + "/somfy/devices", "application/json", (request, response) -> {
+			log.debug("Get somfy devices");
+			response.status(HttpStatus.SC_OK);
+			return homeManager.findResource(DeviceMapTypes.SOMFY_DEVICE[DeviceMapTypes.typeIndex]).getItems(DeviceMapTypes.SOMFY_DEVICE[DeviceMapTypes.typeIndex]);
+		}, new JsonTransformer());
+
+		get (API_CONTEXT + "/map/types", "application/json", (request, response) -> {
+	    	log.debug("Get map types");
+	      	return new DeviceMapTypes().getDeviceMapTypes();
+	    }, new JsonTransformer());
+
+	    // http://ip_address:port/api/devices/exec/renumber CORS request
+	    options(API_CONTEXT + "/exec/renumber", "application/json", (request, response) -> {
+	        response.status(HttpStatus.SC_OK);
+	        response.header("Access-Control-Allow-Origin", request.headers("Origin"));
+	        response.header("Access-Control-Allow-Methods", "POST");
+	        response.header("Access-Control-Allow-Headers", request.headers("Access-Control-Request-Headers"));
+	        response.header("Content-Type", "text/html; charset=utf-8");
+	    	return "";
+	    });
+    	post (API_CONTEXT + "/exec/renumber", "application/json", (request, response) -> {
+	    	log.debug("Renumber devices.");
+	    	deviceRepository.renumber();
+	        return null;
 	    }, new JsonTransformer());
 
     	get (API_CONTEXT + "/backup/available", "application/json", (request, response) -> {

src/main/java/com/bwssystems/HABridge/devicemanagmeent/ResourceHandler.java

@@ -0,0 +1,5 @@
+package com.bwssystems.HABridge.devicemanagmeent;
+
+public interface ResourceHandler {
+	public Object getItems(String type);
+}

src/main/java/com/bwssystems/HABridge/hue/BrightnessDecode.java

@@ -0,0 +1,157 @@
+package com.bwssystems.HABridge.hue;
+
+import java.math.BigDecimal;
+import java.util.HashMap;
+import java.util.Locale;
+import java.util.Map;
+
+import org.apache.commons.lang3.Conversion;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import net.java.dev.eval.Expression;
+
+public class BrightnessDecode {
+	private static final Logger log = LoggerFactory.getLogger(BrightnessDecode.class);
+	private static final String INTENSITY_PERCENT = "${intensity.percent}";
+	private static final String INTENSITY_DECIMAL_PERCENT = "${intensity.decimal_percent}";
+	private static final String INTENSITY_BYTE = "${intensity.byte}";
+	private static final String INTENSITY_MATH = "${intensity.math(";
+	private static final String INTENSITY_MATH_VALUE = "X";
+	private static final String INTENSITY_MATH_CLOSE = ")}";
+	private static final String INTENSITY_MATH_CLOSE_HEX = ").hex}";
+	private static final String INTENSITY_PERCENT_HEX = "${intensity.percent.hex}";
+	private static final String INTENSITY_BYTE_HEX = "${intensity.byte.hex}";
+
+	public static int calculateIntensity(int setIntensity, Integer targetBri, Integer targetBriInc) {
+		if (targetBri != null) {
+			setIntensity = targetBri;
+		} else if (targetBriInc != null) {
+			if ((setIntensity + targetBriInc) <= 0)
+				setIntensity = targetBriInc;
+			else if ((setIntensity + targetBriInc) > 254)
+				setIntensity = targetBriInc;
+			else
+				setIntensity = setIntensity + targetBriInc;
+		}
+		return setIntensity;
+	}
+
+	/*
+	 * light weight templating here, was going to use free marker but it was a
+	 * bit too heavy for what we were trying to do.
+	 *
+	 * currently provides: intensity.byte : 0-254 brightness. this is raw from
+	 * the echo intensity.percent : 0-100, adjusted for the vera
+	 * intensity.math(X*1) : where X is the value from the interface call and
+	 * can use net.java.dev.eval math
+	 */
+	public static String replaceIntensityValue(String request, int intensity, boolean isHex) {
+		if (request == null) {
+			return null;
+		}
+		boolean notDone = true;
+		String replaceValue = null;
+		String replaceTarget = null;
+		int percentBrightness = (int) Math.round(intensity / 255.0 * 100);
+		float decimalBrightness = (float) (intensity / 255.0);
+		Map<String, BigDecimal> variables = new HashMap<String, BigDecimal>();
+		String mathDescriptor = null;
+		
+		while(notDone) {
+			notDone = false;
+			if (request.contains(INTENSITY_BYTE)) {
+				if (isHex) {
+					replaceValue = convertToHex(intensity);
+				} else {
+					replaceValue = String.valueOf(intensity);
+				}
+				replaceTarget = INTENSITY_BYTE;
+				notDone = true;
+			} else if (request.contains(INTENSITY_BYTE_HEX)) {
+				replaceValue = convertToHex(intensity);
+				replaceTarget = INTENSITY_BYTE_HEX;
+				notDone = true;
+			} else if (request.contains(INTENSITY_PERCENT)) {
+				if (isHex) {
+					replaceValue = convertToHex(percentBrightness);
+				} else {
+					replaceValue = String.valueOf(percentBrightness);
+				}
+				replaceTarget = INTENSITY_PERCENT;
+				notDone = true;
+			} else if (request.contains(INTENSITY_PERCENT_HEX)) {
+				replaceValue = convertToHex(percentBrightness);
+				replaceTarget = INTENSITY_PERCENT_HEX;
+				notDone = true;
+			} else if (request.contains(INTENSITY_DECIMAL_PERCENT)) {
+				replaceValue = String.format(Locale.ROOT, "%1.2f", decimalBrightness);
+				replaceTarget = INTENSITY_DECIMAL_PERCENT;
+				notDone = true;
+			} else if (request.contains(INTENSITY_MATH_CLOSE)) {
+				mathDescriptor = request.substring(request.indexOf(INTENSITY_MATH) + INTENSITY_MATH.length(),
+						request.indexOf(INTENSITY_MATH_CLOSE));
+				variables.put(INTENSITY_MATH_VALUE, new BigDecimal(intensity));
+	
+				log.debug("Math eval is: " + mathDescriptor + ", Where " + INTENSITY_MATH_VALUE + " is: "
+						+ String.valueOf(intensity));
+				Integer endResult = calculateMath(variables, mathDescriptor);
+				if(endResult != null) {
+					if (isHex) {
+						replaceValue = convertToHex(endResult);
+					} else {
+						replaceValue = endResult.toString();
+					}
+					replaceTarget = INTENSITY_MATH + mathDescriptor + INTENSITY_MATH_CLOSE;
+					notDone = true;
+				}
+			} else if (request.contains(INTENSITY_MATH_CLOSE_HEX)) {
+				mathDescriptor = request.substring(request.indexOf(INTENSITY_MATH) + INTENSITY_MATH.length(),
+						request.indexOf(INTENSITY_MATH_CLOSE_HEX));
+				variables.put(INTENSITY_MATH_VALUE, new BigDecimal(intensity));
+	
+				Integer endResult = calculateMath(variables, mathDescriptor);
+				if(endResult != null) {
+					if (isHex) {
+						replaceValue = convertToHex(endResult);
+					} else {
+						replaceValue = endResult.toString();
+					}
+					replaceTarget = INTENSITY_MATH + mathDescriptor + INTENSITY_MATH_CLOSE_HEX;
+					notDone = true;
+				}
+			}
+			if(notDone)
+				request = request.replace(replaceTarget, replaceValue);
+		}
+		return request;
+	}
+
+	// Helper Method
+	public static String calculateReplaceIntensityValue(String request, int theIntensity, Integer targetBri, Integer targetBriInc, boolean isHex) {
+		return replaceIntensityValue(request, calculateIntensity(theIntensity, targetBri, targetBriInc), isHex);
+	}
+	
+	// Apache Commons Conversion utils likes little endian too much
+	private static String convertToHex(int theValue) {
+		String destHex = "00";
+		String hexValue = Conversion.intToHex(theValue, 0, destHex, 0, 2);
+		byte[] theBytes = hexValue.getBytes();
+		byte[] newBytes = new byte[2];
+		newBytes[0] = theBytes[1];
+		newBytes[1] = theBytes[0];
+		return new String(newBytes);
+	}
+	
+	private static Integer calculateMath(Map<String, BigDecimal> variables, String mathDescriptor) {
+		Integer endResult = null;
+		try {
+			Expression exp = new Expression(mathDescriptor);
+			BigDecimal result = exp.eval(variables);
+			endResult = Math.round(result.floatValue());
+		} catch (Exception e) {
+			log.warn("Could not execute Math: " + mathDescriptor, e);
+			endResult = null;
+		}
+		return endResult;
+	}
+}

src/main/java/com/bwssystems/HABridge/hue/ColorData.java

@@ -0,0 +1,22 @@
+package com.bwssystems.HABridge.hue;
+
+public class ColorData {
+	public enum ColorMode { XY, CT, HS}
+
+	private ColorMode mode;
+	private Object data;
+	
+	public ColorData(ColorMode mode, Object value) {
+		this.mode = mode;
+		this.data = value;
+	}
+	
+	public Object getData() {
+		return data;
+	}
+
+	public ColorMode getColorMode() {
+		return mode;
+	}
+
+}

src/main/java/com/bwssystems/HABridge/hue/ColorDecode.java

@@ -0,0 +1,234 @@
+package com.bwssystems.HABridge.hue;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.bwssystems.HABridge.hue.ColorData;
+
+public class ColorDecode {
+	private static final Logger log = LoggerFactory.getLogger(ColorDecode.class);
+	private static final String COLOR_R = "${color.r}";
+	private static final String COLOR_G = "${color.g}";
+	private static final String COLOR_B = "${color.b}";
+	private static final Pattern COLOR_MILIGHT = Pattern.compile("\\$\\{color.milight\\:([01234])\\}");
+
+	public static List<Integer> convertCIEtoRGB(List<Double> xy, int brightness) {
+		List<Integer> rgb;
+		double x = xy.get(0); // the given x value
+		double y = xy.get(1); // the given y value
+		double z = 1.0 - x - y;
+		double Y = (double)brightness/(double)254.00; // The given brightness value
+		double X = (Y / y) * x;
+		double Z = (Y / y) * z;
+
+		double r =  X * 1.656492 - Y * 0.354851 - Z * 0.255038;
+		double g = -X * 0.707196 + Y * 1.655397 + Z * 0.036152;
+		double b =  X * 0.051713 - Y * 0.121364 + Z * 1.011530;
+
+		if (r > b && r > g && r > 1.0) {
+
+			g = g / r;
+			b = b / r;
+			r = 1.0;
+		}
+		else if (g > b && g > r && g > 1.0) {
+
+			r = r / g;
+			b = b / g;
+			g = 1.0;
+		}
+		else if (b > r && b > g && b > 1.0) {
+
+			r = r / b;
+			g = g / b;
+			b = 1.0;
+		}
+
+
+		r = r <= 0.0031308 ? 12.92 * r : (1.0 + 0.055) * Math.pow(r, (1.0 / 2.4)) - 0.055;
+		g = g <= 0.0031308 ? 12.92 * g : (1.0 + 0.055) * Math.pow(g, (1.0 / 2.4)) - 0.055;
+		b = b <= 0.0031308 ? 12.92 * b : (1.0 + 0.055) * Math.pow(b, (1.0 / 2.4)) - 0.055;
+		
+	    if (r > b && r > g) {
+	        // red is biggest
+	        if (r > 1.0) {
+	            g = g / r;
+	            b = b / r;
+	            r = 1.0;
+	        }
+	    }
+	    else if (g > b && g > r) {
+	        // green is biggest
+	        if (g > 1.0) {
+	            r = r / g;
+	            b = b / g;
+	            g = 1.0;
+	        }
+	    }
+	    else if (b > r && b > g) {
+	        // blue is biggest
+	        if (b > 1.0) {
+	            r = r / b;
+	            g = g / b;
+	            b = 1.0;
+	        }
+	    }
+	    if(r < 0.0)
+	    	r = 0;
+	    if(g < 0.0)
+	    	g = 0;
+	    if(b < 0.0)
+	    	b = 0;
+
+	    rgb = new ArrayList<Integer>();
+	    rgb.add((int)Math.round(r * 255));
+	    rgb.add((int)Math.round(g * 255));
+	    rgb.add((int)Math.round(b * 255));
+	    log.debug("Color change with XY: " + x + " " + y + " Resulting RGB Values: " + rgb.get(0) + " " + rgb.get(1) + " " + rgb.get(2));
+		return rgb;
+	}
+
+	// took that approximation from http://www.tannerhelland.com/4435/convert-temperature-rgb-algorithm-code/
+	public static List<Integer> convertCTtoRGB(Integer ct) {
+		double temperature = 1000000.0 / (double)ct;
+		temperature /= 100;
+		double r,g,b;
+		if (temperature <= 66) {
+			r = 255;
+			g = temperature;
+	        g = 99.4708025861 * Math.log(g) - 161.1195681661;
+		} else {
+			r = temperature - 60;
+			r = 329.698727446 * (Math.pow(r, -0.1332047592));
+			g = temperature - 60;
+			g = 288.1221695283 * (Math.pow(g, -0.0755148492));
+		}
+
+		if (temperature >= 66) {
+			b = 255;
+		} else {
+			if (temperature <= 19) {
+				b = 0;
+			} else {
+				b = temperature - 10;
+				b = 138.5177312231 * Math.log(b) - 305.0447927307;
+			}
+		}
+        r = assureBounds(r);
+        g = assureBounds(g);
+        b = assureBounds(b);
+        List<Integer> rgb = new ArrayList<Integer>();
+        rgb.add((int)Math.round(r));
+        rgb.add((int)Math.round(g));
+        rgb.add((int)Math.round(b));
+        log.debug("Color change with CT: " + ct + ". Resulting RGB Values: " + rgb.get(0) + " " + rgb.get(1) + " " + rgb.get(2));
+        return rgb;
+	}
+
+	private static double assureBounds(double value) {
+		if (value < 0.0) {
+        	value = 0;
+        }
+        if (value > 255.0) {
+        	value = 255;
+        }
+        return value;
+	}
+
+	@SuppressWarnings("unchecked")
+	public static String replaceColorData(String request, ColorData colorData, int setIntensity, boolean isHex) {
+		if (request == null) {
+			return null;
+		}
+		if (colorData == null) {
+			return request;
+		}
+		boolean notDone = true;
+		ColorData.ColorMode colorMode = colorData.getColorMode();
+		List<Integer> rgb = null;
+		if (colorMode == ColorData.ColorMode.XY) {
+			rgb = convertCIEtoRGB((List<Double>)colorData.getData(), setIntensity);
+		} else if (colorMode == ColorData.ColorMode.CT) {
+			rgb = convertCTtoRGB((Integer)colorData.getData());
+		}
+		
+		while(notDone) {
+			notDone = false;
+			if (request.contains(COLOR_R)) {
+				request = request.replace(COLOR_R, isHex ? String.format("%02X", rgb.get(0)) : String.valueOf(rgb.get(0)));
+				notDone = true;
+			}
+
+			if (request.contains(COLOR_G)) {
+				request = request.replace(COLOR_G, isHex ? String.format("%02X", rgb.get(1)) : String.valueOf(rgb.get(1)));
+				notDone = true;
+			}
+
+			if (request.contains(COLOR_B)) {
+				request = request.replace(COLOR_B, isHex ? String.format("%02X", rgb.get(2)) : String.valueOf(rgb.get(2)));
+				notDone = true;
+			}
+
+			Matcher m = COLOR_MILIGHT.matcher(request);
+			while (m.find()) {
+			    int group = Integer.parseInt(m.group(1));
+			    request = m.replaceFirst(getMilightV5FromRgb(rgb, group));
+			    m.reset(request);
+			}
+			
+			log.debug("Request <<" + request + ">>, not done: " + notDone);
+		}
+		return request;
+	}
+
+	private static String getMilightV5FromRgb(List<Integer> rgb, int group) {
+		double r = (double)rgb.get(0);
+	    double g = (double)rgb.get(1);
+	    double b = (double)rgb.get(2);
+	    if (r > 245 && g > 245 && b > 245) { // it's white
+	    	String retVal = "";
+	    	if (group == 0) {
+	    		retVal += "C2";
+	    	} else if (group == 1) {
+	    		retVal += "C5";
+	    	} else if (group == 2) {
+	    		retVal += "C7";
+	    	} else if (group == 3) {
+	    		retVal += "C9";
+	    	} else if (group == 4) {
+	    		retVal += "CB";
+	    	}
+	    	log.debug("Convert RGB to Milight. Result: WHITE. RGB Values: " + rgb.get(0) + " " + rgb.get(1) + " " + rgb.get(2));
+	    	return retVal + "0055";
+	    } else { // normal color
+	    	r /= (double)0xFF;
+		    g /= (double)0xFF;
+		    b /= (double)0xFF;
+		    double max = Math.max(Math.max(r, g), b), min = Math.min(Math.min(r, g), b);
+		    double h = 0;
+		    double d = max - min;
+
+		    if (max == min) {
+		    	h = 0;
+		    } else {
+		    	if (max == r) {
+					h = ((g - b) / d + (g < b ? 6 : 0)); 
+		    	} else if (max == g) {
+		    		h = ((b - r) / d + 2); 
+		    	} else if (max == b){
+		    		h = ((r - g) / d + 4); 
+		    	}
+		    	h = Math.round(h * 60);
+		    }
+		    int milight = (int)((256 + 176 - Math.floor(h / 360.0 * 255.0)) % 256);
+		    log.debug("Convert RGB to Milight. Result: " + milight + " RGB Values: " + rgb.get(0) + " " + rgb.get(1) + " " + rgb.get(2));
+		    return "40" + String.format("%02X", milight) + "55";
+	    }
+	}
+}

src/main/java/com/bwssystems/HABridge/hue/ColorMap.java

@@ -0,0 +1,75 @@
+package com.bwssystems.HABridge.hue;
+
+public class ColorMap {
+	private double red;
+	private double green;
+	private double blue;
+	private long R;
+	private long G;
+	private long B;
+	private double X;
+	private double Y;
+	private Double Z;
+	private double z;
+	public double getRed() {
+		return red;
+	}
+	public void setRed(double red) {
+		this.red = red;
+	}
+	public double getGreen() {
+		return green;
+	}
+	public void setGreen(double green) {
+		this.green = green;
+	}
+	public double getBlue() {
+		return blue;
+	}
+	public void setBlue(double blue) {
+		this.blue = blue;
+	}
+	public long getR() {
+		return R;
+	}
+	public void setR(long r) {
+		R = r;
+	}
+	public long getG() {
+		return G;
+	}
+	public void setG(long g) {
+		G = g;
+	}
+	public long getB() {
+		return B;
+	}
+	public void setB(long b) {
+		B = b;
+	}
+	public double getX() {
+		return X;
+	}
+	public void setX(double x) {
+		X = x;
+	}
+	public double getY() {
+		return Y;
+	}
+	public void setY(double y) {
+		Y = y;
+	}
+	public Double getZ() {
+		return Z;
+	}
+	public void setZ(Double z) {
+		Z = z;
+	}
+	public double getz() {
+		return z;
+	}
+	public void setz(double z) {
+		this.z = z;
+	}
+
+}

src/main/java/com/bwssystems/HABridge/hue/DeviceDataDecode.java

@@ -0,0 +1,84 @@
+package com.bwssystems.HABridge.hue;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.bwssystems.HABridge.dao.DeviceDescriptor;
+
+public class DeviceDataDecode {
+	private static final Logger log = LoggerFactory.getLogger(DeviceDataDecode.class);
+	private static final String DEVICE_ID = "${device.id}";
+	private static final String DEVICE_UNIQUEID = "${device.uniqueid}";
+	private static final String DEVICE_NAME = "${device.name}";
+	private static final String DEVICE_MAPID = "${device.mapId}";
+	private static final String DEVICE_MAPTYPE = "${device.mapType}";
+	private static final String DEVICE_DEVICETYPE = "${device.deviceType}";
+	private static final String DEVICE_TARGETDEVICE = "${device.targetDevice}";
+	private static final String DEVICE_REQUESTERADDRESS = "${device.requesterAddress}";
+	private static final String DEVICE_DESCRIPTION = "${device.description}";
+	private static final String DEVICE_COMMENTS = "${device.comments}";
+	
+	public static String replaceDeviceData(String request, DeviceDescriptor device) {
+		if (request == null) {
+			return null;
+		}
+		boolean notDone = true;
+		
+		while(notDone) {
+			notDone = false;
+			if (request.contains(DEVICE_ID)) {
+				request = request.replace(DEVICE_ID, device.getId());
+				notDone = true;
+			}
+
+			if (request.contains(DEVICE_UNIQUEID)) {
+				request = request.replace(DEVICE_UNIQUEID, device.getUniqueid());
+				notDone = true;
+			}
+
+			if (request.contains(DEVICE_NAME)) {
+				request = request.replace(DEVICE_NAME, device.getName());
+				notDone = true;
+			}
+
+			if (request.contains(DEVICE_MAPID)) {
+				request = request.replace(DEVICE_MAPID, device.getMapId());
+				notDone = true;
+			}
+
+			if (request.contains(DEVICE_MAPTYPE)) {
+				request = request.replace(DEVICE_MAPTYPE, device.getMapType());
+				notDone = true;
+			}
+
+			if (request.contains(DEVICE_DEVICETYPE)) {
+				request = request.replace(DEVICE_DEVICETYPE, device.getDeviceType());
+				notDone = true;
+			}
+
+			if (request.contains(DEVICE_TARGETDEVICE)) {
+				request = request.replace(DEVICE_TARGETDEVICE, device.getTargetDevice());
+				notDone = true;
+			}
+			
+			if (request.contains(DEVICE_REQUESTERADDRESS)) {
+				request = request.replace(DEVICE_REQUESTERADDRESS, device.getRequesterAddress());
+				notDone = true;
+			}
+
+			if (request.contains(DEVICE_DESCRIPTION)) {
+				request = request.replace(DEVICE_DESCRIPTION, device.getDescription());
+				notDone = true;
+			}
+
+			if (request.contains(DEVICE_COMMENTS)) {
+				request = request.replace(DEVICE_COMMENTS, device.getComments());
+				notDone = true;
+			}
+
+			log.debug("Request <<" + request + ">>, not done: " + notDone);
+		}
+		return request;
+	}
+
+}

src/main/java/com/bwssystems/HABridge/hue/HueMulatorHandler.java

@@ -0,0 +1,9 @@
+package com.bwssystems.HABridge.hue;
+
+import com.bwssystems.HABridge.api.CallItem;
+import com.bwssystems.HABridge.dao.DeviceDescriptor;
+import com.bwssystems.HABridge.hue.ColorData;
+
+public interface HueMulatorHandler {
+	public String deviceHandler(CallItem anItem, MultiCommandUtil aMultiUtil, String lightId, int intensity, Integer targetBri, Integer targetBriInc, ColorData colorData, DeviceDescriptor device, String body);
+}

src/main/java/com/bwssystems/HABridge/hue/MultiCommandUtil.java

@@ -0,0 +1,31 @@
+package com.bwssystems.HABridge.hue;
+
+public class MultiCommandUtil {
+	private Integer setCount;
+	private Integer theDelay;
+	private Integer delayDefault;
+
+	public Integer getSetCount() {
+		return setCount;
+	}
+
+	public void setSetCount(Integer setCount) {
+		this.setCount = setCount;
+	}
+
+	public Integer getTheDelay() {
+		return theDelay;
+	}
+
+	public void setTheDelay(Integer theDelay) {
+		this.theDelay = theDelay;
+	}
+
+	public Integer getDelayDefault() {
+		return delayDefault;
+	}
+
+	public void setDelayDefault(Integer delayDefault) {
+		this.delayDefault = delayDefault;
+	}
+}

src/main/java/com/bwssystems/HABridge/hue/TimeDecode.java

@@ -0,0 +1,44 @@
+package com.bwssystems.HABridge.hue;
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class TimeDecode {
+	private static final Logger log = LoggerFactory.getLogger(TimeDecode.class);
+	private static final String TIME_FORMAT = "${time.format(";
+	private static final String TIME_FORMAT_CLOSE = ")}";
+
+	/*
+	 * light weight templating here, was going to use free marker but it was a
+	 * bit too heavy for what we were trying to do.
+	 *
+	 * currently provides: time format using Java DateTimeFormatter options
+	 */
+	public static String replaceTimeValue(String request) {
+		if (request == null) {
+			return null;
+		}
+		boolean notDone = true;
+		
+		while(notDone) {
+			notDone = false;
+			if (request.contains(TIME_FORMAT)) {
+				String timeFormatDescriptor = request.substring(request.indexOf(TIME_FORMAT) + TIME_FORMAT.length(),
+						request.indexOf(TIME_FORMAT_CLOSE));
+	
+				try {
+					log.debug("Time eval is: " + timeFormatDescriptor);
+				    SimpleDateFormat dateFormat = new SimpleDateFormat(timeFormatDescriptor);
+					request = request.replace(TIME_FORMAT + timeFormatDescriptor + TIME_FORMAT_CLOSE, dateFormat.format(new Date()));
+					notDone = true;
+				} catch (Exception e) {
+					log.warn("Could not format current time: " + timeFormatDescriptor, e);
+				}
+			}
+		}
+		return request;
+	}
+}

src/main/java/com/bwssystems/HABridge/plugins/NestBridge/NestHome.java

@@ -0,0 +1,201 @@
+package com.bwssystems.HABridge.plugins.NestBridge;
+
+import java.util.ArrayList;
+import java.util.ListIterator;
+import java.util.Set;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.bwssystems.HABridge.BridgeSettings;
+import com.bwssystems.HABridge.DeviceMapTypes;
+import com.bwssystems.HABridge.api.CallItem;
+import com.bwssystems.HABridge.dao.DeviceDescriptor;
+import com.bwssystems.HABridge.hue.BrightnessDecode;
+import com.bwssystems.HABridge.hue.ColorData;
+import com.bwssystems.HABridge.hue.MultiCommandUtil;
+import com.bwssystems.nest.controller.Home;
+import com.bwssystems.nest.controller.Nest;
+import com.bwssystems.nest.controller.NestSession;
+import com.bwssystems.nest.controller.Thermostat;
+import com.bwssystems.nest.protocol.error.LoginException;
+import com.bwssystems.nest.protocol.status.WhereDetail;
+import com.bwssystems.nest.protocol.status.WhereItem;
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+
+public class NestHome implements com.bwssystems.HABridge.Home {
+    private static final Logger log = LoggerFactory.getLogger(NestHome.class);
+    private NestSession theSession;
+    private Nest theNest;
+    private ArrayList<NestItem> nestItems;
+	private Gson aGsonHandler;
+	private Boolean isFarenheit;
+    private Boolean validNest;
+	private boolean closed;
+    
+	public NestHome(BridgeSettings bridgeSettings) {
+		super();
+		closed = true;
+		createHome(bridgeSettings);
+		closed = false;
+	}
+	
+	@Override
+	public Object getItems(String type) {
+		if(!validNest)
+			return null;
+		
+		if(nestItems == null) {
+			nestItems = new ArrayList<NestItem>();
+			Set<String> homeNames = theNest.getHomeNames();
+			Home aHome = null;
+			NestItem anItem = null;
+			for(String name : homeNames) {
+				aHome = theNest.getHome(name);
+				anItem = new NestItem();
+				anItem.setId(name);
+				anItem.setName(aHome.getDetail().getName());
+				anItem.setType("Home");
+				anItem.setLocation(aHome.getDetail().getLocation());
+				nestItems.add(anItem);
+			}
+			Thermostat thermo = null;
+			Set<String> thermoNames = theNest.getThermostatNames();
+			for(String name : thermoNames) {
+				thermo = theNest.getThermostat(name);
+				anItem = new NestItem();
+				anItem.setId(name);
+				anItem.setType("Thermostat");
+				String where = null;
+				String homeName= null;
+				Boolean found = false;
+				for(String aHomeName : homeNames) {
+					WhereDetail aDetail = theNest.getWhere(aHomeName);
+					ListIterator<WhereItem> anIterator = aDetail.getWheres().listIterator();
+					while(anIterator.hasNext()) {
+						WhereItem aWhereItem = (WhereItem) anIterator.next();
+						if(aWhereItem.getWhereId().equals(thermo.getDeviceDetail().getWhereId())) {
+							where = aWhereItem.getName();
+							homeName = theNest.getHome(aHomeName).getDetail().getName();
+							found = true;
+							break;
+						}
+					}
+					if(found)
+						break;
+				}
+				anItem.setName(where + "(" + name.substring(name.length() - 4) + ")");
+				anItem.setLocation(where + " - " + homeName);
+				nestItems.add(anItem);
+			}
+		}
+		
+		return nestItems;
+	}
+	
+	@Override
+	public void closeHome() {
+		log.debug("Closing Home.");
+		if(closed) {
+			log.debug("Home is already closed....");
+			return;
+		}
+		if(theSession != null) {
+			theNest.endNestSession();
+		}
+		theNest = null;
+		theSession = null;
+		nestItems = null;
+		closed = true;
+	}
+
+	@Override
+	public String deviceHandler(CallItem anItem, MultiCommandUtil aMultiUtil, String lightId, int intensity,
+			Integer targetBri,Integer targetBriInc, ColorData colorData, DeviceDescriptor device, String body) {
+		String responseString = null;
+		log.debug("executing HUE api request to set away for nest " + anItem.getType() + ": " + anItem.getItem().toString());
+		if(!validNest) {
+			log.warn("Should not get here, no Nest available");
+			responseString = "[{\"error\":{\"type\": 6, \"address\": \"/lights/" + lightId
+					+ "\",\"description\": \"Should not get here, no Nest available\", \"parameter\": \"/lights/"
+					+ lightId + "state\"}}]";
+		} else if (anItem.getType() != null && anItem.getType().trim().equalsIgnoreCase(DeviceMapTypes.NEST_HOMEAWAY[DeviceMapTypes.typeIndex])) {
+			NestInstruction homeAway = null;
+			if(anItem.getItem().isJsonObject())
+				homeAway = aGsonHandler.fromJson(anItem.getItem(), NestInstruction.class);
+			else
+				homeAway = aGsonHandler.fromJson(anItem.getItem().getAsString(), NestInstruction.class);
+			theNest.getHome(homeAway.getName()).setAway(homeAway.getAway());
+		} else if (anItem.getType() != null && anItem.getType().trim().equalsIgnoreCase(DeviceMapTypes.NEST_THERMO_SET[DeviceMapTypes.typeIndex])) {
+			NestInstruction thermoSetting = null;
+			if(anItem.getItem().isJsonObject())
+				thermoSetting = aGsonHandler.fromJson(anItem.getItem(), NestInstruction.class);
+			else
+				thermoSetting = aGsonHandler.fromJson(anItem.getItem().getAsString(), NestInstruction.class);
+			if (thermoSetting.getControl().equalsIgnoreCase("temp")) {
+				if (targetBri != null) {
+					if (isFarenheit)
+						thermoSetting
+								.setTemp(
+										String.valueOf((Double
+												.parseDouble(BrightnessDecode.calculateReplaceIntensityValue(thermoSetting.getTemp(),
+													intensity, targetBri, targetBriInc, false)) - 32.0) / 1.8));
+					else
+						thermoSetting
+								.setTemp(
+										String.valueOf(Double.parseDouble(BrightnessDecode.calculateReplaceIntensityValue(thermoSetting.getTemp(),
+												intensity, targetBri, targetBriInc, false))));
+					log.debug("Setting thermostat: " + thermoSetting.getName() + " to "
+							+ thermoSetting.getTemp() + "C");
+					theNest.getThermostat(thermoSetting.getName())
+							.setTargetTemperature(Float.parseFloat(thermoSetting.getTemp()));
+				}
+			} else if (thermoSetting.getControl().contains("range")
+					|| thermoSetting.getControl().contains("heat")
+					|| thermoSetting.getControl().contains("cool")
+					|| thermoSetting.getControl().contains("off")) {
+				log.debug("Setting thermostat target type: " + thermoSetting.getName() + " to "
+						+ thermoSetting.getControl());
+				theNest.getThermostat(thermoSetting.getName()).setTargetType(thermoSetting.getControl());
+			} else if (thermoSetting.getControl().contains("fan")) {
+				log.debug("Setting thermostat fan mode: " + thermoSetting.getName() + " to "
+						+ thermoSetting.getControl().substring(4));
+				theNest.getThermostat(thermoSetting.getName())
+						.setFanMode(thermoSetting.getControl().substring(4));
+			} else {
+				log.warn("no valid Nest control info: " + thermoSetting.getControl());
+				responseString = "[{\"error\":{\"type\": 6, \"address\": \"/lights/" + lightId
+						+ "\",\"description\": \"no valid Nest control info\", \"parameter\": \"/lights/"
+						+ lightId + "state\"}}]";
+			}
+		}
+		return responseString;
+	}
+
+	@Override
+	public com.bwssystems.HABridge.Home createHome(BridgeSettings bridgeSettings) {
+        theSession = null;
+        theNest = null;
+        nestItems = null;
+        validNest = bridgeSettings.getBridgeSettingsDescriptor().isValidNest();
+		aGsonHandler = null;
+		log.info("Nest Home created." + (validNest ? "" : " No Nest configured."));
+        
+        if(validNest) {
+    		aGsonHandler = new GsonBuilder().create();
+	
+    		isFarenheit = bridgeSettings.getBridgeSettingsDescriptor().isFarenheit();
+	       try {
+	            theSession = new NestSession(bridgeSettings.getBridgeSettingsDescriptor().getNestuser(), bridgeSettings.getBridgeSettingsDescriptor().getNestpwd());
+	        	theNest = new Nest(theSession);
+	        } catch (LoginException e) {
+	            log.error("Caught Login Exception, setting Nest to invalid....");
+	            validNest = false;
+	            theSession = null;
+	        }
+        }
+		return this;
+	}
+}
+

src/main/java/com/bwssystems/HABridge/plugins/NestBridge/NestInstruction.java

@@ -1,4 +1,4 @@
-package com.bwssystems.NestBridge;
+package com.bwssystems.HABridge.plugins.NestBridge;
 
 public class NestInstruction {
 	private String name;

src/main/java/com/bwssystems/HABridge/plugins/NestBridge/NestItem.java

@@ -1,4 +1,4 @@
-package com.bwssystems.NestBridge;
+package com.bwssystems.HABridge.plugins.NestBridge;
 
 import java.io.UnsupportedEncodingException;
 

src/main/java/com/bwssystems/HABridge/plugins/domoticz/DeviceResult.java

@@ -0,0 +1,55 @@
+
+package com.bwssystems.HABridge.plugins.domoticz;
+
+import com.google.gson.annotations.Expose;
+import com.google.gson.annotations.SerializedName;
+
+public class DeviceResult {
+    @SerializedName("Description")
+    @Expose
+    private String description;
+    @SerializedName("Name")
+    @Expose
+    private String name;
+    @SerializedName("Type")
+    @Expose
+    private String type;
+    @SerializedName("idx")
+    @Expose
+    private String idx;
+
+
+
+    public String getDescription() {
+        return description;
+    }
+
+    public void setDescription(String description) {
+        this.description = description;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public String getType() {
+        return type;
+    }
+
+    public void setType(String type) {
+        this.type = type;
+    }
+
+    public String getIdx() {
+        return idx;
+    }
+
+    public void setIdx(String idx) {
+        this.idx = idx;
+    }
+
+}

src/main/java/com/bwssystems/HABridge/plugins/domoticz/Devices.java

@@ -0,0 +1,99 @@
+
+package com.bwssystems.HABridge.plugins.domoticz;
+
+import java.util.List;
+import com.google.gson.annotations.Expose;
+import com.google.gson.annotations.SerializedName;
+
+public class Devices {
+
+    @SerializedName("ActTime")
+    @Expose
+    private Integer actTime;
+    @SerializedName("AllowWidgetOrdering")
+    @Expose
+    private Boolean allowWidgetOrdering;
+    @SerializedName("ServerTime")
+    @Expose
+    private String serverTime;
+    @SerializedName("Sunrise")
+    @Expose
+    private String sunrise;
+    @SerializedName("Sunset")
+    @Expose
+    private String sunset;
+    @SerializedName("result")
+    @Expose
+    private List<DeviceResult> result = null;
+    @SerializedName("status")
+    @Expose
+    private String status;
+    @SerializedName("title")
+    @Expose
+    private String title;
+
+    public Integer getActTime() {
+        return actTime;
+    }
+
+    public void setActTime(Integer actTime) {
+        this.actTime = actTime;
+    }
+
+    public Boolean getAllowWidgetOrdering() {
+        return allowWidgetOrdering;
+    }
+
+    public void setAllowWidgetOrdering(Boolean allowWidgetOrdering) {
+        this.allowWidgetOrdering = allowWidgetOrdering;
+    }
+
+    public String getServerTime() {
+        return serverTime;
+    }
+
+    public void setServerTime(String serverTime) {
+        this.serverTime = serverTime;
+    }
+
+    public String getSunrise() {
+        return sunrise;
+    }
+
+    public void setSunrise(String sunrise) {
+        this.sunrise = sunrise;
+    }
+
+    public String getSunset() {
+        return sunset;
+    }
+
+    public void setSunset(String sunset) {
+        this.sunset = sunset;
+    }
+
+    public List<DeviceResult> getResult() {
+        return result;
+    }
+
+    public void setResult(List<DeviceResult> result) {
+        this.result = result;
+    }
+
+    public String getStatus() {
+        return status;
+    }
+
+    public void setStatus(String status) {
+        this.status = status;
+    }
+
+    public String getTitle() {
+        return title;
+    }
+
+    public void setTitle(String title) {
+        this.title = title;
+    }
+
+}

src/main/java/com/bwssystems/HABridge/plugins/domoticz/DomoticzDevice.java

@@ -0,0 +1,39 @@
+package com.bwssystems.HABridge.plugins.domoticz;
+
+public class DomoticzDevice {
+	private String devicetype;
+	private String devicename;
+	private String idx;
+	private String domoticzaddress;
+	private String domoticzname;
+	public String getDevicetype() {
+		return devicetype;
+	}
+	public void setDevicetype(String devicetype) {
+		this.devicetype = devicetype;
+	}
+	public String getDevicename() {
+		return devicename;
+	}
+	public void setDevicename(String devicename) {
+		this.devicename = devicename;
+	}
+	public String getIdx() {
+		return idx;
+	}
+	public void setIdx(String idx) {
+		this.idx = idx;
+	}
+	public String getDomoticzaddress() {
+		return domoticzaddress;
+	}
+	public void setDomoticzaddress(String domoticzaddress) {
+		this.domoticzaddress = domoticzaddress;
+	}
+	public String getDomoticzname() {
+		return domoticzname;
+	}
+	public void setDomoticzname(String domoticzname) {
+		this.domoticzname = domoticzname;
+	}
+}

src/main/java/com/bwssystems/HABridge/plugins/domoticz/DomoticzHandler.java

@@ -0,0 +1,121 @@
+package com.bwssystems.HABridge.plugins.domoticz;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Base64;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.bwssystems.HABridge.NamedIP;
+import com.bwssystems.HABridge.api.NameValue;
+import com.bwssystems.HABridge.plugins.http.HTTPHandler;
+import com.google.gson.Gson;
+
+public class DomoticzHandler {
+    private static final Logger log = LoggerFactory.getLogger(DomoticzHandler.class);
+    private static final String GET_REQUEST = "/json.htm?type=";
+    private static final String DEVICES_TYPE = "devices";
+    private static final String SCENES_TYPE = "scenes";
+    private static final String FILTER_USED = "&used=true";
+    private NamedIP domoticzAddress;
+
+    public DomoticzHandler(NamedIP addressName) {
+		super();
+        domoticzAddress = addressName;
+	}
+
+	public List<DomoticzDevice> getDevices(HTTPHandler httpClient) {
+    	return getDomoticzDevices(GET_REQUEST, DEVICES_TYPE, FILTER_USED, httpClient);
+    }
+
+	public List<DomoticzDevice> getScenes(HTTPHandler httpClient) {
+    	return getDomoticzDevices(GET_REQUEST, SCENES_TYPE, null, httpClient);
+    }
+
+	private List<DomoticzDevice> getDomoticzDevices(String rootRequest, String type, String postpend, HTTPHandler httpClient) {
+		Devices theDomoticzApiResponse = null;
+		List<DomoticzDevice> deviceList = null;
+
+		String theUrl = null;
+    	String theData;
+    	if(postpend != null && !postpend.isEmpty())
+    		theUrl = buildUrl(rootRequest + type + postpend);
+    	else
+    		theUrl = buildUrl(rootRequest + type);
+   		theData = httpClient.doHttpRequest(theUrl, null, null, null, buildHeaders());
+    	if(theData != null) {
+    		log.debug("GET " + type + " DomoticzApiResponse - data: " + theData);
+	    	theDomoticzApiResponse = new Gson().fromJson(theData, Devices.class);
+	    	if(theDomoticzApiResponse.getResult() == null) {
+    			log.warn("Cannot get any devices for type " + type + " for Domoticz " + domoticzAddress.getName() + " as response is not parsable.");
+	        	return deviceList;
+	    	}
+	    	deviceList = new ArrayList<DomoticzDevice>();
+	    	
+	    	Iterator<DeviceResult> theDeviceNames = theDomoticzApiResponse.getResult().iterator();
+	    	while(theDeviceNames.hasNext()) {
+	    		DeviceResult theDevice = theDeviceNames.next();
+				DomoticzDevice aNewDomoticzDevice = new DomoticzDevice();
+				aNewDomoticzDevice.setDevicetype(theDevice.getType());
+				aNewDomoticzDevice.setDevicename(theDevice.getName());
+				aNewDomoticzDevice.setIdx(theDevice.getIdx());
+				aNewDomoticzDevice.setDomoticzaddress(domoticzAddress.getIp() + ":" + domoticzAddress.getPort());
+				aNewDomoticzDevice.setDomoticzname(domoticzAddress.getName());
+				deviceList.add(aNewDomoticzDevice);
+	    		
+	    	}
+    	}
+    	else {
+    		log.warn("Get Domoticz device types " + type + " for " + domoticzAddress.getName() + " - returned null, no data.");
+    	}
+    	return deviceList;
+    }
+
+	public String buildUrl(String thePayload) {
+		String newUrl = null;
+		
+		if(thePayload != null && !thePayload.isEmpty()) {
+			if(domoticzAddress.getSecure() != null && domoticzAddress.getSecure())
+				newUrl = "https://";
+			else
+				newUrl = "http://";
+			
+			newUrl = newUrl + domoticzAddress.getIp();
+			
+			if(domoticzAddress.getPort() != null && !domoticzAddress.getPort().isEmpty())
+				newUrl = newUrl + ":" + domoticzAddress.getPort();
+
+			if(thePayload.startsWith("/"))
+				newUrl = newUrl + thePayload;
+			else
+				newUrl = newUrl + "/" + thePayload;
+		}
+		
+		return newUrl;
+	}
+	
+	public NameValue[] buildHeaders() {
+		NameValue[] headers = null;
+		
+		if(domoticzAddress.getUsername() != null && !domoticzAddress.getUsername().isEmpty()
+				&& domoticzAddress.getPassword() != null && !domoticzAddress.getPassword().isEmpty()) {
+			NameValue theAuth = new NameValue();
+			theAuth.setName("Authorization");
+			String encoding = Base64.getEncoder().encodeToString((domoticzAddress.getUsername() + ":" + domoticzAddress.getPassword()).getBytes());
+			theAuth.setValue("Basic " + encoding);
+			headers = new NameValue[1];
+			headers[0] = theAuth;
+		}
+		
+		return headers;
+	}
+	public NamedIP getDomoticzAddress() {
+		return domoticzAddress;
+	}
+
+	public void setDomoticzAddress(NamedIP DomoticzAddress) {
+		this.domoticzAddress = DomoticzAddress;
+	}
+
+}

src/main/java/com/bwssystems/HABridge/plugins/domoticz/DomoticzHome.java

@@ -0,0 +1,180 @@
+package com.bwssystems.HABridge.plugins.domoticz;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.bwssystems.HABridge.BridgeSettings;
+import com.bwssystems.HABridge.Home;
+import com.bwssystems.HABridge.NamedIP;
+import com.bwssystems.HABridge.api.CallItem;
+import com.bwssystems.HABridge.api.hue.HueError;
+import com.bwssystems.HABridge.api.hue.HueErrorResponse;
+import com.bwssystems.HABridge.dao.DeviceDescriptor;
+import com.bwssystems.HABridge.hue.BrightnessDecode;
+import com.bwssystems.HABridge.hue.ColorData;
+import com.bwssystems.HABridge.hue.MultiCommandUtil;
+import com.bwssystems.HABridge.plugins.http.HTTPHandler;
+import com.bwssystems.HABridge.plugins.http.HTTPHome;
+import com.google.gson.Gson;
+
+public class DomoticzHome implements Home {
+    private static final Logger log = LoggerFactory.getLogger(DomoticzHome.class);
+	private Map<String, DomoticzHandler> domoticzs;
+	private Boolean validDomoticz;
+    private HTTPHandler httpClient;
+	private boolean closed;
+
+	public DomoticzHome(BridgeSettings bridgeSettings) {
+		super();
+		closed = true;
+		createHome(bridgeSettings);
+		closed = false;
+	}
+
+	@Override
+	public Object getItems(String type) {
+		if(!validDomoticz)
+			return null;
+		log.debug("consolidating devices for hues");
+		List<DomoticzDevice> theResponse = null;
+		Iterator<String> keys = domoticzs.keySet().iterator();
+		List<DomoticzDevice> deviceList = new ArrayList<DomoticzDevice>();
+		while(keys.hasNext()) {
+			String key = keys.next();
+			theResponse = domoticzs.get(key).getDevices(httpClient);
+			if(theResponse != null)
+				addDomoticzDevices(deviceList, theResponse, key);
+			else {
+				log.warn("Cannot get lights for Domoticz with name: " + key + ", skipping this Domoticz.");
+				continue;
+			}
+			theResponse = domoticzs.get(key).getScenes(httpClient);
+			if(theResponse != null)
+				addDomoticzDevices(deviceList, theResponse, key);
+			else
+				log.warn("Cannot get Scenes for Domoticz with name: " + key);
+		}
+		return deviceList;
+	}
+	
+	private Boolean addDomoticzDevices(List<DomoticzDevice> theDeviceList, List<DomoticzDevice> theSourceList, String theKey) {
+		if(!validDomoticz)
+			return null;
+		Iterator<DomoticzDevice> devices = theSourceList.iterator();
+		while(devices.hasNext()) {
+			DomoticzDevice theDevice = devices.next();
+			theDeviceList.add(theDevice);
+		}
+		return true;
+	}
+
+	@Override
+	public String deviceHandler(CallItem anItem, MultiCommandUtil aMultiUtil, String lightId, int intensity,
+			Integer targetBri,Integer targetBriInc, ColorData colorData, DeviceDescriptor device, String body) {
+		Devices theDomoticzApiResponse = null;
+		String responseString = null;
+		
+		String theUrl = anItem.getItem().getAsString();
+		if(theUrl != null && !theUrl.isEmpty () && (theUrl.startsWith("http://") || theUrl.startsWith("https://"))) {
+			String intermediate = theUrl.substring(theUrl.indexOf("://") + 3);
+			String hostPortion = intermediate.substring(0, intermediate.indexOf('/'));
+			String theUrlBody = intermediate.substring(intermediate.indexOf('/') + 1);
+			String hostAddr = null;
+			if (hostPortion.contains(":")) {
+				hostAddr = hostPortion.substring(0, intermediate.indexOf(':'));
+			} else
+				hostAddr = hostPortion;
+			DomoticzHandler theHandler = findHandlerByAddress(hostAddr);
+			if(theHandler != null){
+		    	String theData;
+				String anUrl = BrightnessDecode.calculateReplaceIntensityValue(theUrlBody,
+						intensity, targetBri, targetBriInc, false);
+		   		theData = httpClient.doHttpRequest(theHandler.buildUrl(anUrl), null, null, null, theHandler.buildHeaders());
+		   		try {
+		   			theDomoticzApiResponse = new Gson().fromJson(theData, Devices.class);
+		   			if(theDomoticzApiResponse.getStatus().equals("OK"))
+		   				responseString = null;
+		   			else {
+		    			log.warn("Call failed for Domoticz " + theHandler.getDomoticzAddress().getName() + " with status " + theDomoticzApiResponse.getStatus() + " for item " + theDomoticzApiResponse.getTitle());
+						responseString = new Gson().toJson(HueErrorResponse.createResponse("6", "/lights/" + lightId,
+								"Error on calling url to change device state", "/lights/"
+								+ lightId + "state", null, null).getTheErrors(), HueError[].class);
+		   			}
+		   		} catch (Exception e) {
+	    			log.warn("Cannot interrpret result from call for Domoticz " + theHandler.getDomoticzAddress().getName() + " as response is not parsable.");
+					responseString = new Gson().toJson(HueErrorResponse.createResponse("6", "/lights/" + lightId,
+							"Error on calling url to change device state", "/lights/"
+							+ lightId + "state", null, null).getTheErrors(), HueError[].class);
+		    	}
+			} else {
+				log.warn("Domoticz Call could not complete, no address found: " + theUrl);
+				responseString = new Gson().toJson(HueErrorResponse.createResponse("6", "/lights/" + lightId,
+						"Error on calling url to change device state", "/lights/"
+						+ lightId + "state", null, null).getTheErrors(), HueError[].class);
+			}
+		} else {
+			log.warn("Domoticz Call to be presented as http(s)://<ip_address>(:<port>)/payload, format of request unknown: " + theUrl);
+			responseString = new Gson().toJson(HueErrorResponse.createResponse("6", "/lights/" + lightId,
+					"Error on calling url to change device state", "/lights/"
+					+ lightId + "state", null, null).getTheErrors(), HueError[].class);
+		}
+		return responseString;
+	}
+
+	@Override
+	public Home createHome(BridgeSettings bridgeSettings) {
+		validDomoticz = bridgeSettings.getBridgeSettingsDescriptor().isValidDomoticz();
+		log.info("Domoticz Home created." + (validDomoticz ? "" : " No Domoticz devices configured."));
+		if(!validDomoticz)
+			return null;
+        httpClient = HTTPHome.getHandler();
+		domoticzs = new HashMap<String, DomoticzHandler>();
+		Iterator<NamedIP> theList = bridgeSettings.getBridgeSettingsDescriptor().getDomoticzaddress().getDevices().iterator();
+		while(theList.hasNext()) {
+			NamedIP aDomoticz = theList.next();
+	      	try {
+	      		domoticzs.put(aDomoticz.getName(), new DomoticzHandler(aDomoticz));
+			} catch (Exception e) {
+		        log.error("Cannot get Domoticz client (" + aDomoticz.getName() + ") setup, Exiting with message: " + e.getMessage(), e);
+		        return null;
+			}
+		}
+		return this;
+	}
+
+	private DomoticzHandler findHandlerByAddress(String hostAddress) {
+		DomoticzHandler aHandler = null;
+		boolean found = false;
+		Iterator<String> keys = domoticzs.keySet().iterator();
+		while(keys.hasNext()) {
+			String key = keys.next();
+			aHandler = domoticzs.get(key);
+			if(aHandler != null && aHandler.getDomoticzAddress().getIp().equals(hostAddress)) {
+				found = true;
+				break;
+			}	
+		}
+		if(!found)
+			aHandler = null;
+		return aHandler;
+	}
+	@Override
+	public void closeHome() {
+		log.debug("Closing Home.");
+		if(closed) {
+			log.debug("Home is already closed....");
+			return;
+		}
+
+		if(httpClient != null)
+			httpClient.closeHandler();
+
+		closed = true;		
+	}
+}

src/main/java/com/bwssystems/HABridge/plugins/exec/CommandHome.java

@@ -0,0 +1,108 @@
+package com.bwssystems.HABridge.plugins.exec;
+
+import java.io.IOException;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.bwssystems.HABridge.BridgeSettings;
+import com.bwssystems.HABridge.Home;
+import com.bwssystems.HABridge.api.CallItem;
+import com.bwssystems.HABridge.dao.DeviceDescriptor;
+import com.bwssystems.HABridge.hue.BrightnessDecode;
+import com.bwssystems.HABridge.hue.ColorData;
+import com.bwssystems.HABridge.hue.ColorDecode;
+import com.bwssystems.HABridge.hue.DeviceDataDecode;
+import com.bwssystems.HABridge.hue.MultiCommandUtil;
+import com.bwssystems.HABridge.hue.TimeDecode;
+
+public class CommandHome implements Home {
+	private static final Logger log = LoggerFactory.getLogger(CommandHome.class);
+	private BridgeSettings theSettings;
+	private boolean closed;
+
+	public CommandHome(BridgeSettings bridgeSettings) {
+		super();
+		closed = true;
+		createHome(bridgeSettings);
+		closed = false;
+	}
+
+	@Override
+	public String deviceHandler(CallItem anItem, MultiCommandUtil aMultiUtil, String lightId, int intensity, Integer targetBri, Integer targetBriInc, ColorData colorData, DeviceDescriptor device, String body) {
+		log.debug("Exec Request called with url: " +  anItem.getItem().getAsString() + " and exec Garden: "  + (theSettings.getBridgeSecurity().getExecGarden() == null ? "not given" : theSettings.getBridgeSecurity().getExecGarden()));
+		String responseString = null;
+		String intermediate;
+		if (anItem.getItem().getAsString().contains("exec://"))
+			intermediate = anItem.getItem().getAsString().substring(anItem.getItem().getAsString().indexOf("://") + 3);
+		else
+			intermediate = anItem.getItem().getAsString();
+		intermediate = BrightnessDecode.calculateReplaceIntensityValue(intermediate, intensity, targetBri, targetBriInc, false);
+		if (colorData != null) {
+			intermediate = ColorDecode.replaceColorData(intermediate, colorData, BrightnessDecode.calculateIntensity(intensity, targetBri, targetBriInc), false);	
+		}
+		intermediate = DeviceDataDecode.replaceDeviceData(intermediate, device);
+		intermediate = TimeDecode.replaceTimeValue(intermediate);
+		String execGarden = theSettings.getBridgeSecurity().getExecGarden();
+		if(execGarden != null && !execGarden.trim().isEmpty()) {
+			if(System.getProperty("os.name").toLowerCase().indexOf("win") >= 0)
+				intermediate = execGarden + "\\" + intermediate;
+			else
+				intermediate = execGarden + "/" + intermediate;
+		}
+
+		String anError = doExecRequest(intermediate, lightId);
+		if (anError != null) {
+			responseString = anError;
+		}
+		return responseString;
+	}
+
+	private String doExecRequest(String anItem, String lightId) {
+		log.debug("Executing request: " + anItem);
+		String responseString = null;
+		if (anItem != null && !anItem.equalsIgnoreCase("")) {
+			try {
+				Process p = Runtime.getRuntime().exec(anItem);
+				log.debug("Process running: " + p.isAlive());
+			} catch (IOException e) {
+				log.warn("Could not execute request: " + anItem + " with message: " + e.getMessage());
+				responseString = "[{\"error\":{\"type\": 6, \"address\": \"/lights/" + lightId
+						+ "\",\"description\": \"Error on calling out to device\", \"parameter\": \"/lights/" + lightId
+						+ "state\"}}]";
+			}
+		} else {
+			log.warn("Could not execute request. Request is empty.");
+			responseString = "[{\"error\":{\"type\": 6, \"address\": \"/lights/" + lightId
+					+ "\",\"description\": \"Error on calling out to device\", \"parameter\": \"/lights/" + lightId
+					+ "state\"}}]";
+		}
+
+		return responseString;
+	}
+
+	@Override
+	public Home createHome(BridgeSettings bridgeSettings) {
+		log.info("Command Home for system program execution created.");
+		this.theSettings = bridgeSettings; 
+		return this;
+	}
+
+	@Override
+	public Object getItems(String type) {
+		// noop
+		return null;
+	}
+
+	@Override
+	public void closeHome() {
+		log.debug("Closing Home.");
+		if(closed) {
+			log.debug("Home is already closed....");
+			return;
+		}
+		
+		closed = true;
+	}
+
+}

src/main/java/com/bwssystems/HABridge/plugins/fibaro/FibaroHome.java

@@ -0,0 +1,116 @@
+package com.bwssystems.HABridge.plugins.fibaro;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.bwssystems.HABridge.BridgeSettings;
+import com.bwssystems.HABridge.DeviceMapTypes;
+import com.bwssystems.HABridge.Home;
+import com.bwssystems.HABridge.NamedIP;
+import com.bwssystems.HABridge.api.CallItem;
+import com.bwssystems.HABridge.dao.DeviceDescriptor;
+import com.bwssystems.HABridge.hue.ColorData;
+import com.bwssystems.HABridge.hue.MultiCommandUtil;
+import com.bwssystems.HABridge.plugins.fibaro.json.Device;
+import com.bwssystems.HABridge.plugins.fibaro.json.Scene;
+
+public class FibaroHome implements Home
+{
+	private static final Logger log = LoggerFactory.getLogger(FibaroHome.class);
+	private Map<String, FibaroInfo> fibaros;
+	private Boolean validFibaro;
+	private boolean closed;
+
+	public FibaroHome(BridgeSettings bridgeSettings)
+	{
+		super();
+		closed = true;
+		createHome(bridgeSettings);
+		closed = false;
+	}
+
+	public List<Device> getDevices()
+	{
+		log.debug("consolidating devices for fibaros");
+		Iterator<String> keys = fibaros.keySet().iterator();
+		ArrayList<Device> deviceList = new ArrayList<>();
+		while(keys.hasNext())
+		{
+			String key = keys.next();
+			for(Device device : fibaros.get(key).getDevices())
+				deviceList.add(device);
+		}
+		return deviceList;
+	}
+
+	public List<Scene> getScenes()
+	{
+		log.debug("consolidating scenes for fibaros");
+		Iterator<String> keys = fibaros.keySet().iterator();
+		ArrayList<Scene> sceneList = new ArrayList<>();
+		while(keys.hasNext())
+		{
+			String key = keys.next();
+			for(Scene scene : fibaros.get(key).getScenes())
+				sceneList.add(scene);
+		}
+		return sceneList;
+	}
+
+	@Override
+	public String deviceHandler(CallItem anItem, MultiCommandUtil aMultiUtil, String lightId, int intensity,
+			Integer targetBri,Integer targetBriInc, ColorData colorData, DeviceDescriptor device, String body)
+	{
+		// Not a device handler
+		return null;
+	}
+
+	@Override
+	public Object getItems(String type)
+	{
+		if(validFibaro)
+		{
+			if(type.equalsIgnoreCase(DeviceMapTypes.FIBARO_DEVICE[DeviceMapTypes.typeIndex]))
+				return getDevices();
+			if(type.equalsIgnoreCase(DeviceMapTypes.FIBARO_SCENE[DeviceMapTypes.typeIndex]))
+				return getScenes();
+		}
+		return null;
+	}
+
+	@Override
+	public Home createHome(BridgeSettings bridgeSettings)
+	{
+		validFibaro = bridgeSettings.getBridgeSettingsDescriptor().isValidFibaro();
+		log.info("Fibaro Home created." + (validFibaro ? "" : " No Fibaros configured."));
+		if(validFibaro)
+		{
+			fibaros = new HashMap<String, FibaroInfo>();
+			Iterator<NamedIP> theList = bridgeSettings.getBridgeSettingsDescriptor().getFibaroAddress().getDevices().iterator();
+			while(theList.hasNext())
+			{
+				NamedIP aFibaro = theList.next();
+				fibaros.put(aFibaro.getName(), new FibaroInfo(aFibaro));
+			}
+		}
+		return this;
+	}
+
+	@Override
+	public void closeHome()
+	{
+		log.debug("Closing Home.");
+		if(closed) {
+			log.debug("Home is already closed....");
+			return;
+		}
+		fibaros = null;
+		closed = true;
+	}
+}

src/main/java/com/bwssystems/HABridge/plugins/fibaro/FibaroInfo.java

@@ -0,0 +1,178 @@
+package com.bwssystems.HABridge.plugins.fibaro;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.net.HttpURLConnection;
+import java.net.URL;
+
+import org.apache.commons.codec.binary.Base64;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.bwssystems.HABridge.NamedIP;
+import com.bwssystems.HABridge.plugins.fibaro.json.Device;
+import com.bwssystems.HABridge.plugins.fibaro.json.Room;
+import com.bwssystems.HABridge.plugins.fibaro.json.Scene;
+import com.google.gson.Gson;
+
+public class FibaroInfo
+{
+	private static final Logger log = LoggerFactory.getLogger(FibaroInfo.class);
+
+	private final NamedIP fibaroAddress;
+	private final String fibaroAuth;
+	private final Gson gson;
+
+	// You can disable it if you want TODO config
+	boolean useSaveLogs = true; // This can be used to exclude some devices from list
+	boolean useUserDescription = true;
+	boolean replaceTrash = true;
+	boolean scenesWithLiliCommandOnly = true;
+
+	public FibaroInfo(NamedIP addressName)
+	{
+		super();
+		fibaroAddress = addressName;
+		fibaroAuth = "Basic " + new String(Base64.encodeBase64((addressName.getUsername() + ":" + addressName.getPassword()).getBytes()));
+		gson = new Gson();
+	}
+
+	private String request(String request)
+	{
+		String result = null;
+		try
+		{
+			URL url = new URL("http://" + fibaroAddress.getIp() + ":" + fibaroAddress.getPort() + request);
+			HttpURLConnection connection = (HttpURLConnection) url.openConnection();
+			connection.setRequestMethod("GET");
+			connection.setRequestProperty("Authorization", fibaroAuth);
+			connection.setRequestProperty("Content-Type", "application/json;charset=utf-8");
+			connection.connect();
+			BufferedReader br = new BufferedReader(new InputStreamReader(connection.getInputStream()));
+			StringBuilder buffer = new StringBuilder();
+			String line;
+			while((line = br.readLine()) != null)
+			{
+				buffer.append(line).append("\n");
+			}
+			br.close();
+			result = buffer.toString();
+		}
+		catch(IOException e)
+		{
+			log.warn("Error while get getJson: {} ", request, e);
+		}
+		return result;
+	}
+
+	protected boolean sendCommand(String request)
+	{
+		try
+		{
+			URL url = new URL("http://" + fibaroAddress.getIp() + ":" + fibaroAddress.getPort() + request);
+			HttpURLConnection connection = (HttpURLConnection) url.openConnection();
+			connection.setRequestMethod("GET");
+			connection.setRequestProperty("Authorization", fibaroAuth);
+			connection.getResponseMessage();
+		}
+		catch(IOException e)
+		{
+			log.warn("Error while get getJson: {} ", request, e);
+			return false;
+		}
+		return true;
+	}
+
+	private String replaceTrash(String name)
+	{
+		String sanitizedName = name.replaceAll("[0-9:/-]", "");
+		sanitizedName = name.replaceAll("\\s+", " ");
+		return sanitizedName.trim();
+	}
+	
+	private Room[] getRooms()
+	{
+		String result = request("/api/rooms");
+		Room[] rooms = result == null ? new Room[0] : gson.fromJson(result, Room[].class);
+		if(replaceTrash)
+			for(Room r : rooms)
+				r.setName(replaceTrash(r.getName()));
+		return rooms;
+	}
+
+	public Device[] getDevices()
+	{
+		Room[] rooms = getRooms();
+
+		log.info("Found: " + rooms.length + " rooms");
+
+		String result = request("/api/devices?enabled=true&visible=true");
+		Device[] all_devices = result == null ? new Device[0] : gson.fromJson(result, Device[].class);
+
+		int count = 0;
+		for(Device d : all_devices)
+			if(d.getRoomID() > 0 && (useSaveLogs ? "true".equals(d.getProperties().getSaveLogs()) : true))
+				count++;
+
+		Device[] devices = new Device[count];
+		int i = 0;
+		for(Device d : all_devices)
+			if(d.getRoomID() > 0 && (useSaveLogs ? "true".equals(d.getProperties().getSaveLogs()) : true))
+			{
+				if(useUserDescription && d.getProperties().getUserDescription() != null && !d.getProperties().getUserDescription().isEmpty())
+					d.setName(d.getProperties().getUserDescription());
+				if(replaceTrash)
+					d.setName(replaceTrash(d.getName()));
+				
+				devices[i++] = d;
+
+				for(Room room : rooms)
+					if(d.getRoomID() == room.getId())
+						d.setRoomName(room.getName());
+
+				d.fibaroaddress = fibaroAddress.getIp();
+				d.fibaroport = fibaroAddress.getPort();
+				d.fibaroAuth = fibaroAuth;
+				d.fibaroname = fibaroAddress.getName();
+			}
+
+		log.info("Found: " + devices.length + " devices");
+
+		return devices;
+	}
+
+	public Scene[] getScenes()
+	{
+		Room[] rooms = getRooms();
+		
+		String result = request("/api/scenes?enabled=true&visible=true");
+		Scene[] all_scenes = result == null ? new Scene[0] : gson.fromJson(result, Scene[].class);
+		
+		int count = 0;
+		for(Scene s : all_scenes)
+			if(!scenesWithLiliCommandOnly || s.getLiliStartCommand() != null && !s.getLiliStartCommand().isEmpty())
+				count++;
+		Scene[] scenes = new Scene[count];
+		int i = 0;
+		for(Scene s : all_scenes)
+			if(!scenesWithLiliCommandOnly || s.getLiliStartCommand() != null && !s.getLiliStartCommand().isEmpty())
+			{
+				if(replaceTrash)
+					s.setName(replaceTrash(s.getName()));
+				
+				scenes[i++] = s;
+
+				for(Room room : rooms)
+					if(s.getRoomID() == room.getId())
+						s.setRoomName(room.getName());
+
+				s.fibaroaddress = fibaroAddress.getIp();
+				s.fibaroport = fibaroAddress.getPort();
+				s.fibaroAuth = fibaroAuth;
+				s.fibaroname = fibaroAddress.getName();
+			}
+		log.info("Found: " + count + " scenes");
+		return scenes;
+	}
+}

src/main/java/com/bwssystems/HABridge/plugins/fibaro/ModeType.java

@@ -0,0 +1,35 @@
+package com.bwssystems.HABridge.plugins.fibaro;
+
+public enum ModeType {
+    OFF(0, "Off"),
+    HEAT(1, "Heat"),
+    COOL(2, "Cool"),
+    AUTO(3, "Auto"),
+    AUX_HEAT(4, "Aux Heat"),
+    RESUME(5, "Resume"),
+    FAN_ONLY(6, "Fan Only"),
+    FURNANCE(7, "Furnace"),
+    DRY_AIR(8, "Dry Air"),
+    MOIST_AIR(9, "Moist Air"),
+    AUTO_CHANGEOVER(10, "Auto Changeover"),
+    HEAT_ECON(11, "Heat Econ"),
+    COOL_ECON(12, "Cool Econ"),
+    AWAY(13, "Away"),
+    MANUAL(31, "Manual");
+
+    private int key;
+    private String label;
+
+    private ModeType(int key, String label) {
+        this.key = key;
+        this.label = label;
+    }
+
+    public int getKey() {
+        return key;
+    }
+
+    public String getLabel() {
+        return label;
+    }
+}

src/main/java/com/bwssystems/HABridge/plugins/fibaro/json/Device.java

@@ -0,0 +1,108 @@
+package com.bwssystems.HABridge.plugins.fibaro.json;
+
+import com.google.gson.annotations.SerializedName;
+
+public class Device {
+    private String roomName;
+
+    @SerializedName("id")
+    private String id;
+
+    @SerializedName("name")
+    private String name;
+
+    @SerializedName("roomID")
+    private int roomID;
+
+    @SerializedName("type")
+    private String type;
+
+    @SerializedName("baseType")
+    private String baseType;
+
+    @SerializedName("enabled")
+    private boolean enabled;
+
+    @SerializedName("visible")
+    private boolean visible;
+
+    @SerializedName("isPlugin")
+    private boolean isPlugin;
+
+    @SerializedName("parentId")
+    private int parentId;
+
+    @SerializedName("remoteGatewayId")
+    private int remoteGatewayId;
+
+    @SerializedName("viewXml")
+    private boolean viewXml;
+
+    @SerializedName("configXml")
+    private boolean configXml;
+
+    @SerializedName("interfaces")
+    private Object interfaces;
+
+    @SerializedName("properties")
+    private DeviceProperties properties;
+
+    @SerializedName("actions")
+    private Object actions;
+
+    @SerializedName("created")
+    private int created;
+
+    @SerializedName("modified")
+    private int modified;
+
+    @SerializedName("sortOrder")
+    private int sortOrder;
+
+    public String getRoomName() {
+        return roomName;
+    }
+
+    public void setRoomName(String roomName) {
+        this.roomName = roomName;
+    }
+
+    public String getId() {
+        return id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public int getRoomID() {
+        return roomID;
+    }
+
+    public String getType() {
+        return type;
+    }
+
+    public DeviceProperties getProperties() {
+        return properties;
+    }
+
+    public boolean isThermostat() {
+        return type.equals("com.fibaro.setPoint") || type.equals("com.fibaro.thermostatDanfoss")
+                || type.equals("com.fibaro.thermostatHorstmann");
+    }
+
+    @Override
+    public String toString() {
+        return "{" + id + ", " + name + "}";
+    }
+
+		public String fibaroaddress;
+		public String fibaroport;
+		public String fibaroAuth;
+		public String fibaroname;
+}

src/main/java/com/bwssystems/HABridge/plugins/fibaro/json/DeviceProperties.java

@@ -0,0 +1,244 @@
+package com.bwssystems.HABridge.plugins.fibaro.json;
+
+import com.google.gson.annotations.SerializedName;
+
+public class DeviceProperties {
+    @SerializedName("batteryLevel")
+    private String batteryLevel;
+
+    @SerializedName("UIMessageSendTime")
+    private String UIMessageSendTime;
+
+    @SerializedName("autoConfig")
+    private String autoConfig;
+
+    @SerializedName("color")
+    private String color;
+
+    @SerializedName("date")
+    private String date;
+
+    @SerializedName("dead")
+    private String dead;
+
+    @SerializedName("deviceControlType")
+    private String deviceControlType;
+
+    @SerializedName("deviceIcon")
+    private String deviceIcon;
+
+    @SerializedName("disabled")
+    private String disabled;
+
+    @SerializedName("emailNotificationID")
+    private String emailNotificationID;
+
+    @SerializedName("emailNotificationType")
+    private String emailNotificationType;
+
+    @SerializedName("endPoint")
+    private String endPoint;
+
+    @SerializedName("energy")
+    private String energy;
+
+    @SerializedName("liliOffCommand")
+    private String liliOffCommand;
+
+    @SerializedName("liliOnCommand")
+    private String liliOnCommand;
+
+    @SerializedName("log")
+    private String log;
+
+    @SerializedName("logTemp")
+    private String logTemp;
+
+    @SerializedName("manufacturer")
+    private String manufacturer;
+
+    @SerializedName("markAsDead")
+    private String markAsDead;
+
+    @SerializedName("mode")
+    private String mode;
+
+    @SerializedName("model")
+    private String model;
+
+    @SerializedName("nodeID")
+    private String nodeID;
+
+    @SerializedName("pollingDeadDevice")
+    private String pollingDeadDevice;
+
+    @SerializedName("pollingTime")
+    private String pollingTime;
+
+    @SerializedName("pollingTimeNext")
+    private String pollingTimeNext;
+
+    @SerializedName("pollingTimeSec")
+    private int pollingTimeSec;
+
+    @SerializedName("power")
+    private String power;
+
+    @SerializedName("productInfo")
+    private String productInfo;
+
+    @SerializedName("pushNotificationID")
+    private String pushNotificationID;
+
+    @SerializedName("pushNotificationType")
+    private String pushNotificationType;
+
+    @SerializedName("remoteGatewayId")
+    private String remoteGatewayId;
+
+    @SerializedName("requestNodeNeighborStat")
+    private String requestNodeNeighborStat;
+
+    @SerializedName("requestNodeNeighborStatTimeStemp")
+    private String requestNodeNeighborStatTimeStemp;
+
+    @SerializedName("requestNodeNeighborState")
+    private String requestNodeNeighborState;
+
+    @SerializedName("requestNodeNeighborStateTimeStemp")
+    private String requestNodeNeighborStateTimeStemp;
+
+    @SerializedName("saveLogs")
+    private String saveLogs;
+
+		@SerializedName("showChildren")
+    private String showChildren;
+
+    @SerializedName("smsNotificationID")
+    private String smsNotificationID;
+
+    @SerializedName("smsNotificationType")
+    private String smsNotificationType;
+
+    @SerializedName("supportedModes")
+    private String supportedModes;
+
+    @SerializedName("targetLevel")
+    private String targetLevel;
+
+    @SerializedName("unit")
+    private String unit;
+
+    @SerializedName("useTemplate")
+    private String useTemplate;
+
+    @SerializedName("status")
+    private String status;
+
+    @SerializedName("sunriseHour")
+    private String sunriseHour;
+
+    @SerializedName("sunsetHour")
+    private String sunsetHour;
+
+    @SerializedName("userDescription")
+    private String userDescription;
+
+    @SerializedName("value")
+    private String value;
+
+    @SerializedName("zwaveBuildVersion")
+    private String zwaveBuildVersion;
+
+    @SerializedName("zwaveCompany")
+    private String zwaveCompany;
+
+    @SerializedName("zwaveInfo")
+    private String zwaveInfo;
+
+    @SerializedName("zwaveRegion")
+    private String zwaveRegion;
+
+    @SerializedName("zwaveVersion")
+    private double zwaveVersion;
+
+    public String getBatteryLevel() {
+        return batteryLevel;
+    }
+
+    public String getColor() {
+        return color;
+    }
+
+    public String getDeviceControlType() {
+        return deviceControlType;
+    }
+
+    public String getEnergy() {
+        return energy;
+    }
+
+    public String getPower() {
+        return power;
+    }
+
+    public String getTargetLevel() {
+        return targetLevel;
+    }
+
+    public String getValue() {
+        return value;
+    }
+
+    // --- begin yrWeather plugin ---
+    @SerializedName("Humidity")
+    private String Humidity;
+
+    @SerializedName("Pressure")
+    private String Pressure;
+
+    @SerializedName("Temperature")
+    private String Temperature;
+
+    @SerializedName("WeatherCondition")
+    private String WeatherCondition;
+
+    @SerializedName("Wind")
+    private String Wind;
+
+    public String getHumidity() {
+        return Humidity;
+    }
+
+    public String getPressure() {
+        return Pressure;
+    }
+    
+    public String getSaveLogs()
+		{
+			return saveLogs;
+		}
+
+    public String getTemperature() {
+        return Temperature;
+    }
+
+    public String getWeatherCondition() {
+        return WeatherCondition;
+    }
+
+    public String getWind() {
+        return Wind;
+    }
+    // --- end yrWeather plugin ---
+
+		public String getUserDescription()
+		{
+			return userDescription;
+		}
+
+		public void setUserDescription(String userDescription)
+		{
+			this.userDescription = userDescription;
+		}
+}

src/main/java/com/bwssystems/HABridge/plugins/fibaro/json/Room.java

@@ -0,0 +1,43 @@
+package com.bwssystems.HABridge.plugins.fibaro.json;
+
+import com.google.gson.annotations.SerializedName;
+
+public class Room {
+    @SerializedName("id")
+    private int id;
+
+    @SerializedName("name")
+    private String name;
+
+    @SerializedName("sectionID")
+    private int sectionID;
+
+    @SerializedName("icon")
+    private String icon;
+
+    @SerializedName("defaultSensors")
+    private Sensor defaultSensors;
+
+    @SerializedName("defaultThermostat")
+    private int defaultThermostat;
+
+    @SerializedName("sortOrder")
+    private int sortOrder;
+
+    public int getId() {
+        return id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+		public int getSectionID()
+		{
+			return sectionID;
+		}
+}

src/main/java/com/bwssystems/HABridge/plugins/fibaro/json/Scene.java

@@ -0,0 +1,100 @@
+package com.bwssystems.HABridge.plugins.fibaro.json;
+
+import com.google.gson.annotations.SerializedName;
+
+public class Scene {
+    private String roomName;
+
+    @SerializedName("id")
+    private String id;
+
+    @SerializedName("name")
+    private String name;
+
+    @SerializedName("type")
+    private String type;
+
+    @SerializedName("properties")
+    private String properties;
+
+    @SerializedName("roomID")
+    private int roomID;
+
+    @SerializedName("iconID")
+    private int iconID;
+
+    @SerializedName("runConfig")
+    private String runConfig;
+
+    @SerializedName("autostart")
+    private boolean autostart;
+
+    @SerializedName("protectedByPIN")
+    private boolean protectedByPIN;
+
+    @SerializedName("killable")
+    private boolean killable;
+
+    @SerializedName("maxRunningInstances")
+    private int maxRunningInstances;
+
+    @SerializedName("runningInstances")
+    private int runningInstances;
+
+    @SerializedName("visible")
+    private boolean visible;
+
+    @SerializedName("isLua")
+    private boolean isLua;
+
+    @SerializedName("triggers")
+    private SceneTriggers triggers;
+
+    @SerializedName("liliStartCommand")
+    private String liliStartCommand;
+
+    @SerializedName("liliStopCommand")
+    private String liliStopCommand;
+
+    @SerializedName("sortOrder")
+    private int sortOrder;
+
+    public String getRoomName() {
+        return roomName;
+    }
+
+    public void setRoomName(String roomName) {
+        this.roomName = roomName;
+    }
+
+    public String getId() {
+        return id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public int getRoomID() {
+        return roomID;
+    }
+    
+		public String getLiliStartCommand()
+		{
+			return liliStartCommand;
+		}
+		
+    @Override
+    public String toString() {
+        return "{" + id + ", " + name + "}";
+    }
+
+		public String fibaroaddress;
+		public String fibaroport;
+		public String fibaroAuth;
+		public String fibaroname;
+}

src/main/java/com/bwssystems/HABridge/plugins/fibaro/json/SceneProperties.java

@@ -0,0 +1,11 @@
+package com.bwssystems.HABridge.plugins.fibaro.json;
+
+import com.google.gson.annotations.SerializedName;
+
+public class SceneProperties {
+    @SerializedName("id")
+    private String id;
+
+    @SerializedName("name")
+    private String name;
+}

src/main/java/com/bwssystems/HABridge/plugins/fibaro/json/SceneTriggers.java

@@ -0,0 +1,14 @@
+package com.bwssystems.HABridge.plugins.fibaro.json;
+
+import com.google.gson.annotations.SerializedName;
+
+public class SceneTriggers {
+    @SerializedName("properties")
+    private SceneProperties[] properties;
+
+    @SerializedName("globals")
+    private String[] globals;
+
+    @SerializedName("events")
+    private String[] events;
+}

src/main/java/com/bwssystems/HABridge/plugins/fibaro/json/Sensor.java

@@ -0,0 +1,14 @@
+package com.bwssystems.HABridge.plugins.fibaro.json;
+
+import com.google.gson.annotations.SerializedName;
+
+public class Sensor {
+    @SerializedName("temperature")
+    private int temperature;
+
+    @SerializedName("humidity")
+    private int humidity;
+
+    @SerializedName("light")
+    private int light;
+}

src/main/java/com/bwssystems/HABridge/plugins/hal/DeviceElements.java

@@ -0,0 +1,17 @@
+package com.bwssystems.HABridge.plugins.hal;
+
+import java.util.List;
+import com.google.gson.annotations.SerializedName;
+
+public class DeviceElements {
+	@SerializedName(value="DeviceElements", alternate={"SceneElements", "GroupElements", "HVACElements", "MacroElements", "IrElements", "IrButtons"})
+	private List<DeviceName> DeviceElements;
+
+	public List<DeviceName> getDeviceElements() {
+		return DeviceElements;
+	}
+
+	public void setDeviceElements(List<DeviceName> deviceElements) {
+		DeviceElements = deviceElements;
+	}
+}

src/main/java/com/bwssystems/HABridge/plugins/hal/DeviceName.java

@@ -0,0 +1,17 @@
+package com.bwssystems.HABridge.plugins.hal;
+
+import com.google.gson.annotations.SerializedName;
+
+public class DeviceName {
+	@SerializedName(value="DeviceName", alternate={"SceneName", "GroupName", "HVACName", "MacroName", "IrName", "IrButton"})
+	private String DeviceName;
+
+	public String getDeviceName() {
+		return DeviceName;
+	}
+
+	public void setDeviceName(String deviceName) {
+		DeviceName = deviceName;
+	}
+
+}

src/main/java/com/bwssystems/HABridge/plugins/hal/HalDevice.java

@@ -0,0 +1,34 @@
+package com.bwssystems.HABridge.plugins.hal;
+
+import com.bwssystems.HABridge.NamedIP;
+
+public class HalDevice {
+	private String haldevicetype;
+	private String haldevicename;
+	private NamedIP haladdress;
+	private DeviceElements buttons;
+	public String getHaldevicetype() {
+		return haldevicetype;
+	}
+	public void setHaldevicetype(String haldevicetype) {
+		this.haldevicetype = haldevicetype;
+	}
+	public String getHaldevicename() {
+		return haldevicename;
+	}
+	public void setHaldevicename(String haldevicename) {
+		this.haldevicename = haldevicename;
+	}
+	public NamedIP getHaladdress() {
+		return haladdress;
+	}
+	public void setHaladdress(NamedIP haladdress) {
+		this.haladdress = haladdress;
+	}
+	public DeviceElements getButtons() {
+		return buttons;
+	}
+	public void setButtons(DeviceElements buttons) {
+		this.buttons = buttons;
+	}
+}

src/main/java/com/bwssystems/HABridge/plugins/hal/HalHome.java

@@ -0,0 +1,209 @@
+package com.bwssystems.HABridge.plugins.hal;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.bwssystems.HABridge.BridgeSettings;
+import com.bwssystems.HABridge.Home;
+import com.bwssystems.HABridge.NamedIP;
+import com.bwssystems.HABridge.api.CallItem;
+import com.bwssystems.HABridge.api.hue.HueError;
+import com.bwssystems.HABridge.api.hue.HueErrorResponse;
+import com.bwssystems.HABridge.dao.DeviceDescriptor;
+import com.bwssystems.HABridge.hue.BrightnessDecode;
+import com.bwssystems.HABridge.hue.ColorData;
+import com.bwssystems.HABridge.hue.DeviceDataDecode;
+import com.bwssystems.HABridge.hue.MultiCommandUtil;
+import com.bwssystems.HABridge.hue.TimeDecode;
+import com.google.gson.Gson;
+
+public class HalHome implements Home {
+    private static final Logger log = LoggerFactory.getLogger(HalHome.class);
+	private Map<String, HalInfo> hals;
+	private Boolean validHal;
+	private boolean closed;
+
+	public HalHome(BridgeSettings bridgeSettings) {
+		super();
+		closed = true;
+		createHome(bridgeSettings);
+		closed = false;
+	}
+
+	@Override
+	public Object getItems(String type) {
+		if(!validHal)
+			return null;
+		log.debug("consolidating devices for HALs");
+		List<HalDevice> theResponse = null;
+		Iterator<String> keys = hals.keySet().iterator();
+		List<HalDevice> deviceList = new ArrayList<HalDevice>();
+		while(keys.hasNext()) {
+			String key = keys.next();
+			theResponse = hals.get(key).getLights();
+			if(theResponse != null)
+				addHalDevices(deviceList, theResponse, key);
+			else {
+				log.warn("Cannot get lights for Hal with name: " + key + ", skipping this HAL.");
+				continue;
+			}
+			theResponse = hals.get(key).getAppliances();
+			if(theResponse != null)
+				addHalDevices(deviceList, theResponse, key);
+			else
+				log.warn("Cannot get appliances for Hal with name: " + key);
+			theResponse = hals.get(key).getTheatre();
+			if(theResponse != null)
+				addHalDevices(deviceList, theResponse, key);
+			else
+				log.warn("Cannot get theatre for Hal with name: " + key);
+			theResponse = hals.get(key).getCustom();
+			if(theResponse != null)
+				addHalDevices(deviceList, theResponse, key);
+			else
+				log.warn("Cannot get custom for Hal with name: " + key);
+			theResponse = hals.get(key).getHVAC();
+			if(theResponse != null)
+				addHalDevices(deviceList, theResponse, key);
+			else
+				log.warn("Cannot get HVAC for Hal with name: " + key);
+			theResponse = hals.get(key).getHome(key);
+			if(theResponse != null)
+				addHalDevices(deviceList, theResponse, key);
+			else
+				log.warn("Cannot get Homes for Hal with name: " + key);
+			theResponse = hals.get(key).getGroups();
+			if(theResponse != null)
+				addHalDevices(deviceList, theResponse, key);
+			else
+				log.warn("Cannot get Groups for Hal with name: " + key);
+			theResponse = hals.get(key).getMacros();
+			if(theResponse != null)
+				addHalDevices(deviceList, theResponse, key);
+			else
+				log.warn("Cannot get Macros for Hal with name: " + key);
+			theResponse = hals.get(key).getScenes();
+			if(theResponse != null)
+				addHalDevices(deviceList, theResponse, key);
+			else
+				log.warn("Cannot get Scenes for Hal with name: " + key);
+			theResponse = hals.get(key).getButtons();
+			if(theResponse != null)
+				addHalDevices(deviceList, theResponse, key);
+			else
+				log.warn("Cannot get Buttons for Hal with name: " + key);
+		}
+		return deviceList;
+	}
+	
+	private Boolean addHalDevices(List<HalDevice> theDeviceList, List<HalDevice> theSourceList, String theKey) {
+		if(!validHal)
+			return null;
+		Iterator<HalDevice> devices = theSourceList.iterator();
+		while(devices.hasNext()) {
+			HalDevice theDevice = devices.next();
+			theDeviceList.add(theDevice);
+		}
+		return true;
+	}
+
+	@Override
+	public String deviceHandler(CallItem anItem, MultiCommandUtil aMultiUtil, String lightId, int intensity,
+			Integer targetBri,Integer targetBriInc, ColorData colorData, DeviceDescriptor device, String body) {
+		boolean halFound = false;
+		String responseString = null;
+		String theUrl = anItem.getItem().getAsString();
+		if(theUrl != null && !theUrl.isEmpty () && theUrl.contains("http")) {
+			String intermediate = theUrl.substring(theUrl.indexOf("://") + 3);
+			String hostPortion = intermediate.substring(0, intermediate.indexOf('/'));
+//			String theUrlBody = intermediate.substring(intermediate.indexOf('/') + 1);
+//			String hostAddr = null;
+//			String port = null;
+//			if (hostPortion.contains(":")) {
+//				hostAddr = hostPortion.substring(0, intermediate.indexOf(':'));
+//				port = hostPortion.substring(intermediate.indexOf(':') + 1);
+//			} else
+//				hostAddr = hostPortion;
+			log.debug("executing HUE api request to Http "
+					+ (anItem.getHttpVerb() == null ? "GET" : anItem.getHttpVerb()) + ": "
+					+ anItem.getItem().getAsString());
+
+			String anUrl = null;
+			
+			anUrl = BrightnessDecode.calculateReplaceIntensityValue(intermediate, intensity, targetBri, targetBriInc, false);
+			anUrl = DeviceDataDecode.replaceDeviceData(anUrl, device);
+			anUrl = TimeDecode.replaceTimeValue(anUrl);
+			
+			for (Map.Entry<String, HalInfo> entry : hals.entrySet())
+			{
+				if(entry.getValue().getHalAddress().getIp().equals(hostPortion)) {
+					halFound = true;
+			    	if(entry.getValue().getHalAddress().getSecure()!= null && entry.getValue().getHalAddress().getSecure())
+			    		anUrl = "https://" + anUrl;
+			    	else
+			    		anUrl = "http://" + anUrl;
+
+			    	if(!anUrl.contains("?Token="))
+						anUrl = anUrl + "?Token=" + entry.getValue().getHalAddress().getPassword();
+					
+					log.debug("executing HUE api request to Http "
+							+ (anItem.getHttpVerb() == null ? "GET" : anItem.getHttpVerb()) + ": "
+							+ anUrl);
+
+					if (entry.getValue().deviceCommand(anUrl) == null) {
+						log.warn("Error on calling hal to change device state: " + anUrl);
+						responseString = new Gson().toJson(HueErrorResponse.createResponse("6", "/lights/" + lightId,
+								"Error on calling url to change device state", "/lights/"
+								+ lightId + "state", null, null).getTheErrors(), HueError[].class);
+					}
+				}
+			}
+		}
+		
+		if(!halFound) {
+			log.warn("No HAL found to call: " + theUrl);
+			responseString = new Gson().toJson(HueErrorResponse.createResponse("6", "/lights/" + lightId,
+					"No HAL found.", "/lights/"
+					+ lightId + "state", null, null).getTheErrors(), HueError[].class);
+		}
+		return responseString;
+	}
+
+	@Override
+	public Home createHome(BridgeSettings bridgeSettings) {
+		validHal = bridgeSettings.getBridgeSettingsDescriptor().isValidHal();
+		log.info("HAL Home created." + (validHal ? "" : " No HAL devices configured."));
+		if(!validHal)
+			return null;
+		hals = new HashMap<String, HalInfo>();
+		Iterator<NamedIP> theList = bridgeSettings.getBridgeSettingsDescriptor().getHaladdress().getDevices().iterator();
+		while(theList.hasNext()) {
+			NamedIP aHal = theList.next();
+	      	try {
+	      		hals.put(aHal.getName(), new HalInfo(aHal, bridgeSettings.getBridgeSettingsDescriptor().getHaltoken()));
+			} catch (Exception e) {
+		        log.error("Cannot get hal client (" + aHal.getName() + ") setup, Exiting with message: " + e.getMessage(), e);
+		        return null;
+			}
+		}
+		return this;
+	}
+
+	@Override
+	public void closeHome() {
+		log.debug("Closing Home.");
+		if(closed) {
+			log.debug("Home is already closed....");
+			return;
+		}
+		
+		hals = null;
+		closed = true;
+	}
+}

src/main/java/com/bwssystems/HABridge/plugins/hal/HalInfo.java

@@ -0,0 +1,211 @@
+package com.bwssystems.HABridge.plugins.hal;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.bwssystems.HABridge.NamedIP;
+import com.bwssystems.HABridge.plugins.http.HTTPHandler;
+import com.bwssystems.HABridge.plugins.http.HTTPHome;
+import com.bwssystems.HABridge.util.TextStringFormatter;
+import com.google.gson.Gson;
+
+public class HalInfo {
+    private static final Logger log = LoggerFactory.getLogger(HalInfo.class);
+    private static final String DEVICE_REQUEST = "/DeviceData!DeviceCmd=GetNames!DeviceType=";
+    private static final String HVAC_REQUEST = "/HVACData!HVACCmd=GetNames";
+    private static final String GROUP_REQUEST = "/GroupData!GroupCmd=GetNames";
+    private static final String MACRO_REQUEST = "/MacroData!MacroCmd=GetNames";
+    private static final String SCENE_REQUEST = "/SceneData!SceneCmd=GetNames";
+    private static final String IRDATA_REQUEST = "/IrData!IRCmd=GetNames";
+    private static final String IRBUTTON_REQUEST = "/IrData!IRCmd=GetButtons!IrDevice=";
+    private static final String TOKEN_REQUEST = "?Token=";
+    private static final String LIGHT_REQUEST = "Light";
+    private static final String APPL_REQUEST = "Appl";
+    // private static final String VIDEO_REQUEST = "Video";
+    private static final String THEATRE_REQUEST = "Theatre";
+    private static final String CUSTOM_REQUEST = "Custom";
+    private static final String HVAC_TYPE = "HVAC";
+    private static final String HOME_TYPE = "Home";
+    private static final String GROUP_TYPE = "Group";
+    private static final String MACRO_TYPE = "Macro";
+    private static final String SCENE_TYPE = "Scene";
+    private static final String IRDATA_TYPE = "IrData";
+    private HTTPHandler httpClient;
+    private NamedIP halAddress;
+
+    public HalInfo(NamedIP addressName, String aGivenToken) {
+		super();
+        httpClient = HTTPHome.getHandler();
+        halAddress = addressName;
+        if(halAddress.getPassword() == null || halAddress.getPassword().trim().isEmpty())
+        	halAddress.setPassword(aGivenToken);
+	}
+
+	public List<HalDevice> getLights() {
+    	return getHalDevices(DEVICE_REQUEST + LIGHT_REQUEST + TOKEN_REQUEST, LIGHT_REQUEST);
+    }
+
+	public List<HalDevice> getAppliances() {
+    	return getHalDevices(DEVICE_REQUEST + APPL_REQUEST + TOKEN_REQUEST, APPL_REQUEST);
+    }
+
+	public List<HalDevice> getTheatre() {
+    	return getHalDevices(DEVICE_REQUEST + THEATRE_REQUEST + TOKEN_REQUEST, THEATRE_REQUEST);
+    }
+
+	public List<HalDevice> getCustom() {
+    	return getHalDevices(DEVICE_REQUEST + CUSTOM_REQUEST + TOKEN_REQUEST, CUSTOM_REQUEST);
+    }
+
+	public List<HalDevice> getHVAC() {
+    	return getHalDevices(HVAC_REQUEST + TOKEN_REQUEST, HVAC_TYPE);
+    }
+
+	public List<HalDevice> getGroups() {
+    	return getHalDevices(GROUP_REQUEST + TOKEN_REQUEST, GROUP_TYPE);
+    }
+
+	public List<HalDevice> getMacros() {
+    	return getHalDevices(MACRO_REQUEST + TOKEN_REQUEST, MACRO_TYPE);
+    }
+
+	public List<HalDevice> getScenes() {
+    	return getHalDevices(SCENE_REQUEST + TOKEN_REQUEST, SCENE_TYPE);
+    }
+
+	public List<HalDevice> getButtons() {
+		 List<HalDevice> irDataDevices = getHalDevices(IRDATA_REQUEST + TOKEN_REQUEST, IRDATA_TYPE);
+		 
+		 return getDeviceButtons(irDataDevices);
+    }
+
+	public List<HalDevice> getHome(String theDeviceName) {
+		List<HalDevice> deviceList = null;
+    	deviceList = new ArrayList<HalDevice>();
+		HalDevice aNewHalDevice = new HalDevice();
+		aNewHalDevice.setHaldevicetype(HOME_TYPE);
+		aNewHalDevice.setHaldevicename(theDeviceName);
+		deviceList.add(aNewHalDevice);
+    	return deviceList;
+    }
+
+	private List<HalDevice> getHalDevices(String apiType, String deviceType) {
+		DeviceElements theHalApiResponse = null;
+		List<HalDevice> deviceList = null;
+
+		String theUrl = null;
+    	String theData;
+    	if(halAddress.getSecure()!= null && halAddress.getSecure())
+    		theUrl = "https://";
+    	else
+    		theUrl = "http://";
+   		theUrl = theUrl + halAddress.getIp() + apiType + halAddress.getPassword();
+   		theData = httpClient.doHttpRequest(theUrl, null, null, null, null);
+    	if(theData != null) {
+    		log.debug("GET " + deviceType + " HalApiResponse - data: " + theData);
+	    	theHalApiResponse = new Gson().fromJson(theData, DeviceElements.class);
+	    	if(theHalApiResponse == null || theHalApiResponse.getDeviceElements() == null) {
+	    		StatusDescription theStatus = new Gson().fromJson(theData, StatusDescription.class);
+	    		if(theStatus.getStatus() == null) {
+	    			log.warn("Cannot get an devices for type " + deviceType + " for hal " + halAddress.getName() + " as response is not parsable.");
+	    		}
+	    		else {
+	    			log.warn("Cannot get an devices for type " + deviceType + " for hal " + halAddress.getName() + ". Status: " + theStatus.getStatus() + ", with description: " + theStatus.getDescription());
+	    		}
+	        	return deviceList;
+	    	}
+	    	deviceList = new ArrayList<HalDevice>();
+	    	
+	    	Iterator<DeviceName> theDeviceNames = theHalApiResponse.getDeviceElements().iterator();
+	    	while(theDeviceNames.hasNext()) {
+	    		DeviceName theDevice = theDeviceNames.next();
+				HalDevice aNewHalDevice = new HalDevice();
+				aNewHalDevice.setHaldevicetype(deviceType);
+				aNewHalDevice.setHaldevicename(theDevice.getDeviceName());
+				NamedIP theaddress = new NamedIP();
+				theaddress.setIp(halAddress.getIp());
+				theaddress.setName(halAddress.getName());
+				aNewHalDevice.setHaladdress(theaddress);
+				deviceList.add(aNewHalDevice);
+	    		
+	    	}
+    	}
+    	else {
+    		log.warn("Get Hal device types " + deviceType + " for " + halAddress.getName() + " - returned null, no data.");
+    	}
+    	return deviceList;
+    }
+
+	private List<HalDevice> getDeviceButtons(List<HalDevice> theIrDevices) {
+		DeviceElements theHalApiResponse = null;
+		List<HalDevice> deviceList = null;
+
+		String theUrl = null;
+		String theData;
+		if(theIrDevices == null)
+			return null;
+		Iterator<HalDevice> theHalDevices = theIrDevices.iterator();
+		deviceList = new ArrayList<HalDevice>();
+		while (theHalDevices.hasNext()) {
+			HalDevice theHalDevice = theHalDevices.next();
+	    	if(halAddress.getSecure()!= null && halAddress.getSecure())
+	    		theUrl = "https://";
+	    	else
+	    		theUrl = "http://";
+			theUrl = theUrl + halAddress.getIp() + IRBUTTON_REQUEST + TextStringFormatter.forQuerySpaceUrl(theHalDevice.getHaldevicename()) + TOKEN_REQUEST + halAddress.getPassword();
+			theData = httpClient.doHttpRequest(theUrl, null, null, null, null);
+			if (theData != null) {
+				log.debug("GET IrData for IR Device " + theHalDevice.getHaldevicename() + " HalApiResponse - data: " + theData);
+				try {
+					theHalApiResponse = new Gson().fromJson(theData, DeviceElements.class);
+				} catch (Exception e) {
+					theHalApiResponse = null;
+				}
+				if (theHalApiResponse == null || theHalApiResponse.getDeviceElements() == null) {
+					StatusDescription theStatus = new Gson().fromJson(theData, StatusDescription.class);
+					if (theStatus.getStatus() == null) {
+						log.warn("Cannot get buttons for IR Device " + theHalDevice.getHaldevicename() + " for hal "
+								+ halAddress.getName() + " as response is not parsable.");
+					} else {
+						log.warn("Cannot get buttons for IR Device " + theHalDevice.getHaldevicename() + " for hal "
+								+ halAddress.getName() + ". Status: " + theStatus.getStatus() + ", with description: "
+								+ theStatus.getDescription());
+					}
+					return deviceList;
+				}
+				theHalDevice.setButtons(theHalApiResponse);
+				deviceList.add(theHalDevice);
+
+			} else {
+				log.warn("Get Hal buttons for IR Device " + theHalDevice.getHaldevicename() + " for "
+						+ halAddress.getName() + " - returned null, no data.");
+			}
+		}
+		return deviceList;
+	}
+
+	public String deviceCommand(String theUrl) {
+		String theData = null;
+		theData = httpClient.doHttpRequest(theUrl, null, null, null, null);
+		return theData;
+	}
+	
+	public NamedIP getHalAddress() {
+		return halAddress;
+	}
+
+	public void setHalAddress(NamedIP halAddress) {
+		this.halAddress = halAddress;
+	}
+
+	public void closeInfo() {
+		if(httpClient != null)
+			httpClient.closeHandler();
+		httpClient = null;
+		halAddress = null;
+	}
+}

src/main/java/com/bwssystems/HABridge/plugins/hal/StatusDescription.java

@@ -0,0 +1,18 @@
+package com.bwssystems.HABridge.plugins.hal;
+
+public class StatusDescription {
+	private String Status;
+	private String Description;
+	public String getStatus() {
+		return Status;
+	}
+	public void setStatus(String status) {
+		Status = status;
+	}
+	public String getDescription() {
+		return Description;
+	}
+	public void setDescription(String description) {
+		Description = description;
+	}
+}

src/main/java/com/bwssystems/HABridge/plugins/harmony/ButtonPress.java

@@ -0,0 +1,53 @@
+package com.bwssystems.HABridge.plugins.harmony;
+
+public class ButtonPress {
+	private String device;
+	private String button;
+	private Integer delay;
+	private Integer count;
+	private String hub;
+	private Integer pressTime;
+	public String getDevice() {
+		return device;
+	}
+	public void setDevice(String device) {
+		this.device = device;
+	}
+	public String getButton() {
+		return button;
+	}
+	public void setButton(String button) {
+		this.button = button;
+	}
+	public Integer getDelay() {
+		return delay;
+	}
+	public void setDelay(Integer delay) {
+		this.delay = delay;
+	}
+	public Integer getCount() {
+		return count;
+	}
+	public void setCount(Integer count) {
+		this.count = count;
+	}
+	public Boolean isValid() {
+		if (device != null && !device.isEmpty()){
+			if (button != null && !button.isEmpty())
+				return true;
+		}
+		return false;
+	}
+	public String getHub() {
+		return hub;
+	}
+	public void setHub(String hub) {
+		this.hub = hub;
+	}
+	public Integer getPressTime() {
+		return pressTime;
+	}
+	public void setPressTime(Integer pressTime) {
+		this.pressTime = pressTime;
+	}
+}

src/main/java/com/bwssystems/HABridge/plugins/harmony/DevModeResponse.java

@@ -1,4 +1,4 @@
-package com.bwssystems.harmony;
+package com.bwssystems.HABridge.plugins.harmony;
 
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;

src/main/java/com/bwssystems/HABridge/plugins/harmony/HarmonyActivity.java

@@ -1,4 +1,4 @@
-package com.bwssystems.harmony;
+package com.bwssystems.HABridge.plugins.harmony;
 
 import java.io.UnsupportedEncodingException;
 

src/main/java/com/bwssystems/HABridge/plugins/harmony/HarmonyDevice.java

@@ -1,4 +1,4 @@
-package com.bwssystems.harmony;
+package com.bwssystems.HABridge.plugins.harmony;
 
 import java.io.UnsupportedEncodingException;
 

src/main/java/com/bwssystems/HABridge/plugins/harmony/HarmonyHandler.java

@@ -1,4 +1,4 @@
-package com.bwssystems.harmony;
+package com.bwssystems.HABridge.plugins.harmony;
 
 import java.util.List;
 
@@ -62,7 +62,7 @@ public class HarmonyHandler {
 	}
 
 	public Boolean startActivity(RunActivity anActivity) {
-		log.debug("Harmony api start activity requested for: " + anActivity.getName() + " noop mode: " + noopCalls);
+		log.debug("Harmony api start activity requested for: " + anActivity.getName() + " for a hub: " + anActivity.getHub() + " noop mode: " + noopCalls);
 		if (anActivity.isValid()) {
 			try {
 				if (noopCalls || devMode) {
@@ -72,7 +72,7 @@ public class HarmonyHandler {
             				devResponse.setCurrentActivity(devResponse.getConfig().getActivityByName(anActivity.getName()));
             		}
 
-					log.info("noop mode: Harmony api start activity requested for: " + anActivity.getName());
+					log.info("noop mode: Harmony api start activity requested for: " + anActivity.getName() + " for a hub: " + anActivity.getHub());
 				}
 				else
 					harmonyClient.startActivity(Integer.parseInt(anActivity.getName()));
@@ -81,12 +81,12 @@ public class HarmonyHandler {
 					if (!noopCalls)
 						harmonyClient.startActivityByName(anActivity.getName());
 				} catch (IllegalArgumentException ei) {
-					log.error("Error in finding activity: " + anActivity.getName());
+					log.error("Error in finding activity: " + anActivity.getName() + " for a hub: " + anActivity.getHub());
 					return false;
 				}
 			}
 		} else {
-			log.error("Error in finding activity: " + anActivity.getName());
+			log.error("Error in finding activity: " + anActivity.getName() + " for a hub: " + anActivity.getHub());
 			return false;
 		}
 
@@ -94,26 +94,30 @@ public class HarmonyHandler {
 	}
 
 	public Boolean pressButton(ButtonPress aDeviceButton) {
-		log.debug("Harmony api press a button requested for device: " + aDeviceButton.getDevice() + " and a for button: " + aDeviceButton.getButton() + " noop mode: " + noopCalls);
+		log.debug("Harmony api press a button requested for device: " + aDeviceButton.getDevice() + " and a for button: " + aDeviceButton.getButton() + " with pressTime of: " + aDeviceButton.getPressTime() + " for a hub: " + aDeviceButton.getHub() + " noop mode: " + noopCalls);
 		if (aDeviceButton.isValid()) {
 			try {
 				if (noopCalls || devMode) {
-					log.info("noop mode: Harmony api press a button requested for device: " + aDeviceButton.getDevice() + " and a for button: " + aDeviceButton.getButton());
+					log.info("noop mode: Harmony api press a button requested for device: " + aDeviceButton.getDevice() + " and a for button: " + aDeviceButton.getButton() +
+							" with a pressTime of: " + aDeviceButton.getPressTime() + " for a hub: " + aDeviceButton.getHub());
 				}
-            	else
-					harmonyClient.pressButton(Integer.parseInt(aDeviceButton.getDevice()), aDeviceButton.getButton());
-				
+            	else {
+            		if(aDeviceButton.getPressTime() != null && aDeviceButton.getPressTime() > 0)
+            			harmonyClient.pressButton(Integer.parseInt(aDeviceButton.getDevice()), aDeviceButton.getButton(), aDeviceButton.getPressTime());
+            		else
+            			harmonyClient.pressButton(Integer.parseInt(aDeviceButton.getDevice()), aDeviceButton.getButton());
+            	}
 			} catch (IllegalArgumentException e) {
 				try {
 					if (!noopCalls)
 						harmonyClient.pressButton(aDeviceButton.getDevice(), aDeviceButton.getButton());
 				} catch (IllegalArgumentException ei) {
-					log.error("Error in finding device: " + aDeviceButton.getDevice() +" and a button: " + aDeviceButton.getButton());
+					log.error("Error in finding device: " + aDeviceButton.getDevice() +" and a button: " + aDeviceButton.getButton() + " for a hub: " + aDeviceButton.getHub());
 					return false;
 				}
 			}
 		} else {
-			log.error("Error in finding device: " + aDeviceButton.getDevice() +" and a button: " + aDeviceButton.getButton());
+			log.error("Error in finding device: " + aDeviceButton.getDevice() +" and a button: " + aDeviceButton.getButton() + " for a hub: " + aDeviceButton.getHub());
 			return false;
 		}
 

src/main/java/com/bwssystems/HABridge/plugins/harmony/HarmonyHome.java

@@ -0,0 +1,272 @@
+package com.bwssystems.HABridge.plugins.harmony;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.bwssystems.HABridge.BridgeSettings;
+import com.bwssystems.HABridge.DeviceMapTypes;
+import com.bwssystems.HABridge.Home;
+import com.bwssystems.HABridge.IpList;
+import com.bwssystems.HABridge.NamedIP;
+import com.bwssystems.HABridge.api.CallItem;
+import com.bwssystems.HABridge.dao.DeviceDescriptor;
+import com.bwssystems.HABridge.hue.BrightnessDecode;
+import com.bwssystems.HABridge.hue.ColorData;
+import com.bwssystems.HABridge.hue.MultiCommandUtil;
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+
+import net.whistlingfish.harmony.config.Activity;
+import net.whistlingfish.harmony.config.Device;
+
+public class HarmonyHome implements Home {
+    private static final Logger log = LoggerFactory.getLogger(HarmonyHome.class);
+	private Map<String, HarmonyServer> hubs;
+	private Boolean isDevMode;
+	private Boolean validHarmony;
+	private Gson aGsonHandler;
+	private boolean closed;
+
+	public HarmonyHome(BridgeSettings bridgeSettings) {
+		super();
+		closed = true;
+		createHome(bridgeSettings);
+		closed = false;
+	}
+
+	@Override
+	public void closeHome() {
+		if(!validHarmony)
+			return;
+		log.debug("Closing Home.");
+		if(closed) {
+			log.debug("Home is already closed....");
+			return;
+		}
+		if(isDevMode || hubs == null)
+			return;
+		Iterator<String> keys = hubs.keySet().iterator();
+		while(keys.hasNext()) {
+			String key = keys.next();
+			hubs.get(key).getMyHarmony().shutdown();
+		}
+		
+		hubs = null;
+		closed = true;
+	}
+
+	public HarmonyHandler getHarmonyHandler(String aName) {
+		if(!validHarmony)
+			return null;
+		HarmonyHandler aHandler = null;
+		if(aName == null || aName.equals("")) {
+			aName = "default";
+		}
+
+		if(hubs.get(aName) == null) {
+			Set<String> keys = hubs.keySet();
+			if(!keys.isEmpty()) {
+				aHandler = hubs.get(keys.toArray()[0]).getMyHarmony();
+			}
+			else
+				aHandler = null;
+		}
+		else
+			aHandler = hubs.get(aName).getMyHarmony();
+		return aHandler;
+	}
+	
+	public List<HarmonyActivity> getActivities() {
+		Iterator<String> keys = hubs.keySet().iterator();
+		ArrayList<HarmonyActivity> activityList = new ArrayList<HarmonyActivity>();
+		if(!validHarmony)
+			return null;
+		while(keys.hasNext()) {
+			String key = keys.next();
+			Iterator<Activity> activities = hubs.get(key).getMyHarmony().getActivities().iterator();
+			while(activities.hasNext()) {
+				HarmonyActivity anActivity = new HarmonyActivity();
+				anActivity.setActivity(activities.next());
+				anActivity.setHub(key);
+				activityList.add(anActivity);
+			}
+		}
+		return activityList;
+	}
+	public List<HarmonyActivity> getCurrentActivities() {
+		Iterator<String> keys = hubs.keySet().iterator();
+		ArrayList<HarmonyActivity> activityList = new ArrayList<HarmonyActivity>();
+		if(!validHarmony)
+			return null;
+		while(keys.hasNext()) {
+			String key = keys.next();
+			Activity theActivity = hubs.get(key).getMyHarmony().getCurrentActivity();
+			HarmonyActivity anActivity = new HarmonyActivity();
+			anActivity.setActivity(theActivity);
+			anActivity.setHub(key);
+			activityList.add(anActivity);
+		}
+		return activityList;
+	}
+	public List<HarmonyDevice> getDevices() {
+		Iterator<String> keys = hubs.keySet().iterator();
+		ArrayList<HarmonyDevice> deviceList = new ArrayList<HarmonyDevice>();
+		if(!validHarmony)
+			return null;
+		while(keys.hasNext()) {
+			String key = keys.next();
+			Iterator<Device> devices = hubs.get(key).getMyHarmony().getDevices().iterator();
+			while(devices.hasNext()) {
+				HarmonyDevice aDevice = new HarmonyDevice();
+				aDevice.setDevice(devices.next());
+				aDevice.setHub(key);
+				deviceList.add(aDevice);
+			}
+		}
+		return deviceList;
+	}
+
+	@Override
+	public String deviceHandler(CallItem anItem, MultiCommandUtil aMultiUtil, String lightId, int intensity,
+			Integer targetBri,Integer targetBriInc, ColorData colorData, DeviceDescriptor device, String body) {
+		String responseString = null;
+		log.debug("executing HUE api request to change " + anItem.getType() + " to Harmony: " + device.getName());
+		if(!validHarmony) {
+			log.warn("Should not get here, no harmony configured");
+			responseString = "[{\"error\":{\"type\": 6, \"address\": \"/lights/" + lightId
+					+ "\",\"description\": \"Should not get here, no harmony configured\", \"parameter\": \"/lights/"
+					+ lightId + "state\"}}]";			
+		} else {
+			if(anItem.getType().trim().equalsIgnoreCase(DeviceMapTypes.HARMONY_ACTIVITY[DeviceMapTypes.typeIndex]))
+			{
+				RunActivity anActivity = null;
+				if(anItem.getItem().isJsonObject())
+					anActivity = aGsonHandler.fromJson(anItem.getItem(), RunActivity.class);
+				else
+					anActivity = aGsonHandler.fromJson(anItem.getItem().getAsString(), RunActivity.class);
+				if(anActivity.getHub() == null || anActivity.getHub().isEmpty())
+					anActivity.setHub(device.getTargetDevice());
+				HarmonyHandler myHarmony = getHarmonyHandler(anActivity.getHub());
+				if (myHarmony == null) {
+					log.warn("Should not get here, no harmony hub available");
+					responseString = "[{\"error\":{\"type\": 6, \"address\": \"/lights/" + lightId
+							+ "\",\"description\": \"Should not get here, no harmony hub available\", \"parameter\": \"/lights/"
+							+ lightId + "state\"}}]";
+				} else {
+					myHarmony.startActivity(anActivity);
+				}
+			} else if(anItem.getType().trim().equalsIgnoreCase(DeviceMapTypes.HARMONY_BUTTON[DeviceMapTypes.typeIndex])) {
+				String url = null;
+				if(anItem.getItem().isJsonObject() || anItem.getItem().isJsonArray()) {
+					url = aGsonHandler.toJson(anItem.getItem());
+				} else
+					url = anItem.getItem().getAsString();
+
+				if (url.substring(0, 1).equalsIgnoreCase("{")) {
+					url = "[" + url + "]";
+				}
+				
+				url = BrightnessDecode.calculateReplaceIntensityValue(url, intensity, targetBri, targetBriInc, false);
+				ButtonPress[] deviceButtons = aGsonHandler.fromJson(url, ButtonPress[].class);
+	        	Integer theCount = 1;
+        		for(int z = 0; z < deviceButtons.length; z++) {
+	        		if(deviceButtons[z].getCount() != null && deviceButtons[z].getCount() > 0)
+	        			theCount = deviceButtons[z].getCount();
+	        		for(int y = 0; y < theCount; y++) {
+	        			if( y > 0 || z > 0) {
+								try {
+									Thread.sleep(aMultiUtil.getTheDelay());
+								} catch (InterruptedException e) {
+									// ignore
+								}
+							}
+							if (anItem.getDelay() != null && anItem.getDelay() > 0)
+								aMultiUtil.setTheDelay(anItem.getDelay());
+							else
+								aMultiUtil.setTheDelay(aMultiUtil.getDelayDefault());
+	    	        	log.debug("pressing button: " + deviceButtons[z].getDevice() + " - " + deviceButtons[z].getButton() + " with pressTime of: " + deviceButtons[z].getPressTime() + " - iteration: " + String.valueOf(z) + " - count: " + String.valueOf(y));
+	    				if(deviceButtons[z].getHub() == null || deviceButtons[z].getHub().isEmpty())
+	    					deviceButtons[z].setHub(device.getTargetDevice());
+	    				HarmonyHandler myHarmony = getHarmonyHandler(deviceButtons[z].getHub());
+	    				if (myHarmony == null)
+	    					log.warn("Button Press - Should not get here, no harmony hub available");
+	    				else
+	    					myHarmony.pressButton(deviceButtons[z]);
+	        		}
+        		}
+			}
+		}
+		return responseString;
+	}
+
+	@Override
+	public Home createHome(BridgeSettings bridgeSettings) {
+        isDevMode = Boolean.parseBoolean(System.getProperty("dev.mode", "false"));
+        validHarmony = bridgeSettings.getBridgeSettingsDescriptor().isValidHarmony();
+		log.info("Harmony Home created." + (validHarmony ? "" : " No Harmony devices configured.") + (isDevMode ? " DevMode is set." : ""));
+		if(validHarmony || isDevMode) {
+			hubs = new HashMap<String, HarmonyServer>();
+			aGsonHandler =
+					new GsonBuilder()
+					.create();
+			if(isDevMode) {
+				NamedIP devModeIp = new NamedIP();
+				devModeIp.setIp("10.10.10.10");
+				devModeIp.setName("devMode");
+				List<NamedIP> theList = new ArrayList<NamedIP>();
+				theList.add(devModeIp);
+				IpList thedevList = new IpList();
+				thedevList.setDevices(theList);
+				bridgeSettings.getBridgeSettingsDescriptor().setHarmonyAddress(thedevList);
+			}
+			Iterator<NamedIP> theList = bridgeSettings.getBridgeSettingsDescriptor().getHarmonyAddress().getDevices().iterator();
+			while(theList.hasNext() && validHarmony) {
+				NamedIP aHub = theList.next();
+				boolean loopControl = true;
+				int retryCount = 0;
+				while(loopControl) {
+					try {
+			      		hubs.put(aHub.getName(), HarmonyServer.setup(bridgeSettings.getBridgeSettingsDescriptor(), isDevMode, aHub));
+			      		loopControl = false;
+					} catch (Exception e) {
+						if(retryCount > 3) {
+					        log.error("Cannot get harmony client (" + aHub.getName() + ") setup, Exiting with message: " + e.getMessage(), e);
+					        loopControl = false;
+						} else {
+							try {
+								Thread.sleep(2000);
+							} catch (InterruptedException e1) {
+								// ignore
+							}
+						}
+							
+						retryCount++;
+					}
+				}
+			}
+			if(hubs.isEmpty())
+				validHarmony = false;
+		}
+		return this;
+	}
+
+	@Override
+	public Object getItems(String type) {
+		if(validHarmony) {
+			if(type.equalsIgnoreCase(DeviceMapTypes.HARMONY_ACTIVITY[DeviceMapTypes.typeIndex]))
+				return getActivities();
+			if(type.equalsIgnoreCase(DeviceMapTypes.HARMONY_BUTTON[DeviceMapTypes.typeIndex]))
+				return getDevices();
+			if(type.equalsIgnoreCase("current_activity"))
+				return getCurrentActivities();
+		}
+		return null;
+	}
+}

src/main/java/com/bwssystems/HABridge/plugins/harmony/HarmonyServer.java

@@ -0,0 +1,119 @@
+package com.bwssystems.HABridge.plugins.harmony;
+
+import static java.lang.String.format;
+
+import javax.inject.Inject;
+
+import com.bwssystems.HABridge.plugins.http.HTTPHandler;
+import com.bwssystems.HABridge.plugins.http.HTTPHome;
+
+import org.apache.http.client.methods.HttpGet;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.bwssystems.HABridge.BridgeSettingsDescriptor;
+import com.bwssystems.HABridge.NamedIP;
+import com.google.inject.Guice;
+import com.google.inject.Injector;
+
+import net.whistlingfish.harmony.ActivityChangeListener;
+import net.whistlingfish.harmony.HarmonyClient;
+import net.whistlingfish.harmony.HarmonyClientModule;
+import net.whistlingfish.harmony.config.Activity;
+import net.whistlingfish.harmony.protocol.OAReplyProvider;
+
+import java.net.URLEncoder;
+
+public class HarmonyServer {
+
+    private static final String ACTIVIY_ID = "${activity.id}";
+    private static final String ACTIVIY_LABEL = "${activity.label}";
+
+    @Inject
+    private HarmonyClient harmonyClient;
+
+    private HarmonyHandler myHarmony;
+    private DevModeResponse devResponse;
+    private OAReplyProvider dummyProvider;
+    private NamedIP myNameAndIP;
+    private Boolean isDevMode;
+    private HTTPHandler httpClient;
+    private Logger log = LoggerFactory.getLogger(HarmonyServer.class);
+
+    public HarmonyServer(NamedIP theHarmonyAddress) {
+        super();
+        myHarmony = null;
+        dummyProvider = null;
+        myNameAndIP = theHarmonyAddress;
+        isDevMode = false;
+        httpClient = HTTPHome.getHandler();
+    }
+
+    public static HarmonyServer setup(
+            BridgeSettingsDescriptor bridgeSettings,
+            Boolean harmonyDevMode,
+            NamedIP theHarmonyAddress
+    ) throws Exception {
+        if (!bridgeSettings.isValidHarmony() && harmonyDevMode) {
+            return new HarmonyServer(theHarmonyAddress);
+        }
+        Injector injector = null;
+        if (!harmonyDevMode) {
+            injector = Guice.createInjector(new HarmonyClientModule());
+        }
+        HarmonyServer mainObject = new HarmonyServer(theHarmonyAddress);
+        if (!harmonyDevMode) {
+            injector.injectMembers(mainObject);
+        }
+        mainObject.execute(bridgeSettings, harmonyDevMode);
+        return mainObject;
+    }
+
+    private void execute(BridgeSettingsDescriptor mySettings, Boolean harmonyDevMode) throws Exception {
+        Boolean noopCalls = Boolean.parseBoolean(System.getProperty("noop.calls", "false"));
+        isDevMode = harmonyDevMode;
+        String modeString = "";
+        if (dummyProvider != null) {
+            log.debug("something is very wrong as dummyProvider is not null...");
+        }
+        if (isDevMode) {
+            modeString = " (development mode)";
+        } else if (noopCalls) {
+            modeString = " (no op calls to harmony)";
+        }
+        log.info("setup initiated " + modeString + "....");
+        if (isDevMode) {
+            harmonyClient = null;
+            devResponse = new DevModeResponse();
+        } else {
+            devResponse = null;
+            harmonyClient.addListener(new ActivityChangeListener() {
+                @Override
+                public void activityStarted(Activity activity) {
+                    String webhook = myNameAndIP.getWebhook();
+                    if(webhook != null) {
+                        try {
+                            // Replacing variables
+                            webhook = webhook.replace(ACTIVIY_ID, activity.getId().toString());
+                            webhook = webhook.replace(ACTIVIY_LABEL, URLEncoder.encode(activity.getLabel(), "UTF-8"));
+
+                            log.info(format("calling webhook: %s", webhook));
+
+                            // Calling webhook
+                            httpClient.doHttpRequest(webhook, HttpGet.METHOD_NAME, null, null, null);
+                        } catch (Exception e) {
+                            log.warn("could not call webhook: " + webhook, e);
+                        }
+                    }
+                    log.info(format("activity changed: [%d] %s", activity.getId(), activity.getLabel()));
+                }
+            });
+            harmonyClient.connect(myNameAndIP.getIp());
+        }
+        myHarmony = new HarmonyHandler(harmonyClient, noopCalls, devResponse);
+    }
+
+    public HarmonyHandler getMyHarmony() {
+        return myHarmony;
+    }
+}

src/main/java/com/bwssystems/HABridge/plugins/harmony/RunActivity.java

@@ -1,7 +1,8 @@
-package com.bwssystems.harmony;
+package com.bwssystems.HABridge.plugins.harmony;
 
 public class RunActivity {
 	private String name;
+	private String hub;
 
 	public String getName() {
 		return name;
@@ -15,4 +16,12 @@ public class RunActivity {
 			return true;
 		return false;
 	}
+
+	public String getHub() {
+		return hub;
+	}
+
+	public void setHub(String hub) {
+		this.hub = hub;
+	}
 }

src/main/java/com/bwssystems/HABridge/plugins/hass/Field.java

@@ -0,0 +1,29 @@
+
+package com.bwssystems.HABridge.plugins.hass;
+
+import java.util.Map;
+
+import com.google.gson.JsonElement;
+import com.google.gson.annotations.Expose;
+import com.google.gson.annotations.SerializedName;
+
+public class Field {
+
+    @SerializedName("fields")
+    @Expose
+    private Map<String, JsonElement> fields;
+
+	public Field(Map<String, JsonElement> fields) {
+		super();
+		this.fields = fields;
+	}
+
+	public Map<String, JsonElement> getFields() {
+		return fields;
+	}
+
+	public void setFields(Map<String, JsonElement> fields) {
+		this.fields = fields;
+	}
+
+}

src/main/java/com/bwssystems/HABridge/plugins/hass/FieldDeserializer.java

@@ -0,0 +1,31 @@
+package com.bwssystems.HABridge.plugins.hass;
+
+import java.lang.reflect.Type;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Map.Entry;
+
+import com.google.gson.JsonDeserializationContext;
+import com.google.gson.JsonDeserializer;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+
+public class FieldDeserializer implements JsonDeserializer<Field> {
+	private Map<String, JsonElement> fields;
+    @Override
+    public Field deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext ctx)
+    {
+        JsonObject obj = json.getAsJsonObject();
+        String theKey;
+
+        fields = new HashMap<String, JsonElement>();
+        for(Entry<String, JsonElement> entry:obj.entrySet()){
+        	theKey = entry.getKey();
+            JsonElement theRawDetail = obj.get(theKey);
+            fields.put(theKey, theRawDetail);
+        }
+        
+        return new Field(fields);
+    }
+
+}

src/main/java/com/bwssystems/HABridge/plugins/hass/HassCommand.java

@@ -0,0 +1,32 @@
+package com.bwssystems.HABridge.plugins.hass;
+
+public class HassCommand {
+	private String entityId;
+	private String hassName;
+	private String state;
+	private String bri;
+	public String getEntityId() {
+		return entityId;
+	}
+	public void setEntityId(String entityId) {
+		this.entityId = entityId;
+	}
+	public String getHassName() {
+		return hassName;
+	}
+	public void setHassName(String hassName) {
+		this.hassName = hassName;
+	}
+	public String getState() {
+		return state;
+	}
+	public void setState(String state) {
+		this.state = state;
+	}
+	public String getBri() {
+		return bri;
+	}
+	public void setBri(String bri) {
+		this.bri = bri;
+	}	
+}

src/main/java/com/bwssystems/HABridge/plugins/hass/HassDevice.java

@@ -0,0 +1,46 @@
+package com.bwssystems.HABridge.plugins.hass;
+
+public class HassDevice {
+	private State deviceState;
+	private String deviceName;
+	private String domain;
+	private Boolean secure;
+	private String hassaddress;
+	private String hassname;
+	public State getDeviceState() {
+		return deviceState;
+	}
+	public void setDeviceState(State deviceState) {
+		this.deviceState = deviceState;
+	}
+	public String getDeviceName() {
+		return deviceName;
+	}
+	public void setDeviceName(String deviceName) {
+		this.deviceName = deviceName;
+	}
+	public String getDomain() {
+		return domain;
+	}
+	public void setDomain(String domain) {
+		this.domain = domain;
+	}
+	public Boolean getSecure() {
+		return secure;
+	}
+	public void setSecure(Boolean secure) {
+		this.secure = secure;
+	}
+	public String getHassaddress() {
+		return hassaddress;
+	}
+	public void setHassaddress(String hassaddress) {
+		this.hassaddress = hassaddress;
+	}
+	public String getHassname() {
+		return hassname;
+	}
+	public void setHassname(String hassname) {
+		this.hassname = hassname;
+	}
+}

src/main/java/com/bwssystems/HABridge/plugins/hass/HassHome.java

@@ -0,0 +1,174 @@
+package com.bwssystems.HABridge.plugins.hass;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.bwssystems.HABridge.BridgeSettings;
+import com.bwssystems.HABridge.Home;
+import com.bwssystems.HABridge.NamedIP;
+import com.bwssystems.HABridge.api.CallItem;
+import com.bwssystems.HABridge.dao.DeviceDescriptor;
+import com.bwssystems.HABridge.hue.BrightnessDecode;
+import com.bwssystems.HABridge.hue.ColorData;
+import com.bwssystems.HABridge.hue.MultiCommandUtil;
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import com.google.gson.JsonElement;
+
+public class HassHome implements Home {
+    private static final Logger log = LoggerFactory.getLogger(HassHome.class);
+	private Map<String, HomeAssistant> hassMap;
+	private Boolean validHass;
+	private Gson aGsonHandler;
+	private boolean closed;
+	
+	public HassHome(BridgeSettings bridgeSettings) {
+		super();
+		closed = true;
+		createHome(bridgeSettings);
+		closed = false;
+	}
+
+	@Override
+	public Home createHome(BridgeSettings bridgeSettings) {
+		hassMap = null;
+		aGsonHandler = null;
+		validHass = bridgeSettings.getBridgeSettingsDescriptor().isValidHass();
+		log.info("HomeAssistant Home created." + (validHass ? "" : " No HomeAssistants configured."));
+		if(validHass) {
+			hassMap = new HashMap<String,HomeAssistant>();
+			aGsonHandler =
+					new GsonBuilder()
+					.create();
+			Iterator<NamedIP> theList = bridgeSettings.getBridgeSettingsDescriptor().getHassaddress().getDevices().iterator();
+			while(theList.hasNext() && validHass) {
+				NamedIP aHass = theList.next();
+		      	try {
+		      		hassMap.put(aHass.getName(), new HomeAssistant(aHass));
+				} catch (Exception e) {
+			        log.error("Cannot get hass (" + aHass.getName() + ") setup, Exiting with message: " + e.getMessage(), e);
+			        validHass = false;
+				}
+			}
+        }
+		return this;
+	}
+
+	public HomeAssistant getHomeAssistant(String aName) {
+		if(!validHass)
+			return null;
+		HomeAssistant aHomeAssistant;
+		if(aName == null || aName.equals("")) {
+			aHomeAssistant = null;
+			log.debug("Cannot get HomeAssistant for name as it is empty.");
+		}
+		else {
+			aHomeAssistant = hassMap.get(aName);
+			log.debug("Retrieved a HomeAssistant for name: " + aName);
+		}
+		return aHomeAssistant;
+	}
+	
+	@Override
+	public Object getItems(String type) {
+		log.debug("consolidating devices for hass");
+		if(!validHass)
+			return null;
+		List<State> theResponse = null;
+		Iterator<String> keys = hassMap.keySet().iterator();
+		List<HassDevice> deviceList = new ArrayList<HassDevice>();
+		while(keys.hasNext()) {
+			String key = keys.next();
+			theResponse = hassMap.get(key).getDevices();
+			if(theResponse != null)
+				addHassDevices(deviceList, theResponse, key);
+			else {
+				log.warn("Cannot get devices for HomeAssistant with name: " + key + ", skipping this Hass.");
+				continue;
+			}
+		}
+		return deviceList;
+	}
+
+	private Boolean addHassDevices(List<HassDevice> theDeviceList, List<State> theSourceList, String theKey) {
+		if(!validHass)
+			return null;
+		Iterator<State> devices = theSourceList.iterator();
+		while(devices.hasNext()) {
+			State theDevice = devices.next();
+			HassDevice aNewHassDevice = new HassDevice();
+			aNewHassDevice.setDeviceState(theDevice);
+			aNewHassDevice.setHassaddress(hassMap.get(theKey).getHassAddress().getIp());
+			aNewHassDevice.setHassname(theKey);
+			JsonElement friendlyName = theDevice.getAttributes().get("friendly_name");
+			if(friendlyName == null)
+				aNewHassDevice.setDeviceName(theDevice.getEntityId());
+			else
+				aNewHassDevice.setDeviceName(friendlyName.getAsString());
+			aNewHassDevice.setDomain(theDevice.getEntityId().substring(0, theDevice.getEntityId().indexOf(".")));
+			theDeviceList.add(aNewHassDevice);
+		}
+		return true;
+	}
+	
+	@Override
+	public String deviceHandler(CallItem anItem, MultiCommandUtil aMultiUtil, String lightId, int intensity,
+			Integer targetBri,Integer targetBriInc, ColorData colorData, DeviceDescriptor device, String body) {
+		String theReturn = null;
+		log.debug("executing HUE api request to send message to HomeAssistant: " + anItem.getItem().toString());
+		if(!validHass) {
+			log.warn("Should not get here, no HomeAssistant clients configured");
+			theReturn = "[{\"error\":{\"type\": 6, \"address\": \"/lights/" + lightId
+					+ "\",\"description\": \"Should not get here, no HomeAssistants configured\", \"parameter\": \"/lights/"
+					+ lightId + "state\"}}]";
+
+		} else {
+			HassCommand hassCommand = null;
+			if(anItem.getItem().isJsonObject())
+				hassCommand = aGsonHandler.fromJson(anItem.getItem(), HassCommand.class);
+			else
+				hassCommand = aGsonHandler.fromJson(anItem.getItem().getAsString(), HassCommand.class);
+			hassCommand.setBri(BrightnessDecode.replaceIntensityValue(hassCommand.getBri(),
+								BrightnessDecode.calculateIntensity(intensity, targetBri, targetBriInc), false));
+			HomeAssistant homeAssistant = getHomeAssistant(hassCommand.getHassName());
+			if (homeAssistant == null) {
+				log.warn("Should not get here, no HomeAssistants available");
+				theReturn = "[{\"error\":{\"type\": 6, \"address\": \"/lights/" + lightId
+						+ "\",\"description\": \"Should not get here, no HiomeAssistant clients available\", \"parameter\": \"/lights/"
+						+ lightId + "state\"}}]";
+			} else {
+					log.debug("calling HomeAssistant: " + hassCommand.getHassName() + " - "
+							+ hassCommand.getEntityId() + " - " + hassCommand.getState() + " - " + hassCommand.getBri());
+					homeAssistant.callCommand(hassCommand);
+			}
+		}
+		return theReturn;
+	}
+
+	@Override
+	public void closeHome() {
+		if(!validHass)
+			return;
+		log.debug("Closing Home.");
+		if(closed) {
+			log.debug("Home is already closed....");
+			return;
+		}
+		if(hassMap == null)
+			return;
+		Iterator<String> keys = hassMap.keySet().iterator();
+		while(keys.hasNext()) {
+			String key = keys.next();
+			hassMap.get(key).closeClient();
+		}
+		
+		hassMap = null;
+		closed = true;
+	}
+}

src/main/java/com/bwssystems/HABridge/plugins/hass/HomeAssistant.java

@@ -0,0 +1,116 @@
+package com.bwssystems.HABridge.plugins.hass;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import org.apache.http.client.methods.HttpGet;
+import org.apache.http.client.methods.HttpPost;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.bwssystems.HABridge.NamedIP;
+import com.bwssystems.HABridge.api.NameValue;
+import com.bwssystems.HABridge.plugins.http.HTTPHandler;
+import com.bwssystems.HABridge.plugins.http.HTTPHome;
+import com.google.gson.Gson;
+
+public class HomeAssistant {
+    private static final Logger log = LoggerFactory.getLogger(HomeAssistant.class);
+    private NamedIP hassAddress;
+    private HTTPHandler anHttpHandler;
+
+	public HomeAssistant(NamedIP addressName) {
+		super();
+		anHttpHandler = HTTPHome.getHandler();
+        hassAddress = addressName;
+	}
+
+	public NamedIP getHassAddress() {
+		return hassAddress;
+	}
+
+	public void setHassAddress(NamedIP hassAddress) {
+		this.hassAddress = hassAddress;
+	}
+
+	public Boolean callCommand(HassCommand aCommand) {
+		log.debug("calling HomeAssistant: " + aCommand.getHassName() + " - "
+				+ aCommand.getEntityId() + " - " + aCommand.getState() + " - " + aCommand.getBri());
+		String aUrl = null;
+		if(hassAddress.getSecure() != null && hassAddress.getSecure())
+			aUrl = "https";
+		else
+			aUrl = "http";
+		String domain = aCommand.getEntityId().substring(0, aCommand.getEntityId().indexOf("."));
+		aUrl = aUrl + "://" + hassAddress.getIp() + ":" + hassAddress.getPort() + "/api/services/";
+		if(domain.equals("group"))
+			aUrl = aUrl + "homeassistant";
+		else
+			aUrl = aUrl + domain;
+		String aBody = "{\"entity_id\":\"" + aCommand.getEntityId() + "\"";
+		NameValue[] headers = null;
+		if(hassAddress.getPassword() != null && !hassAddress.getPassword().isEmpty()) {
+			NameValue password = new NameValue();
+			password.setName("x-ha-access");
+			password.setValue(hassAddress.getPassword());
+			headers = new NameValue[1];
+			headers[0] = password;
+		}
+		if(aCommand.getState().equalsIgnoreCase("on")) {
+			aUrl = aUrl + "/turn_on";
+			if(aCommand.getBri() != null)
+				aBody = aBody + ",\"brightness\":" + aCommand.getBri() + "}";
+			else
+				aBody = aBody + "}";
+		}
+		else {
+			aUrl = aUrl + "/turn_off";
+			aBody = aBody + "}";			
+		}
+		log.debug("Calling HomeAssistant with url: " + aUrl);
+   		String theData = anHttpHandler.doHttpRequest(aUrl, HttpPost.METHOD_NAME, "application/json", aBody, headers);
+   		log.debug("call Command return is: <" + theData + ">");
+		return true;
+	}
+
+	public List<State> getDevices() {
+		List<State> theDeviceStates = null;
+		State[] theHassStates;
+		String theUrl = null;
+    	String theData;
+		NameValue[] headers = null;
+		if(hassAddress.getPassword() != null && !hassAddress.getPassword().isEmpty()) {
+			NameValue password = new NameValue();
+			password.setName("x-ha-access");
+			password.setValue(hassAddress.getPassword());
+			headers = new NameValue[1];
+			headers[0] = password;
+		}
+		if(hassAddress.getSecure() != null && hassAddress.getSecure())
+			theUrl = "https";
+		else
+			theUrl = "http";
+   		theUrl = theUrl + "://" + hassAddress.getIp() + ":" + hassAddress.getPort() + "/api/states";
+   		theData = anHttpHandler.doHttpRequest(theUrl, HttpGet.METHOD_NAME, "application/json", null, headers);
+    	if(theData != null) {
+    		log.debug("GET Hass States - data: " + theData);
+    		theHassStates = new Gson().fromJson(theData, State[].class);
+	    	if(theHassStates == null) {
+	    		log.warn("Cannot get an devices for HomeAssistant " + hassAddress.getName() + " as response is not parsable.");
+	    	}
+	    	else {
+	    		theDeviceStates = new ArrayList<State>(Arrays.asList(theHassStates));
+	    	}
+    	}
+    	else
+    		log.warn("Cannot get an devices for HomeAssistant " + hassAddress.getName() + " http call failed.");
+		return theDeviceStates;
+	}
+
+	
+	protected void closeClient() {
+		anHttpHandler.closeHandler();
+		anHttpHandler = null;
+	}
+}

src/main/java/com/bwssystems/HABridge/plugins/hass/Service.java

@@ -0,0 +1,60 @@
+
+package com.bwssystems.HABridge.plugins.hass;
+
+import java.util.Map;
+
+import com.google.gson.annotations.Expose;
+import com.google.gson.annotations.SerializedName;
+
+public class Service {
+
+    @SerializedName("domain")
+    @Expose
+    private String domain;
+    @SerializedName("services")
+    @Expose
+    private Map<String, ServiceElement> services;
+
+    public Service(String domain, Map<String, ServiceElement> services) {
+		super();
+		this.domain = domain;
+		this.services = services;
+	}
+
+	/**
+     * 
+     * @return
+     *     The domain
+     */
+    public String getDomain() {
+        return domain;
+    }
+
+    /**
+     * 
+     * @param domain
+     *     The domain
+     */
+    public void setDomain(String domain) {
+        this.domain = domain;
+    }
+
+    /**
+     * 
+     * @return
+     *     The services
+     */
+	public Map<String, ServiceElement> getServices() {
+		return services;
+	}
+
+    /**
+     * 
+     * @param domain
+     *     The services
+     */
+	public void setServices(Map<String, ServiceElement> services) {
+		this.services = services;
+	}
+
+}

src/main/java/com/bwssystems/HABridge/plugins/hass/ServiceDeserializer.java

@@ -0,0 +1,36 @@
+package com.bwssystems.HABridge.plugins.hass;
+
+import java.lang.reflect.Type;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Map.Entry;
+
+import com.google.gson.JsonDeserializationContext;
+import com.google.gson.JsonDeserializer;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+
+public class ServiceDeserializer implements JsonDeserializer<Service> {
+	private Map<String, ServiceElement> services;
+	private String domain;
+    @Override
+    public Service deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext ctx)
+    {
+        JsonObject objServices = json.getAsJsonObject();
+        String theKey;
+        domain = objServices.get("domain").getAsString();
+        JsonObject obj = objServices.get("services").getAsJsonObject();
+        services = new HashMap<String, ServiceElement>();
+        for(Entry<String, JsonElement> entry:obj.entrySet()){
+        	ServiceElement theServiceElement = new ServiceElement();
+        	theKey = entry.getKey();
+	            JsonObject theRawDetail = obj.getAsJsonObject(theKey);
+	            
+	            theServiceElement.setDescription(theRawDetail.get("description").getAsString());
+	            theServiceElement.setField(ctx.deserialize(theRawDetail.get("fields"), Field.class));
+	            services.put(theKey, theServiceElement);
+        } 
+        return new Service(domain, services);
+    }
+
+}

src/main/java/com/bwssystems/HABridge/plugins/hass/ServiceElement.java

@@ -0,0 +1,52 @@
+
+package com.bwssystems.HABridge.plugins.hass;
+
+import com.google.gson.annotations.Expose;
+import com.google.gson.annotations.SerializedName;
+
+public class ServiceElement {
+
+    @SerializedName("description")
+    @Expose
+    private String description;
+    @SerializedName("fields")
+    @Expose
+    private Field fields;
+
+    /**
+     * 
+     * @return
+     *     The description
+     */
+    public String getDescription() {
+        return description;
+    }
+
+    /**
+     * 
+     * @param description
+     *     The description
+     */
+    public void setDescription(String description) {
+        this.description = description;
+    }
+
+    /**
+     * 
+     * @return
+     *     The fields
+     */
+    public Field getFields() {
+        return fields;
+    }
+
+    /**
+     * 
+     * @param fields
+     *     The fields
+     */
+    public void setField(Field fields) {
+        this.fields = fields;
+    }
+
+}

src/main/java/com/bwssystems/HABridge/plugins/hass/State.java

@@ -0,0 +1,117 @@
+package com.bwssystems.HABridge.plugins.hass;
+
+import java.util.Map;
+
+import com.google.gson.JsonElement;
+import com.google.gson.annotations.Expose;
+import com.google.gson.annotations.SerializedName;
+
+public class State {
+
+@SerializedName("attributes")
+@Expose
+private Map<String, JsonElement>  attributes;
+@SerializedName("entity_id")
+@Expose
+private String entityId;
+@SerializedName("last_changed")
+@Expose
+private String lastChanged;
+@SerializedName("last_updated")
+@Expose
+private String lastUpdated;
+@SerializedName("state")
+@Expose
+private String state;
+
+/**
+* 
+* @return
+* The attributes
+*/
+public Map<String, JsonElement>  getAttributes() {
+return attributes;
+}
+
+/**
+* 
+* @param attributes
+* The attributes
+*/
+public void setAttributes(Map<String, JsonElement>  attributes) {
+this.attributes = attributes;
+}
+
+/**
+* 
+* @return
+* The entityId
+*/
+public String getEntityId() {
+return entityId;
+}
+
+/**
+* 
+* @param entityId
+* The entity_id
+*/
+public void setEntityId(String entityId) {
+this.entityId = entityId;
+}
+
+/**
+* 
+* @return
+* The lastChanged
+*/
+public String getLastChanged() {
+return lastChanged;
+}
+
+/**
+* 
+* @param lastChanged
+* The last_changed
+*/
+public void setLastChanged(String lastChanged) {
+this.lastChanged = lastChanged;
+}
+
+/**
+* 
+* @return
+* The lastUpdated
+*/
+public String getLastUpdated() {
+return lastUpdated;
+}
+
+/**
+* 
+* @param lastUpdated
+* The last_updated
+*/
+public void setLastUpdated(String lastUpdated) {
+this.lastUpdated = lastUpdated;
+}
+
+/**
+* 
+* @return
+* The state
+*/
+public String getState() {
+return state;
+}
+
+/**
+* 
+* @param state
+* The state
+*/
+public void setState(String state) {
+this.state = state;
+}
+
+}

src/main/java/com/bwssystems/HABridge/plugins/http/HTTPHandler.java

@@ -0,0 +1,135 @@
+package com.bwssystems.HABridge.plugins.http;
+
+import java.io.IOException;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.nio.charset.Charset;
+
+import org.apache.http.client.ClientProtocolException;
+import org.apache.http.client.methods.CloseableHttpResponse;
+import org.apache.http.client.methods.HttpGet;
+import org.apache.http.client.methods.HttpPost;
+import org.apache.http.client.methods.HttpPut;
+import org.apache.http.client.methods.HttpUriRequest;
+import org.apache.http.entity.ContentType;
+import org.apache.http.entity.StringEntity;
+import org.apache.http.util.EntityUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.bwssystems.HABridge.api.NameValue;
+
+public class HTTPHandler {
+	private static final Logger log = LoggerFactory.getLogger(HTTPHandler.class);
+	
+	public HTTPHandler() {
+		super();
+	}
+
+
+	// This function executes the url from the device repository against the
+	// target as http or https as defined
+	public String doHttpRequest(String url, String httpVerb, String contentType, String body, NameValue[] headers) {
+		log.debug("doHttpRequest with url: " + url + " with http command: " + httpVerb + " with body: " + body);
+		HttpUriRequest request = null;
+		String theContent = null;
+		URI theURI = null;
+		ContentType parsedContentType = null;
+		StringEntity requestBody = null;
+
+		if (contentType != null && !contentType.trim().isEmpty()) {
+			parsedContentType = ContentType.parse(contentType);
+			if (body != null && body.length() > 0)
+				requestBody = new StringEntity(body, parsedContentType);
+		}
+		try {
+			theURI = new URI(url);
+		} catch (URISyntaxException e1) {
+			log.warn("Error creating URI http request: " + url + " with message: " + e1.getMessage());
+			return null;
+		}
+
+		try {
+			if (httpVerb == null || httpVerb.trim().isEmpty() || HttpGet.METHOD_NAME.equalsIgnoreCase(httpVerb)) {
+				request = new HttpGet(theURI);
+			} else if (HttpPost.METHOD_NAME.equalsIgnoreCase(httpVerb)) {
+				HttpPost postRequest = new HttpPost(theURI);
+				if (requestBody != null)
+					postRequest.setEntity(requestBody);
+				request = postRequest;
+			} else if (HttpPut.METHOD_NAME.equalsIgnoreCase(httpVerb)) {
+				HttpPut putRequest = new HttpPut(theURI);
+				if (requestBody != null)
+					putRequest.setEntity(requestBody);
+				request = putRequest;
+			} else
+				request = new HttpGet(theURI);
+
+		} catch (IllegalArgumentException e) {
+			log.warn("Error creating outbound http request: IllegalArgumentException in log", e);
+			return null;
+		}
+		log.debug("Making outbound call in doHttpRequest: <<<" + request.toString() + ">>>");
+		if (headers != null && headers.length > 0) {
+			for (int i = 0; i < headers.length; i++) {
+				request.setHeader(headers[i].getName(), headers[i].getValue());
+			}
+		}
+		CloseableHttpResponse response = null;
+		for (int retryCount = 0; retryCount < 2; retryCount++) {
+			try {
+				response = HttpClientPool.getClient().execute(request);
+				log.debug((httpVerb == null ? "GET" : httpVerb) + " execute (" + retryCount + ") on URL responded: "
+						+ response.getStatusLine().getStatusCode());
+				if (response != null && response.getEntity() != null) {
+					try {
+
+						theContent = EntityUtils.toString(response.getEntity(), Charset.forName("UTF-8")); // read
+																											// content
+																											// for
+																											// data
+
+						EntityUtils.consume(response.getEntity()); // close out
+																	// inputstream
+																	// ignore
+																	// content
+					} catch (Exception e) {
+						log.debug("Error ocurred in handling response entity after successful call, still responding success. "
+										+ e.getMessage(), e);
+					}
+				}
+				if (response != null && response.getStatusLine().getStatusCode() >= 200 && response.getStatusLine().getStatusCode() < 300) {
+					log.debug("Successfull response - The http response is <<<" + theContent + ">>>");
+					retryCount = 2;
+				} else if (response != null) {
+					log.warn("HTTP response code was not an expected successful response of between 200 - 299, the code was: "
+									+ response.getStatusLine());
+					if (response.getStatusLine().getStatusCode() == 504) {
+						log.warn("HTTP response code was 504, retrying...");
+					} else
+						retryCount = 2;
+					
+					theContent = null;
+				}
+				
+			} catch (ClientProtocolException e) {
+				log.warn("Client Protocol Exception received, retyring....");
+			}catch (IOException e) {
+				log.warn("Error calling out to HA gateway: IOException in log: " + e.getMessage());
+				retryCount = 2;
+			}
+
+			if(retryCount < 2) {
+				theContent = null;
+				try {
+					Thread.sleep(1000);
+				} catch (InterruptedException e1) {
+					// noop
+				}
+			}
+		}
+		return theContent;
+	}
+	public void closeHandler() {
+	}
+}

src/main/java/com/bwssystems/HABridge/plugins/http/HTTPHome.java

@@ -0,0 +1,125 @@
+package com.bwssystems.HABridge.plugins.http;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.bwssystems.HABridge.BridgeSettings;
+import com.bwssystems.HABridge.Home;
+import com.bwssystems.HABridge.api.CallItem;
+import com.bwssystems.HABridge.api.NameValue;
+import com.bwssystems.HABridge.api.hue.HueError;
+import com.bwssystems.HABridge.api.hue.HueErrorResponse;
+import com.bwssystems.HABridge.dao.DeviceDescriptor;
+import com.bwssystems.HABridge.hue.BrightnessDecode;
+import com.bwssystems.HABridge.hue.ColorData;
+import com.bwssystems.HABridge.hue.ColorDecode;
+import com.bwssystems.HABridge.hue.DeviceDataDecode;
+import com.bwssystems.HABridge.hue.MultiCommandUtil;
+import com.bwssystems.HABridge.hue.TimeDecode;
+import com.google.gson.Gson;
+
+public class HTTPHome implements Home {
+	private static final Logger log = LoggerFactory.getLogger(HTTPHome.class);
+	private static HTTPHandler anHttpHandler = null;
+	private boolean closed;
+
+	public HTTPHome(BridgeSettings bridgeSettings) {
+		super();
+		closed = true;
+		createHome(bridgeSettings);
+		closed = false;
+	}
+	
+	public static HTTPHandler getHandler() {
+		if(anHttpHandler == null)
+			anHttpHandler = new HTTPHandler();
+		return anHttpHandler;
+	}
+
+	@Override
+	public String deviceHandler(CallItem anItem, MultiCommandUtil aMultiUtil, String lightId, int intensity,
+			Integer targetBri,Integer targetBriInc, ColorData colorData, DeviceDescriptor device, String body) {
+		String responseString = null;
+		
+		String theUrl = anItem.getItem().getAsString();
+		if(theUrl != null && !theUrl.isEmpty () && (theUrl.startsWith("http://") || theUrl.startsWith("https://"))) {
+			//Backwards Compatibility Items
+			if(anItem.getHttpVerb() == null || anItem.getHttpVerb().isEmpty())
+			{
+				if(device.getHttpVerb() != null && !device.getHttpVerb().isEmpty())
+					anItem.setHttpVerb(device.getHttpVerb());
+			}
+	
+			if(anItem.getHttpHeaders() == null || anItem.getHttpHeaders().isEmpty()) {
+				if(device.getHeaders() != null && !device.getHeaders().isEmpty() )
+					anItem.setHttpHeaders(device.getHeaders());
+			}
+	
+			log.debug("executing HUE api request to Http "
+					+ (anItem.getHttpVerb() == null ? "GET" : anItem.getHttpVerb()) + ": "
+					+ anItem.getItem().getAsString());
+
+			String anUrl = BrightnessDecode.calculateReplaceIntensityValue(theUrl,
+					intensity, targetBri, targetBriInc, false);
+			if (colorData != null) {
+				anUrl = ColorDecode.replaceColorData(anUrl, colorData, BrightnessDecode.calculateIntensity(intensity, targetBri, targetBriInc), false);	
+			}
+			anUrl = DeviceDataDecode.replaceDeviceData(anUrl, device);
+			anUrl = TimeDecode.replaceTimeValue(anUrl);
+
+			String aBody = null;
+			if(anItem.getHttpBody()!= null && !anItem.getHttpBody().isEmpty()) {
+				aBody = BrightnessDecode.calculateReplaceIntensityValue(anItem.getHttpBody(),
+						intensity, targetBri, targetBriInc, false);
+				if (colorData != null) {
+					aBody = ColorDecode.replaceColorData(aBody, colorData, BrightnessDecode.calculateIntensity(intensity, targetBri, targetBriInc), false);	
+				}
+				aBody = DeviceDataDecode.replaceDeviceData(aBody, device);
+				aBody = TimeDecode.replaceTimeValue(aBody);
+			}
+			// make call
+			if (anHttpHandler.doHttpRequest(anUrl, anItem.getHttpVerb(), anItem.getContentType(), aBody,
+					new Gson().fromJson(anItem.getHttpHeaders(), NameValue[].class)) == null) {
+				log.warn("Error on calling url to change device state: " + anUrl);
+				responseString = new Gson().toJson(HueErrorResponse.createResponse("6", "/lights/" + lightId,
+						"Error on calling url to change device state", "/lights/"
+						+ lightId + "state", null, null).getTheErrors(), HueError[].class);
+			}
+		} else {
+			log.warn("HTTP Call to be presented as http(s)://<ip_address>(:<port>)/payload, format of request unknown: " + theUrl);
+			responseString = new Gson().toJson(HueErrorResponse.createResponse("6", "/lights/" + lightId,
+					"Error on calling url to change device state", "/lights/"
+					+ lightId + "state", null, null).getTheErrors(), HueError[].class);
+		}
+
+		return responseString;
+	}
+
+	@Override
+	public Home createHome(BridgeSettings bridgeSettings) {
+		if(anHttpHandler == null)
+			anHttpHandler = new HTTPHandler();
+		log.info("Http Home created.");
+		return this;
+	}
+
+	@Override
+	public Object getItems(String type) {
+		// Not a resource
+		return null;
+	}
+
+	@Override
+	public void closeHome() {
+		log.debug("Closing Home.");
+		if(closed) {
+			log.debug("Home is already closed....");
+			return;
+		}
+		if(anHttpHandler != null)
+			anHttpHandler.closeHandler();
+		anHttpHandler = null;
+		closed = true;
+	}
+
+}

src/main/java/com/bwssystems/HABridge/plugins/http/HttpClientPool.java

@@ -0,0 +1,128 @@
+package com.bwssystems.HABridge.plugins.http;
+
+import java.io.IOException;
+import java.util.concurrent.ArrayBlockingQueue;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.TimeUnit;
+
+import org.apache.http.impl.client.CloseableHttpClient;
+import org.apache.http.impl.client.HttpClients;
+import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public final class HttpClientPool {
+  private static final Logger log = LoggerFactory.getLogger(HttpClientPool.class);
+
+  // Single-element enum to implement Singleton.
+  private static enum Singleton {
+    // Just one of me so constructor will be called once.
+    Client;
+    // The thread-safe client.
+    private final CloseableHttpClient threadSafeClient;
+    // The pool monitor.
+    private final IdleConnectionMonitorThread monitor;
+
+    // The constructor creates it - thus late
+    private Singleton() {
+      PoolingHttpClientConnectionManager cm = new PoolingHttpClientConnectionManager();
+      // Increase max total connection to 200
+      cm.setMaxTotal(200);
+      // Increase default max connection per route to 20
+      cm.setDefaultMaxPerRoute(20);
+      // Build the client.
+      threadSafeClient = HttpClients.custom()
+              .setConnectionManager(cm)
+              .build();
+      // Start up an eviction thread.
+      monitor = new IdleConnectionMonitorThread(cm);
+      // Don't stop quitting.
+      monitor.setDaemon(true);
+      monitor.start();
+    }
+
+    public CloseableHttpClient get() {
+      return threadSafeClient;
+    }
+
+  }
+
+  public static CloseableHttpClient getClient() {
+    // The thread safe client is held by the singleton.
+    return Singleton.Client.get();
+  }
+
+  // Watches for stale connections and evicts them.
+  private static class IdleConnectionMonitorThread extends Thread {
+    // The manager to watch.
+    private final PoolingHttpClientConnectionManager cm;
+    // Use a BlockingQueue to stop everything.
+    private final BlockingQueue<Stop> stopSignal = new ArrayBlockingQueue<Stop>(1);
+
+    // Pushed up the queue.
+    private static class Stop {
+      // The return queue.
+      private final BlockingQueue<Stop> stop = new ArrayBlockingQueue<Stop>(1);
+
+      // Called by the process that is being told to stop.
+      public void stopped() {
+        // Push me back up the queue to indicate we are now stopped.
+        stop.add(this);
+      }
+
+      // Called by the process requesting the stop.
+      public void waitForStopped() throws InterruptedException {
+        // Wait until the callee acknowledges that it has stopped.
+        stop.take();
+      }
+
+    }
+
+    IdleConnectionMonitorThread(PoolingHttpClientConnectionManager cm) {
+      super();
+      this.cm = cm;
+    }
+
+    @Override
+    public void run() {
+      try {
+        // Holds the stop request that stopped the process.
+        Stop stopRequest;
+        // Every 5 seconds.
+        while ((stopRequest = stopSignal.poll(5, TimeUnit.SECONDS)) == null) {
+          // Close expired connections
+          cm.closeExpiredConnections();
+          // Optionally, close connections that have been idle too long.
+          cm.closeIdleConnections(60, TimeUnit.SECONDS);
+          // Look at pool stats.
+          log.debug("Stats: {}", cm.getTotalStats());
+        }
+        // Acknowledge the stop request.
+        stopRequest.stopped();
+      } catch (InterruptedException ex) {
+        // terminate
+      }
+    }
+
+    public void shutdown() throws InterruptedException, IOException {
+      log.info("Shutting down client pool");
+      // Signal the stop to the thread.
+      Stop stop = new Stop();
+      stopSignal.add(stop);
+      // Wait for the stop to complete.
+      stop.waitForStopped();
+      // Close the pool - Added
+      Singleton.Client.threadSafeClient.close();
+      // Close the connection manager.
+      cm.close();
+      log.info("Client pool shut down");
+    }
+
+  }
+
+  public static void shutdown() throws InterruptedException, IOException {
+    // Shutdown the monitor.
+    Singleton.Client.monitor.shutdown();
+  }
+
+}

src/main/java/com/bwssystems/HABridge/plugins/hue/HueDevice.java

@@ -1,4 +1,4 @@
-package com.bwssystems.hue;
+package com.bwssystems.HABridge.plugins.hue;
 
 import com.bwssystems.HABridge.api.hue.DeviceResponse;