Modifying 'Blue Iris Integration intranet'

This App+Handler bundle allows to integrate it with Samsung SmartThings, allowing to to manage Blue Iris signal and profile state via SmartThings app - either manually or automatically, by subscribing to location events (like Home, Away, etc).
The main difference with existing integration (by @pursual) is that this one works locally, thus eliminating need to create a potential security breach by exposing ports to internet (it works without any port forwarding). Of course it means BlueIris server should reside on the same network segment as SmartThings Hub.

devicetypes/classicgod/fibaro-wall-plug-zw5.src/fibaro-wall-plug-zw5.groovy

@@ -1,368 +0,0 @@
-/**
- *  Fibaro Wall Plug ZW5
- *  Requires: Fibaro Double Switch 2 Child Device
- *
- *  Copyright 2017 Artur Draga
- *
- *  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.
- *
- */
-metadata {
-	definition (name: "Fibaro Wall Plug ZW5", namespace: "ClassicGOD", author: "Artur Draga") {
-		capability "Switch"
-		capability "Energy Meter"
-		capability "Power Meter"
-		capability "Configuration"
-		capability "Health Check"
-
-		command "reset"
-		command "refresh"
-
-		fingerprint deviceId: "0x1001", inClusters:"0x5E,0x22,0x59,0x56,0x7A,0x32,0x71,0x73,0x98,0x31,0x85,0x70,0x72,0x5A,0x8E,0x25,0x86"
-		fingerprint deviceId: "0x1001", inClusters:"0x5E,0x22,0x59,0x56,0x7A,0x32,0x71,0x73,0x31,0x85,0x70,0x72,0x5A,0x8E,0x25,0x86"
-	}
-
-	tiles (scale: 2) {
-		multiAttributeTile(name:"switch", type: "lighting", width: 3, height: 4, canChangeIcon: true){
-			tileAttribute ("device.switch", key: "PRIMARY_CONTROL") {
-				attributeState "off", label: 'Off', action: "switch.on", icon: "st.switches.switch.off", backgroundColor: "#ffffff", nextState:"turningOn"
-				attributeState "on", label: 'On', action: "switch.off", icon: "st.switches.switch.on", backgroundColor: "#00a0dc", nextState:"turningOff"
-				attributeState "turningOn", label:'Turning On', action:"switch.off", icon:"st.switches.switch.on", backgroundColor:"#00a0dc", nextState:"turningOff"
-				attributeState "turningOff", label:'Turning Off', action:"switch.on", icon:"st.switches.switch.off", backgroundColor:"#ffffff", nextState:"turningOn"
-			}
-			tileAttribute("device.combinedMeter", key:"SECONDARY_CONTROL") {
-				attributeState("combinedMeter", label:'${currentValue}')
-			} 
-		}
-		valueTile("power", "device.power", decoration: "flat", width: 2, height: 2) {
-			state "power", label:'${currentValue}\nW', action:"refresh"
-		}
-		valueTile("energy", "device.energy", decoration: "flat", width: 2, height: 2) {
-			state "energy", label:'${currentValue}\nkWh', action:"refresh"
-		}
-		valueTile("reset", "device.energy", decoration: "flat", width: 2, height: 2) {
-			state "reset", label:'reset\nkWh', action:"reset"
-		}
-	}
-
-	preferences {
-		input ( name: "logging", title: "Logging", type: "boolean", required: false )
-		parameterMap().each {
-			input (
-				name: it.key,
-				title: "${it.num}. ${it.title}",
-				description: it.descr,
-				type: it.type,
-				options: it.options,
-				range: (it.min != null && it.max != null) ? "${it.min}..${it.max}" : null,
-				defaultValue: it.def,
-				required: false
-			)
-		}
-	}
-}
-
-//UI and tile functions
-def on() {
-	encap(zwave.basicV1.basicSet(value: 255))
-}
-
-def off() {
-	encap(zwave.basicV1.basicSet(value: 0))
-}
-
-def reset() {
-	def cmds = []
-	cmds << zwave.meterV3.meterReset()
-	cmds << zwave.meterV3.meterGet(scale: 0)
-	cmds << zwave.meterV3.meterGet(scale: 2)
-	encapSequence(cmds,1000)
-}
-
-def refresh() {
-	def cmds = []
-	cmds << zwave.meterV3.meterGet(scale: 0)
-	cmds << zwave.meterV3.meterGet(scale: 2)
-	cmds << zwave.sensorMultilevelV5.sensorMultilevelGet(sensorType: 4)
-	encapSequence(cmds,1000)
-}
-
-//Configuration and synchronization
-def updated() {
-	if ( state.lastUpdated && (now() - state.lastUpdated) < 500 ) return
-	def cmds = []
-	logging("${device.displayName} - Executing updated()","info")
-	
-	def Integer cmdCount = 0
-	parameterMap().each {
-		if(settings."$it.key" != null) {
-			if (state."$it.key" == null) { state."$it.key" = [value: null, state: "synced"] }
-			if (state."$it.key".value != settings."$it.key" as Integer || state."$it.key".state == "notSynced") {
-				state."$it.key".value = settings."$it.key" as Integer
-				state."$it.key".state = "notSynced"
-				cmds << zwave.configurationV2.configurationSet(configurationValue: intToParam(state."$it.key".value, it.size), parameterNumber: it.num, size: it.size)
-				cmds << zwave.configurationV2.configurationGet(parameterNumber: it.num)
-				cmdCount = cmdCount + 1
-			}
-		}
-	}
-	
-	if ( cmdCount > 0 ) { 
-		logging("${device.displayName} - sending config.", "info")
-		sendEvent(name: "combinedMeter", value: "SYNC IN PROGRESS.", displayed: false)
-		runIn((5+cmdCount*2), syncCheck)
-	}
-	
-	state.lastUpdated = now()
-	if (cmds) { response(encapSequence(cmds,1000)) }
-}
-
-def syncCheck() {
-	logging("${device.displayName} - Executing syncCheck()","info")
-	def Integer count = 0
-	if (device.currentValue("combinedMeter")?.contains("SYNC") && device.currentValue("combinedMeter") != "SYNC OK.") {
-		parameterMap().each {
-			if (state."$it.key".state == "notSynced" ) {
-				count = count + 1
-			} 
-		}
-	}
-	if (count == 0) {
-		logging("${device.displayName} - Sync Complete","info")
-		sendEvent(name: "combinedMeter", value: "SYNC OK.", displayed: false)
-	} else {
-		logging("${device.displayName} Sync Incomplete","info")
-		if (device.currentValue("combinedMeter") != "SYNC FAILED!") {
-			sendEvent(name: "combinedMeter", value: "SYNC INCOMPLETE.", displayed: false)
-		}
-	}
-}
-
-//event handlers related to configuration and sync
-def zwaveEvent(physicalgraph.zwave.commands.configurationv2.ConfigurationReport cmd) {
-	def paramKey = parameterMap().find( {it.num == cmd.parameterNumber } ).key
-	logging("${device.displayName} - Parameter ${paramKey} value is ${cmd.scaledConfigurationValue} expected " + state."$paramKey".value, "info")
-	if (state."$paramKey".value == cmd.scaledConfigurationValue) {
-		state."$paramKey".state = "synced"
-	}
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.applicationstatusv1.ApplicationRejectedRequest cmd) {
-	logging("${device.displayName} - rejected request!","warn")
-	if (device.currentValue("combinedMeter") == "SYNC IN PROGRESS.") { 
-		sendEvent(name: "combinedMeter", value: "SYNC FAILED!", displayed: false)
-	}
-}
-
-//event handlers
-def zwaveEvent(physicalgraph.zwave.commands.basicv1.BasicReport cmd) {
-	//ignore
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.switchbinaryv1.SwitchBinaryReport cmd) {
-	logging("${device.displayName} - SwitchBinaryReport received, value: ${cmd.value}","info")
-	sendEvent([name: "switch", value: (cmd.value == 0 ) ? "off": "on"])
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.sensormultilevelv5.SensorMultilevelReport cmd) {
-	logging("${device.displayName} - SensorMultilevelReport received, value: ${cmd.scaledSensorValue} scale: ${cmd.scale}","info")
-	if (cmd.sensorType == 4) { 
-		sendEvent([name: "power", value: cmd.scaledSensorValue, unit: "W"]) 
-		updateCombinedMeter()
-	}
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.meterv3.MeterReport cmd) {
-	logging("${device.displayName} - MeterReport received, value: ${cmd.scaledMeterValue} scale: ${cmd.scale}","info")
-	switch (cmd.scale) {
-		case 0:
-			sendEvent([name: "energy", value: cmd.scaledMeterValue, unit: "kWh"])
-			break
-		case 2:
-			sendEvent([name: "power", value: cmd.scaledMeterValue, unit: "W"])
-			break
-	}
-	updateCombinedMeter()
-}
-
-//other
-private updateCombinedMeter() {
-	if (!device.currentValue("combinedMeter")?.contains("SYNC") || device.currentValue("combinedMeter") == "SYNC OK." || device.currentValue("combinedMeter") == null ) {
-		sendEvent([name: "combinedMeter", value: "${device.currentValue("power")} W / ${device.currentValue("energy")} kWh", displayed: false])
-	}
-}
-
-/*
-####################
-## Z-Wave Toolkit ##
-####################
-*/
-def parse(String description) {	  
-	def result = []
-	logging("${device.displayName} - Parsing: ${description}")
-	if (description.startsWith("Err 106")) {
-		result = createEvent(
-			descriptionText: "Failed to complete the network security key exchange. If you are unable to receive data from it, you must remove it from your network and add it again.",
-			eventType: "ALERT",
-			name: "secureInclusion",
-			value: "failed",
-			displayed: true,
-		)
-	} else if (description == "updated") {
-		return null
-	} else {
-		def cmd = zwave.parse(description, cmdVersions()) 
-		if (cmd) {
-			logging("${device.displayName} - Parsed: ${cmd}")
-			zwaveEvent(cmd)
-		}
-	}
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.securityv1.SecurityMessageEncapsulation cmd) {
-	def encapsulatedCommand = cmd.encapsulatedCommand(cmdVersions()) 
-	if (encapsulatedCommand) {
-		logging("${device.displayName} - Parsed SecurityMessageEncapsulation into: ${encapsulatedCommand}")
-		zwaveEvent(encapsulatedCommand)
-	} else {
-		log.warn "Unable to extract secure cmd from $cmd"
-		createEvent(descriptionText: cmd.toString())
-	}
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.crc16encapv1.Crc16Encap cmd) {
-	def version = cmdVersions()[cmd.commandClass as Integer]
-	def ccObj = version ? zwave.commandClass(cmd.commandClass, version) : zwave.commandClass(cmd.commandClass)
-	def encapsulatedCommand = ccObj?.command(cmd.command)?.parse(cmd.data)
-	if (!encapsulatedCommand) {
-		log.warn "Could not extract crc16 command from $cmd"
-	} else {
-		logging("${device.displayName} - Parsed Crc16Encap into: ${encapsulatedCommand}")
-		zwaveEvent(encapsulatedCommand)
-	}
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.multichannelv3.MultiChannelCmdEncap cmd) {
-	def encapsulatedCommand = cmd.encapsulatedCommand(cmdVersions())
-	if (encapsulatedCommand) {
-		logging("${device.displayName} - Parsed MultiChannelCmdEncap ${encapsulatedCommand}")
-		zwaveEvent(encapsulatedCommand, cmd.sourceEndPoint as Integer)
-	}
-}
-
-
-private logging(text, type = "debug") {
-	if (settings.logging == "true") {
-		log."$type" text
-	}
-}
-
-private secEncap(physicalgraph.zwave.Command cmd) {
-	logging("${device.displayName} - encapsulating command using Secure Encapsulation, command: $cmd","info")
-	zwave.securityV1.securityMessageEncapsulation().encapsulate(cmd).format()
-}
-
-private crcEncap(physicalgraph.zwave.Command cmd) {
-		logging("${device.displayName} - encapsulating command using CRC16 Encapsulation, command: $cmd","info")
-		zwave.crc16EncapV1.crc16Encap().encapsulate(cmd).format() // doesn't work righ now because SmartThings...
-		//"5601${cmd.format()}0000"
-}
-
-private multiEncap(physicalgraph.zwave.Command cmd, Integer ep) {
-	logging("${device.displayName} - encapsulating command using Multi Channel Encapsulation, ep: $ep command: $cmd","info")
-	zwave.multiChannelV3.multiChannelCmdEncap(destinationEndPoint:ep).encapsulate(cmd)
-}
-
-private encap(physicalgraph.zwave.Command cmd) {
-	if (zwaveInfo.zw.contains("s")) { 
-		secEncap(cmd)
-	} else if (zwaveInfo.cc.contains("56")){ 
-		crcEncap(cmd)
-	} else {
-		logging("${device.displayName} - no encapsulation supported for command: $cmd","info")
-		cmd.format()
-	}
-}
-
-private encap(physicalgraph.zwave.Command cmd, Integer ep) {
-	encap(multiEncap(cmd, ep))
-}
-
-private encap(List encapList) {
-	encap(encapList[0], encapList[1])
-}
-
-private encap(Map encapMap) {
-	encap(encapMap.cmd, encapMap.ep)
-}
-
-private encapSequence(cmds, Integer delay=250) {
-	delayBetween(cmds.collect{ encap(it) }, delay)
-}
-
-private encapSequence(cmds, Integer delay, Integer ep) {
-	delayBetween(cmds.collect{ encap(it, ep) }, delay)
-}
-
-private List intToParam(Long value, Integer size = 1) {
-	def result = []
-	size.times { 
-		result = result.plus(0, (value & 0xFF) as Short)
-		value = (value >> 8)
-	}
-	return result
-}
-/*
-##########################
-## Device Configuration ##
-##########################
-*/
-private Map cmdVersions() {
-	//[0x5E: 2, 0x59: 1, 0x80: 1, 0x56: 1, 0x7A: 3, 0x73: 1, 0x98: 1, 0x22: 1, 0x85: 2, 0x5B: 1, 0x70: 2, 0x8E: 2, 0x86: 2, 0x84: 2, 0x75: 2, 0x72: 2] //Fibaro KeyFob
-	//[0x5E: 2, 0x86: 1, 0x72: 2, 0x59: 1, 0x80: 1, 0x73: 1, 0x56: 1, 0x22: 1, 0x31: 5, 0x98: 1, 0x7A: 3, 0x20: 1, 0x5A: 1, 0x85: 2, 0x84: 2, 0x71: 3, 0x8E: 2, 0x70: 2, 0x30: 1, 0x9C: 1] //Fibaro Motion Sensor ZW5
-	//[0x5E: 2, 0x86: 1, 0x72: 1, 0x59: 1, 0x73: 1, 0x22: 1, 0x56: 1, 0x32: 3, 0x71: 1, 0x98: 1, 0x7A: 1, 0x25: 1, 0x5A: 1, 0x85: 2, 0x70: 2, 0x8E: 2, 0x60: 3, 0x75: 1, 0x5B: 1] //Fibaro Double Switch 2
-	[0x5E: 2, 0x22: 1, 0x59: 1, 0x56: 1, 0x7A: 1, 0x32: 3, 0x71: 1, 0x73: 1, 0x98: 1, 0x31: 5, 0x85: 2, 0x70: 2, 0x72: 2, 0x5A: 1, 0x8E: 2, 0x25: 1, 0x86: 2] //Fibaro Wall Plug ZW5
-}
-
-private parameterMap() {[
-	[key: "alwaysActive", num: 1, size: 1, type: "enum", options: [0: "0 - inactive", 1: "1 - activated"], def: "0", title: "Always on function", descr: null],
-	[key: "restoreState", num: 2, size: 1, type: "enum", options: [0: "0 - power off after power failure", 1: "1 - restore state"], def: "1", title: "Restore state after power failure", descr: null],
-	[key: "overloadSafety", num: 3, size: 2, type: "number", def: 0, min: 0, max: 30000 , title: "Overload safety switch", descr: null],
-	[key: "immediatePowerReports", num: 10, size: 1, type: "number", def: 80, min: 1, max: 100, title: "Immediate power reports", descr: null],
-	[key: "standardPowerReports", num: 11, size: 1, type: "number", def: 15, min: 1, max: 100, title: "Standard power reports", descr: null], 
-	[key: "powerReportFrequency", num: 12, size: 2, type: "number", def: 30, min: 5, max: 600, title: "Power reporting interval", descr: null],
-	[key: "energyReport", num: 13, size: 2, type: "number", def: 10, min: 0, max: 500, title: "Energy reports", descr: null], 
-	[key: "periodicReports", num: 14, size: 2, type: "number", def: 3600, min: 0, max: 32400, title: "Periodic power and energy reports", descr: null], 
-	[key: "deviceEnergyConsumed", num: 15, size: 1, type: "enum", options: [0: "0 - don't measure", 1: "1 - measure"], def: "0", title: "Energy consumed by the device itself", descr: null],
-	[key: "powerLoad", num: 40, size: 2, type: "number", def: 25000, min: 1000, max: 30000, title: "Power load which makes the LED ring flash violet", descr: null],
-	[key: "ringColorOn", num: 41, size: 1, type: "enum", options: [
-		0: "0 - Off",
-		1: "1 - Load based - continuous", 
-		2: "2 - Load based - steps", 
-		3: "3 - White", 
-		4: "4 - Red", 
-		5: "5 - Green", 
-		6: "6 - Blue", 
-		7: "7 - Yellow", 
-		8: "8 - Cyan", 
-		9: "9 - Magenta"
-		], def: "1", title: "Ring LED color when on", descr: null],
-	[key: "ringColorOff", num: 42, size: 1, type: "enum", options: [
-		0: "0 - Off",
-		1: "1 - Last measured power",  
-		3: "3 - White", 
-		4: "4 - Red", 
-		5: "5 - Green", 
-		6: "6 - Blue", 
-		7: "7 - Yellow", 
-		8: "8 - Cyan", 
-		9: "9 - Magenta"
-		], def: "0", title: "Ring LED color when off", descr: null]
-]}

devicetypes/df/blueiris2.src/blueiris2.groovy

