Merge pull request #1988 from SmartThingsCommunity/staging

Rolling up staging to production

devicetypes/smartthings/aeon-multisensor-6.src/aeon-multisensor-6.groovy

@@ -103,7 +103,7 @@ metadata {
 		}
 
 		valueTile("illuminance", "device.illuminance", inactiveLabel: false, width: 2, height: 2) {
-			state "illuminance", label:'${currentValue} lux', unit:""
+			state "illuminance", label:'${currentValue} ${unit}', unit:"lux"
 		}
 
 		valueTile("ultravioletIndex", "device.ultravioletIndex", inactiveLabel: false, width: 2, height: 2) {
@@ -410,4 +410,4 @@ private command(physicalgraph.zwave.Command cmd) {
 private commands(commands, delay=200) {
 	log.info "sending commands: ${commands}"
 	delayBetween(commands.collect{ command(it) }, delay)
-}
+}

devicetypes/smartthings/aeon-multisensor-gen5.src/aeon-multisensor-gen5.groovy

@@ -86,7 +86,7 @@ metadata {
 			state "humidity", label:'${currentValue}% humidity', unit:""
 		}
 		valueTile("illuminance", "device.illuminance", inactiveLabel: false, width: 2, height: 2) {
-			state "luminosity", label:'${currentValue} lux', unit:""
+			state "luminosity", label:'${currentValue} ${unit}', unit:"lux"
 		}
 		valueTile("battery", "device.battery", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
 			state "battery", label:'${currentValue}% battery', unit:""
@@ -282,4 +282,5 @@ private secure(physicalgraph.zwave.Command cmd) {
 
 private secureSequence(commands, delay=200) {
 	delayBetween(commands.collect{ secure(it) }, delay)
-}
+}
+

devicetypes/smartthings/aeon-multisensor.src/aeon-multisensor.groovy

@@ -79,7 +79,7 @@ metadata {
 			state "humidity", label:'${currentValue}% humidity', unit:""
 		}
 		valueTile("illuminance", "device.illuminance", inactiveLabel: false, width: 2, height: 2) {
-			state "luminosity", label:'${currentValue} lux', unit:""
+			state "luminosity", label:'${currentValue} ${unit}', unit:"lux"
 		}
 		valueTile("battery", "device.battery", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
 			state "battery", label:'${currentValue}% battery', unit:""
@@ -193,4 +193,4 @@ def configure() {
 		// set data reporting period to 5 minutes
 		zwave.configurationV1.configurationSet(parameterNumber: 111, size: 4, scaledConfigurationValue: 300).format()
 	])
-}
+}

devicetypes/stelpro/stelpro-ki-thermostat.src/stelpro-ki-thermostat.groovy