@@ -0,0 +1,559 @@
+/**
+ *  Copyright 2015 SmartThings
+ *
+ *  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.
+ *
+ *  BlueIris (LocalConnect2)
+ *
+ *  Author: Nicolas Neverov
+ *  Date: 2017-04-30
+ */
+
+ metadata {
+   definition (name: "blueiris2", namespace: "df", author: "df") {
+      capability "Sensor"
+      capability "Actuator"
+        capability "Configuration"
+        capability "Refresh"
+        attribute "state", "enum", ["disarmed", "arming", "armed", "disarming", "unknown"]
+        attribute "status", "string"
+        command "arm"
+        command "disarm"
+        command "location" "STRING"
+        command "retry"
+        command "timeout"
+   }
+
+   // simulator metadata
+   simulator {
+   }
+
+   preferences {
+      input name:"username", type:"text", title: "Username", description: "BlueIris Username", required: true
+      input name:"password", type:"password", title: "Password", description: "BlueIris Password", required: true
+   }
+
+   // UI tile definitions
+   tiles(scale: 2) {
+       multiAttributeTile(name:"bi_detail_tile", type:"generic", width:6, height:4) {
+         tileAttribute("device.state", key: "PRIMARY_CONTROL") {
+               attributeState "disarmed", label:"Disarmed", action:"arm", icon:"st.locks.lock.unlocked", backgroundColor:"#ffffff"
+               attributeState "arming", label:"Arming...", action:"arm", icon:"st.locks.lock.locked", backgroundColor:"#79b821"
+               attributeState "armed", label:"Armed", action:"disarm", icon:"st.locks.lock.locked", backgroundColor:"#79b821"
+               attributeState "disarming", label:"Disarming...", action:"disarm", icon:"st.locks.lock.unlocked", backgroundColor:"#ffffff"
+               attributeState "unknown", label:"Unknown", action:"retry", icon:"st.locks.lock.unknown", backgroundColor:"#ff0000"
+               attributeState "refreshing", action:"Refresh.refresh", icon:"st.secondary.refresh", backgroundColor:"#ffffff"
+            }
+            tileAttribute("device.status", key: "SECONDARY_CONTROL") {
+            attributeState("default", label:'${currentValue}', defaultState:true)
+            }
+      }
+
+      standardTile("bi_refresh_tile", "device.refresh", decoration: "flat", width: 2, height: 2) {
+         state "default", action:"Refresh.refresh", icon:"st.secondary.refresh"
+      }
+
+      main "bi_detail_tile"
+      details(["bi_detail_tile", "bi_refresh_tile"])
+   }
+}
+
+def fsmExecInternal(fsmDefinition, stateId, Map params)
+{
+   def actionResult = null;
+
+   def fsmState = fsmDefinition[stateId?.toString()]
+   if(fsmState == null || fsmState.isFinal) {
+      return [error:"fsmExecInternal: state [$stateId] ${fsmState == null ? 'does not exist' : 'is final'} and cannot be actioned upon"]
+   }
+
+	while(!fsmState.isFinal && !actionResult?.isAsync) {
+		actionResult = fsmState.action(params)
+		fsmState = fsmDefinition[actionResult.nextStateId?.toString()]
+		if(fsmState == null) {
+			return [error:"fsmExecInternal: state [${actionResult.nextStateId}] does not exist and cannot be actioned upon"]
+		}
+		log.debug("fsmExecInternal: transitioned state [$stateId] to [$actionResult.nextStateId] (isFinal:${fsmState.isFinal?:false}); result isAsync:${actionResult.isAsync?:false}")
+      	stateId = actionResult.nextStateId
+	}
+   	return [actionResult:actionResult]
+}
+
+def fsmGetStateId(Map persistentStg)
+{
+	persistentStg.fsmState
+}
+
+def fsmExec(Map persistentStg, fsmDefinition, Map params = null)
+{
+   def stateId = fsmGetStateId(persistentStg) ?: params.fsmInitialState
+   if(!stateId) {
+      return [error: "fsmExec: cannot determine initial state, must be specified via params.fsmInitialState"]
+   }
+
+	log.debug("fsmExec: ${persistentStg.fsmState ? 'proceeding' : 'starting'} with fsm state [$stateId]")
+	params = (params != null ? params : [:])
+	params.persistentStg = (params.persistentStg != null ? params.persistentStg : persistentStg)
+
+   def rc = fsmExecInternal(fsmDefinition, stateId, params)
+   if(rc.actionResult) {
+      persistentStg.fsmState = rc.actionResult.nextStateId
+   }
+   return rc
+}
+
+
+def getBlueIrisHubAction(Map body)
+{
+	final host = getHostAddress();
+	final path = "/json"
+
+	def hubAction = new physicalgraph.device.HubAction(
+		method: "POST",
+		path: path,
+		headers: [HOST:host],
+		body: body
+	)
+	log.info "getBlueIrisHubAction: prepared hubaction $hubAction, requestId: $hubAction.requestId"
+
+	hubAction
+}
+
+def sendError(statusMsg)
+{
+	sendEvent(name:"status", value: statusMsg)
+	sendEvent(name:"state", value: "unknown")
+	parent.onNotification("$device.displayName: $statusMsg");
+}
+
+def sendEventInit(cmd)
+{
+	def state;
+	switch(cmd.id) {
+    	case 'status': 
+        	state = 'unknown'
+            break
+        case 'set': 
+        	state = (cmd.workflow == 'arm' ? 'arming' : 'disarming')
+            break
+        default: 
+        	state = 'unknown' //TODO: error
+  	}
+	sendEvent(name:"state", value: state)
+	sendEvent(name:"status", value: "Logging in...")
+}
+
+def sendEventLogin(cmd)
+{
+	sendEvent(name:"status", value: "Opening session...")
+}
+
+def sendEventStatus(cmd)
+{
+	sendEvent(name:"status", value: "Getting status...")
+}
+
+def sendEventSet(cmd)
+{
+	log.debug("sendEventSet: executing ${cmd.workflow} workflow, ${cmd.context ? ('context: ' + cmd.context + ',') : ''} signal:${cmd.signal}, profile:${cmd.profile}")
+	sendEvent(name:"status", value: "Executing '${cmd.workflow.toString() == 'arm' ? 'arm' : 'disarm'}${cmd.context ? ' ' + cmd.context : ''}' command")
+}
+
+def sendEventFinalize(cmd, signal, profile, workflow)
+{
+	def isArmed = (workflow.toString() == 'arm')
+	def statusMsg = null
+    def statusDetails = null
+	if(cmd.id == 'set') {
+        statusMsg = "Successfully ${isArmed ? 'armed' : 'disarmed'}${cmd.context ? ' \'' + cmd.context + '\'' : ''} ..."
+        statusDetails = "Successfully ${isArmed ? 'armed' : 'disarmed'} ${cmd.context ? '\'' + cmd.context + '\'' : ''}"
+  	} else if(cmd.id == 'status') {
+		statusMsg = "Status is '${isArmed ? 'Armed' : 'Disarmed'}'"
+    	statusDetails = "Current status is '${isArmed ? 'Armed' : 'Disarmed'}' [signal:${signal ? 'green' : 'red'}, profile:${profile}]"
+	}
+    
+	sendEvent(name:"state", value: isArmed ? "armed" : "disarmed")
+	sendEvent(name:"status", value: statusMsg)
+	parent.onNotification("${device.displayName}: ${statusDetails}");
+}
+
+
+def getBIfFsmDef()
+{
+	[
+		init: [
+			action: {Map params ->
+            	def cmd = params.cmd
+   				params.persistentStg.cmd = params.cmd
+				sendEventInit(cmd)
+				parent.onBeginAsyncOp(getOperationTimeoutMs())
+				def haction = getBlueIrisHubAction([cmd: 'login']);
+				cmd.requestId = haction.requestId
+
+				[nextStateId:'login', isAsync:true, hubAction:haction]
+			}
+		],
+		login: [
+			action: {Map params ->
+            	def cmd = params.persistentStg.cmd            
+                def respData = params.respMsg.data
+
+				if(respData?.result == 'fail' && respData.session) {
+                	sendEventLogin(cmd)
+					
+					final u = settings.username
+    				final p = settings.password
+					final token = "$u:${respData.session}:$p"
+                    log.debug("getBIfFsmDef[login]: logging in user \"$u\"")
+					def haction = getBlueIrisHubAction([cmd: 'login', session: "${respData.session}", response: "${token.encodeAsMD5()}"]);
+					cmd.requestId = haction.requestId
+                    cmd.session = respData.session
+					[nextStateId: (cmd.id == 'set' ? 'set' : 'status'), isAsync:true, hubAction: haction]
+				} else {
+					log.error("getBIfFsmDef[login]: error: unexpected result from login call: $params.respMsg.data")
+					parent.onEndAsyncOp()
+					sendError("Error logging in: unexpected result $params.respMsg.data?.result")
+					[nextStateId: 'error']
+				}
+			}
+		],
+		status: [
+			action: {Map params ->
+            	def cmd = params.persistentStg.cmd
+                def respData = params.respMsg.data
+				if(respData?.result == 'success') {
+					sendEventStatus(cmd)
+					def haction = getBlueIrisHubAction([cmd: 'status', session: "${cmd.session}"]);
+					cmd.requestId = haction.requestId
+					[nextStateId: 'finalize', isAsync:true, hubAction: haction]
+				} else {
+					parent.onEndAsyncOp()
+					log.error("getBIfFsmDef[status]: error creating session: unsuccessful result from session login call: ${respData}");
+					sendError("Error establishing session: ${respData?.data?.reason}")
+					[nextStateId:'error']
+				}
+			}
+		],
+		set: [
+			action: {Map params ->
+            	def cmd = params.persistentStg.cmd
+                def respData = params.respMsg.data
+				if(respData?.result == 'success') {
+					sendEventSet(cmd)
+                    def hubActionParams = [cmd: 'status', session: "${cmd.session}"]
+                    if(cmd.signal != null) {
+                    	hubActionParams.signal = cmd.signal ? 1 : 0
+                    }
+                    if(cmd.profile != null) {
+                    	hubActionParams.profile = cmd.profile
+                    }
+					def haction = getBlueIrisHubAction(hubActionParams);
+					cmd.requestId = haction.requestId
+					[nextStateId:'finalize', isAsync:true, hubAction: haction]
+				} else {
+					parent.onEndAsyncOp()
+					log.error("getBIfFsmDef[action]: error creating session: unsuccessful result from session login call: ${respData}");
+					sendError("Error establishing session: ${respData.data?.reason}")
+					[nextStateId:'error']
+				}
+			}
+		],
+		finalize: [
+			action: {Map params ->
+              	boolean success = false
+                final cmd = params.persistentStg.cmd
+                final respData = params.respMsg.data
+                
+				if(respData?.result == 'success') {
+                
+                	def respSignal = (respData.data?.signal != null ? respData.data.signal == '1' :  null);
+                    def respProfile = respData.data?.profile
+
+					log.debug("getBIfFsmDef[finalize]: received 'success' response status, finalizing command ${cmd}, "
+                    			+ "response: [signal:${respSignal}, profile:${respProfile}]")
+
+					if( cmd.id == 'set'
+                       	&& (cmd.signal == null || cmd.signal == respSignal)
+                       	&& (cmd.profile == null || respProfile == cmd.profile.toString())) {
+
+							sendEventFinalize(cmd, respSignal, respProfile, cmd.workflow)
+                            success = true
+                            
+                 	} else if(cmd.id == 'status' && respSignal != null && respProfile != null) {
+
+						def config = parent.onGetConfig()
+						def workflow = deduceWorkflow(respSignal, respProfile, config)
+                     	sendEventFinalize(cmd, respSignal, respProfile, workflow)
+ 						success = true
+                   	} 
+              	}
+
+				parent.onEndAsyncOp()
+                if(success) {
+                	[nextStateId:'success']
+              	} else {
+					log.error("getBIfFsmDef[finalize]: error setting status: unsuccessful result from setting status/signal: $params.respMsg.data");
+					sendError("Error setting status/signal: ${respData.data?.reason ?: 'signal mismatch...' }")
+					[nextStateId:'error']
+				}
+			}
+		],
+		timeout: [
+			action: {Map params ->
+				log.error("getBIfFsmDef[timeout]: operation timed out")
+				sendError("Operation timed out...")
+				[nextStateId:'error']
+			}
+		],
+		success: [
+			isFinal:true
+		],
+		error: [
+			isFinal:true
+		]
+	]
+}
+
+
+def configure()
+{
+	log.debug("configure: reseting states")
+	sendEvent(name:"status", value: ".")
+	sendEvent(name:"state", value: "disarmed") //TODO: initial state calc
+ }
+
+
+private getBIStg(boolean reset = false)
+{
+	if (state.biStg == null || reset) {
+		state.biStg = [:]
+	}
+	state.biStg
+}
+
+private Map getBICommands()
+{
+	return [
+    	set: {Map p ->
+			def rc = [
+            	id: 'set',
+        		signal: p.signal,
+        		profile: p.profile,
+                workflow: p.workflow	//one of ['arm', 'disarm']
+ 			]
+            if (p.context != null) {
+            	rc.context = p.context	//optional (location mode name)
+            }
+            
+            rc
+        },
+    	status: {->
+			return [
+            	id: 'status',
+                status: true
+ 			]
+        }
+
+        
+    ]
+}
+
+//signal: null (N/A), true(green), false(red)
+//profile: null (N/A), number
+private deduceWorkflow(Boolean signal, String profile, final config)
+{
+	if ((signal != null && !signal) || 
+    	(config.arming?.disarm?.signal == signal && config.arming?.disarm?.profile.toString() == profile)) {
+
+		"disarm"
+  	} else {
+    	"arm"
+    }
+}
+
+def arm()
+{
+	log.debug('arm: running fsm')
+
+	def config = parent.onGetConfig()
+    log.debug("arm: retrieved config: $config")
+
+	def armConfig = config.arming?.arm
+    if(armConfig) {
+
+		def rc = fsmExec(getBIStg(true), getBIfFsmDef(), [fsmInitialState:'init', cmd:getBICommands().set(
+        					signal:armConfig.signal, profile:armConfig.profile, workflow:'arm')])
+    
+		if(rc.error || !rc.actionResult.isAsync) {
+			log.error("arm: error executing fsm: ${rc.error ?: 'expected asynchronious action result'}")
+		} else {
+			return rc.actionResult.hubAction
+		}
+    } else {
+    	log.error("arm: missing configuration (arming/arm) in $config")
+	    // TODO: check return
+    }
+    
+}
+
+def disarm()
+{
+	log.debug('disarm: running fsm')
+    
+	def config = parent.onGetConfig();
+    log.debug("disarm: retrieved config: $config")
+
+	def disarmConfig = config.arming?.disarm
+    if(disarmConfig) {
+		def rc = fsmExec(getBIStg(true), getBIfFsmDef(), [fsmInitialState:'init', cmd:getBICommands().set(
+    		     			signal:disarmConfig.signal, profile:disarmConfig.profile, workflow:'disarm')])
+
+		if(rc.error || !rc.actionResult.isAsync) {
+			log.error("disarm: error executing fsm: ${rc.error ?: 'expected asynchronious action result'}")
+		} else {
+			return rc.actionResult.hubAction
+		}
+   	} else {
+    	log.error("disarm: missing configuration (arming/arm) in $config")
+	    // TODO: check return
+    }
+}
+
+def location(locationId)
+{
+	def config = parent.onGetConfig()
+    log.debug("location: retrieved config: $config, processing location $locationId")
+    
+    def locationConfig = config.location ? config.location[locationId] : null
+    if(locationConfig) {
+
+		def rc = fsmExec(getBIStg(true), getBIfFsmDef(), [fsmInitialState:'init', cmd:getBICommands().set(
+        			signal: locationConfig.signal, profile: locationConfig.profile, 
+                    workflow: deduceWorkflow(locationConfig.signal, locationConfig.profile, config), context: locationConfig.name)])
+
+		if(rc.error || !rc.actionResult.isAsync) {
+			log.error("location: error executing fsm: ${rc.error ?: 'expected asynchronious action result'}")
+		} else {
+			return rc.actionResult.hubAction
+		}
+	
+    } else {
+    	log.debug("location: no active configuration found for locationId:${locationId}' in configuration [$config]")
+	    // TODO: check return
+	}
+	
+}
+
+def retry()
+{
+	def stg = getBIStg()
+
+	if(stg.cmd != null) {
+		log.debug("retry: running fsm with cmd:$stg.cmd")
+		def rc = fsmExec(getBIStg(true), getBIfFsmDef(), [fsmInitialState:'init', cmd:stg.cmd])
+
+		if(rc.error || !rc.actionResult.isAsync) {
+			log.error("retry: error executing fsm: ${rc.error ?: 'expected asynchronious action result'}")
+		} else {
+			return rc.actionResult.hubAction
+		}
+	} else {
+      log.debug("retry: no state to retry")
+    }
+}
+
+def timeout()
+{
+	def stg = getBIStg()
+	log.debug("timeout: running fsm with cmd:${stg.cmd}")
+
+	def rc = fsmExec(getBIStg(true), getBIfFsmDef(), [fsmInitialState:'timeout', cmd:stg.cmd])
+
+	if(rc.error || rc.actionResult.isAsync) {
+		log.error("timeout: error executing fsm: ${rc.error ?: 'expected synchronious action result'}")
+	}
+}
+
+def refresh()
+{
+	log.debug('refresh: running fsm: status command')
+
+	def rc = fsmExec(getBIStg(true), getBIfFsmDef(), [fsmInitialState:'init', cmd:getBICommands().status()])
+
+	if(rc.error || !rc.actionResult.isAsync) {
+		log.error("refresh: error executing fsm: ${rc.error ?: 'expected asynchronious action result'}")
+	} else {
+		return rc.actionResult.hubAction
+	}
+}
+
+def parse(msg)
+{
+	def lanMsg = parseLanMessage(msg)
+	log.info "parse: parsed lan message: $lanMsg"
+
+
+	if (lanMsg && lanMsg.headers && lanMsg.body) {
+    	log.info "parse: parsed lan message requestId:$lanMsg.requestId, body:$lanMsg.body"
+
+		def stg = getBIStg()
+
+		if(fsmGetStateId(stg) && stg.cmd.requestId == lanMsg.requestId) {
+			log.debug("parse: received expected response mesage; requestId:$lanMsg.requestId, state:${fsmGetStateId(stg)}")
+
+			def rc = fsmExec(stg, getBIfFsmDef(), [respMsg:lanMsg])
+
+			if(rc.error) {
+				log.error("parse: error executing fsm: ${rc.error ?: 'expected asynchronious action result'}")
+			} else if(rc.actionResult.isAsync) {
+				return [rc.actionResult.hubAction]
+			}
+
+		} else {
+			log.error("parse: skipping message: request id does not match: stg.request_id:$stg.cmd.requestId, lanMsg.requestId:$lanMsg.requestId")
+		}
+
+	} else {
+		log.error("parse: skipping message: unrecognized lan message")
+	}
+}
+
+
+private getOperationTimeoutMs()
+{
+   10 * 1000;
+}
+
+private Integer convertHexToInt(hex) {
+   Integer.parseInt(hex,16)
+}
+
+private String convertHexToIP(hex) {
+   [convertHexToInt(hex[0..1]),convertHexToInt(hex[2..3]),convertHexToInt(hex[4..5]),convertHexToInt(hex[6..7])].join(".")
+}
+
+private getHostAddress() {
+   def parts = device.deviceNetworkId.split(":")
+   def ip = convertHexToIP(parts[0])
+   def port = convertHexToInt(parts[1])
+   return ip + ":" + port
+}
+
+private hashMD5(String somethingToHash) {
+   java.security.MessageDigest.getInstance("MD5").digest(somethingToHash.getBytes("UTF-8")).encodeHex().toString()
+}
+
+private calcDigestAuth(String method, String uri) {
+   def HA1 =  hashMD5("${getUsername}::${getPassword}")
+   def HA2 = hashMD5("${method}:${uri}")
+   def response = hashMD5("${HA1}::::auth:${HA2}")
+
+   'Digest username="'+ getUsername() + '", realm="", nonce="", uri="'+ uri +'", qop=auth, nc=, cnonce="", response="' + response + '", opaque=""'
+}

devicetypes/drzwave/ezmultipli.src/ezmultipli.groovy