@@ -1,549 +0,0 @@
-/**
- *  Copyright 2017 Stelpro
- *
- *  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
- *  in compliance with the License. You may obtain a copy of the License at:
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed
- *  on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License
- *  for the specific language governing permissions and limitations under the License.
- *
- *  Stelpro Ki Thermostat
- *
- *  Author: Stelpro
- *
- *  Date: 2017-05-08
- */
-
-preferences {
-    input("zipcode", "text", title: "ZipCode (Outdoor Temperature)", description: "[Do not use space](Blank = No Forecast)")
-    input("heatdetails", "enum", title: "Do you want a detailed operating state notification?", options: ["No", "Yes"], defaultValue: "No", required: false, displayDuringSetup: true)
-}
-
-metadata {
-    definition (name: "Stelpro Ki Thermostat", namespace: "stelpro", author: "Stelpro") {
-        capability "Thermostat"
-        capability "Temperature Measurement"
-        capability "Actuator"
-        capability "Polling"
-        capability "Refresh"
-        capability "Sensor"
-        capability "Configuration"
-
-        attribute "outsideTemp", "number"
-
-        command "switchMode"
-        command "quickSetHeat"
-        command "quickSetOutTemp"
-        command "increaseHeatSetpoint"
-        command "decreaseHeatSetpoint"
-        command "setCustomThermostatMode"
-        command "eco"
-        command "applyNow"
-
-        fingerprint deviceId: "0x0806", inClusters: "0x5E,0x86,0x72,0x40,0x43,0x31,0x85,0x59,0x5A,0x73,0x20,0x42"
-    }
-
-    // simulator metadata
-    simulator {
-        //Add test code here
-    }
-
-    tiles {
-		multiAttributeTile(name:"thermostatMulti", type:"thermostat", width:6, height:4) {
-			tileAttribute("device.temperature", key: "PRIMARY_CONTROL") {
-				attributeState("temp", label:'${currentValue}')
-                attributeState("high", label:'HIGH')
-            	attributeState("low", label:'LOW')
-            	attributeState("--", label:'--')
-			}
-            tileAttribute("device.heatingSetpoint", key: "VALUE_CONTROL") {
-				attributeState("VALUE_UP", action: "increaseHeatSetpoint")
-                attributeState("VALUE_DOWN", action: "decreaseHeatSetpoint")
-			}
-			tileAttribute("device.thermostatOperatingState", key: "OPERATING_STATE") {
-				attributeState("idle", backgroundColor:"#44b621")
-				attributeState("heating", backgroundColor:"#ffa81e")
-			}
-			tileAttribute("device.thermostatMode", key: "THERMOSTAT_MODE") {
-				attributeState("off", label:'Off')
-				attributeState("comfort", label:'Comfort')
-				attributeState("eco", label:'Eco')
-			}
-            tileAttribute("device.heatingSetpoint", key: "HEATING_SETPOINT")
-            {
-            	attributeState("heatingSetpoint", label:'${currentValue}')
-            }
-		}
-        standardTile("mode", "device.thermostatMode", width: 2, height: 2) {
-        	state "off", label:'${name}', action:"switchMode", nextState:"to_comfort", icon:"st.thermostat.off"
-			state "comfort", label:'${name}', action:"switchMode", nextState:"to_eco", icon:"http://cdn.device-icons.smartthings.com/Home/home29-icn@2x.png"
-			state "eco", label:'${name}', action:"switchMode", nextState:"...", icon:"http://cdn.device-icons.smartthings.com/Outdoor/outdoor3-icn@2x.png"
-			state "to_comfort", label: "comfort", action:"switchMode", nextState:"to_eco"
-			state "to_eco", label: "eco", action:"switchMode", nextState:"..."
-			state "...", label: "...", action:"heat", nextState:"comfort"
-        }
-        valueTile("heatingSetpoint", "device.heatingSetpoint", width: 2, height: 2) {
-            state "temperature", label:'Setpoint\n${currentValue}°', backgroundColors:[
-                    [value: 31, color: "#153591"],
-                    [value: 44, color: "#1e9cbb"],
-                    [value: 59, color: "#90d2a7"],
-                    [value: 74, color: "#44b621"],
-                    [value: 84, color: "#f1d801"],
-                    [value: 95, color: "#d04e00"],
-                    [value: 96, color: "#bc2323"]
-            ]
-            state "--", label:'--', backgroundColor:"#bdbdbd"
-        }
-        standardTile("refresh", "device.refresh", decoration: "flat", width: 2, height: 2) {
-            state "default", action:"refresh.refresh", icon:"st.secondary.refresh"
-        }
-        main ("thermostatMulti")
-        details(["thermostatMulti", "mode", "heatingSetpoint", "refresh"])
-    }
-}
-
-def parse(String description)
-{
-	if (description == "updated")
-    	return []
-
-    def unitScale = getTemperatureScale()
-    //Class, version
-    def map = createEvent(zwaveEvent(zwave.parse(description, [0x40:2, 0x43:2, 0x31:3, 0x42:1])))
-    if (!map) {
-        return null
-    }
-
-    def result = [map]
-    if (map.name in ["heatingSetpoint","thermostatMode"]) {
-        def map2 = [
-                name: "thermostatSetpoint",
-                unit: getTemperatureScale()
-        ]
-        if (map.name == "thermostatMode") {
-            state.lastTriedMode = map.value
-        }
-        else {
-            def mode = device.latestValue("thermostatMode")
-            log.info "THERMOSTAT, latest mode = ${mode}"
-            if (map.name == "heatingSetpoint") {
-                map2.value = map.value
-                map2.unit = map.unit
-            }
-        }
-        if (map2.value != null) {
-            log.debug "THERMOSTAT, adding setpoint event: $map"
-            result << createEvent(map2)
-        }
-    }
-    log.debug "Parse returned $result"
-    result
-}
-
-// Event Generation
-def zwaveEvent(physicalgraph.zwave.commands.thermostatsetpointv2.ThermostatSetpointReport cmd)
-{
-    def cmdScale = cmd.scale == 1 ? "F" : "C"
-    def temp;
-    float tempfloat;
-    def map = [:]
-    if (cmd.scaledValue >= 327)
-    {
-    	map.value = "--"
-    }
-    else
-    {
-        temp = convertTemperatureIfNeeded(cmd.scaledValue, cmdScale, cmd.precision)
-        tempfloat = (Math.round(temp.toFloat() * 2)) / 2
-        map.value = tempfloat
-    }
-    map.unit = getTemperatureScale()
-    map.displayed = false
-    switch (cmd.setpointType) {
-        case 1:
-            map.name = "heatingSetpoint"
-            break;
-        default:
-            return [:]
-    }
-    // So we can respond with same format
-    state.size = cmd.size
-    state.scale = cmd.scale
-    state.precision = cmd.precision
-    sendEvent(name:"heatingSetpoint", value:map.value)
-    map
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.sensormultilevelv3.SensorMultilevelReport cmd)
-{
-    def temp;
-    float tempfloat;
-    def format;
-    def map = [:]
-    if (cmd.sensorType == 1) {
-        map.value = convertTemperatureIfNeeded(cmd.scaledSensorValue, cmd.scale == 1 ? "F" : "C", cmd.precision)
-        map.unit = getTemperatureScale()
-        map.name = "temperature"
-
-        temp = map.value
-        if (temp == "32765")		//0x7FFD
-        {
-            map.value = "low"
-        }
-        else if (temp == "32767")	//0x7FFF
-        {
-            map.value = "high"
-        }
-        else if (temp == "-32768")	//0x8000
-        {
-            map.value = "--"
-        }
-        else
-        {
-    		tempfloat = (Math.round(temp.toFloat() * 2)) / 2
-    		map.value = tempfloat
-        }
-
-    } else if (cmd.sensorType == 5) {
-        map.value = cmd.scaledSensorValue
-        map.unit = "%"
-        map.name = "humidity"
-    }
-    sendEvent(name:"temperature", value:map.value)
-    map
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.thermostatoperatingstatev1.ThermostatOperatingStateReport cmd)
-{
-    def map = [:]
-    switch (cmd.operatingState) {
-        case physicalgraph.zwave.commands.thermostatoperatingstatev1.ThermostatOperatingStateReport.OPERATING_STATE_IDLE:
-        map.value = "idle"
-        break
-        case physicalgraph.zwave.commands.thermostatoperatingstatev1.ThermostatOperatingStateReport.OPERATING_STATE_HEATING:
-        map.value = "heating"
-        break
-    }
-    map.name = "thermostatOperatingState"
-    
-    if (settings.heatdetails == "No") {
-    	map.displayed = false
-    }
-    
-    map
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.thermostatmodev2.ThermostatModeReport cmd) {
-    def map = [:]
-    switch (cmd.mode) {
-        case physicalgraph.zwave.commands.thermostatmodev2.ThermostatModeReport.MODE_HEAT:
-            map.value = "comfort"
-            break
-        case physicalgraph.zwave.commands.thermostatmodev2.ThermostatModeReport.MODE_OFF:
-            map.value = "off"
-            break
-        default:
-            map.value = "eco"
-            break
-    }
-    map.name = "thermostatMode"
-    sendEvent(name:"thermostatMode", value:map.value)
-    map
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.associationv2.AssociationReport cmd) {
-	delayBetween([
-    	zwave.associationV1.associationRemove(groupingIdentifier:1, nodeId:0).format(),
-        zwave.associationV1.associationSet(groupingIdentifier:1, nodeId:[zwaveHubNodeId]).format(),
-        poll()
-    ], 2300)
-}
-
-
-def zwaveEvent(physicalgraph.zwave.commands.thermostatmodev2.ThermostatModeSupportedReport cmd) {
-    log.debug "Zwave event received: $cmd"
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.basicv1.BasicReport cmd) {
-    log.debug "Zwave event received: $cmd"
-}
-
-def zwaveEvent(physicalgraph.zwave.Command cmd) {
-    log.warn "Unexpected zwave command $cmd"
-}
-
-// Command Implementations
-def poll() {
-    def weather
-
-    // If there is a zipcode defined, weather forecast will be sent. Otherwise, no weather forecast.
-    if (settings.zipcode) {
-        log.debug "ZipCode: ${settings.zipcode}"
-        weather = getWeatherFeature( "conditions", settings.zipcode )
-
-        // Check if the variable is populated, otherwise return.
-        if (!weather) {
-            log.debug( "Something went wrong, no data found." )
-            return false
-        }
-
-        // Set the tiles
-        def locationScale = getTemperatureScale()
-        def tempToSend
-        if (locationScale == "C")
-        {
-            log.debug( "Outdoor Temperature: ${weather.current_observation.temp_c}ºC" )
-            sendEvent( name: 'outsideTemp', value: weather.current_observation.temp_c )
-            tempToSend = weather.current_observation.temp_c
-        }
-        else
-        {
-            log.debug( "Outdoor Temperature: ${weather.current_observation.temp_f}ºF" )
-            sendEvent( name: 'outsideTemp', value: weather.current_observation.temp_f )
-            tempToSend = weather.current_observation.temp_f
-        }
-
-
-        delayBetween([
-                quickSetOutTemp(tempToSend),
-                zwave.thermostatOperatingStateV1.thermostatOperatingStateGet().format(),
-                zwave.thermostatModeV2.thermostatModeGet().format(),
-                zwave.thermostatSetpointV2.thermostatSetpointGet(setpointType: 1).format(),
-                zwave.sensorMultilevelV3.sensorMultilevelGet().format(), // current temperature
-                sendEvent( name: 'change', value: 0 )
-        ], 100)
-    } else {
-        delayBetween([
-                zwave.thermostatOperatingStateV1.thermostatOperatingStateGet().format(),
-                zwave.thermostatModeV2.thermostatModeGet().format(),
-                zwave.thermostatSetpointV2.thermostatSetpointGet(setpointType: 1).format(),
-                zwave.sensorMultilevelV3.sensorMultilevelGet().format(), // current temperature
-                sendEvent( name: 'change', value: 0 )
-        ], 100)
-    }
-}
-
-def refresh() {
-	poll()
-}
-
-def configure() {
-	poll()
-}
-
-def applyNow() {
-    float currentHeatSetpoint = device.currentValue("heatingSetpoint")
-    def deviceScale
-    def locationScale = getTemperatureScale()
-
-    sendEvent( name: 'change', value: 0 )
-    log.debug("currentHeatSetpoint $currentHeatSetpoint")
-    if (locationScale == "C")
-    {
-        deviceScale = 0
-    }
-    else
-    {
-        deviceScale = 1
-    }
-
-    delayBetween([
-            zwave.thermostatSetpointV2.thermostatSetpointSet(setpointType: 1, scale: deviceScale, precision: state.precision, scaledValue: currentHeatSetpoint).format(),
-            poll()
-    ], 1000)
-}
-
-def quickSetHeat(degrees) {
-    setHeatingSetpoint(degrees, 0)
-}
-
-def setHeatingSetpoint(degrees, delay = 0) {
-    sendEvent(name:"heatingSetpoint", value:degrees)
-    applyNow()
-}
-
-def quickSetOutTemp(degrees) {
-    setOutdoorTemperature(degrees, 0)
-}
-
-def setOutdoorTemperature(degrees, delay = 0) {
-    setOutdoorTemperature(degrees.toDouble(), delay)
-}
-
-def setOutdoorTemperature(Double degrees, Integer delay = 0) {
-    def deviceScale
-    def locationScale = getTemperatureScale()
-    def p = (state.precision == null) ? 1 : state.precision
-
-    if (locationScale == "C")
-    {
-        deviceScale = 0
-    }
-    else
-    {
-        deviceScale = 1
-    }
-    log.info "setOutdoorTemperature: ${degrees}"
-    zwave.sensorMultilevelV3.sensorMultilevelReport(sensorType: 1, scale: deviceScale, precision: p,  scaledSensorValue: degrees).format()
-}
-
-def increaseHeatSetpoint()
-{
-	def currentMode = device.currentState("thermostatMode")?.value
-    if (currentMode != "off")
-    {
-        float currentSetpoint = device.currentValue("heatingSetpoint")
-        def locationScale = getTemperatureScale()
-        float maxSetpoint
-        float step
-
-        if (locationScale == "C")
-        {
-            maxSetpoint = 30;
-            step = 0.5
-        }
-        else
-        {
-            maxSetpoint = 86
-            step = 1
-        }
-
-        if (currentSetpoint < maxSetpoint)
-        {
-            currentSetpoint = currentSetpoint + step
-            quickSetHeat(currentSetpoint)
-        }
-    }
-}
-
-def decreaseHeatSetpoint()
-{
-	def currentMode = device.currentState("thermostatMode")?.value
-    if (currentMode != "off")
-    {
-        float currentSetpoint = device.currentValue("heatingSetpoint")
-        def locationScale = getTemperatureScale()
-        float minSetpoint
-        float step
-
-        if (locationScale == "C")
-        {
-            minSetpoint = 5;
-            step = 0.5
-        }
-        else
-        {
-            minSetpoint = 41
-            step = 1
-        }
-
-        if (currentSetpoint > minSetpoint)
-        {
-            currentSetpoint = currentSetpoint - step
-            quickSetHeat(currentSetpoint)
-        }
-    }
-}
-
-def switchMode() {
-    def currentMode = device.currentState("thermostatMode")?.value
-    def lastTriedMode = state.lastTriedMode ?: currentMode ?: "comfort"
-    def supportedModes = getDataByName("supportedModes")
-    def modeOrder = modes()
-    def next = { modeOrder[modeOrder.indexOf(it) + 1] ?: modeOrder[0] }
-    def nextMode = next(lastTriedMode)
-    if (supportedModes?.contains(currentMode)) {
-        while (!supportedModes.contains(nextMode) && nextMode != "comfort") {
-            nextMode = next(nextMode)
-        }
-    }
-    state.lastTriedMode = nextMode
-    delayBetween([
-            zwave.thermostatModeV2.thermostatModeSet(mode: modeMap[nextMode]).format(),
-            poll()
-    ], 1000)
-}
-
-def modes() {
-    ["comfort", "eco", "off"]
-}
-
-def getModeMap() { [
-		"off": 0,
-        "comfort": 1,
-        "eco": 11,
-]}
-
-def getDataByName(String name) {
-    state[name] ?: device.getDataValue(name)
-}
-
-def setCoolingSetpoint(coolingSetpoint) {
-    log.trace "${device.displayName} does not support cool setpoint"
-}
-
-def off() {
-    log.trace "off mode applied"
-	delayBetween([
-		zwave.thermostatModeV2.thermostatModeSet(mode: 0).format(),
-		poll()
-	], 1000)
-}
-
-def heat() {
-	log.trace "heat mode applied"
-	delayBetween([
-		zwave.thermostatModeV2.thermostatModeSet(mode: 1).format(),
-		poll()
-	], 1000)
-}
-
-def eco() {
-	log.trace "eco mode applied"
-	delayBetween([
-		zwave.thermostatModeV2.thermostatModeSet(mode: 11).format(),
-		poll()
-	], 1000)
-}
-
-def auto() {
-    log.trace "${device.displayName} does not support auto mode"
-}
-
-def emergencyHeat() {
-    log.trace "${device.displayName} does not support emergency heat mode"
-}
-
-def cool() {
-    log.trace "${device.displayName} does not support cool mode"
-}
-
-def setCustomThermostatMode(mode) {
-   setThermostatMode(mode)
-}
-
-def setThermostatMode(String value) {
-	delayBetween([
-		zwave.thermostatModeV2.thermostatModeSet(mode: modeMap[value]).format(),
-		poll()
-	], 1000)
-}
-
-def fanOn() {
-    log.trace "${device.displayName} does not support fan on"
-}
-
-def fanAuto() {
-    log.trace "${device.displayName} does not support fan auto"
-}
-
-def fanCirculate() {
-    log.trace "${device.displayName} does not support fan circulate"
-}
-
-def setThermostatFanMode() {
-    log.trace "${device.displayName} does not support fan mode"
-}

smartapps/opent2t/opent2t-smartapp-test.src/opent2t-smartapp-test.groovy

@@ -1,3 +1,7 @@
+import javax.crypto.Mac;
+import javax.crypto.spec.SecretKeySpec;
+import java.security.InvalidKeyException;
+
 /**
  *  OpenT2T SmartApp Test
  *
@@ -39,7 +43,7 @@ definition(
  *  garageDoors         | door          | open, close           | unknown, closed, open, closing, opening
  *  cameras             | image         | take                  | <String>
  *  thermostats         | thermostat    | setHeatingSetpoint,   | temperature, heatingSetpoint, coolingSetpoint,
- *	                    |				| setCoolingSetpoint,   | thermostatSetpoint, thermostatMode,
+ * 	                    |				| setCoolingSetpoint,   | thermostatSetpoint, thermostatMode,
  *                      |				| off, heat, cool, auto,| thermostatFanMode, thermostatOperatingState
  *                      |				| emergencyHeat,        |
  *                      |				| setThermostatMode,    |
@@ -55,7 +59,7 @@ preferences {
 		input "contactSensors", "capability.contactSensor", title: "Which Contact Sensors", multiple: true, required: false, hideWhenEmpty: true
 		input "garageDoors", "capability.garageDoorControl", title: "Which Garage Doors?", multiple: true, required: false, hideWhenEmpty: true
 		input "locks", "capability.lock", title: "Which Locks?", multiple: true, required: false, hideWhenEmpty: true
-		input "cameras", "capability.videoCapture", title: "Which Cameras?",  multiple: true, required: false, hideWhenEmpty: true
+		input "cameras", "capability.videoCapture", title: "Which Cameras?", multiple: true, required: false, hideWhenEmpty: true
 		input "motionSensors", "capability.motionSensor", title: "Which Motion Sensors?", multiple: true, required: false, hideWhenEmpty: true
 		input "presenceSensors", "capability.presenceSensor", title: "Which Presence Sensors", multiple: true, required: false, hideWhenEmpty: true
 		input "switches", "capability.switch", title: "Which Switches and Lights?", multiple: true, required: false, hideWhenEmpty: true
@@ -66,44 +70,49 @@ preferences {
 
 def getInputs() {
 	def inputList = []
-	inputList += contactSensors?: []
+	inputList += contactSensors ?: []
-	inputList += garageDoors?: []
+	inputList += garageDoors ?: []
-	inputList += locks?: []
+	inputList += locks ?: []
-	inputList += cameras?: []
+	inputList += cameras ?: []
-	inputList += motionSensors?: []
+	inputList += motionSensors ?: []
-	inputList += presenceSensors?: []
+	inputList += presenceSensors ?: []
-	inputList += switches?: []
+	inputList += switches ?: []
-	inputList += thermostats?: []
+	inputList += thermostats ?: []
-	inputList += waterSensors?: []
+	inputList += waterSensors ?: []
 	return inputList
 }
 
 //API external Endpoints
 mappings {
 	path("/devices") {
-		action: [
+		action:
+		[
 				GET: "getDevices"
 		]
 	}
 	path("/devices/:id") {
-		action: [
+		action:
+		[
 				GET: "getDevice"
 		]
 	}
 	path("/update/:id") {
-		action: [
+		action:
+		[
 				PUT: "updateDevice"
 		]
 	}
 	path("/deviceSubscription") {
-		action: [
+		action:
-				POST: "registerDeviceChange",
+		[
+				POST  : "registerDeviceChange",
 				DELETE: "unregisterDeviceChange"
 		]
 	}
 	path("/locationSubscription") {
-		action: [
+		action:
-				POST: "registerDeviceGraph",
+		[
+				POST  : "registerDeviceGraph",
 				DELETE: "unregisterDeviceGraph"
 		]
 	}
@@ -116,14 +125,21 @@ def installed() {
 
 def updated() {
 	log.debug "Updating with settings: ${settings}"
-	if(state.deviceSubscriptionMap == null){
+
+	//Initialize state variables if didn't exist.
+	if (state.deviceSubscriptionMap == null) {
 		state.deviceSubscriptionMap = [:]
 		log.debug "deviceSubscriptionMap created."
 	}
-	if( state.locationSubscriptionMap == null){
+	if (state.locationSubscriptionMap == null) {
 		state.locationSubscriptionMap = [:]
 		log.debug "locationSubscriptionMap created."
 	}
+	if (state.verificationKeyMap == null) {
+		state.verificationKeyMap = [:]
+		log.debug "verificationKeyMap created."
+	}
+
 	unsubscribe()
 	registerAllDeviceSubscriptions()
 }
@@ -132,9 +148,11 @@ def initialize() {
 	log.debug "Initializing with settings: ${settings}"
 	state.deviceSubscriptionMap = [:]
 	log.debug "deviceSubscriptionMap created."
-	registerAllDeviceSubscriptions()
 	state.locationSubscriptionMap = [:]
 	log.debug "locationSubscriptionMap created."
+	state.verificationKeyMap = [:]
+	log.debug "verificationKeyMap created."
+	registerAllDeviceSubscriptions()
 }
 
 /*** Subscription Functions  ***/