@@ -38,9 +38,9 @@ metadata {
     tiles (scale: 2){      
 		multiAttributeTile(name:"switch", type: "lighting", width: 6, height: 4, canChangeIcon: true){
 			tileAttribute ("device.switch", key: "PRIMARY_CONTROL", icon: "st.Lighting.light18") {
-				attributeState "on", label:'${name}', action:"switch.off", icon:"st.switches.light.on", backgroundColor:"#00A0DC", nextState:"turningOff"
+				attributeState "on", label:'${name}', action:"switch.off", icon:"st.switches.light.on", backgroundColor:"#79b821", nextState:"turningOff"
 				attributeState "off", label:'${name}', action:"switch.on", icon:"st.switches.light.off", backgroundColor:"#ffffff", nextState:"turningOn"
-				attributeState "turningOn", label:'${name}', icon:"st.switches.light.on", backgroundColor:"#00A0DC"
+				attributeState "turningOn", label:'${name}', icon:"st.switches.light.on", backgroundColor:"#79b821"
 				attributeState "turningOff", label:'${name}', icon:"st.switches.light.off", backgroundColor:"#ffffff"
 			}
 			tileAttribute ("device.color", key: "COLOR_CONTROL") {
@@ -52,20 +52,20 @@ metadata {
         }
 
 		standardTile("motion", "device.motion", width: 2, height: 2, canChangeIcon: true, canChangeBackground: true) {
-			state "active", label:'motion', icon:"st.motion.motion.active", backgroundColor:"#00A0DC"
-			state "inactive", label:'no motion', icon:"st.motion.motion.inactive", backgroundColor:"#cccccc"
+			state "active", label:'motion', icon:"st.motion.motion.active", backgroundColor:"#53a7c0"
+			state "inactive", label:'no motion', icon:"st.motion.motion.inactive", backgroundColor:"#ffffff"
 		}
 		valueTile("temperature", "device.temperature", width: 2, height: 2) {
 			state "temperature", label:'${currentValue}°', unit:"F", icon:"", // would be better if the units would switch to the desired units of the system (imperial or metric)
 			backgroundColors:[
-				[value: 0,  color: "#153591"], // blue=cold
-				[value: 65, color: "#44b621"], // green
-				[value: 70, color: "#44b621"], // green
-				[value: 75, color: "#f1d801"], // yellow
-				[value: 80, color: "#f1d801"], // yellow
-				[value: 85, color: "#f1d801"], // yellow
-				[value: 90, color: "#d04e00"], // red
-				[value: 95, color: "#bc2323"]  // red=hot
+				[value: 0,  color: "#1010ff"], // blue=cold
+				[value: 65, color: "#a0a0f0"],
+				[value: 70, color: "#e0e050"],
+				[value: 75, color: "#f0d030"], // yellow
+				[value: 80, color: "#fbf020"],
+				[value: 85, color: "#fbdc01"],
+				[value: 90, color: "#fb3a01"],
+				[value: 95, color: "#fb0801"]  // red=hot
 			]
 		}
 

devicetypes/fibargroup/fibaro-door-window-sensor-zw5-with-temperature.src/fibaro-door-window-sensor-zw5-with-temperature.groovy

@@ -39,8 +39,8 @@ metadata {
             }
 
             tileAttribute("device.tamper", key:"SECONDARY_CONTROL") {
-				attributeState("active", label:'tamper active', backgroundColor:"#00A0DC")
-				attributeState("inactive", label:'tamper inactive', backgroundColor:"#CCCCCC")
+				attributeState("active", label:'tamper active', backgroundColor:"#53a7c0")
+				attributeState("inactive", label:'tamper inactive', backgroundColor:"#ffffff")
 			}
         }
 

devicetypes/fibargroup/fibaro-door-window-sensor-zw5.src/fibaro-door-window-sensor-zw5.groovy

@@ -37,8 +37,8 @@ metadata {
             }
 
             tileAttribute("device.tamper", key:"SECONDARY_CONTROL") {
-				attributeState("active", label:'tamper active', backgroundColor:"#00A0DC")
-				attributeState("inactive", label:'tamper inactive', backgroundColor:"#CCCCCC")
+				attributeState("active", label:'tamper active', backgroundColor:"#53a7c0")
+				attributeState("inactive", label:'tamper inactive', backgroundColor:"#ffffff")
 			}
         }
 

devicetypes/fibargroup/fibaro-motion-sensor-zw5.src/fibaro-motion-sensor-zw5.groovy

@@ -34,8 +34,8 @@ metadata {
     tiles(scale: 2) {
     	multiAttributeTile(name:"FGMS", type:"lighting", width:6, height:4) {//with generic type secondary control text is not displayed in Android app
         	tileAttribute("device.motion", key:"PRIMARY_CONTROL") {
-            	attributeState("inactive", label:"no motion", icon:"st.motion.motion.inactive", backgroundColor:"#cccccc")
-            	attributeState("active", label:"motion", icon:"st.motion.motion.active", backgroundColor:"#00A0DC")
+            	attributeState("inactive", label:"no motion", icon:"st.motion.motion.inactive", backgroundColor:"#79b821")
+            	attributeState("active", label:"motion", icon:"st.motion.motion.active", backgroundColor:"#ffa81e")
             }
 
             tileAttribute("device.tamper", key:"SECONDARY_CONTROL") {

devicetypes/johnrucker/coopboss-h3vx.src/coopboss-h3vx.groovy

@@ -95,12 +95,12 @@ metadata {
 		multiAttributeTile(name:"doorCtrl", type:"generic", width:6, height:4) {tileAttribute("device.doorState", key: "PRIMARY_CONTROL") 
         	{  
 			attributeState "unknown", label: '${name}', action:"openDoor", icon: "st.Outdoor.outdoor20", nextState:"Sent"          
-			attributeState "open", label: '${name}', action:"closeDoor", icon: "st.Outdoor.outdoor20", backgroundColor: "#00A0DC" , nextState:"Sent"
-			attributeState "opening", label: '${name}', action:"closeDoor", icon: "st.Outdoor.outdoor20", backgroundColor: "#00A0DC"
-			attributeState "closed", label: '${name}', action:"openDoor", icon: "st.Outdoor.outdoor20", backgroundColor: "#ffffff", nextState:"Sent"
-			attributeState "closing", label: '${name}', action:"openDoor", icon: "st.Outdoor.outdoor20", backgroundColor: "#ffffff"
-			attributeState "jammed", label: '${name}', action:"closeDoorHiI", icon: "st.Outdoor.outdoor20", backgroundColor: "#ff0000", nextState:"Sent"
-			attributeState "forced close", label: 'forced\rclose', action:"openDoor", icon: "st.Outdoor.outdoor20", backgroundColor: "#ff8000", nextState:"Sent"
+			attributeState "open", label: '${name}', action:"closeDoor", icon: "st.Outdoor.outdoor20", backgroundColor: "#0000ff" , nextState:"Sent" 
+			attributeState "opening", label: '${name}', action:"closeDoor", icon: "st.Outdoor.outdoor20", backgroundColor: "#ffa81e"            
+			attributeState "closed", label: '${name}', action:"openDoor", icon: "st.Outdoor.outdoor20", backgroundColor: "#79b821", nextState:"Sent" 
+			attributeState "closing", label: '${name}', action:"openDoor", icon: "st.Outdoor.outdoor20", backgroundColor: "#ffa81e" 
+			attributeState "jammed", label: '${name}', action:"closeDoorHiI", icon: "st.Outdoor.outdoor20", backgroundColor: "#ff0000", nextState:"Sent" 
+			attributeState "forced close", label: 'forced\rclose', action:"openDoor", icon: "st.Outdoor.outdoor20", backgroundColor: "#ff8000", nextState:"Sent"   
 			attributeState "fault", label: 'FAULT', action:"openDoor", icon: "st.Outdoor.outdoor20", backgroundColor: "#ff0000", nextState:"Sent"              
 			attributeState "Sent", label: 'wait', icon: "st.motion.motion.active", backgroundColor: "#ffa81e"              
 			} 
@@ -135,13 +135,13 @@ metadata {
     	}        
         
 		standardTile("autoClose", "device.autoCloseEnable", width: 2, height: 2){
-			state "on", label: 'Auto', action:"autoCloseOff", icon: "st.doors.garage.garage-closing", backgroundColor: "#00A0DC", nextState:"Sent"
+			state "on", label: 'Auto', action:"autoCloseOff", icon: "st.doors.garage.garage-closing", backgroundColor: "#79b821", nextState:"Sent"
 			state "off", label: 'Auto', action:"autoCloseOn", icon: "st.doors.garage.garage-closing", nextState:"Sent"
 			state "Sent", label: 'wait', icon: "st.motion.motion.active", backgroundColor: "#ffa81e"              
 		}    
         
 		standardTile("autoOpen", "device.autoOpenEnable", width: 2, height: 2){
-			state "on", label: 'Auto', action:"autoOpenOff", icon: "st.doors.garage.garage-opening", backgroundColor: "#00A0DC", nextState:"Sent"
+			state "on", label: 'Auto', action:"autoOpenOff", icon: "st.doors.garage.garage-opening", backgroundColor: "#79b821", nextState:"Sent"
 			state "off", label: 'Auto', action:"autoOpenOn", icon: "st.doors.garage.garage-opening", nextState:"Sent"
 			state "Sent", label: 'wait', icon: "st.motion.motion.active", backgroundColor: "#ffa81e"              
 		}            
@@ -189,13 +189,13 @@ metadata {
         
 		standardTile("aux1", "device.Aux1", width: 2, height: 2, canChangeIcon: true) {
 			state "off", label:'Aux 1', action:"Aux1On", icon:"st.switches.switch.off", backgroundColor:"#ffffff", nextState:"Sent"        
-			state "on", label:'Aux 1', action:"Aux1Off", icon:"st.switches.switch.on", backgroundColor:"#00A0DC", nextState:"Sent"
+			state "on", label:'Aux 1', action:"Aux1Off", icon:"st.switches.switch.on", backgroundColor:"#79b821", nextState:"Sent"
 			state "Sent", label: 'wait', icon: "st.motion.motion.active", backgroundColor: "#ffa81e"            
 		}        
         
 		standardTile("aux2", "device.Aux2", width: 2, height: 2, canChangeIcon: true) {
 			state "off", label:'Aux 2', action:"Aux2On", icon:"st.switches.switch.off", backgroundColor:"#ffffff", nextState:"Sent"        
-			state "on", label:'Aux 2', action:"Aux2Off", icon:"st.switches.switch.on", backgroundColor:"#00A0DC", nextState:"Sent"
+			state "on", label:'Aux 2', action:"Aux2Off", icon:"st.switches.switch.on", backgroundColor:"#79b821", nextState:"Sent"
 			state "Sent", label: 'wait', icon: "st.motion.motion.active", backgroundColor: "#ffa81e"   
 		}            
         

devicetypes/smartthings/aeon-key-fob.src/aeon-key-fob.groovy

@@ -21,7 +21,6 @@ metadata {
 		capability "Battery"
 
 		fingerprint deviceId: "0x0101", inClusters: "0x86,0x72,0x70,0x80,0x84,0x85"
-		fingerprint mfr: "0086", prod: "0001", model: "0026", deviceJoinName: "Aeon Panic Button"
 	}
 
 	simulator {
@@ -131,12 +130,5 @@ def updated() {
 }
 
 def initialize() {
-	def zwMap = getZwaveInfo()
-	def buttons = 4 // Default for Key Fob
-
-	// Only one button for Aeon Panic Button
-	if (zwMap && zwMap.mfr == "0086" && zwMap.prod == "0001" && zwMap.model == "0026") {
-		buttons = 1
-	}
-	sendEvent(name: "numberOfButtons", value: buttons)
+	sendEvent(name: "numberOfButtons", value: 4)
 }

devicetypes/smartthings/aeon-multisensor-6.src/.st-ignore

@@ -1,2 +0,0 @@
-.st-ignore
-README.md

devicetypes/smartthings/aeon-multisensor-6.src/README.md

@@ -1,43 +0,0 @@
-# Aeon Multisensor 6
-
-Cloud Execution
-
-Works with: 
-
-* [Aeon Labs MultiSensor 6](https://www.smartthings.com/products/aeon-labs-multisensor-6)
-
-## Table of contents
-
-* [Capabilities](#capabilities)
-* [Health](#device-health)
-* [Troubleshooting](#troubleshooting)
-
-## Capabilities
-
-* **Motion Sensor** - can detect motion
-* **Temperature Measurement** - defines device measures current temperature
-* **Relative Humidity Measurement** - allow reading the relative humidity from devices that support it
-* **Illuminance Measurement** - gives the illuminance reading from devices that support it
-* **Ultraviolet Index** - gives the ability to get the ultraviolet index from devices that report it
-* **Configuration** - _configure()_ command called when device is installed or device preferences updated
-* **Sensor** - detects sensor events
-* **Battery** - defines device uses a battery
-* **Health Check** - indicates ability to get device health notifications
-
-## Device Health
-
-Aeon Labs MultiSensor 6 is polled by the hub.
-As of hubCore version 0.14.38 the hub sends up reports every 15 minutes regardless of whether the state changed.
-Device-Watch allows 2 check-in misses from device plus some lag time. So Check-in interval = (2*15 + 2)mins = 32 mins.
-Not to mention after going OFFLINE when the device is plugged back in, it might take a considerable amount of time for
-the device to appear as ONLINE again. This is because if this listening device does not respond to two poll requests in a row,
-it is not polled for 5 minutes by the hub. This can delay up the process of being marked ONLINE by quite some time.
-
-* __32min__ checkInterval
-
-## Troubleshooting
-
-If the device doesn't pair when trying from the SmartThings mobile app, it is possible that the device is out of range.
-Pairing needs to be tried again by placing the device closer to the hub.
-Instructions related to pairing, resetting and removing the device from SmartThings can be found in the following link:
-* [Aeon Labs MultiSensor 6 Troubleshooting Tips](https://support.smartthings.com/hc/en-us/articles/206157226)

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

@@ -22,7 +22,6 @@ metadata {
 		capability "Configuration"
 		capability "Sensor"
 		capability "Battery"
-		capability "Health Check"
 
 		attribute "tamper", "enum", ["detected", "clear"]
 		attribute "batteryStatus", "string"
@@ -30,7 +29,6 @@ metadata {
 
 		fingerprint deviceId: "0x2101", inClusters: "0x5E,0x86,0x72,0x59,0x85,0x73,0x71,0x84,0x80,0x30,0x31,0x70,0x7A", outClusters: "0x5A"
 		fingerprint deviceId: "0x2101", inClusters: "0x5E,0x86,0x72,0x59,0x85,0x73,0x71,0x84,0x80,0x30,0x31,0x70,0x7A,0x5A"
-		fingerprint mfr:"0086", prod:"0102", model:"0064", deviceJoinName: "Aeon Labs MultiSensor 6"
 	}
 
 	simulator {
@@ -105,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) {
@@ -129,14 +127,7 @@ metadata {
 	}
 }
 
-def installed(){
-// Device-Watch simply pings if no device events received for 32min(checkInterval)
-	sendEvent(name: "checkInterval", value: 2 * 15 * 60 + 2 * 60, displayed: false, data: [protocol: "zwave", hubHardwareId: device.hub.hardwareID])
-}
-
 def updated() {
-// Device-Watch simply pings if no device events received for 32min(checkInterval)
-	sendEvent(name: "checkInterval", value: 2 * 15 * 60 + 2 * 60, displayed: false, data: [protocol: "zwave", hubHardwareId: device.hub.hardwareID])
 	log.debug "Updated with settings: ${settings}"
 	log.debug "${device.displayName} is now ${device.latestValue("powerSupply")}"
 
@@ -335,13 +326,6 @@ def zwaveEvent(physicalgraph.zwave.Command cmd) {
 	createEvent(descriptionText: cmd.toString(), isStateChange: false)
 }
 
-/**
- * PING is used by Device-Watch in attempt to reach the Device
- * */
-def ping() {
-	secure(zwave.batteryV1.batteryGet())
-}
-
 def configure() {
 	// This sensor joins as a secure device if you double-click the button to include it
 	log.debug "${device.displayName} is configuring its settings"
@@ -426,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/smartthings/ct100-thermostat.src/ct100-thermostat.groovy

@@ -9,7 +9,6 @@ metadata {
 		capability "Configuration"
 		capability "Refresh"
 		capability "Sensor"
-		capability "Health Check"
 		
 		attribute "thermostatFanState", "string"
 
@@ -19,7 +18,6 @@ metadata {
 		command "quickSetHeat"
 
 		fingerprint deviceId: "0x08", inClusters: "0x43,0x40,0x44,0x31,0x80,0x85,0x60"
-		fingerprint mfr:"0098", prod:"6401", model:"0107", deviceJoinName: "2Gig CT100 Programmable Thermostat"
 	}
 
 	// simulator metadata
@@ -108,16 +106,6 @@ metadata {
 	}
 }
 
-def updated() {
-	// Device-Watch simply pings if no device events received for 32min(checkInterval)
-	sendEvent(name: "checkInterval", value: 2 * 15 * 60 + 2 * 60, displayed: false, data: [protocol: "zwave", hubHardwareId: device.hub.hardwareID])
-}
-
-def installed() {
-	// Device-Watch simply pings if no device events received for 32min(checkInterval)
-	sendEvent(name: "checkInterval", value: 2 * 15 * 60 + 2 * 60, displayed: false, data: [protocol: "zwave", hubHardwareId: device.hub.hardwareID])
-}
-
 def parse(String description)
 {
 	def result = []
@@ -451,14 +439,6 @@ def setCoolingSetpoint(Double degrees, Integer delay = 30000) {
 	], delay)
 }
 
-/**
- * PING is used by Device-Watch in attempt to reach the Device
- * */
-def ping() {
-	log.debug "ping() called"
-	refresh()
-}
-
 def configure() {
 	delayBetween([
 		zwave.thermostatModeV2.thermostatModeSupportedGet().format(),

devicetypes/smartthings/fibaro-door-window-sensor.src/fibaro-door-window-sensor.groovy

@@ -68,8 +68,8 @@
 
 	tiles {
 		standardTile("contact", "device.contact", width: 2, height: 2) {
-			state "open",   label: '${name}', icon: "st.contact.contact.open",   backgroundColor: "#e86d13"
-			state "closed", label: '${name}', icon: "st.contact.contact.closed", backgroundColor: "#00A0DC"
+			state "open",   label: '${name}', icon: "st.contact.contact.open",   backgroundColor: "#ffa81e"
+			state "closed", label: '${name}', icon: "st.contact.contact.closed", backgroundColor: "#79b821"
 		}
 		valueTile("temperature", "device.temperature", inactiveLabel: false) {
 			state "temperature", label:'${currentValue}°',
@@ -86,7 +86,7 @@
 		}
         standardTile("tamper", "device.alarm") {
 			state("secure", label:'secure',    icon:"st.locks.lock.locked",   backgroundColor:"#ffffff")
-			state("tampered", label:'tampered', icon:"st.locks.lock.unlocked", backgroundColor:"#00a0dc")
+			state("tampered", label:'tampered', icon:"st.locks.lock.unlocked", backgroundColor:"#53a7c0")
 		}
 		valueTile("battery", "device.battery", inactiveLabel: false, decoration: "flat") {
 			state "battery", label:'${currentValue}% battery', unit:""

devicetypes/smartthings/fibaro-motion-sensor.src/fibaro-motion-sensor.groovy

@@ -107,8 +107,8 @@
 			state "configure", label:'', action:"configuration.configure", icon:"st.secondary.configure"
 		}
         standardTile("acceleration", "device.acceleration") {
-			state("active", label:'vibration', icon:"st.motion.acceleration.active", backgroundColor:"#00a0dc")
-			state("inactive", label:'still', icon:"st.motion.acceleration.inactive", backgroundColor:"#cccccc")
+			state("active", label:'vibration', icon:"st.motion.acceleration.active", backgroundColor:"#53a7c0")
+			state("inactive", label:'still', icon:"st.motion.acceleration.inactive", backgroundColor:"#ffffff")
 		}
 
 

devicetypes/smartthings/fortrezz-water-valve.src/fortrezz-water-valve.groovy

@@ -12,13 +12,13 @@
  *
  */
 metadata {
-	definition (name: "Fortrezz Water Valve", namespace: "smartthings", author: "SmartThings", ocfDeviceType: "oic.d.watervalve") {
+	definition (name: "Fortrezz Water Valve", namespace: "smartthings", author: "SmartThings") {
 		capability "Actuator"
 		capability "Health Check"
 		capability "Valve"
 		capability "Refresh"
 		capability "Sensor"
-
+        
 		fingerprint deviceId: "0x1000", inClusters: "0x25,0x72,0x86,0x71,0x22,0x70"
 		fingerprint mfr:"0084", prod:"0213", model:"0215", deviceJoinName: "FortrezZ Water Valve"
 	}
@@ -34,22 +34,19 @@ metadata {
 	}
 
 	// tile definitions
-	tiles(scale: 2) {
-		multiAttributeTile(name:"valve", type: "generic", width: 6, height: 4, canChangeIcon: true){
-			tileAttribute ("device.valve", key: "PRIMARY_CONTROL") {
-				attributeState "open", label: '${name}', action: "valve.close", icon: "st.valves.water.open", backgroundColor: "#00A0DC", nextState:"closing"
-				attributeState "closed", label: '${name}', action: "valve.open", icon: "st.valves.water.closed", backgroundColor: "#ffffff", nextState:"opening"
-				attributeState "opening", label: '${name}', action: "valve.close", icon: "st.valves.water.open", backgroundColor: "#00A0DC"
-				attributeState "closing", label: '${name}', action: "valve.open", icon: "st.valves.water.closed", backgroundColor: "#ffffff"
-			}
+	tiles {
+		standardTile("contact", "device.contact", width: 2, height: 2, canChangeIcon: true) {
+			state "open", label: '${name}', action: "valve.close", icon: "st.valves.water.open", backgroundColor: "#00A0DC", nextState:"closing"
+			state "closed", label: '${name}', action: "valve.open", icon: "st.valves.water.closed", backgroundColor: "#ffffff", nextState:"opening"
+			state "opening", label: '${name}', action: "valve.close", icon: "st.valves.water.open", backgroundColor: "#00A0DC"
+			state "closing", label: '${name}', action: "valve.open", icon: "st.valves.water.closed", backgroundColor: "#ffffff"
 		}
-
-		standardTile("refresh", "device.valve", width: 2, height: 2, inactiveLabel: false, decoration: "flat") {
+		standardTile("refresh", "device.switch", inactiveLabel: false, decoration: "flat") {
 			state "default", label:'', action:"refresh.refresh", icon:"st.secondary.refresh"
 		}
 
-		main "valve"
-		details(["valve","refresh"])
+		main "contact"
+		details(["contact","refresh"])
 	}
 }
 
@@ -65,23 +62,22 @@ def updated(){
 
 def parse(String description) {
 	log.trace description
+	def result = null
 	def cmd = zwave.parse(description)
 	if (cmd) {
-		return zwaveEvent(cmd)
+		result = createEvent(zwaveEvent(cmd))
 	}
-	log.debug "Could not parse message"
-	return null
+	log.debug "Parse returned ${result?.descriptionText}"
+	return result
 }
 
 def zwaveEvent(physicalgraph.zwave.commands.switchbinaryv1.SwitchBinaryReport cmd) {
 	def value = cmd.value ? "closed" : "open"
-
-	return [createEventWithDebug([name: "contact", value: value, descriptionText: "$device.displayName valve is $value"]),
-			createEventWithDebug([name: "valve", value: value, descriptionText: "$device.displayName valve is $value"])]
+	[name: "contact", value: value, descriptionText: "$device.displayName valve is $value"]
 }
 
 def zwaveEvent(physicalgraph.zwave.Command cmd) {
-	return createEvent([:]) // Handles all Z-Wave commands we aren't interested in
+	[:] // Handles all Z-Wave commands we aren't interested in
 }
 
 def open() {
@@ -102,9 +98,3 @@ def ping() {
 def refresh() {
 	zwave.switchBinaryV1.switchBinaryGet().format()
 }
-
-def createEventWithDebug(eventMap) {
-	def event = createEvent(eventMap)
-	log.debug "Event created with ${event?.descriptionText}"
-	return event
-}

devicetypes/smartthings/mimolite-garage-door-controller.src/mimolite-garage-door-controller.groovy

@@ -62,8 +62,8 @@ metadata {
 			state "off", label: '${name}', action: "on", icon: "st.switches.switch.off", backgroundColor: "#ffffff"
         }
         standardTile("contact", "device.contact", inactiveLabel: false) {
-			state "open", label: '${name}', icon: "st.contact.contact.open", backgroundColor: "#e86d13"
-			state "closed", label: '${name}', icon: "st.contact.contact.closed", backgroundColor: "#00A0DC"
+			state "open", label: '${name}', icon: "st.contact.contact.open", backgroundColor: "#ffa81e"
+			state "closed", label: '${name}', icon: "st.contact.contact.closed", backgroundColor: "#79b821"
 		}
         standardTile("refresh", "device.switch", inactiveLabel: false, decoration: "flat") {
 			state "default", label:'', action:"refresh.refresh", icon:"st.secondary.refresh"

devicetypes/smartthings/smartalert-siren.src/README.md

@@ -4,7 +4,7 @@ Cloud Execution
 
 Works with:
 
-* [FortrezZ Siren Strobe Alarm](https://www.smartthings.com/products/fortrezz-siren-strobe-alarm)
+* [FortrezZ Siren Strobe Alarm](https://www.smartthings.com/works-with-smartthings/other/fortrezz-water-valve)
 
 ## Table of contents
 

devicetypes/smartthings/smartpower-dimming-outlet.src/smartpower-dimming-outlet.groovy

@@ -44,9 +44,9 @@ metadata {
 	tiles(scale: 2) {
 		multiAttributeTile(name:"switch", type: "lighting", width: 6, height: 4, canChangeIcon: true){
 			tileAttribute ("device.switch", key: "PRIMARY_CONTROL") {
-				attributeState "on", label:'${name}', action:"switch.off", icon:"st.switches.switch.on", backgroundColor:"#00A0DC", nextState:"turningOff"
+				attributeState "on", label:'${name}', action:"switch.off", icon:"st.switches.switch.on", backgroundColor:"#79b821", nextState:"turningOff"
 				attributeState "off", label:'${name}', action:"switch.on", icon:"st.switches.switch.off", backgroundColor:"#ffffff", nextState:"turningOn"
-				attributeState "turningOn", label:'${name}', action:"switch.off", icon:"st.switches.switch.on", backgroundColor:"#00A0DC", nextState:"turningOff"
+				attributeState "turningOn", label:'${name}', action:"switch.off", icon:"st.switches.switch.on", backgroundColor:"#79b821", nextState:"turningOff"
 				attributeState "turningOff", label:'${name}', action:"switch.on", icon:"st.switches.switch.off", backgroundColor:"#ffffff", nextState:"turningOn"
 			}
 			tileAttribute ("device.level", key: "SLIDER_CONTROL") {

devicetypes/smartthings/smartsense-garage-door-sensor-button.src/smartsense-garage-door-sensor-button.groovy

@@ -56,8 +56,8 @@ metadata {
 			state("closing", label:'${name}', icon:"st.doors.garage.garage-closing", backgroundColor:"#00A0DC")
 		}
 		standardTile("contact", "device.contact") {
-			state("open", label:'${name}', icon:"st.contact.contact.open", backgroundColor:"#e86d13")
-			state("closed", label:'${name}', icon:"st.contact.contact.closed", backgroundColor:"#00A0DC")
+			state("open", label:'${name}', icon:"st.contact.contact.open", backgroundColor:"#ffa81e")
+			state("closed", label:'${name}', icon:"st.contact.contact.closed", backgroundColor:"#79b821")
 		}
 		standardTile("acceleration", "device.acceleration", decoration: "flat") {
 			state("active", label:'${name}', icon:"st.motion.acceleration.active", backgroundColor:"#00A0DC")

devicetypes/smartthings/smartsense-motion-sensor.src/smartsense-motion-sensor.groovy

@@ -61,8 +61,8 @@ metadata {
 	tiles(scale: 2) {
 		multiAttributeTile(name: "motion", type: "generic", width: 6, height: 4) {
 			tileAttribute("device.motion", key: "PRIMARY_CONTROL") {
-				attributeState "active", label: 'motion', icon: "st.motion.motion.active", backgroundColor: "#00A0DC"
-				attributeState "inactive", label: 'no motion', icon: "st.motion.motion.inactive", backgroundColor: "#cccccc"
+				attributeState "active", label: 'motion', icon: "st.motion.motion.active", backgroundColor: "#53a7c0"
+				attributeState "inactive", label: 'no motion', icon: "st.motion.motion.inactive", backgroundColor: "#ffffff"
 			}
 		}
 		valueTile("temperature", "device.temperature", width: 2, height: 2) {

devicetypes/smartthings/smartsense-multi-sensor.src/smartsense-multi-sensor.groovy

@@ -87,8 +87,8 @@ metadata {
 			state("closed", label: 'Closed', icon: "st.contact.contact.closed", backgroundColor: "#00a0dc")
 		}
 		standardTile("acceleration", "device.acceleration", width: 2, height: 2) {
-			state("active", label: 'Active', icon: "st.motion.acceleration.active", backgroundColor: "#00a0dc")
-			state("inactive", label: 'Inactive', icon: "st.motion.acceleration.inactive", backgroundColor: "#cccccc")
+			state("active", label: 'Active', icon: "st.motion.acceleration.active", backgroundColor: "#53a7c0")
+			state("inactive", label: 'Inactive', icon: "st.motion.acceleration.inactive", backgroundColor: "#ffffff")
 		}
 		valueTile("temperature", "device.temperature", width: 2, height: 2) {
 			state("temperature", label: '${currentValue}°',
@@ -178,7 +178,7 @@ private List<Map> handleAcceleration(descMap) {
 			result += parseAxis(descMap.additionalAttrs)
 		}
 	} else if (descMap.clusterInt == 0xFC02 && descMap.attrInt == 0x0012) {
-		def addAttrs = descMap.additionalAttrs ?: []
+		def addAttrs = descMap.additionalAttrs
 		addAttrs << ["attrInt": descMap.attrInt, "value": descMap.value]
 		result += parseAxis(addAttrs)
 	}

devicetypes/smartthings/testing/simulated-refrigerator-door.src/simulated-refrigerator-door.groovy

@@ -22,16 +22,16 @@ metadata {
 
 	tiles {
 		standardTile("contact", "device.contact", width: 2, height: 2) {
-			state("closed", label:'${name}', icon:"st.contact.contact.closed", backgroundColor:"#00A0DC", action: "open")
-			state("open", label:'${name}', icon:"st.contact.contact.open", backgroundColor:"#e86d13", action: "close")
+			state("closed", label:'${name}', icon:"st.contact.contact.closed", backgroundColor:"#79b821", action: "open")
+			state("open", label:'${name}', icon:"st.contact.contact.open", backgroundColor:"#ffa81e", action: "close")
 		}
 		standardTile("freezerDoor", "device.contact", width: 2, height: 2, decoration: "flat") {
-			state("closed", label:'Freezer', icon:"st.contact.contact.closed", backgroundColor:"#00A0DC")
-			state("open", label:'Freezer', icon:"st.contact.contact.open", backgroundColor:"#e86d13")
+			state("closed", label:'Freezer', icon:"st.contact.contact.closed", backgroundColor:"#79b821")
+			state("open", label:'Freezer', icon:"st.contact.contact.open", backgroundColor:"#ffa81e")
 		}
 		standardTile("mainDoor", "device.contact", width: 2, height: 2, decoration: "flat") {
-			state("closed", label:'Fridge', icon:"st.contact.contact.closed", backgroundColor:"#00A0DC")
-			state("open", label:'Fridge', icon:"st.contact.contact.open", backgroundColor:"#e86d13")
+			state("closed", label:'Fridge', icon:"st.contact.contact.closed", backgroundColor:"#79b821")
+			state("open", label:'Fridge', icon:"st.contact.contact.open", backgroundColor:"#ffa81e")
 		}
 		standardTile("control", "device.contact", width: 1, height: 1, decoration: "flat") {
 			state("closed", label:'${name}', icon:"st.contact.contact.closed", action: "open")

devicetypes/smartthings/testing/simulated-refrigerator.src/simulated-refrigerator.groovy

@@ -25,8 +25,8 @@ metadata {
 
 	tiles(scale: 2) {
 		standardTile("contact", "device.contact", width: 4, height: 4) {
-			state("closed", label:'${name}', icon:"st.fridge.fridge-closed", backgroundColor:"#00A0DC")
-			state("open", label:'${name}', icon:"st.fridge.fridge-open", backgroundColor:"#e86d13")
+			state("closed", label:'${name}', icon:"st.fridge.fridge-closed", backgroundColor:"#79b821")
+			state("open", label:'${name}', icon:"st.fridge.fridge-open", backgroundColor:"#ffa81e")
 		}
 		childDeviceTile("freezerDoor", "freezerDoor", height: 2, width: 2, childTileName: "freezerDoor")
 		childDeviceTile("mainDoor", "mainDoor", height: 2, width: 2, childTileName: "mainDoor")

devicetypes/smartthings/tile-ux/tile-multiattribute-generic.src/tile-multiattribute-generic.groovy

@@ -27,7 +27,7 @@ metadata {
 			tileAttribute("device.switch", key: "PRIMARY_CONTROL") {
 				attributeState "on", label:'${name}', action:"switch.off", icon:"st.switches.switch.on", backgroundColor:"#00A0DC", nextState:"turningOff"
 				attributeState "off", label:'${name}', action:"switch.on", icon:"st.switches.switch.off", backgroundColor:"#ffffff", nextState:"turningOn"
-				attributeState "turningOn", label:'${name}', action:"switch.off", icon:"st.switches.switch.on", backgroundColor:"#00A0DC", nextState:"turningOff"
+				attributeState "turningOn", label:'${name}', action:"switch.off", icon:"st.switches.switch.on", backgroundColor:"#79b821", nextState:"turningOff"
 				attributeState "turningOff", label:'${name}', action:"switch.on", icon:"st.switches.switch.off", backgroundColor:"#ffffff", nextState:"turningOn"
 			}
 		}
@@ -35,7 +35,7 @@ metadata {
 			tileAttribute("device.switch", key: "PRIMARY_CONTROL") {
 				attributeState "on", label:'${name}', backgroundColor:"#00A0DC", nextState:"turningOff"
 				attributeState "off", label:'${name}', backgroundColor:"#ffffff", nextState:"turningOn"
-				attributeState "turningOn", label:'${name}', backgroundColor:"#00A0DC", nextState:"turningOff"
+				attributeState "turningOn", label:'${name}', backgroundColor:"#79b821", nextState:"turningOff"
 				attributeState "turningOff", label:'${name}', backgroundColor:"#ffffff", nextState:"turningOn"
 			}
 			tileAttribute("device.level", key: "SECONDARY_CONTROL") {
@@ -59,7 +59,7 @@ metadata {
 			tileAttribute("device.switch", key: "SECONDARY_CONTROL") {
 				attributeState "on", label:'${name}', action:"switch.off", icon:"st.switches.switch.on", backgroundColor:"#00A0DC", nextState:"turningOff"
 				attributeState "off", label:'${name}', action:"switch.on", backgroundColor:"#ffffff", nextState:"turningOn"
-				attributeState "turningOn", label:'…', action:"switch.off", icon:"st.switches.switch.on", backgroundColor:"#00A0DC", nextState:"turningOff"
+				attributeState "turningOn", label:'…', action:"switch.off", icon:"st.switches.switch.on", backgroundColor:"#79b821", nextState:"turningOff"
 				attributeState "turningOff", label:'…', action:"switch.on", backgroundColor:"#ffffff", nextState:"turningOn"
 			}
 			tileAttribute("device.level", key: "VALUE_CONTROL") {

devicetypes/smartthings/wemo-light-switch.src/wemo-light-switch.groovy

@@ -40,11 +40,11 @@ metadata {
     tiles(scale: 2) {
         multiAttributeTile(name:"rich-control", type: "switch", canChangeIcon: true){
             tileAttribute ("device.switch", key: "PRIMARY_CONTROL") {
-                 attributeState "on", label:'${name}', action:"switch.off", icon:"st.Home.home30", backgroundColor:"#00A0DC", nextState:"turningOff"
+                 attributeState "on", label:'${name}', action:"switch.off", icon:"st.Home.home30", backgroundColor:"#79b821", nextState:"turningOff"
                  attributeState "off", label:'${name}', action:"switch.on", icon:"st.Home.home30", backgroundColor:"#ffffff", nextState:"turningOn"
-                 attributeState "turningOn", label:'${name}', action:"switch.off", icon:"st.Home.home30", backgroundColor:"#00A0DC", nextState:"turningOff"
+                 attributeState "turningOn", label:'${name}', action:"switch.off", icon:"st.Home.home30", backgroundColor:"#79b821", nextState:"turningOff"
                  attributeState "turningOff", label:'${name}', action:"switch.on", icon:"st.Home.home30", backgroundColor:"#ffffff", nextState:"turningOn"
-                 attributeState "offline", label:'${name}', icon:"st.Home.home30", backgroundColor:"#cccccc"
+                 attributeState "offline", label:'${name}', icon:"st.Home.home30", backgroundColor:"#ff0000"
  			}
             tileAttribute ("currentIP", key: "SECONDARY_CONTROL") {
              	 attributeState "currentIP", label: ''

devicetypes/smartthings/wemo-motion.src/wemo-motion.groovy

@@ -46,8 +46,8 @@
         }
 
 		standardTile("motion", "device.motion", width: 2, height: 2) {
-			state("active", label:'motion', icon:"st.motion.motion.active", backgroundColor:"#00A0DC")
-			state("inactive", label:'no motion', icon:"st.motion.motion.inactive", backgroundColor:"#CCCCCC")
+			state("active", label:'motion', icon:"st.motion.motion.active", backgroundColor:"#53a7c0")
+			state("inactive", label:'no motion', icon:"st.motion.motion.inactive", backgroundColor:"#ffffff")
       		state("offline", label:'${name}', icon:"st.motion.motion.inactive", backgroundColor:"#ff0000")
 		}
 

devicetypes/smartthings/wemo-switch.src/wemo-switch.groovy

@@ -38,11 +38,11 @@
     tiles(scale: 2) {
         multiAttributeTile(name:"rich-control", type: "switch", canChangeIcon: true){
             tileAttribute ("device.switch", key: "PRIMARY_CONTROL") {
-                 attributeState "on", label:'${name}', action:"switch.off", icon:"st.switches.switch.off", backgroundColor:"#00A0DC", nextState:"turningOff"
+                 attributeState "on", label:'${name}', action:"switch.off", icon:"st.switches.switch.off", backgroundColor:"#79b821", nextState:"turningOff"
                  attributeState "off", label:'${name}', action:"switch.on", icon:"st.switches.switch.on", backgroundColor:"#ffffff", nextState:"turningOn"
-                 attributeState "turningOn", label:'${name}', action:"switch.off", icon:"st.switches.switch.off", backgroundColor:"#00A0DC", nextState:"turningOff"
+                 attributeState "turningOn", label:'${name}', action:"switch.off", icon:"st.switches.switch.off", backgroundColor:"#79b821", nextState:"turningOff"
                  attributeState "turningOff", label:'${name}', action:"switch.on", icon:"st.switches.switch.on", backgroundColor:"#ffffff", nextState:"turningOn"
-                 attributeState "offline", label:'${name}', icon:"st.switches.switch.off", backgroundColor:"#cccccc"
+                 attributeState "offline", label:'${name}', icon:"st.switches.switch.off", backgroundColor:"#ff0000"
  			}
             tileAttribute ("currentIP", key: "SECONDARY_CONTROL") {
              	 attributeState "currentIP", label: ''
@@ -50,11 +50,11 @@
         }
 
         standardTile("switch", "device.switch", width: 2, height: 2, canChangeIcon: true) {
-            state "on", label:'${name}', action:"switch.off", icon:"st.switches.switch.off", backgroundColor:"#00A0DC", nextState:"turningOff"
+            state "on", label:'${name}', action:"switch.off", icon:"st.switches.switch.off", backgroundColor:"#79b821", nextState:"turningOff"
             state "off", label:'${name}', action:"switch.on", icon:"st.switches.switch.on", backgroundColor:"#ffffff", nextState:"turningOn"
-            state "turningOn", label:'${name}', action:"switch.off", icon:"st.switches.switch.off", backgroundColor:"#00A0DC", nextState:"turningOff"
+            state "turningOn", label:'${name}', action:"switch.off", icon:"st.switches.switch.off", backgroundColor:"#79b821", nextState:"turningOff"
             state "turningOff", label:'${name}', action:"switch.on", icon:"st.switches.switch.on", backgroundColor:"#ffffff", nextState:"turningOn"
-            state "offline", label:'${name}', icon:"st.switches.switch.off", backgroundColor:"#cccccc"
+            state "offline", label:'${name}', icon:"st.switches.switch.off", backgroundColor:"#ff0000"
         }
 
         standardTile("refresh", "device.switch", inactiveLabel: false, height: 2, width: 2, decoration: "flat") {

devicetypes/smartthings/zigbee-dimmer.src/zigbee-dimmer.groovy

@@ -25,7 +25,6 @@ metadata {
 
         fingerprint profileId: "0104", inClusters: "0000, 0003, 0004, 0005, 0006, 0008"
         fingerprint profileId: "0104", inClusters: "0000, 0003, 0004, 0005, 0006, 0008, 0B04, FC0F", outClusters: "0019", manufacturer: "OSRAM", model: "LIGHTIFY A19 ON/OFF/DIM", deviceJoinName: "SYLVANIA Smart A19 Soft White"
-        fingerprint profileId: "0104", inClusters: "0000, 0003, 0004, 0005, 0006, 0008, FC0F", outClusters: "0019", manufacturer: "OSRAM", model: "LIGHTIFY A19 ON/OFF/DIM 10 Year", deviceJoinName: "SYLVANIA Smart 10-Year A19"
         fingerprint profileId: "0104", inClusters: "0000, 0003, 0004, 0005, 0006, 0008, FF00", outClusters: "0019", manufacturer: "MRVL", model: "MZ100", deviceJoinName: "Wemo Bulb"
         fingerprint profileId: "0104", inClusters: "0000, 0003, 0004, 0005, 0006, 0008, 0B05", outClusters: "0019", manufacturer: "OSRAM SYLVANIA", model: "iQBR30", deviceJoinName: "Sylvania Ultra iQ"
         fingerprint profileId: "0104", inClusters: "0000, 0003, 0004, 0005, 0006, 0008, FC0F", outClusters: "0019", manufacturer: "OSRAM", model: "LIGHTIFY PAR38 ON/OFF/DIM", deviceJoinName: "SYLVANIA Smart PAR38 Soft White"

devicetypes/smartthings/zigbee-lock.src/zigbee-lock.groovy

@@ -34,7 +34,7 @@ import physicalgraph.zigbee.zcl.DataType
         fingerprint profileId: "0104", inClusters: "0000,0001,0003,0009,000A,0101,0020", outClusters: "000A,0019", manufacturer: "Yale", model: "YRD210 PB DB", deviceJoinName: "Yale Push Button Deadbolt Lock"
         fingerprint profileId: "0104", inClusters: "0000,0001,0003,0009,000A,0101,0020", outClusters: "000A,0019", manufacturer: "Yale", model: "YRD220/240 TSDB", deviceJoinName: "Yale Touch Screen Deadbolt Lock"
         fingerprint profileId: "0104", inClusters: "0000,0001,0003,0009,000A,0101,0020", outClusters: "000A,0019", manufacturer: "Yale", model: "YRL210 PB LL", deviceJoinName: "Yale Push Button Lever Lock"
-        fingerprint profileId: "0104", inClusters: "0000,0001,0003,0009,000A,0101,0020", outClusters: "000A,0019", manufacturer: "Yale", model: "YRD226/246 TSDB", deviceJoinName: "Yale Touch Screen Deadbolt Lock"
+	fingerprint profileId: "0104", inClusters: "0000,0001,0003,0009,000A,0101,0020", outClusters: "000A,0019", manufacturer: "Yale", model: "YRD226/246 TSDB", deviceJoinName: "Yale Touch Screen Deadbolt Lock"
 	}
 
     tiles(scale: 2) {

devicetypes/smartthings/zigbee-rgb-bulb.src/zigbee-rgb-bulb.groovy

@@ -1,5 +1,5 @@
 /**
- *  Copyright 2017 SmartThings
+ *  Copyright 2016 SmartThings
  *
  *  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:
@@ -64,7 +64,6 @@ private getATTRIBUTE_HUE() { 0x0000 }
 private getATTRIBUTE_SATURATION() { 0x0001 }
 private getHUE_COMMAND() { 0x00 }
 private getSATURATION_COMMAND() { 0x03 }
-private getMOVE_TO_HUE_AND_SATURATION_COMMAND() { 0x06 }
 private getCOLOR_CONTROL_CLUSTER() { 0x0300 }
 
 // Parse incoming device messages to generate events
@@ -85,11 +84,11 @@ def parse(String description) {
 
 		if (zigbeeMap?.clusterInt == COLOR_CONTROL_CLUSTER) {
 			if(zigbeeMap.attrInt == ATTRIBUTE_HUE){  //Hue Attribute
-				def hueValue = Math.round(zigbee.convertHexToInt(zigbeeMap.value) / 0xfe * 100)
+				def hueValue = Math.round(zigbee.convertHexToInt(zigbeeMap.value) / 255 * 100)
 				sendEvent(name: "hue", value: hueValue, descriptionText: "Color has changed")
 			}
 			else if(zigbeeMap.attrInt == ATTRIBUTE_SATURATION){ //Saturation Attribute
-				def saturationValue = Math.round(zigbee.convertHexToInt(zigbeeMap.value) / 0xfe * 100)
+				def saturationValue = Math.round(zigbee.convertHexToInt(zigbeeMap.value) / 255 * 100)
 				sendEvent(name: "saturation", value: saturationValue, descriptionText: "Color has changed", displayed: false)
 			}
 		}
@@ -124,12 +123,7 @@ def ping() {
 }
 
 def refresh() {
-	zigbee.onOffRefresh() +
-	zigbee.levelRefresh() +
-	zigbee.readAttribute(COLOR_CONTROL_CLUSTER, ATTRIBUTE_HUE) +
-	zigbee.readAttribute(COLOR_CONTROL_CLUSTER, ATTRIBUTE_SATURATION) +
-	zigbee.onOffConfig(0, 300) +
-	zigbee.levelConfig()
+	zigbee.onOffRefresh() + zigbee.levelRefresh() + zigbee.readAttribute(COLOR_CONTROL_CLUSTER, ATTRIBUTE_HUE) + zigbee.readAttribute(COLOR_CONTROL_CLUSTER, ATTRIBUTE_SATURATION) + zigbee.onOffConfig(0, 300) + zigbee.levelConfig() + zigbee.configureReporting(COLOR_CONTROL_CLUSTER, ATTRIBUTE_HUE, DataType.UINT8, 1, 3600, 0x01) + zigbee.configureReporting(COLOR_CONTROL_CLUSTER, ATTRIBUTE_SATURATION, DataType.UINT8, 1, 3600, 0x01)
 }
 
 def configure() {
@@ -139,38 +133,26 @@ def configure() {
 	sendEvent(name: "checkInterval", value: 3 * 10 * 60 + 1 * 60, displayed: false, data: [protocol: "zigbee", hubHardwareId: device.hub.hardwareID])
 
 	// OnOff minReportTime 0 seconds, maxReportTime 5 min. Reporting interval if no activity
-	refresh()
+	zigbee.onOffConfig(0, 300) + zigbee.levelConfig() + zigbee.configureReporting(COLOR_CONTROL_CLUSTER, ATTRIBUTE_HUE, DataType.UINT8, 1, 3600, 0x01) + zigbee.configureReporting(COLOR_CONTROL_CLUSTER, ATTRIBUTE_SATURATION, DataType.UINT8, 1, 3600, 0x01) + zigbee.onOffRefresh() + zigbee.levelRefresh() + zigbee.readAttribute(COLOR_CONTROL_CLUSTER, ATTRIBUTE_HUE) + zigbee.readAttribute(COLOR_CONTROL_CLUSTER, ATTRIBUTE_SATURATION)
 }
 
 def setLevel(value) {
 	zigbee.setLevel(value)
 }
 
-private getScaledHue(value) {
-	zigbee.convertToHexString(Math.round(value * 0xfe / 100.0), 2)
-}
-
-private getScaledSaturation(value) {
-	zigbee.convertToHexString(Math.round(value * 0xfe / 100.0), 2)
-}
-
 def setColor(value){
 	log.trace "setColor($value)"
-	zigbee.on() +
-	zigbee.command(COLOR_CONTROL_CLUSTER, MOVE_TO_HUE_AND_SATURATION_COMMAND,
-		getScaledHue(value.hue), getScaledSaturation(value.saturation), "0000") +
-	zigbee.readAttribute(COLOR_CONTROL_CLUSTER, ATTRIBUTE_HUE) +
-	zigbee.readAttribute(COLOR_CONTROL_CLUSTER, ATTRIBUTE_SATURATION)
+	zigbee.on() + setHue(value.hue) + "delay 500" + setSaturation(value.saturation)
 }
 
 def setHue(value) {
-	zigbee.command(COLOR_CONTROL_CLUSTER, HUE_COMMAND, getScaledHue(value), "00", "0000") +
-	zigbee.readAttribute(COLOR_CONTROL_CLUSTER, ATTRIBUTE_HUE)
+	def scaledHueValue = zigbee.convertToHexString(Math.round(value * 0xfe / 100.0), 2)
+	zigbee.command(COLOR_CONTROL_CLUSTER, HUE_COMMAND, scaledHueValue, "00", "0500")       //payload-> hue value, direction (00-> shortest distance), transition time (1/10th second) (0500 in U16 reads 5)
 }
 
 def setSaturation(value) {
-	zigbee.command(COLOR_CONTROL_CLUSTER, SATURATION_COMMAND, getScaledSaturation(value), "0000") +
-	zigbee.readAttribute(COLOR_CONTROL_CLUSTER, ATTRIBUTE_SATURATION)
+	def scaledSatValue = zigbee.convertToHexString(Math.round(value * 0xfe / 100.0), 2)
+	zigbee.command(COLOR_CONTROL_CLUSTER, SATURATION_COMMAND, scaledSatValue, "0500") + "delay 1000" + zigbee.readAttribute(COLOR_CONTROL_CLUSTER, ATTRIBUTE_SATURATION)
 }
 
 def installed() {
@@ -179,4 +161,4 @@ def installed() {
 			sendEvent(name: "level", value: 100)
 		}
 	}
-}
+}

devicetypes/smartthings/zigbee-rgbw-bulb.src/zigbee-rgbw-bulb.groovy

@@ -1,5 +1,5 @@
 /**
- *  Copyright 2017 SmartThings
+ *  Copyright 2016 SmartThings
  *
  *  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:
@@ -46,9 +46,9 @@ metadata {
     tiles(scale: 2) {
         multiAttributeTile(name:"switch", type: "lighting", width: 6, height: 4, canChangeIcon: true){
             tileAttribute ("device.switch", key: "PRIMARY_CONTROL") {
-                attributeState "on", label:'${name}', action:"switch.off", icon:"st.lights.philips.hue-single", backgroundColor:"#00A0DC", nextState:"turningOff"
+                attributeState "on", label:'${name}', action:"switch.off", icon:"st.lights.philips.hue-single", backgroundColor:"#79b821", nextState:"turningOff"
                 attributeState "off", label:'${name}', action:"switch.on", icon:"st.lights.philips.hue-single", backgroundColor:"#ffffff", nextState:"turningOn"
-                attributeState "turningOn", label:'${name}', action:"switch.off", icon:"st.lights.philips.hue-single", backgroundColor:"#00A0DC", nextState:"turningOff"
+                attributeState "turningOn", label:'${name}', action:"switch.off", icon:"st.lights.philips.hue-single", backgroundColor:"#79b821", nextState:"turningOff"
                 attributeState "turningOff", label:'${name}', action:"switch.on", icon:"st.lights.philips.hue-single", backgroundColor:"#ffffff", nextState:"turningOn"
             }
             tileAttribute ("device.level", key: "SLIDER_CONTROL") {
@@ -78,7 +78,6 @@ private getATTRIBUTE_HUE() { 0x0000 }
 private getATTRIBUTE_SATURATION() { 0x0001 }
 private getHUE_COMMAND() { 0x00 }
 private getSATURATION_COMMAND() { 0x03 }
-private getMOVE_TO_HUE_AND_SATURATION_COMMAND() { 0x06 }
 private getCOLOR_CONTROL_CLUSTER() { 0x0300 }
 private getATTRIBUTE_COLOR_TEMPERATURE() { 0x0007 }
 
@@ -103,11 +102,11 @@ def parse(String description) {
 
         if (zigbeeMap?.clusterInt == COLOR_CONTROL_CLUSTER) {
             if(zigbeeMap.attrInt == ATTRIBUTE_HUE){  //Hue Attribute
-                def hueValue = Math.round(zigbee.convertHexToInt(zigbeeMap.value) / 0xfe * 100)
+                def hueValue = Math.round(zigbee.convertHexToInt(zigbeeMap.value) / 255 * 100)
                 sendEvent(name: "hue", value: hueValue, descriptionText: "Color has changed")
             }
             else if(zigbeeMap.attrInt == ATTRIBUTE_SATURATION){ //Saturation Attribute
-                def saturationValue = Math.round(zigbee.convertHexToInt(zigbeeMap.value) / 0xfe * 100)
+                def saturationValue = Math.round(zigbee.convertHexToInt(zigbeeMap.value) / 255 * 100)
                 sendEvent(name: "saturation", value: saturationValue, descriptionText: "Color has changed", displayed: false)
             }
         }
@@ -142,13 +141,7 @@ def ping() {
 }
 
 def refresh() {
-    zigbee.onOffRefresh() +
-    zigbee.levelRefresh() +
-    zigbee.readAttribute(COLOR_CONTROL_CLUSTER, ATTRIBUTE_COLOR_TEMPERATURE) +
-    zigbee.readAttribute(COLOR_CONTROL_CLUSTER, ATTRIBUTE_HUE) +
-    zigbee.readAttribute(COLOR_CONTROL_CLUSTER, ATTRIBUTE_SATURATION) +
-    zigbee.onOffConfig(0, 300) +
-    zigbee.levelConfig()
+    zigbee.onOffRefresh() + zigbee.levelRefresh() + zigbee.readAttribute(COLOR_CONTROL_CLUSTER, ATTRIBUTE_COLOR_TEMPERATURE) + zigbee.readAttribute(COLOR_CONTROL_CLUSTER, ATTRIBUTE_HUE) + zigbee.readAttribute(COLOR_CONTROL_CLUSTER, ATTRIBUTE_SATURATION) + zigbee.onOffConfig(0, 300) + zigbee.levelConfig() + zigbee.colorTemperatureConfig() + zigbee.configureReporting(COLOR_CONTROL_CLUSTER, ATTRIBUTE_HUE, DataType.UINT8, 1, 3600, 0x01) + zigbee.configureReporting(COLOR_CONTROL_CLUSTER, ATTRIBUTE_SATURATION, DataType.UINT8, 1, 3600, 0x01)
 }
 
 def configure() {
@@ -163,12 +156,7 @@ def configure() {
 
 def setColorTemperature(value) {
     setGenericName(value)
-    value = value as Integer
-    def tempInMired = (1000000 / value) as Integer
-    def finalHex = zigbee.swapEndianHex(zigbee.convertToHexString(tempInMired, 4))
-
-    zigbee.command(COLOR_CONTROL_CLUSTER, 0x0A, "$finalHex 0000") +
-    zigbee.readAttribute(COLOR_CONTROL_CLUSTER, ATTRIBUTE_COLOR_TEMPERATURE)
+    zigbee.setColorTemperature(value)
 }
 
 //Naming based on the wiki article here: http://en.wikipedia.org/wiki/Color_temperature
@@ -192,31 +180,19 @@ def setLevel(value) {
     zigbee.setLevel(value)
 }
 
-private getScaledHue(value) {
-    zigbee.convertToHexString(Math.round(value * 0xfe / 100.0), 2)
-}
-
-private getScaledSaturation(value) {
-    zigbee.convertToHexString(Math.round(value * 0xfe / 100.0), 2)
-}
-
 def setColor(value){
     log.trace "setColor($value)"
-    zigbee.on() +
-    zigbee.command(COLOR_CONTROL_CLUSTER, MOVE_TO_HUE_AND_SATURATION_COMMAND,
-        getScaledHue(value.hue), getScaledSaturation(value.saturation), "0000") +
-    zigbee.readAttribute(COLOR_CONTROL_CLUSTER, ATTRIBUTE_HUE) +
-    zigbee.readAttribute(COLOR_CONTROL_CLUSTER, ATTRIBUTE_SATURATION)
+    zigbee.on() + setHue(value.hue) + "delay 300" + setSaturation(value.saturation)
 }
 
 def setHue(value) {
-    zigbee.command(COLOR_CONTROL_CLUSTER, HUE_COMMAND, getScaledHue(value), "00", "0000") +
-    zigbee.readAttribute(COLOR_CONTROL_CLUSTER, ATTRIBUTE_HUE)
+    def scaledHueValue = zigbee.convertToHexString(Math.round(value * 0xfe / 100.0), 2)
+    zigbee.command(COLOR_CONTROL_CLUSTER, HUE_COMMAND, scaledHueValue, "00", "0500")       //payload-> hue value, direction (00-> shortest distance), transition time (1/10th second) (0500 in U16 reads 5)
 }
 
 def setSaturation(value) {
-    zigbee.command(COLOR_CONTROL_CLUSTER, SATURATION_COMMAND, getScaledSaturation(value), "0000") +
-    zigbee.readAttribute(COLOR_CONTROL_CLUSTER, ATTRIBUTE_SATURATION)
+    def scaledSatValue = zigbee.convertToHexString(Math.round(value * 0xfe / 100.0), 2)
+    zigbee.command(COLOR_CONTROL_CLUSTER, SATURATION_COMMAND, scaledSatValue, "0500") + "delay 1000" + zigbee.readAttribute(COLOR_CONTROL_CLUSTER, ATTRIBUTE_SATURATION)
 }
 
 def installed() {
@@ -225,4 +201,4 @@ def installed() {
             sendEvent(name: "level", value: 100)
         }
     }
-}
+}

devicetypes/smartthings/zigbee-switch.src/zigbee-switch.groovy

@@ -41,9 +41,9 @@ metadata {
     tiles(scale: 2) {
         multiAttributeTile(name:"switch", type: "lighting", width: 6, height: 4, canChangeIcon: true){
             tileAttribute ("device.switch", key: "PRIMARY_CONTROL") {
-                attributeState "on", label:'${name}', action:"switch.off", icon:"st.switches.light.on", backgroundColor:"#00A0DC", nextState:"turningOff"
+                attributeState "on", label:'${name}', action:"switch.off", icon:"st.switches.light.on", backgroundColor:"#79b821", nextState:"turningOff"
                 attributeState "off", label:'${name}', action:"switch.on", icon:"st.switches.light.off", backgroundColor:"#ffffff", nextState:"turningOn"
-                attributeState "turningOn", label:'${name}', action:"switch.off", icon:"st.switches.light.on", backgroundColor:"#00A0DC", nextState:"turningOff"
+                attributeState "turningOn", label:'${name}', action:"switch.off", icon:"st.switches.light.on", backgroundColor:"#79b821", nextState:"turningOff"
                 attributeState "turningOff", label:'${name}', action:"switch.on", icon:"st.switches.light.off", backgroundColor:"#ffffff", nextState:"turningOn"
             }
         }

devicetypes/smartthings/zigbee-valve.src/zigbee-valve.groovy

@@ -39,7 +39,7 @@ metadata {
 
     tiles(scale: 2) {
         multiAttributeTile(name:"valve", type: "generic", width: 6, height: 4, canChangeIcon: true){
-            tileAttribute ("device.valve", key: "PRIMARY_CONTROL") {
+            tileAttribute ("device.contact", key: "PRIMARY_CONTROL") {
                 attributeState "open", label: '${name}', action: "valve.close", icon: "st.valves.water.open", backgroundColor: "#00A0DC", nextState:"closing"
                 attributeState "closed", label: '${name}', action: "valve.open", icon: "st.valves.water.closed", backgroundColor: "#ffffff", nextState:"opening"
                 attributeState "opening", label: '${name}', action: "valve.close", icon: "st.valves.water.open", backgroundColor: "#00A0DC", nextState:"closing"
@@ -83,9 +83,6 @@ def parse(String description) {
             }
         }
         sendEvent(event)
-        //handle valve attribute
-        event.name = "valve"
-        sendEvent(event)
     }
     else {
         def descMap = zigbee.parseDescriptionAsMap(description)

devicetypes/smartthings/zigbee-white-color-temperature-bulb.src/zigbee-white-color-temperature-bulb.groovy

@@ -1,5 +1,5 @@
 /**
- *  Copyright 2017 SmartThings
+ *  Copyright 2015 SmartThings
  *
  *  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:
@@ -45,9 +45,9 @@ metadata {
     tiles(scale: 2) {
         multiAttributeTile(name:"switch", type: "lighting", width: 6, height: 4, canChangeIcon: true){
             tileAttribute ("device.switch", key: "PRIMARY_CONTROL") {
-                attributeState "on", label:'${name}', action:"switch.off", icon:"st.switches.light.on", backgroundColor:"#00A0DC", nextState:"turningOff"
+                attributeState "on", label:'${name}', action:"switch.off", icon:"st.switches.light.on", backgroundColor:"#79b821", nextState:"turningOff"
                 attributeState "off", label:'${name}', action:"switch.on", icon:"st.switches.light.off", backgroundColor:"#ffffff", nextState:"turningOn"
-                attributeState "turningOn", label:'${name}', action:"switch.off", icon:"st.switches.light.on", backgroundColor:"#00A0DC", nextState:"turningOff"
+                attributeState "turningOn", label:'${name}', action:"switch.off", icon:"st.switches.light.on", backgroundColor:"#79b821", nextState:"turningOff"
                 attributeState "turningOff", label:'${name}', action:"switch.on", icon:"st.switches.light.off", backgroundColor:"#ffffff", nextState:"turningOn"
             }
             tileAttribute ("device.level", key: "SLIDER_CONTROL") {
@@ -71,11 +71,6 @@ metadata {
     }
 }
 
-// Globals
-private getMOVE_TO_COLOR_TEMPERATURE_COMMAND() { 0x0A }
-private getCOLOR_CONTROL_CLUSTER() { 0x0300 }
-private getATTRIBUTE_COLOR_TEMPERATURE() { 0x0007 }
-
 // Parse incoming device messages to generate events
 def parse(String description) {
     log.debug "description is $description"
@@ -128,11 +123,7 @@ def ping() {
 }
 
 def refresh() {
-    zigbee.onOffRefresh() +
-    zigbee.levelRefresh() +
-    zigbee.colorTemperatureRefresh() +
-    zigbee.onOffConfig(0, 300) +
-    zigbee.levelConfig()
+    zigbee.onOffRefresh() + zigbee.levelRefresh() + zigbee.colorTemperatureRefresh() + zigbee.onOffConfig(0, 300) + zigbee.levelConfig() + zigbee.colorTemperatureConfig()
 }
 
 def configure() {
@@ -147,12 +138,7 @@ def configure() {
 
 def setColorTemperature(value) {
     setGenericName(value)
-	value = value as Integer
-    def tempInMired = (1000000 / value) as Integer
-    def finalHex = zigbee.swapEndianHex(zigbee.convertToHexString(tempInMired, 4))
-
-    zigbee.command(COLOR_CONTROL_CLUSTER, MOVE_TO_COLOR_TEMPERATURE_COMMAND, "$finalHex 0000") +
-    zigbee.readAttribute(COLOR_CONTROL_CLUSTER, ATTRIBUTE_COLOR_TEMPERATURE)
+    zigbee.setColorTemperature(value)
 }
 
 //Naming based on the wiki article here: http://en.wikipedia.org/wiki/Color_temperature

devicetypes/smartthings/zll-dimmer-bulb.src/zll-dimmer-bulb.groovy

@@ -49,9 +49,9 @@ metadata {
     tiles(scale: 2) {
         multiAttributeTile(name:"switch", type: "lighting", width: 6, height: 4, canChangeIcon: true){
             tileAttribute ("device.switch", key: "PRIMARY_CONTROL") {
-                attributeState "on", label:'${name}', action:"switch.off", icon:"st.switches.light.on", backgroundColor:"#00A0DC", nextState:"turningOff"
+                attributeState "on", label:'${name}', action:"switch.off", icon:"st.switches.light.on", backgroundColor:"#79b821", nextState:"turningOff"
                 attributeState "off", label:'${name}', action:"switch.on", icon:"st.switches.light.off", backgroundColor:"#ffffff", nextState:"turningOn"
-                attributeState "turningOn", label:'${name}', action:"switch.off", icon:"st.switches.light.on", backgroundColor:"#00A0DC", nextState:"turningOff"
+                attributeState "turningOn", label:'${name}', action:"switch.off", icon:"st.switches.light.on", backgroundColor:"#79b821", nextState:"turningOff"
                 attributeState "turningOff", label:'${name}', action:"switch.on", icon:"st.switches.light.off", backgroundColor:"#ffffff", nextState:"turningOn"
             }
             tileAttribute ("device.level", key: "SLIDER_CONTROL") {

devicetypes/smartthings/zll-rgb-bulb.src/zll-rgb-bulb.groovy

@@ -1,5 +1,5 @@
 /**
- *  Copyright 2017 SmartThings
+ *  Copyright 2016 SmartThings
  *
  *  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:
@@ -55,7 +55,6 @@ private getATTRIBUTE_HUE() { 0x0000 }
 private getATTRIBUTE_SATURATION() { 0x0001 }
 private getHUE_COMMAND() { 0x00 }
 private getSATURATION_COMMAND() { 0x03 }
-private getMOVE_TO_HUE_AND_SATURATION_COMMAND() { 0x06 }
 private getCOLOR_CONTROL_CLUSTER() { 0x0300 }
 
 // Parse incoming device messages to generate events
@@ -73,11 +72,11 @@ def parse(String description) {
 
 		if (zigbeeMap?.clusterInt == COLOR_CONTROL_CLUSTER) {
 			if(zigbeeMap.attrInt == ATTRIBUTE_HUE){  //Hue Attribute
-				def hueValue = Math.round(zigbee.convertHexToInt(zigbeeMap.value) / 0xfe * 100)
+				def hueValue = Math.round(zigbee.convertHexToInt(zigbeeMap.value) / 255 * 360)
 				sendEvent(name: "hue", value: hueValue, displayed:false)
 			}
 			else if(zigbeeMap.attrInt == ATTRIBUTE_SATURATION){ //Saturation Attribute
-				def saturationValue = Math.round(zigbee.convertHexToInt(zigbeeMap.value) / 0xfe * 100)
+				def saturationValue = Math.round(zigbee.convertHexToInt(zigbeeMap.value) / 255 * 100)
 				sendEvent(name: "saturation", value: saturationValue, displayed:false)
 			}
 		}
@@ -109,46 +108,28 @@ def configure() {
 }
 
 def configureAttributes() {
-	zigbee.onOffConfig() +
-	zigbee.levelConfig()
+	zigbee.onOffConfig() + zigbee.levelConfig() + zigbee.configureReporting(COLOR_CONTROL_CLUSTER, ATTRIBUTE_HUE, DataType.UINT8, 1, 3600, 0x01) + zigbee.configureReporting(COLOR_CONTROL_CLUSTER, ATTRIBUTE_SATURATION, DataType.UINT8, 1, 3600, 0x01)
 }
 
 def refreshAttributes() {
-	zigbee.onOffRefresh() +
-	zigbee.levelRefresh() +
-	zigbee.readAttribute(COLOR_CONTROL_CLUSTER, ATTRIBUTE_HUE) +
-	zigbee.readAttribute(COLOR_CONTROL_CLUSTER, ATTRIBUTE_SATURATION)
+	zigbee.onOffRefresh() + zigbee.levelRefresh() + zigbee.readAttribute(COLOR_CONTROL_CLUSTER, ATTRIBUTE_HUE) + zigbee.readAttribute(COLOR_CONTROL_CLUSTER, ATTRIBUTE_SATURATION)
 }
 
 def setLevel(value) {
 	zigbee.setLevel(value) + zigbee.onOffRefresh() + zigbee.levelRefresh()         //adding refresh because of ZLL bulb not conforming to send-me-a-report
 }
 
-private getScaledHue(value) {
-	zigbee.convertToHexString(Math.round(value * 0xfe / 100.0), 2)
-}
-
-private getScaledSaturation(value) {
-	zigbee.convertToHexString(Math.round(value * 0xfe / 100.0), 2)
-}
-
 def setColor(value){
 	log.trace "setColor($value)"
-	zigbee.on() +
-	zigbee.command(COLOR_CONTROL_CLUSTER, MOVE_TO_HUE_AND_SATURATION_COMMAND,
-		getScaledHue(value.hue), getScaledSaturation(value.saturation), "0000") +
-	zigbee.readAttribute(COLOR_CONTROL_CLUSTER, ATTRIBUTE_HUE) +
-	zigbee.readAttribute(COLOR_CONTROL_CLUSTER, ATTRIBUTE_SATURATION)
+	zigbee.on() + setHue(value.hue) + ["delay 300"] + setSaturation(value.saturation) + ["delay 2000"] + refreshAttributes()
 }
 
 def setHue(value) {
-	//payload-> hue value, direction (00-> shortest distance), transition time (1/10th second)
-	zigbee.command(COLOR_CONTROL_CLUSTER, HUE_COMMAND, getScaledHue(value), "00", "0000") +
-	zigbee.readAttribute(COLOR_CONTROL_CLUSTER, ATTRIBUTE_HUE)
+	def scaledHueValue = zigbee.convertToHexString(Math.round(value * 0xfe / 100.0), 2)
+	zigbee.command(COLOR_CONTROL_CLUSTER, HUE_COMMAND, scaledHueValue, "00", "0500") + ["delay 1500"] + zigbee.readAttribute(COLOR_CONTROL_CLUSTER, ATTRIBUTE_HUE)      //payload-> hue value, direction (00-> shortest distance), transition time (1/10th second) (0500 in U16 reads 5)
 }
 
 def setSaturation(value) {
-	//payload-> sat value, transition time
-	zigbee.command(COLOR_CONTROL_CLUSTER, SATURATION_COMMAND, getScaledSaturation(value), "0000") +
-	zigbee.readAttribute(COLOR_CONTROL_CLUSTER, ATTRIBUTE_SATURATION)
+	def scaledSatValue = zigbee.convertToHexString(Math.round(value * 0xfe / 100.0), 2)
+	zigbee.command(COLOR_CONTROL_CLUSTER, SATURATION_COMMAND, scaledSatValue, "0500") + ["delay 1500"] + zigbee.readAttribute(COLOR_CONTROL_CLUSTER, ATTRIBUTE_SATURATION)      //payload-> sat value, transition time
 }

devicetypes/smartthings/zll-rgbw-bulb.src/zll-rgbw-bulb.groovy

@@ -1,5 +1,5 @@
 /**
- *  Copyright 2017 SmartThings
+ *  Copyright 2016 SmartThings
  *
  *  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:
@@ -70,7 +70,6 @@ private getATTRIBUTE_HUE() { 0x0000 }
 private getATTRIBUTE_SATURATION() { 0x0001 }
 private getHUE_COMMAND() { 0x00 }
 private getSATURATION_COMMAND() { 0x03 }
-private getMOVE_TO_HUE_AND_SATURATION_COMMAND() { 0x06 }
 private getCOLOR_CONTROL_CLUSTER() { 0x0300 }
 private getATTRIBUTE_COLOR_TEMPERATURE() { 0x0007 }
 
@@ -89,11 +88,11 @@ def parse(String description) {
 
         if (zigbeeMap?.clusterInt == COLOR_CONTROL_CLUSTER) {
             if(zigbeeMap.attrInt == ATTRIBUTE_HUE){  //Hue Attribute
-                def hueValue = Math.round(zigbee.convertHexToInt(zigbeeMap.value) / 0xfe * 100)
+                def hueValue = Math.round(zigbee.convertHexToInt(zigbeeMap.value) / 255 * 360)
                 sendEvent(name: "hue", value: hueValue, displayed:false)
             }
             else if(zigbeeMap.attrInt == ATTRIBUTE_SATURATION){ //Saturation Attribute
-                def saturationValue = Math.round(zigbee.convertHexToInt(zigbeeMap.value) / 0xfe * 100)
+                def saturationValue = Math.round(zigbee.convertHexToInt(zigbeeMap.value) / 255 * 100)
                 sendEvent(name: "saturation", value: saturationValue, displayed:false)
             }
         }
@@ -125,16 +124,11 @@ def configure() {
 }
 
 def configureAttributes() {
-    zigbee.onOffConfig() +
-    zigbee.levelConfig()
+    zigbee.onOffConfig() + zigbee.levelConfig() + zigbee.colorTemperatureConfig() + zigbee.configureReporting(COLOR_CONTROL_CLUSTER, ATTRIBUTE_HUE, DataType.UINT8, 1, 3600, 0x01) + zigbee.configureReporting(COLOR_CONTROL_CLUSTER, ATTRIBUTE_SATURATION, DataType.UINT8, 1, 3600, 0x01)
 }
 
 def refreshAttributes() {
-    zigbee.onOffRefresh() +
-    zigbee.levelRefresh() +
-    zigbee.colorTemperatureRefresh() +
-    zigbee.readAttribute(COLOR_CONTROL_CLUSTER, ATTRIBUTE_HUE) +
-    zigbee.readAttribute(COLOR_CONTROL_CLUSTER, ATTRIBUTE_SATURATION)
+    zigbee.onOffRefresh() + zigbee.levelRefresh() + zigbee.colorTemperatureRefresh() + zigbee.readAttribute(COLOR_CONTROL_CLUSTER, ATTRIBUTE_HUE) + zigbee.readAttribute(COLOR_CONTROL_CLUSTER, ATTRIBUTE_SATURATION)
 }
 
 def setColorTemperature(value) {
@@ -145,32 +139,17 @@ def setLevel(value) {
     zigbee.setLevel(value) + zigbee.onOffRefresh() + zigbee.levelRefresh()        //adding refresh because of ZLL bulb not conforming to send-me-a-report
 }
 
-private getScaledHue(value) {
-    zigbee.convertToHexString(Math.round(value * 0xfe / 100.0), 2)
-}
-
-private getScaledSaturation(value) {
-    zigbee.convertToHexString(Math.round(value * 0xfe / 100.0), 2)
-}
-
 def setColor(value){
     log.trace "setColor($value)"
-    zigbee.on() +
-    zigbee.command(COLOR_CONTROL_CLUSTER, MOVE_TO_HUE_AND_SATURATION_COMMAND,
-        getScaledHue(value.hue), getScaledSaturation(value.saturation), "0000") +
-    zigbee.onOffRefresh() +
-    zigbee.readAttribute(COLOR_CONTROL_CLUSTER, ATTRIBUTE_HUE) +
-    zigbee.readAttribute(COLOR_CONTROL_CLUSTER, ATTRIBUTE_SATURATION)
+    zigbee.on() + setHue(value.hue) + ["delay 300"] + setSaturation(value.saturation) + ["delay 2000"] + refreshAttributes()
 }
 
 def setHue(value) {
-    //payload-> hue value, direction (00-> shortest distance), transition time (1/10th second)
-    zigbee.command(COLOR_CONTROL_CLUSTER, HUE_COMMAND, getScaledHue(value), "00", "0000") +
-    zigbee.readAttribute(COLOR_CONTROL_CLUSTER, ATTRIBUTE_HUE)
+    def scaledHueValue = zigbee.convertToHexString(Math.round(value * 0xfe / 100.0), 2)
+    zigbee.command(COLOR_CONTROL_CLUSTER, HUE_COMMAND, scaledHueValue, "00", "0500") + ["delay 1500"] + zigbee.readAttribute(COLOR_CONTROL_CLUSTER, ATTRIBUTE_HUE)       //payload-> hue value, direction (00-> shortest distance), transition time (1/10th second) (0500 in U16 reads 5)
 }
 
 def setSaturation(value) {
-    //payload-> sat value, transition time
-    zigbee.command(COLOR_CONTROL_CLUSTER, SATURATION_COMMAND, getScaledSaturation(value), "0000") +
-    zigbee.readAttribute(COLOR_CONTROL_CLUSTER, ATTRIBUTE_SATURATION)
+    def scaledSatValue = zigbee.convertToHexString(Math.round(value * 0xfe / 100.0), 2)
+    zigbee.command(COLOR_CONTROL_CLUSTER, SATURATION_COMMAND, scaledSatValue, "0500") + ["delay 1500"] + zigbee.readAttribute(COLOR_CONTROL_CLUSTER, ATTRIBUTE_SATURATION)      //payload-> sat value, transition time
 }

devicetypes/smartthings/zll-white-color-temperature-bulb-5000k.src/zll-white-color-temperature-bulb-5000k.groovy

@@ -1,5 +1,5 @@
 /**
- *  Copyright 2017 SmartThings
+ *  Copyright 2016 SmartThings
  *
  *  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:
@@ -66,11 +66,6 @@ metadata {
     }
 }
 
-// Globals
-private getMOVE_TO_COLOR_TEMPERATURE_COMMAND() { 0x0A }
-private getCOLOR_CONTROL_CLUSTER() { 0x0300 }
-private getATTRIBUTE_COLOR_TEMPERATURE() { 0x0007 }
-
 // Parse incoming device messages to generate events
 def parse(String description) {
     log.debug "description is $description"
@@ -100,14 +95,14 @@ def setLevel(value) {
 }
 
 def refresh() {
-    def cmds = zigbee.onOffRefresh() + zigbee.levelRefresh() + zigbee.colorTemperatureRefresh()
+	def cmds = zigbee.onOffRefresh() + zigbee.levelRefresh() + zigbee.colorTemperatureRefresh()
 
-    // Do NOT config if the device is the Eaton Halo_LT01, it responds with "switch:off" to onOffConfig, and maybe other weird things with the others
+	// Do NOT config if the device is the Eaton Halo_LT01, it responds with "switch:off" to onOffConfig, and maybe other weird things with the others
     if (!((device.getDataValue("manufacturer") == "Eaton") && (device.getDataValue("model") == "Halo_LT01"))) {
-        cmds += zigbee.onOffConfig() + zigbee.levelConfig()
+        cmds = cmds + zigbee.onOffConfig() + zigbee.levelConfig() + zigbee.colorTemperatureConfig()
     }
 
-    cmds
+	cmds
 }
 
 def poll() {
@@ -143,7 +138,7 @@ def configure() {
     log.debug "configure()"
     configureHealthCheck()
     // Implementation note: for the Eaton Halo_LT01, it responds with "switch:off" to onOffConfig, so be sure this is before the call to onOffRefresh
-    zigbee.onOffConfig() + zigbee.levelConfig() + zigbee.onOffRefresh() + zigbee.levelRefresh() + zigbee.colorTemperatureRefresh()
+    zigbee.onOffConfig() + zigbee.levelConfig() + zigbee.colorTemperatureConfig() + zigbee.onOffRefresh() + zigbee.levelRefresh() + zigbee.colorTemperatureRefresh()
 }
 
 def updated() {
@@ -153,12 +148,7 @@ def updated() {
 
 def setColorTemperature(value) {
     setGenericName(value)
-    value = value as Integer
-    def tempInMired = (1000000 / value) as Integer
-    def finalHex = zigbee.swapEndianHex(zigbee.convertToHexString(tempInMired, 4))
-
-    zigbee.command(COLOR_CONTROL_CLUSTER, MOVE_TO_COLOR_TEMPERATURE_COMMAND, "$finalHex 0000") +
-    zigbee.readAttribute(COLOR_CONTROL_CLUSTER, ATTRIBUTE_COLOR_TEMPERATURE)
+    zigbee.setColorTemperature(value) + ["delay 1500"] + zigbee.colorTemperatureRefresh()
 }
 
 //Naming based on the wiki article here: http://en.wikipedia.org/wiki/Color_temperature

devicetypes/smartthings/zll-white-color-temperature-bulb.src/zll-white-color-temperature-bulb.groovy

@@ -1,5 +1,5 @@
 /**
- *  Copyright 2017 SmartThings
+ *  Copyright 2016 SmartThings
  *
  *  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:
@@ -68,11 +68,6 @@ metadata {
     }
 }
 
-// Globals
-private getMOVE_TO_COLOR_TEMPERATURE_COMMAND() { 0x0A }
-private getCOLOR_CONTROL_CLUSTER() { 0x0300 }
-private getATTRIBUTE_COLOR_TEMPERATURE() { 0x0007 }
-
 // Parse incoming device messages to generate events
 def parse(String description) {
     log.debug "description is $description"
@@ -99,11 +94,7 @@ def setLevel(value) {
 }
 
 def refresh() {
-    zigbee.onOffRefresh() +
-    zigbee.levelRefresh() +
-    zigbee.colorTemperatureRefresh() +
-    zigbee.onOffConfig() +
-    zigbee.levelConfig()
+    zigbee.onOffRefresh() + zigbee.levelRefresh() + zigbee.colorTemperatureRefresh() + zigbee.onOffConfig() + zigbee.levelConfig() + zigbee.colorTemperatureConfig()
 }
 
 def poll() {
@@ -138,7 +129,8 @@ def configureHealthCheck() {
 def configure() {
     log.debug "configure()"
     configureHealthCheck()
-    refresh()
+    zigbee.onOffConfig() + zigbee.levelConfig() + zigbee.colorTemperatureConfig() + zigbee.onOffRefresh() + zigbee.levelRefresh() + zigbee.colorTemperatureRefresh()
+
 }
 
 def updated() {
@@ -148,12 +140,7 @@ def updated() {
 
 def setColorTemperature(value) {
     setGenericName(value)
-    value = value as Integer
-    def tempInMired = (1000000 / value) as Integer
-    def finalHex = zigbee.swapEndianHex(zigbee.convertToHexString(tempInMired, 4))
-
-    zigbee.command(COLOR_CONTROL_CLUSTER, MOVE_TO_COLOR_TEMPERATURE_COMMAND, "$finalHex 0000") +
-    zigbee.readAttribute(COLOR_CONTROL_CLUSTER, ATTRIBUTE_COLOR_TEMPERATURE)
+    zigbee.setColorTemperature(value) + ["delay 1500"] + zigbee.colorTemperatureRefresh()
 }
 
 //Naming based on the wiki article here: http://en.wikipedia.org/wiki/Color_temperature

devicetypes/smartthings/zwave-device-multichannel.src/zwave-device-multichannel.groovy

@@ -75,10 +75,6 @@ def parse(String description) {
 	return result
 }
 
-def uninstalled() {
-	sendEvent(name: "epEvent", value: "delete all", isStateChange: true, displayed: false, descriptionText: "Delete endpoint devices")
-}
-
 def zwaveEvent(physicalgraph.zwave.commands.wakeupv1.WakeUpNotification cmd) {
 	[ createEvent(descriptionText: "${device.displayName} woke up", isStateChange:true),
 	  response(["delay 2000", zwave.wakeUpV1.wakeUpNoMoreInformation().format()]) ]

devicetypes/smartthings/zwave-door-window-sensor.src/zwave-door-window-sensor.groovy

@@ -30,15 +30,9 @@ metadata {
 		fingerprint deviceId: "0x0701", inClusters: "0x5E,0x86,0x72,0x98", outClusters: "0x5A,0x82"
 		fingerprint deviceId: "0x0701", inClusters: "0x5E,0x80,0x71,0x85,0x70,0x72,0x86,0x30,0x31,0x84,0x59,0x73,0x5A,0x8F,0x98,0x7A", outClusters:"0x20" // Philio multi+
 		fingerprint mfr:"0086", prod:"0002", model:"001D", deviceJoinName: "Aeon Labs Door/Window Sensor (Gen 5)"
-		fingerprint mfr:"0086", prod:"0102", model:"0070", deviceJoinName:  "Aeon Labs Door/Window Sensor 6"
-		fingerprint mfr:"0086", prod:"0102", model:"0059", deviceJoinName: "Aeon Labs Recessed Door Sensor"
 		fingerprint mfr:"014A", prod:"0001", model:"0002", deviceJoinName: "Ecolink Door/Window Sensor"
-		fingerprint mfr:"014A", prod:"0001", model:"0003", deviceJoinName: "Ecolink Tilt Sensor"
+		fingerprint mfr:"0086", prod:"0102", model:"0070", deviceJoinName:  "Aeon Labs Door/Window Sensor 6"
 		fingerprint mfr:"011A", prod:"0601", model:"0903", deviceJoinName: "Enerwave Magnetic Door/Window Sensor"
-		fingerprint mfr:"014F", prod:"2001", model:"0102", deviceJoinName: "Nortek GoControl Door/Window Sensor"
-		fingerprint mfr:"0063", prod:"4953", model:"3031", deviceJoinName: "Jasco Hinge Pin Door Sensor"
-		fingerprint mfr:"019A", prod:"0003", model:"0003", deviceJoinName: "Sensative Strips"
-
 	}
 
 	// simulator metadata

devicetypes/smartthings/zwave-lock.src/zwave-lock.groovy

@@ -26,24 +26,7 @@ metadata {
 
 		fingerprint deviceId: "0x4003", inClusters: "0x98"
 		fingerprint deviceId: "0x4004", inClusters: "0x98"
-		fingerprint mfr:"0090", prod:"0001", model:"0236", deviceJoinName: "KwikSet SmartCode 910 Deadbolt Door Lock"
-		fingerprint mfr:"0090", prod:"0003", model:"0238", deviceJoinName: "KwikSet SmartCode 910 Deadbolt Door Lock"
-		fingerprint mfr:"0090", prod:"0001", model:"0001", deviceJoinName: "KwikSet SmartCode 910 Contemporary Deadbolt Door Lock"
-		fingerprint mfr:"0090", prod:"0003", model:"0339", deviceJoinName: "KwikSet SmartCode 912 Lever Door Lock"
-		fingerprint mfr:"0090", prod:"0003", model:"4006", deviceJoinName: "KwikSet SmartCode 914 Deadbolt Door Lock" //backlit version
-		fingerprint mfr:"0090", prod:"0003", model:"0440", deviceJoinName: "KwikSet SmartCode 914 Deadbolt Door Lock"
-		fingerprint mfr:"0090", prod:"0001", model:"0642", deviceJoinName: "KwikSet SmartCode 916 Touchscreen Deadbolt Door Lock"
-		fingerprint mfr:"0090", prod:"0003", model:"0642", deviceJoinName: "KwikSet SmartCode 916 Touchscreen Deadbolt Door Lock"
-		fingerprint mfr:"003B", prod:"6341", model:"0544", deviceJoinName: "Schlage Camelot Touchscreen Deadbolt Door Lock"
-		fingerprint mfr:"003B", prod:"6341", model:"5044", deviceJoinName: "Schlage Century Touchscreen Deadbolt Door Lock"
-		fingerprint mfr:"003B", prod:"634B", model:"504C", deviceJoinName: "Schlage Connected Keypad Lever Door Lock"
-		fingerprint mfr:"0129", prod:"0002", model:"0800", deviceJoinName: "Yale Touchscreen Deadbolt Door Lock" // YRD120
-		fingerprint mfr:"0129", prod:"0002", model:"0000", deviceJoinName: "Yale Touchscreen Deadbolt Door Lock" // YRD220, YRD240
-		fingerprint mfr:"0129", prod:"0002", model:"FFFF", deviceJoinName: "Yale Touchscreen Lever Door Lock" // YRD220
-		fingerprint mfr:"0129", prod:"0004", model:"0800", deviceJoinName: "Yale Push Button Deadbolt Door Lock" // YRD110
-		fingerprint mfr:"0129", prod:"0004", model:"0000", deviceJoinName: "Yale Push Button Deadbolt Door Lock" // YRD210
-		fingerprint mfr:"0129", prod:"0001", model:"0000", deviceJoinName: "Yale Push Button Lever Door Lock" // YRD210
-		fingerprint mfr:"0129", prod:"8002", model:"0600", deviceJoinName: "Yale Assure Lock with Bluetooth"
+		fingerprint mfr:"0129", prod:"0002", model:"0000", deviceJoinName: "Yale Key Free Touchscreen Deadbolt"
 	}
 
 	simulator {

devicetypes/smartthings/zwave-motion-sensor.src/zwave-motion-sensor.groovy

@@ -29,7 +29,7 @@ metadata {
 		fingerprint mfr: "0060", prod: "0001", model: "0002", deviceJoinName: "Everspring Motion Sensor"  // Everspring SP814
 		fingerprint mfr: "0060", prod: "0001", model: "0003", deviceJoinName: "Everspring Motion Sensor"  // Everspring HSP02
 		fingerprint mfr: "011A", prod: "0601", model: "0901", deviceJoinName: "Enerwave Motion Sensor"  // Enerwave ZWN-BPC
-		fingerprint mfr: "0063", prod: "4953", model: "3133", deviceJoinName: "GE Portable Smart Motion Sensor"
+		fingerprint mfr: "0063", prod: "4953", model: "3133", deviceJoinName: "GE Smart Motion Sensor"
 	}
 
 	simulator {

devicetypes/smartthings/zwave-plus-motion-temp-sensor.src/zwave-plus-motion-temp-sensor.groovy

@@ -37,8 +37,8 @@ metadata {
 
 	tiles {
 		standardTile("motion", "device.motion", width: 3, height: 2) {
-			state "active", label:'motion', icon:"st.motion.motion.active", backgroundColor:"#00A0DC"
-			state "inactive", label:'no motion', icon:"st.motion.motion.inactive", backgroundColor:"#CCCCCC"
+			state "active", label:'motion', icon:"st.motion.motion.active", backgroundColor:"#53a7c0"
+			state "inactive", label:'no motion', icon:"st.motion.motion.inactive", backgroundColor:"#ffffff"
 		}
 
 		valueTile("temperature", "device.temperature", inactiveLabel: false) {

devicetypes/smartthings/zwave-smoke-alarm.src/zwave-smoke-alarm.groovy

@@ -22,7 +22,6 @@ metadata {
 		attribute "alarmState", "string"
 
 		fingerprint deviceId: "0xA100", inClusters: "0x20,0x80,0x70,0x85,0x71,0x72,0x86"
-		fingerprint mfr:"0138", prod:"0001", model:"0001", deviceJoinName: "First Alert Smoke Detector"
 		fingerprint mfr:"0138", prod:"0001", model:"0002", deviceJoinName: "First Alert Smoke Detector and Carbon Monoxide Alarm (ZCOMBO)"
 	}
 

devicetypes/smartthings/zwave-water-valve.src/.st-ignore

@@ -1,2 +0,0 @@
-.st-ignore
-README.md

devicetypes/smartthings/zwave-water-valve.src/README.md

@@ -1,38 +0,0 @@
-# Z-Wave Water Valve
-
-Cloud Execution
-
-Works with: 
-
-* [Leak Intelligence Leak Gopher Water Shutoff Valve](https://www.smartthings.com/works-with-smartthings/other/leak-intelligence-leak-gopher-water-shutoff-valve)
-
-
-## Table of contents
-
-* [Capabilities](#capabilities)
-* [Health](#device-health)
-* [Troubleshooting](#Troubleshooting)
-
-## Capabilities
-
-* **Actuator** - represents that a Device has commands
-* **Health Check** - indicates ability to get device health notifications
-* **Valve** - allows for the control of a valve device
-* **Polling** - represents that poll() can be implemented for the device
-* **Refresh** - _refresh()_ command for status updates
-* **Sensor** - detects sensor events
-
-## Device Health
-
-SmartThings platform will ping the device after `checkInterval` seconds of inactivity in last attempt to reach the device before marking it `OFFLINE`
-
-* __32min__ checkInterval
-
-## Troubleshooting
-
-If the device doesn't pair when trying from the SmartThings mobile app, it is possible that the device is out of range.
-Pairing needs to be tried again by placing the device closer to the hub.
-Instructions related to pairing, resetting and removing the device from SmartThings can be found in the following link:
-* [Leak Intelligence Leak Gopher Water Shutoff Valve Troubleshooting Tips](https://support.smartthings.com/hc/en-us/articles/209631423-Leak-Gopher-Z-Wave-Valve-Control)
-
-

devicetypes/smartthings/zwave-water-valve.src/zwave-water-valve.groovy

@@ -12,16 +12,14 @@
  *
  */
 metadata {
-	definition (name: "Z-Wave Water Valve", namespace: "smartthings", author: "SmartThings", ocfDeviceType: "oic.d.watervalve") {
+	definition (name: "Z-Wave Water Valve", namespace: "smartthings", author: "SmartThings") {
 		capability "Actuator"
-		capability "Health Check"
 		capability "Valve"
 		capability "Polling"
 		capability "Refresh"
 		capability "Sensor"
 
 		fingerprint deviceId: "0x1006", inClusters: "0x25"
-		fingerprint mfr:"0173", prod:"0003", model:"0002", deviceJoinName: "Leak Intelligence Leak Gopher Water Shutoff Valve"
 	}
 
 	// simulator metadata
@@ -37,7 +35,7 @@ metadata {
 	// tile definitions
 	tiles(scale: 2) {
 		multiAttributeTile(name:"valve", type: "generic", width: 6, height: 4, canChangeIcon: true){
-			tileAttribute ("device.valve", key: "PRIMARY_CONTROL") {
+			tileAttribute ("device.contact", key: "PRIMARY_CONTROL") {
 				attributeState "open", label: '${name}', action: "valve.close", icon: "st.valves.water.open", backgroundColor: "#00A0DC", nextState:"closing"
 				attributeState "closed", label: '${name}', action: "valve.open", icon: "st.valves.water.closed", backgroundColor: "#ffffff", nextState:"opening"
 				attributeState "opening", label: '${name}', action: "valve.close", icon: "st.valves.water.open", backgroundColor: "#00A0DC"
@@ -45,7 +43,7 @@ metadata {
 			}
 		}
 
-		standardTile("refresh", "device.valve", width: 2, height: 2, inactiveLabel: false, decoration: "flat") {
+		standardTile("refresh", "device.contact", width: 2, height: 2, inactiveLabel: false, decoration: "flat") {
 			state "default", label:'', action:"refresh.refresh", icon:"st.secondary.refresh"
 		}
 
@@ -55,32 +53,24 @@ metadata {
 
 }
 
-def installed() {
-	// Device-Watch simply pings if no device events received for 32min(checkInterval)
-	sendEvent(name: "checkInterval", value: 2 * 15 * 60 + 2 * 60, displayed: false, data: [protocol: "zwave", hubHardwareId: device.hub.hardwareID])
-}
-
 def updated() {
-	// Device-Watch simply pings if no device events received for 32min(checkInterval)
-	sendEvent(name: "checkInterval", value: 2 * 15 * 60 + 2 * 60, displayed: false, data: [protocol: "zwave", hubHardwareId: device.hub.hardwareID])
 	response(refresh())
 }
 
 def parse(String description) {
 	log.trace "parse description : $description"
+	def result = null
 	def cmd = zwave.parse(description, [0x20: 1])
 	if (cmd) {
-		return zwaveEvent(cmd)
+		result = createEvent(zwaveEvent(cmd))
 	}
-	log.debug "Could not parse message"
-	return null
+	log.debug "Parse returned ${result?.descriptionText}"
+	return result
 }
 
 def zwaveEvent(physicalgraph.zwave.commands.basicv1.BasicReport cmd) {
-	def value = cmd.value == 0xFF ?  "open" : cmd.value == 0x00 ? "closed" : "unknown"
-
-	return [createEventWithDebug([name: "contact", value: value, descriptionText: "$device.displayName valve is $value"]),
-			createEventWithDebug([name: "valve", value: value, descriptionText: "$device.displayName valve is $value"])]
+    def value = cmd.value == 0xFF ?  "open" : cmd.value == 0x00 ? "closed" : "unknown"
+    [name: "contact", value: value, descriptionText: "$device.displayName valve is $value"]
 }
 
 def zwaveEvent(physicalgraph.zwave.commands.manufacturerspecificv2.ManufacturerSpecificReport cmd) {   //TODO should show MSR when device is discovered
@@ -90,22 +80,20 @@ def zwaveEvent(physicalgraph.zwave.commands.manufacturerspecificv2.ManufacturerS
     log.debug "productTypeId:    ${cmd.productTypeId}"
     def msr = String.format("%04X-%04X-%04X", cmd.manufacturerId, cmd.productTypeId, cmd.productId)
     updateDataValue("MSR", msr)
-    return createEventWithDebug([descriptionText: "$device.displayName MSR: $msr", isStateChange: false])
+    [descriptionText: "$device.displayName MSR: $msr", isStateChange: false]
 }
 
 def zwaveEvent(physicalgraph.zwave.commands.deviceresetlocallyv1.DeviceResetLocallyNotification cmd) {
-    return createEventWithDebug([descriptionText: cmd.toString(), isStateChange: true, displayed: true])
+    [descriptionText: cmd.toString(), isStateChange: true, displayed: true]
 }
 
 def zwaveEvent(physicalgraph.zwave.commands.switchbinaryv1.SwitchBinaryReport cmd) {
 	def value = cmd.value == 0xFF ?  "open" : cmd.value == 0x00 ? "closed" : "unknown"
-
-	return [createEventWithDebug([name: "contact", value: value, descriptionText: "$device.displayName valve is $value"]),
-			createEventWithDebug([name: "valve", value: value, descriptionText: "$device.displayName valve is $value"])]
+	[name: "contact", value: value, descriptionText: "$device.displayName valve is $value"]
 }
 
 def zwaveEvent(physicalgraph.zwave.Command cmd) {
-	return createEvent([:]) // Handles all Z-Wave commands we aren't interested in
+	[:] // Handles all Z-Wave commands we aren't interested in
 }
 
 def open() {
@@ -126,13 +114,6 @@ def poll() {
     zwave.switchBinaryV1.switchBinaryGet().format()
 }
 
-/**
- * PING is used by Device-Watch in attempt to reach the Device
- * */
-def ping() {
-	refresh()
-}
-
 def refresh() {
     log.debug "refresh() is called"
     def commands = [zwave.switchBinaryV1.switchBinaryGet().format()]
@@ -141,9 +122,3 @@ def refresh() {
     }
     delayBetween(commands,100)
 }
-
-def createEventWithDebug(eventMap) {
-	def event = createEvent(eventMap)
-	log.debug "Event created with ${event?.descriptionText}"
-	return event
-}

smartapps/df/blueiris-localconnect2.src/blueiris-localconnect2.groovy

@@ -0,0 +1,384 @@
+/**
+ *  Copyright 2015 SmartThings
+ *
+ *  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.
+ *
+ *  BlueIris (LocalConnect2)
+ *
+ *  Author: Nicolas Neverov
+ *  Date: 2017-04-30
+ */
+
+
+definition(
+    name: "BlueIris (LocalConnect2)",
+    namespace: "df",
+    author: "df",
+    description: "BlueIris local integration",
+    category: "Safety & Security",
+    singleInstance: true,
+    iconUrl: "https://graph.api.smartthings.com/api/devices/icons/st.doors.garage.garage-closed",
+    iconX2Url: "https://graph.api.smartthings.com/api/devices/icons/st.doors.garage.garage-closed?displaySize=2x"
+)
+
+preferences {
+	page(name: "setup", title: "Blue Iris Setup", content: "pageSetupCallback")
+	page(name: "mode", title: "Blue Iris Modes Setup", content: "renderModePage")
+	page(name: "validate", title: "Blue Iris Setup", content: "pageValidateCallback")
+
+}
+
+def switchHandler(evt) 
+{
+    log.debug "setupDevice: switch event: $evt.value"
+}
+
+
+private Map getValidators()
+{
+	return [
+		hostAddress: { addr ->
+        	return addr ==~ /\d+\.\d+\.\d+\.\d+(:\d+)?/
+    	},
+        mode: { Map p ->
+        	def rc = []
+
+			if (p.aProfileApply) {
+            	if (p.aProfile == null) {
+                	rc.push("Arming profile is required");
+                } else if (p.aProfile < 1 || p.aProfile > 5) {
+                	rc.push("Arming profile must be within [1-5] range")
+                }
+            }
+
+			if (p.dProfileApply) {
+            	if (p.dProfile == null) {
+                	rc.push("Disarming profile is required");
+                } else if (p.dProfile < 1 || p.dProfile > 5) {
+                	rc.push("Disarming profile must be within [1-5] range")
+                }
+            }
+
+			def armProfile = p.aProfileApply ? p.aProfile : 0;
+			def disarmProfile = p.dProfileApply ? p.dProfile : 0;
+			if (p.aSignal == p.dSignal && armProfile == disarmProfile && armProfile != null) {
+            	rc.push("Arming and disarming signal/profile combinations must differ")
+            }
+
+            return rc
+        }
+	]
+}
+
+def pageSetupCallback()
+{
+	if (canInstallLabs()) {
+		log.debug("pageSetupCallback: refreshing")
+
+		def v = getValidators()
+		return dynamicPage(name:"setup", title:"Setting up Blue Iris integration", nextPage:"", install: false, uninstall: true) {
+        
+			section("New BlueIris Server setup") {
+            		input name:"devicename", type:"text", title: "Device name", required:true, defaultValue: "Blue Iris Server"
+    	        	input name:"hub", type:"hub", title: "Hub gateway", required:true 
+   	        		input name:"ip", type:"text", title: "IP address:port", required:true, submitOnChange:true 
+	                if (!v.hostAddress(ip)) {
+                    	paragraph(required:true, "Please specify valid IP address")
+                    }
+	   	        	input name:"username", type:"text", title: "Username", required:true, autoCorrect:false
+    	        	input name:"password", type:"password", title: "Password", required:true, autoCorrect:false
+			}
+            if(v.hostAddress(ip)) {
+            	section("") {
+					href(title:"Next", description:"", page:"mode", required:true)
+              	}
+            }
+		}
+
+	} else {
+
+		return dynamicPage(name:"setup", title:"Upgrade needed", nextPage:"", install:false, uninstall: true) {
+			section("Upgrade needed") {
+				paragraph "Hub firmware needs to be upgraded"
+			}
+		}
+	}
+
+}
+
+private	makeProfileInput(inputName)
+{
+	input(name:inputName.toString(), type:"number", title:"Select profile [1-5]:", range:"1..5", submitOnChange:true, required:true)
+}
+
+def renderModePage() {
+	def v = getValidators()
+
+	return dynamicPage(name:"mode", title:"Setting up Blue Iris modes", nextPage:"", install: false, uninstall: true) {
+		section(hideable:true, "Arming modes") {
+            input(name:"armSignal", type:"enum", title:"When Armed, set signal to", options:["Green","N/A"], defaultValue:"Green", submitOnChange:true, required:false)
+			input(name:"armProfileApply", type:"bool", title:"Also, change profile?", defaultValue:false, submitOnChange:true) 
+            if (armProfileApply) {
+                makeProfileInput("armProfile")
+           	}
+            
+			input(name:"disarmSignal", type:"enum", title:"When Disarmed, set signal to", options: ["Red", "N/A"], defaultValue:"Red", submitOnChange:true, required:false)
+			input(name:"disarmProfileApply", type:"bool", title:"Also, change profile?", defaultValue:false, submitOnChange:true) 
+            if (disarmProfileApply) {
+                makeProfileInput("disarmProfile")
+           	}
+		}
+        
+        section(hideable:true, "Location modes") {
+        	location.modes.each {mode->
+        		input(name:"locationSignal${mode.id}".toString(), type:"enum", title:"When in \"$mode.name\" mode, set signal to", options: ["Green", "Red", "N/A"], defaultValue:"N/A", required:false, submitOnChange:true)
+				input(name:"locationProfileApply${mode.id}".toString(), type:"bool", title:"Also, change profile?", defaultValue:false, required:false, submitOnChange:true) 
+            	if (settings["locationProfileApply${mode.id}".toString()] == true) {
+                    makeProfileInput("locationProfile${mode.id}")
+	           	}
+        	}
+     	}
+
+		def p = [
+        	aSignal: armSignal,
+        	aProfileApply: armProfileApply,
+            aProfile: armProfile,
+            dSignal: disarmSignal,
+            dProfileApply: disarmProfileApply,
+            dProfile: disarmProfile
+        ]
+       
+		def valRc = v.mode(p)
+        if (valRc) {
+        	section("Please correct errors:") {
+            	valRc.each {err ->
+                	paragraph(required:true, "*** $err")
+                }
+            }
+        } else {
+			section("") {
+				href(title:"Next", description:"", page:"validate", required:true)
+			}
+      	}
+        
+  	}
+}
+
+def pageValidateCallback()
+{
+	if(ip ==~ /\d+\.\d+\.\d+\.\d+(:\d+)?/) {
+    	return dynamicPage(name:"validate", title:"Setting up Blue Iris integration", install:true, uninstall:false) {
+        	section() {
+            	paragraph( 
+                	image: "https://s3.amazonaws.com/smartapp-icons/Convenience/Cat-Convenience.png",
+                	title:"Ready to install", 
+                    "Press 'Done' to confirm installation"
+             	)
+          	}
+        }
+	} else {
+    	return dynamicPage(name:"validate", title:"Setting up Blue Iris", nextPage:"", install: false, uninstall:false) {
+        	section("Error validating setup preferences") {
+            	paragraph( 
+                	image: "https://s3.amazonaws.com/smartapp-icons/Convenience/Cat-Convenience.png",
+                	title:"IP Address", 
+                    required:true, 
+                    "Should look similar to 111.222.333.555:8001 (port is optional)"
+             	)
+            }
+        }
+    }
+}
+
+
+def installed()
+{
+	log.debug("installed: started") //with $settings
+	init()
+}
+
+def updated()
+{
+	log.debug("updated: started"); //with $settings
+	uninit();
+	init()
+}
+
+def uninstalled()
+{
+
+	uninit(false);
+}
+
+def init()
+{
+	if(!state.subscribed) {
+    	subscribe(location, "mode", modeChangeHandler)
+		state.subscribed = true
+	}
+
+	state.config = assembleConfig()
+
+    final dni = ipEpToHex(ip)
+    def d = getChildDevice(dni)
+    
+    if(d) {
+    	log.debug("init: deleting existing BlueIris Server device, dni:$dni")
+    	deleteChildDevice(dni)
+    }
+    
+    if(true) {
+		log.debug "init: adding new BlueIris Server device, dni:$dni, username:$username, password:*****, gateway hub id:$hub.id"
+		d = addChildDevice("df", "blueiris2", dni, hub.id, 
+        	[name:"blueiris", label: devicename, completedSetup:true,
+             "preferences":["username":username, "password":password]
+            ])
+		d.configure()
+	    subscribe(d, "switch", switchHandler)
+    } else {
+
+		log.debug "init: skipping adding BlueIris Server device, dni:$dni - already exists"
+    }
+    
+}
+
+def uninit(boolean f_unsubscribe = true)
+{
+	if(state.subscribed) {
+
+		if(f_unsubscribe) {
+			unsubscribe()
+        }
+        
+        getAllChildDevices().each {
+        }
+        
+		state.subscribed = false
+    }
+}
+
+
+def modeChangeHandler(evt)
+{
+    def f_arm = (evt.value == 'Away')
+	log.debug("modeChangeHandler: detected mode change: $evt.name:$evt.value: ${f_arm ? 'arming' : 'disarming'}")
+
+	def mode = null
+	location.modes.each {m->
+    	if (m.name == evt.value) {
+        	mode = m
+      	}
+    }
+
+	getAllChildDevices().each {
+    	it.location(mode.id)
+    }
+}
+
+def asyncOpCallback()
+{
+	log.debug("asyncOpCallback: timeout:$atomicState.asyncOpTimeout, ${now() - atomicState.asyncOpTs}(msec) elapsed")
+    if(atomicState.asyncOpTimeout) {
+    	getAllChildDevices().each {
+        	it.timeout()
+        }
+    }
+}
+
+def onBeginAsyncOp(int timeout_ms)
+{
+	log.debug("onBeginAsyncOp: ${now()}")
+    atomicState.asyncOpTimeout = true
+    atomicState.asyncOpTs = now()
+	runOnce(new Date(now() + timeout_ms), asyncOpCallback, [overwrite: true])
+}
+
+def onEndAsyncOp()
+{
+	log.debug("onEndAsyncOp: ${now()}")
+    atomicState.asyncOpTimeout = false
+	runOnce(new Date(now() + 1), asyncOpCallback, [overwrite: true])
+}
+
+def onNotification(msg)
+{
+	log.debug("sendNotification: sending $msg")
+	sendNotificationEvent(msg)
+}
+
+def onGetConfig()
+{
+	return state.config
+}
+
+private assembleConfig()
+{
+	def getElementCfg = {prefix, id, name ->
+    	def signal = settings["${prefix}Signal${id}".toString()]
+        def profileApply = settings["${prefix}ProfileApply${id}".toString()]
+        def profile = settings["${prefix}Profile${id}".toString()]
+        
+    	return signal != 'N/A' || profileApply ? [
+        	name: name,
+        	signal: signal == 'N/A' ? null : (signal == "Green"),
+            profile: profileApply ? profile : null
+        ] : null
+    }
+
+    def rc = [
+    	arming: [
+        	arm: getElementCfg('arm', '', 'Arm'),
+            disarm: getElementCfg('disarm', '', 'Disarm')
+        ],
+        location: [:]
+    ]
+
+	location.modes.each {mode->
+    	rc.location["$mode.id".toString()] = getElementCfg('location', mode.id, mode.name)
+    }
+
+	log.info("onGetConfig: assembled config: [$rc]")
+	rc
+}
+
+private Boolean canInstallLabs()
+{
+	return hasAllHubsOver("000.011.00603")
+}
+
+private Boolean hasAllHubsOver(String desiredFirmware)
+{
+	return realHubFirmwareVersions.every { fw -> fw >= desiredFirmware }
+}
+
+private List getRealHubFirmwareVersions()
+{
+	return location.hubs*.firmwareVersionString.findAll { it }
+}
+
+private String ipEpToHex(ep) {
+	final parts = ep.split(':');
+    final ipHex = parts[0].tokenize('.').collect{ String.format('%02X', it.toInteger() ) }.join()
+    final portHex = String.format('%04X', (parts[1]?:80).toInteger())
+   
+    return "$ipHex:$portHex"
+}
+
+
+private String hexToString(String txtInHex)
+{
+	byte [] txtInByte = new byte [txtInHex.length() / 2];
+	int j = 0;
+	for (int i = 0; i < txtInHex.length(); i += 2)
+	{
+			txtInByte[j++] = Byte.parseByte(txtInHex.substring(i, i + 2), 16);
+	}
+	return new String(txtInByte);
+}

smartapps/gideon-api/gideon-smart-home.src/gideon-smart-home.groovy

@@ -765,6 +765,7 @@ def turnOffSwitch() {
         } else {
             
             device.off();
+                  
             return [Device_id: params.id, result_action: "200"]
         }
 }
@@ -788,7 +789,6 @@ def getTempSensorsStatus(id) {
             return []
         } else {
         	def bat = getBatteryStatus(device.id)
-            def scale = [Scale: location.temperatureScale]
-        	return [temperature: device.currentValue('temperature')] + bat + scale
+        	return [temperature: device.currentValue('temperature')] + bat
    		}
-   }
+   }

smartapps/naissan/lights-off-with-no-motion-and-presence.src/lights-off-with-no-motion-and-presence.groovy

@@ -15,66 +15,66 @@ definition(
 )
 
 preferences {
-  section("Light switches to turn off") {
-    input "switches", "capability.switch", title: "Choose light switches", multiple: true
-  }
-  section("Turn off when there is no motion and presence") {
-    input "motionSensor", "capability.motionSensor", title: "Choose motion sensor"
-    input "presenceSensors", "capability.presenceSensor", title: "Choose presence sensors", multiple: true
-  }
-  section("Delay before turning off") {
-    input "delayMins", "number", title: "Minutes of inactivity?"
-  }
+	section("Light switches to turn off") {
+		input "switches", "capability.switch", title: "Choose light switches", multiple: true
+	}
+	section("Turn off when there is no motion and presence") {
+		input "motionSensor", "capability.motionSensor", title: "Choose motion sensor"
+   		input "presenceSensors", "capability.presenceSensor", title: "Choose presence sensors", multiple: true
+	}
+	section("Delay before turning off") {                    
+		input "delayMins", "number", title: "Minutes of inactivity?"
+	}
 }
 
 def installed() {
-  subscribe(motionSensor, "motion", motionHandler)
-  subscribe(presenceSensors, "presence", presenceHandler)
+	subscribe(motionSensor, "motion", motionHandler)
+    subscribe(presenceSensors, "presence", presenceHandler)
 }
 
 def updated() {
-  unsubscribe()
-  subscribe(motionSensor, "motion", motionHandler)
-  subscribe(presenceSensors, "presence", presenceHandler)
+	unsubscribe()
+	subscribe(motionSensor, "motion", motionHandler)
+    subscribe(presenceSensors, "presence", presenceHandler)
 }
 
 def motionHandler(evt) {
-  log.debug "handler $evt.name: $evt.value"
-  if (evt.value == "inactive") {
-    runIn(delayMins * 60, scheduleCheck, [overwrite: true])
-  }
+	log.debug "handler $evt.name: $evt.value"
+	if (evt.value == "inactive") {
+		runIn(delayMins * 60, scheduleCheck, [overwrite: false])
+	}
 }
 
 def presenceHandler(evt) {
-  log.debug "handler $evt.name: $evt.value"
-  if (evt.value == "not present") {
-    runIn(delayMins * 60, scheduleCheck, [overwrite: true])
-  }
+	log.debug "handler $evt.name: $evt.value"
+	if (evt.value == "not present") {
+		runIn(delayMins * 60, scheduleCheck, [overwrite: false])
+	}
 }
 
 def isActivePresence() {
-  // check all the presence sensors, make sure none are present
-  def noPresence = presenceSensors.find{it.currentPresence == "present"} == null
-  !noPresence
+	// check all the presence sensors, make sure none are present
+	def noPresence = presenceSensors.find{it.currentPresence == "present"} == null
+	!noPresence		
 }
 
 def scheduleCheck() {
-  log.debug "scheduled check"
-  def motionState = motionSensor.currentState("motion")
+	log.debug "scheduled check"
+	def motionState = motionSensor.currentState("motion")
     if (motionState.value == "inactive") {
-      def elapsed = now() - motionState.rawDateCreated.time
-      def threshold = 1000 * 60 * delayMins - 1000
-      if (elapsed >= threshold) {
-        if (!isActivePresence()) {
-          log.debug "Motion has stayed inactive since last check ($elapsed ms) and no presence:  turning lights off"
-          switches.off()
-        } else {
-          log.debug "Presence is active: do nothing"
+        def elapsed = now() - motionState.rawDateCreated.time
+    	def threshold = 1000 * 60 * delayMins - 1000
+    	if (elapsed >= threshold) {
+        	if (!isActivePresence()) {
+            	log.debug "Motion has stayed inactive since last check ($elapsed ms) and no presence:  turning lights off"
+            	switches.off()
+            } else {
+            	log.debug "Presence is active: do nothing"
+            }
+    	} else {
+        	log.debug "Motion has not stayed inactive long enough since last check ($elapsed ms): do nothing"
         }
-      } else {
-        log.debug "Motion has not stayed inactive long enough since last check ($elapsed ms): do nothing"
-      }
     } else {
-      log.debug "Motion is active: do nothing"
+    	log.debug "Motion is active: do nothing"
     }
-}
+}

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

@@ -1,7 +1,3 @@
-import javax.crypto.Mac;
-import javax.crypto.spec.SecretKeySpec;
-import java.security.InvalidKeyException;
-
 /**
  *  OpenT2T SmartApp Test
  *
@@ -43,7 +39,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,    |
@@ -59,7 +55,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
@@ -70,49 +66,44 @@ preferences {
 
 def getInputs() {
 	def inputList = []
-	inputList += contactSensors ?: []
-	inputList += garageDoors ?: []
-	inputList += locks ?: []
-	inputList += cameras ?: []
-	inputList += motionSensors ?: []
-	inputList += presenceSensors ?: []
-	inputList += switches ?: []
-	inputList += thermostats ?: []
-	inputList += waterSensors ?: []
+	inputList += contactSensors?: []
+	inputList += garageDoors?: []
+	inputList += locks?: []
+	inputList += cameras?: []
+	inputList += motionSensors?: []
+	inputList += presenceSensors?: []
+	inputList += switches?: []
+	inputList += thermostats?: []
+	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:
-		[
-				POST  : "registerDeviceChange",
+		action: [
+				POST: "registerDeviceChange",
 				DELETE: "unregisterDeviceChange"
 		]
 	}
 	path("/locationSubscription") {
-		action:
-		[
-				POST  : "registerDeviceGraph",
+		action: [
+				POST: "registerDeviceGraph",
 				DELETE: "unregisterDeviceGraph"
 		]
 	}
@@ -125,21 +116,14 @@ def installed() {
 
 def updated() {
 	log.debug "Updating with settings: ${settings}"
-
-	//Initialize state variables if didn't exist.
-	if (state.deviceSubscriptionMap == null) {
+	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()
 }
@@ -148,11 +132,9 @@ 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  ***/
@@ -166,7 +148,7 @@ def registerAllDeviceSubscriptions() {
 def registerChangeHandler(myList) {
 	myList.each { myDevice ->
 		def theAtts = myDevice.supportedAttributes
-		theAtts.each { att ->
+		theAtts.each {att ->
 			subscribe(myDevice, att.name, deviceEventHandler)
 			log.info "Registering for ${myDevice.displayName}.${att.name}"
 		}
@@ -178,38 +160,31 @@ 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 (state.deviceSubscriptionMap[deviceId] == null) {
+		if(subscriptionEndpt != 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"]
 }
 
@@ -219,19 +194,18 @@ 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 (state.deviceSubscriptionMap[deviceId]?.contains(subscriptionEndpt)) {
-				if (state.deviceSubscriptionMap[deviceId].size() == 1) {
+		if(subscriptionEndpt != null && subscriptionEndpt != "undefined"){
+			if (state.deviceSubscriptionMap[deviceId]?.contains(subscriptionEndpt)){
+				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 {
@@ -243,33 +217,25 @@ 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")
@@ -281,17 +247,16 @@ def unregisterDeviceGraph() {
 	def subscriptionEndpt = params.subscriptionURL
 
 	try {
-		if (subscriptionEndpt != null && subscriptionEndpt != "undefined") {
-			if (state.locationSubscriptionMap[location.id]?.contains(subscriptionEndpt)) {
-				if (state.locationSubscriptionMap[location.id].size() == 1) {
+		if(subscriptionEndpt != null && subscriptionEndpt != "undefined"){
+			if (state.locationSubscriptionMap[location.id]?.contains(subscriptionEndpt)){
+				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) {
@@ -299,40 +264,28 @@ 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 evtDevice = evt.device
-	def evtDeviceType = getDeviceType(evtDevice)
-	def deviceData = [];
+	def evt_device = evt.device
+	def evt_deviceType = getDeviceType(evt_device)
+	def deviceInfo
 
-	if (evt.data != null) {
+	def params = [ body: [deviceName: evt_device.displayName, deviceId: evt_device.id,  locationId: location.id] ]
+
+	if(evt.data != null){
 		def evtData = parseJson(evt.data)
-		log.info "Received event for ${evtDevice.displayName}, data: ${evtData},  description: ${evt.descriptionText}"
+		log.info "Received event for ${evt_device.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 ${evtDevice.displayName} is ${state.deviceSubscriptionMap[evtDevice.id]}"
-	state.deviceSubscriptionMap[evtDevice.id].each {
+	log.debug "Current subscription urls for ${evt_device.displayName} is ${state.deviceSubscriptionMap[evt_device.id]}"
+	state.deviceSubscriptionMap[evt_device.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}"
@@ -345,27 +298,20 @@ 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 evtDevice = evt.device
-			def evtDeviceType = getDeviceType(evtDevice)
-			def params = [body: [eventType: evt.name, deviceId: evtDevice.id, locationId: location.id]]
+			def evt_device = evt.device
+			def evt_deviceType = getDeviceType(evt_device)
+			log.info "DeviceName: ${evt_device.displayName}, DeviceID: ${evt_device.id}, deviceType: ${evt_deviceType}"
 
-			if (evt.name == "DeviceDeleted" && state.deviceSubscriptionMap[deviceId] != null) {
-				state.deviceSubscriptionMap.remove(evtDevice.id)
-			}
+			def params = [ body: [ eventType:evt.name, deviceId: evt_device.id, locationId: location.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}"
@@ -380,23 +326,6 @@ 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  ***/
 
@@ -405,10 +334,10 @@ def getDevices() {
 	def deviceData = []
 	inputs?.each {
 		def deviceType = getDeviceType(it)
-		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()]
+		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()]
 		} 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)]
 		}
 	}
 
@@ -421,10 +350,10 @@ def getDevice() {
 	def it = findDevice(params.id)
 	def deviceType = getDeviceType(it)
 	def device
-	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()]
+	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()]
 	} 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}"
@@ -437,18 +366,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") {
-				switch (device.currentThermostatMode) {
+			}else if (command == "thermostatSetpoint"){
+				switch(device.currentThermostatMode){
 					case "cool":
 						log.info "Update: ${device.displayName}, [${command}, ${value}]"
 						device.setCoolingSetpoint(value)
@@ -462,7 +391,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)) {
@@ -472,11 +401,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 {
@@ -503,16 +432,17 @@ private getDeviceType(device) {
 	log.debug "supported commands: [${device}, ${device.supportedCommands}]"
 
 	//Loop through the device capability list to determine the device type.
-	capabilities.each { capability ->
-		switch (capability.name.toLowerCase()) {
+	capabilities.each {capability ->
+		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 {
@@ -559,24 +489,24 @@ private deviceAttributeList(device, deviceType) {
 	allAttributes.each { attribute ->
 		try {
 			def currentState = device.currentState(attribute.name)
-			if (currentState != null) {
-				switch (attribute.name) {
+			if(currentState != null ){
+				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) {
-			attributeList.putAll([(attribute.name): null]);
+		} catch(e) {
+			attributeList.putAll([ (attribute.name): null ]);
 		}
 	}
 	return attributeList
@@ -649,7 +579,8 @@ 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 = ""
 			}
@@ -658,5 +589,5 @@ private mapDeviceCommands(command, value) {
 			break
 	}
 
-	return [resultCommand, resultValue]
+	return [resultCommand,resultValue]
 }

smartapps/smartthings/left-it-open.src/left-it-open.groovy

@@ -27,82 +27,84 @@ definition(
 
 preferences {
 
-  section("Monitor this door or window") {
-    input "contact", "capability.contactSensor"
-  }
-
-  section("And notify me if it's open for more than this many minutes (default 10)") {
-    input "openThreshold", "number", description: "Number of minutes", required: false
-  }
-
-  section("Delay between notifications (default 10 minutes") {
-    input "frequency", "number", title: "Number of minutes", description: "", required: false
-  }
-
-  section("Via text message at this number (or via push notification if not specified") {
-    input("recipients", "contact", title: "Send notifications to") {
-      input "phone", "phone", title: "Phone number (optional)", required: false
+	section("Monitor this door or window") {
+		input "contact", "capability.contactSensor"
+	}
+	section("And notify me if it's open for more than this many minutes (default 10)") {
+		input "openThreshold", "number", description: "Number of minutes", required: false
+	}
+    section("Delay between notifications (default 10 minutes") {
+        input "frequency", "number", title: "Number of minutes", description: "", required: false
     }
-  }
+	section("Via text message at this number (or via push notification if not specified") {
+        input("recipients", "contact", title: "Send notifications to") {
+            input "phone", "phone", title: "Phone number (optional)", required: false
+        }
+	}
 }
 
 def installed() {
-  log.trace "installed()"
-  subscribe()
+	log.trace "installed()"
+	subscribe()
 }
 
 def updated() {
-  log.trace "updated()"
-  unsubscribe()
-  subscribe()
+	log.trace "updated()"
+	unsubscribe()
+	subscribe()
 }
 
 def subscribe() {
-  subscribe(contact, "contact.open", doorOpen)
-  subscribe(contact, "contact.closed", doorClosed)
+	subscribe(contact, "contact.open", doorOpen)
+	subscribe(contact, "contact.closed", doorClosed)
 }
 
-def doorOpen(evt) {
-  log.trace "doorOpen($evt.name: $evt.value)"
-  def delay = (openThreshold != null && openThreshold != "") ? openThreshold * 60 : 600
-  runIn(delay, doorOpenTooLong, [overwrite: true])
+def doorOpen(evt)
+{
+	log.trace "doorOpen($evt.name: $evt.value)"
+	def t0 = now()
+	def delay = (openThreshold != null && openThreshold != "") ? openThreshold * 60 : 600
+	runIn(delay, doorOpenTooLong, [overwrite: false])
+	log.debug "scheduled doorOpenTooLong in ${now() - t0} msec"
 }
 
-def doorClosed(evt) {
-  log.trace "doorClosed($evt.name: $evt.value)"
-  unschedule(doorOpenTooLong)
+def doorClosed(evt)
+{
+	log.trace "doorClosed($evt.name: $evt.value)"
 }
 
 def doorOpenTooLong() {
-  def contactState = contact.currentState("contact")
-  def freq = (frequency != null && frequency != "") ? frequency * 60 : 600
+	def contactState = contact.currentState("contact")
+    def freq = (frequency != null && frequency != "") ? frequency * 60 : 600
 
-  if (contactState.value == "open") {
-    def elapsed = now() - contactState.rawDateCreated.time
-    def threshold = ((openThreshold != null && openThreshold != "") ? openThreshold * 60000 : 60000) - 1000
-    if (elapsed >= threshold) {
-      log.debug "Contact has stayed open long enough since last check ($elapsed ms):  calling sendMessage()"
-      sendMessage()
-      runIn(freq, doorOpenTooLong, [overwrite: false])
-    } else {
-      log.debug "Contact has not stayed open long enough since last check ($elapsed ms):  doing nothing"
-    }
-  } else {
-    log.warn "doorOpenTooLong() called but contact is closed:  doing nothing"
-  }
+	if (contactState.value == "open") {
+		def elapsed = now() - contactState.rawDateCreated.time
+		def threshold = ((openThreshold != null && openThreshold != "") ? openThreshold * 60000 : 60000) - 1000
+		if (elapsed >= threshold) {
+			log.debug "Contact has stayed open long enough since last check ($elapsed ms):  calling sendMessage()"
+			sendMessage()
+            runIn(freq, doorOpenTooLong, [overwrite: false])
+		} else {
+			log.debug "Contact has not stayed open long enough since last check ($elapsed ms):  doing nothing"
+		}
+	} else {
+		log.warn "doorOpenTooLong() called but contact is closed:  doing nothing"
+	}
 }
 
-void sendMessage() {
-  def minutes = (openThreshold != null && openThreshold != "") ? openThreshold : 10
-  def msg = "${contact.displayName} has been left open for ${minutes} minutes."
-  log.info msg
-  if (location.contactBookEnabled) {
-    sendNotificationToContacts(msg, recipients)
-  } else {
-    if (phone) {
-      sendSms phone, msg
-    } else {
-      sendPush msg
+void sendMessage()
+{
+	def minutes = (openThreshold != null && openThreshold != "") ? openThreshold : 10
+	def msg = "${contact.displayName} has been left open for ${minutes} minutes."
+	log.info msg
+    if (location.contactBookEnabled) {
+        sendNotificationToContacts(msg, recipients)
+    }
+    else {
+        if (phone) {
+            sendSms phone, msg
+        } else {
+            sendPush msg
+        }
     }
-  }
 }

smartapps/smartthings/smart-nightlight.src/smart-nightlight.groovy

@@ -98,7 +98,7 @@ def motionHandler(evt) {
 	else {
 		state.motionStopTime = now()
 		if(delayMinutes) {
-			runIn(delayMinutes*60, turnOffMotionAfterDelay, [overwrite: true])
+			runIn(delayMinutes*60, turnOffMotionAfterDelay, [overwrite: false])
 		} else {
 			turnOffMotionAfterDelay()
 		}

smartapps/tslagle13/hello-home-phrase-director.src/hello-home-phrase-director.groovy

@@ -125,19 +125,19 @@
       if(allOk) {
     
       if(everyoneIsAway() && (state.sunMode == "sunrise")) {
-        log.debug("Home is Empty  Setting New Away Mode")
+        log.info("Home is Empty  Setting New Away Mode")
         def delay = (falseAlarmThreshold != null && falseAlarmThreshold != "") ? falseAlarmThreshold * 60 : 10 * 60 
         runIn(delay, "setAway")
       }
     
       if(everyoneIsAway() && (state.sunMode == "sunset")) {
-        log.debug("Home is Empty  Setting New Away Mode")
+        log.info("Home is Empty  Setting New Away Mode")
         def delay = (falseAlarmThreshold != null && falseAlarmThreshold != "") ? falseAlarmThreshold * 60 : 10 * 60 
         runIn(delay, "setAway")
       }
       
       else {
-      log.debug("Home is Occupied Setting New Home Mode")
+      log.info("Home is Occupied Setting New Home Mode")
       setHome()
     
     
@@ -152,7 +152,7 @@
         log.debug("Checking if everyone is away")
     
         if(everyoneIsAway()) {
-          log.debug("Nobody is home, running away sequence")
+          log.info("Nobody is home, running away sequence")
           def delay = (falseAlarmThreshold != null && falseAlarmThreshold != "") ? falseAlarmThreshold * 60 : 10 * 60 
           runIn(delay, "setAway")
         }
@@ -161,7 +161,7 @@
     else {
     	def lastTime = state[evt.deviceId]
         if (lastTime == null || now() - lastTime >= 1 * 60000) {
-      		log.debug("Someone is home, running home sequence")
+      		log.info("Someone is home, running home sequence")
       		setHome()
         }    
     	state[evt.deviceId] = now()
@@ -175,14 +175,14 @@
       if(everyoneIsAway()) {
         if(state.sunMode == "sunset") {
           def message = "Performing \"${awayNight}\" for you as requested."
-          log.debug(message)
+          log.info(message)
           sendAway(message)
           location.helloHome.execute(settings.awayNight)
         }
         
         else if(state.sunMode == "sunrise") {
           def message = "Performing \"${awayDay}\" for you as requested."
-          log.debug(message)
+          log.info(message)
           sendAway(message)
           location.helloHome.execute(settings.awayDay)
           }
@@ -192,19 +192,19 @@
       }
     
       else {
-        log.debug("Somebody returned home before we set to '${newAwayMode}'")
+        log.info("Somebody returned home before we set to '${newAwayMode}'")
       }
     }
     
     //set home mode when house is occupied
     def setHome() {
     sendOutOfDateNotification()
-    log.debug("Setting Home Mode!!")
+    log.info("Setting Home Mode!!")
     if(anyoneIsHome()) {
           if(state.sunMode == "sunset"){
           if (location.mode != "${homeModeNight}"){
           def message = "Performing \"${homeNight}\" for you as requested."
-            log.debug(message)
+            log.info(message)
             sendHome(message)
             location.helloHome.execute(settings.homeNight)
             }
@@ -213,7 +213,7 @@
           if(state.sunMode == "sunrise"){
           if (location.mode != "${homeModeDay}"){
           def message = "Performing \"${homeDay}\" for you as requested."
-            log.debug(message)
+            log.info(message)
             sendHome(message)
             location.helloHome.execute(settings.homeDay)
                 }
@@ -329,4 +329,4 @@
         	sendNotification("Your version of Hello, Home Phrase Director is currently out of date. Please look for the new version of Hello, Home Phrase Director now called 'Routine Director' in the marketplace.")
         	state.lastTime = (new Date() + 31).getTime()
         }
-    }
+    }