@@ -144,47 +162,43 @@ def registerAllDeviceSubscriptions() {
 	registerChangeHandler(inputs)
 }
 
-//Subscribe to events from a list of devices
-def registerChangeHandler(myList) {
-	myList.each { myDevice ->
-		def theAtts = myDevice.supportedAttributes
-		theAtts.each {att ->
-			subscribe(myDevice, att.name, deviceEventHandler)
-			log.info "Registering for ${myDevice.displayName}.${att.name}"
-		}
-	}
-}
-
 //Endpoints function: Subscribe to events from a specific device
 def registerDeviceChange() {
 	def subscriptionEndpt = params.subscriptionURL
 	def deviceId = params.deviceId
 	def myDevice = findDevice(deviceId)
-	if( myDevice == null ){
+
+	if (myDevice == null) {
 		httpError(404, "Cannot find device with device ID ${deviceId}.")
 	}
 
 	def theAtts = myDevice.supportedAttributes
 	try {
-		theAtts.each {att ->
+		theAtts.each { att ->
 			subscribe(myDevice, att.name, deviceEventHandler)
 		}
 		log.info "Subscribing for ${myDevice.displayName}"
 
-		if(subscriptionEndpt != null){
+		if (subscriptionEndpt != null) {
-			if(state.deviceSubscriptionMap[deviceId] == null){
+			if (state.deviceSubscriptionMap[deviceId] == null) {
 				state.deviceSubscriptionMap.put(deviceId, [subscriptionEndpt])
 				log.info "Added subscription URL: ${subscriptionEndpt} for ${myDevice.displayName}"
-			} else if (!state.deviceSubscriptionMap[deviceId].contains(subscriptionEndpt)){
+			} else if (!state.deviceSubscriptionMap[deviceId].contains(subscriptionEndpt)) {
 				state.deviceSubscriptionMap[deviceId] << subscriptionEndpt
 				log.info "Added subscription URL: ${subscriptionEndpt} for ${myDevice.displayName}"
 			}
+
+			if (params.key != null) {
+				state.verificationKeyMap[subscriptionEndpt] = params.key
+				log.info "Added verification key: ${params.key} for ${subscriptionEndpt}"
+			}
 		}
 	} catch (e) {
 		httpError(500, "something went wrong: $e")
 	}
 
 	log.info "Current subscription map is ${state.deviceSubscriptionMap}"
+	log.info "Current verification key map is ${state.verificationKeyMap}"
 	return ["succeed"]
 }
 
@@ -194,18 +208,19 @@ def unregisterDeviceChange() {
 	def deviceId = params.deviceId
 	def myDevice = findDevice(deviceId)
 
-	if( myDevice == null ){
+	if (myDevice == null) {
 		httpError(404, "Cannot find device with device ID ${deviceId}.")
 	}
 
 	try {
-		if(subscriptionEndpt != null && subscriptionEndpt != "undefined"){
+		if (subscriptionEndpt != null && subscriptionEndpt != "undefined") {
-			if (state.deviceSubscriptionMap[deviceId]?.contains(subscriptionEndpt)){
+			if (state.deviceSubscriptionMap[deviceId]?.contains(subscriptionEndpt)) {
-				if(state.deviceSubscriptionMap[deviceId].size() == 1){
+				if (state.deviceSubscriptionMap[deviceId].size() == 1) {
 					state.deviceSubscriptionMap.remove(deviceId)
 				} else {
 					state.deviceSubscriptionMap[deviceId].remove(subscriptionEndpt)
 				}
+				state.verificationKeyMap.remove(subscriptionEndpt)
 				log.info "Removed subscription URL: ${subscriptionEndpt} for ${myDevice.displayName}"
 			}
 		} else {
@@ -217,25 +232,33 @@ def unregisterDeviceChange() {
 	}
 
 	log.info "Current subscription map is ${state.deviceSubscriptionMap}"
+	log.info "Current verification key map is ${state.verificationKeyMap}"
 }
 
 //Endpoints function: Subscribe to device additiona/removal updated in a location
 def registerDeviceGraph() {
 	def subscriptionEndpt = params.subscriptionURL
 
-	if (subscriptionEndpt != null && subscriptionEndpt != "undefined"){
+	if (subscriptionEndpt != null && subscriptionEndpt != "undefined") {
 		subscribe(location, "DeviceCreated", locationEventHandler, [filterEvents: false])
 		subscribe(location, "DeviceUpdated", locationEventHandler, [filterEvents: false])
 		subscribe(location, "DeviceDeleted", locationEventHandler, [filterEvents: false])
 
-		if(state.locationSubscriptionMap[location.id] == null){
+		if (state.locationSubscriptionMap[location.id] == null) {
 			state.locationSubscriptionMap.put(location.id, [subscriptionEndpt])
 			log.info "Added subscription URL: ${subscriptionEndpt} for Location ${location.name}"
-		} else if (!state.locationSubscriptionMap[location.id].contains(subscriptionEndpt)){
+		} else if (!state.locationSubscriptionMap[location.id].contains(subscriptionEndpt)) {
 			state.locationSubscriptionMap[location.id] << subscriptionEndpt
 			log.info "Added subscription URL: ${subscriptionEndpt} for Location ${location.name}"
 		}
+
+		if (params.key != null) {
+			state.verificationKeyMap[subscriptionEndpt] = params.key
+			log.info "Added verification key: ${params.key} for ${subscriptionEndpt}"
+		}
+
 		log.info "Current location subscription map is ${state.locationSubscriptionMap}"
+		log.info "Current verification key map is ${state.verificationKeyMap}"
 		return ["succeed"]
 	} else {
 		httpError(400, "missing input parameter: subscriptionURL")
@@ -247,16 +270,17 @@ def unregisterDeviceGraph() {
 	def subscriptionEndpt = params.subscriptionURL
 
 	try {
-		if(subscriptionEndpt != null && subscriptionEndpt != "undefined"){
+		if (subscriptionEndpt != null && subscriptionEndpt != "undefined") {
-			if (state.locationSubscriptionMap[location.id]?.contains(subscriptionEndpt)){
+			if (state.locationSubscriptionMap[location.id]?.contains(subscriptionEndpt)) {
-				if(state.locationSubscriptionMap[location.id].size() == 1){
+				if (state.locationSubscriptionMap[location.id].size() == 1) {
 					state.locationSubscriptionMap.remove(location.id)
 				} else {
 					state.locationSubscriptionMap[location.id].remove(subscriptionEndpt)
 				}
+				state.verificationKeyMap.remove(subscriptionEndpt)
 				log.info "Removed subscription URL: ${subscriptionEndpt} for Location ${location.name}"
 			}
-		}else{
+		} else {
 			httpError(400, "missing input parameter: subscriptionURL")
 		}
 	} catch (e) {
@@ -264,28 +288,40 @@ def unregisterDeviceGraph() {
 	}
 
 	log.info "Current location subscription map is ${state.locationSubscriptionMap}"
+	log.info "Current verification key map is ${state.verificationKeyMap}"
 }
 
 //When events are triggered, send HTTP post to web socket servers
 def deviceEventHandler(evt) {
-	def evt_device = evt.device
+	def evtDevice = evt.device
-	def evt_deviceType = getDeviceType(evt_device)
+	def evtDeviceType = getDeviceType(evtDevice)
-	def deviceInfo
+	def deviceData = [];
 
-	def params = [ body: [deviceName: evt_device.displayName, deviceId: evt_device.id,  locationId: location.id] ]
+	if (evt.data != null) {
-
-	if(evt.data != null){
 		def evtData = parseJson(evt.data)
-		log.info "Received event for ${evt_device.displayName}, data: ${evtData},  description: ${evt.descriptionText}"
+		log.info "Received event for ${evtDevice.displayName}, data: ${evtData},  description: ${evt.descriptionText}"
 	}
 
+	if (evtDeviceType == "thermostat") {
+		deviceData = [name: evtDevice.displayName, id: evtDevice.id, status: evtDevice.status, deviceType: evtDeviceType, manufacturer: evtDevice.manufacturerName, model: evtDevice.modelName, attributes: deviceAttributeList(evtDevice, evtDeviceType), locationMode: getLocationModeInfo(), locationId: location.id]
+	} else {
+		deviceData = [name: evtDevice.displayName, id: evtDevice.id, status: evtDevice.status, deviceType: evtDeviceType, manufacturer: evtDevice.manufacturerName, model: evtDevice.modelName, attributes: deviceAttributeList(evtDevice, evtDeviceType), locationId: location.id]
+	}
+
+	def params = [body: deviceData]
+
 	//send event to all subscriptions urls
-	log.debug "Current subscription urls for ${evt_device.displayName} is ${state.deviceSubscriptionMap[evt_device.id]}"
+	log.debug "Current subscription urls for ${evtDevice.displayName} is ${state.deviceSubscriptionMap[evtDevice.id]}"
-	state.deviceSubscriptionMap[evt_device.id].each {
+	state.deviceSubscriptionMap[evtDevice.id].each {
 		params.uri = "${it}"
+		if (state.verificationKeyMap[it] != null) {
+			def key = state.verificationKeyMap[it]
+			params.header = [Signature: ComputHMACValue(key, groovy.json.JsonOutput.toJson(params.body))]
+		}
 		log.trace "POST URI: ${params.uri}"
+		log.trace "Header: ${params.header}"
 		log.trace "Payload: ${params.body}"
-		try{
+		try {
 			httpPostJson(params) { resp ->
 				log.trace "response status code: ${resp.status}"
 				log.trace "response data: ${resp.data}"
@@ -298,20 +334,27 @@ def deviceEventHandler(evt) {
 
 def locationEventHandler(evt) {
 	log.info "Received event for location ${location.name}/${location.id}, Event: ${evt.name}, description: ${evt.descriptionText}, apiServerUrl: ${apiServerUrl("")}"
-	switch(evt.name){
+	switch (evt.name) {
 		case "DeviceCreated":
 		case "DeviceDeleted":
-			def evt_device = evt.device
+			def evtDevice = evt.device
-			def evt_deviceType = getDeviceType(evt_device)
+			def evtDeviceType = getDeviceType(evtDevice)
-			log.info "DeviceName: ${evt_device.displayName}, DeviceID: ${evt_device.id}, deviceType: ${evt_deviceType}"
+			def params = [body: [eventType: evt.name, deviceId: evtDevice.id, locationId: location.id]]
 
-			def params = [ body: [ eventType:evt.name, deviceId: evt_device.id, locationId: location.id ] ]
+			if (evt.name == "DeviceDeleted" && state.deviceSubscriptionMap[deviceId] != null) {
+				state.deviceSubscriptionMap.remove(evtDevice.id)
+			}
 
 			state.locationSubscriptionMap[location.id].each {
 				params.uri = "${it}"
+				if (state.verificationKeyMap[it] != null) {
+					def key = state.verificationKeyMap[it]
+					params.header = [Signature: ComputHMACValue(key, groovy.json.JsonOutput.toJson(params.body))]
+				}
 				log.trace "POST URI: ${params.uri}"
+				log.trace "Header: ${params.header}"
 				log.trace "Payload: ${params.body}"
-				try{
+				try {
 					httpPostJson(params) { resp ->
 						log.trace "response status code: ${resp.status}"
 						log.trace "response data: ${resp.data}"
@@ -326,6 +369,23 @@ def locationEventHandler(evt) {
 	}
 }
 
+private ComputHMACValue(key, data) {
+	try {
+		SecretKeySpec secretKeySpec = new SecretKeySpec(key.getBytes("UTF-8"), "HmacSHA1")
+		Mac mac = Mac.getInstance("HmacSHA1")
+		mac.init(secretKeySpec)
+		byte[] digest = mac.doFinal(data.getBytes("UTF-8"))
+		return byteArrayToString(digest)
+	} catch (InvalidKeyException e) {
+		log.error "Invalid key exception while converting to HMac SHA1"
+	}
+}
+
+private def byteArrayToString(byte[] data) {
+	BigInteger bigInteger = new BigInteger(1, data)
+	String hash = bigInteger.toString(16)
+	return hash
+}
 
 /*** Device Query/Update Functions  ***/
 
@@ -334,10 +394,10 @@ def getDevices() {
 	def deviceData = []
 	inputs?.each {
 		def deviceType = getDeviceType(it)
-		if(deviceType == "thermostat") {
+		if (deviceType == "thermostat") {
-			deviceData << [name: it.displayName, id: it.id, status:it.status, deviceType:deviceType, manufacturer:it.manufacturerName, model:it.modelName, attributes: deviceAttributeList(it, deviceType), locationMode: getLocationModeInfo()]
+			deviceData << [name: it.displayName, id: it.id, status: it.status, deviceType: deviceType, manufacturer: it.manufacturerName, model: it.modelName, attributes: deviceAttributeList(it, deviceType), locationMode: getLocationModeInfo()]
 		} else {
-			deviceData << [name: it.displayName, id: it.id, status:it.status, deviceType:deviceType, manufacturer:it.manufacturerName, model:it.modelName, attributes: deviceAttributeList(it, deviceType)]
+			deviceData << [name: it.displayName, id: it.id, status: it.status, deviceType: deviceType, manufacturer: it.manufacturerName, model: it.modelName, attributes: deviceAttributeList(it, deviceType)]
 		}
 	}
 
@@ -350,10 +410,10 @@ def getDevice() {
 	def it = findDevice(params.id)
 	def deviceType = getDeviceType(it)
 	def device
-	if(deviceType == "thermostat") {
+	if (deviceType == "thermostat") {
-		device = [name: it.displayName, id: it.id, status:it.status, deviceType:deviceType, manufacturer:it.manufacturerName, model:it.modelName, attributes: deviceAttributeList(it,deviceType), locationMode: getLocationModeInfo()]
+		device = [name: it.displayName, id: it.id, status: it.status, deviceType: deviceType, manufacturer: it.manufacturerName, model: it.modelName, attributes: deviceAttributeList(it, deviceType), locationMode: getLocationModeInfo()]
 	} else {
-		device = [name: it.displayName, id: it.id, status:it.status, deviceType:deviceType, manufacturer:it.manufacturerName, model:it.modelName, attributes: deviceAttributeList(it, deviceType)]
+		device = [name: it.displayName, id: it.id, status: it.status, deviceType: deviceType, manufacturer: it.manufacturerName, model: it.modelName, attributes: deviceAttributeList(it, deviceType)]
 	}
 
 	log.debug "getDevice, return: ${device}"
@@ -366,18 +426,18 @@ void updateDevice() {
 	request.JSON.each {
 		def command = it.key
 		def value = it.value
-		if (command){
+		if (command) {
 			def commandList = mapDeviceCommands(command, value)
 			command = commandList[0]
 			value = commandList[1]
 
 			if (command == "setAwayMode") {
 				log.info "Setting away mode to ${value}"
-				if (location.modes?.find {it.name == value}) {
+				if (location.modes?.find { it.name == value }) {
 					location.setMode(value)
 				}
-			}else if (command == "thermostatSetpoint"){
+			} else if (command == "thermostatSetpoint") {
-				switch(device.currentThermostatMode){
+				switch (device.currentThermostatMode) {
 					case "cool":
 						log.info "Update: ${device.displayName}, [${command}, ${value}]"
 						device.setCoolingSetpoint(value)
@@ -391,7 +451,7 @@ void updateDevice() {
 						httpError(501, "this mode: ${device.currentThermostatMode} does not allow changing thermostat setpoint.")
 						break
 				}
-			}else if (!device) {
+			} else if (!device) {
 				log.error "updateDevice, Device not found"
 				httpError(404, "Device not found")
 			} else if (!device.hasCommand(command)) {
@@ -401,11 +461,11 @@ void updateDevice() {
 				if (command == "setColor") {
 					log.info "Update: ${device.displayName}, [${command}, ${value}]"
 					device."$command"(hex: value)
-				} else if(value.isNumber()) {
+				} else if (value.isNumber()) {
 					def intValue = value as Integer
 					log.info "Update: ${device.displayName}, [${command}, ${intValue}(int)]"
 					device."$command"(intValue)
-				} else if (value){
+				} else if (value) {
 					log.info "Update: ${device.displayName}, [${command}, ${value}]"
 					device."$command"(value)
 				} else {
@@ -432,17 +492,16 @@ private getDeviceType(device) {
 	log.debug "supported commands: [${device}, ${device.supportedCommands}]"
 
 	//Loop through the device capability list to determine the device type.
-	capabilities.each {capability ->
+	capabilities.each { capability ->
-		switch(capability.name.toLowerCase())
+		switch (capability.name.toLowerCase()) {
-		{
 			case "switch":
 				deviceType = "switch"
 
 				//If the device also contains "Switch Level" capability, identify it as a "light" device.
-				if (capabilities.any{it.name.toLowerCase() == "switch level"}){
+				if (capabilities.any { it.name.toLowerCase() == "switch level" }) {
 
 					//If the device also contains "Power Meter" capability, identify it as a "dimmerSwitch" device.
-					if (capabilities.any{it.name.toLowerCase() == "power meter"}){
+					if (capabilities.any { it.name.toLowerCase() == "power meter" }) {
 						deviceType = "dimmerSwitch"
 						return deviceType
 					} else {
@@ -489,24 +548,24 @@ private deviceAttributeList(device, deviceType) {
 	allAttributes.each { attribute ->
 		try {
 			def currentState = device.currentState(attribute.name)
-			if(currentState != null ){
+			if (currentState != null) {
-				switch(attribute.name){
+				switch (attribute.name) {
 					case 'temperature':
-						attributeList.putAll([ (attribute.name): currentState.value, 'temperatureScale':location.temperatureScale ])
+						attributeList.putAll([(attribute.name): currentState.value, 'temperatureScale': location.temperatureScale])
 						break;
 					default:
-						attributeList.putAll([(attribute.name): currentState.value ])
+						attributeList.putAll([(attribute.name): currentState.value])
 						break;
 				}
-				if( deviceType == "genericSensor" ){
+				if (deviceType == "genericSensor") {
 					def key = attribute.name + "_lastUpdated"
-					attributeList.putAll([ (key): currentState.isoDate ])
+					attributeList.putAll([(key): currentState.isoDate])
 				}
 			} else {
-				attributeList.putAll([ (attribute.name): null ]);
+				attributeList.putAll([(attribute.name): null]);
 			}
-		} catch(e) {
+		} catch (e) {
-			attributeList.putAll([ (attribute.name): null ]);
+			attributeList.putAll([(attribute.name): null]);
 		}
 	}
 	return attributeList
@@ -579,8 +638,7 @@ private mapDeviceCommands(command, value) {
 			if (value == 1 || value == "1" || value == "lock") {
 				resultCommand = "lock"
 				resultValue = ""
-			}
+			} else if (value == 0 || value == "0" || value == "unlock") {
-			else if (value == 0 || value == "0" || value == "unlock") {
 				resultCommand = "unlock"
 				resultValue = ""
 			}
@@ -589,5 +647,5 @@ private mapDeviceCommands(command, value) {
 			break
 	}
 
-	return [resultCommand,resultValue]
+	return [resultCommand, resultValue]
 }