Modifying 'staring my 1st app'

devicetypes/smartthings/life360-user.src/life360-user.groovy

@@ -39,7 +39,7 @@ metadata {
 }
 
 def generatePresenceEvent(boolean present) {
-	log.info "Life360 generatePresenceEvent($present)"
+	log.debug "Here in generatePresenceEvent!"
 	def value = formatValue(present)
 	def linkText = getLinkText(device)
 	def descriptionText = formatDescriptionText(linkText, present)

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

@@ -128,7 +128,7 @@ private Map parseCatchAllMessage(String description) {
 				if (cluster.command == 0x07) {
 					if (cluster.data[0] == 0x00){
 						log.debug "TEMP REPORTING CONFIG RESPONSE" + cluster
-						resultMap = [name: "checkInterval", value: 60 * 12, displayed: false, data: [protocol: "zigbee", hubHardwareId: device.hub.hardwareID]]
+						sendEvent(name: "checkInterval", value: 60 * 12, displayed: false, data: [protocol: "zigbee", hubHardwareId: device.hub.hardwareID])
 					}
 					else {
 						log.warn "TEMP REPORTING CONFIG FAILED- error code:${cluster.data[0]}"

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

@@ -132,7 +132,7 @@ private Map parseCatchAllMessage(String description) {
 				if (cluster.command == 0x07) {
 					if (cluster.data[0] == 0x00) {
 						log.debug "TEMP REPORTING CONFIG RESPONSE" + cluster
-						resultMap = [name: "checkInterval", value: 60 * 12, displayed: false, data: [protocol: "zigbee", hubHardwareId: device.hub.hardwareID]]
+						sendEvent(name: "checkInterval", value: 60 * 12, displayed: false, data: [protocol: "zigbee", hubHardwareId: device.hub.hardwareID])
 					}
 					else {
 						log.warn "TEMP REPORTING CONFIG FAILED- error code:${cluster.data[0]}"

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

@@ -161,7 +161,7 @@ private Map parseCatchAllMessage(String description) {
 				if (cluster.command == 0x07) {
 					if(cluster.data[0] == 0x00) {
 						log.debug "TEMP REPORTING CONFIG RESPONSE" + cluster
-						resultMap = [name: "checkInterval", value: 60 * 12, displayed: false, data: [protocol: "zigbee", hubHardwareId: device.hub.hardwareID]]
+						sendEvent(name: "checkInterval", value: 60 * 12, displayed: false, data: [protocol: "zigbee", hubHardwareId: device.hub.hardwareID])
 					}
 					else {
 						log.warn "TEMP REPORTING CONFIG FAILED- error code:${cluster.data[0]}"
@@ -339,7 +339,7 @@ private Map getContactResult(value) {
 	log.debug "Contact: ${device.displayName} value = ${value}"
 	def descriptionText = value == 'open' ? '{{ device.displayName }} was opened' : '{{ device.displayName }} was closed'
 	sendEvent(name: 'contact', value: value, descriptionText: descriptionText, displayed: false, translatable: true)
-	return [name: 'status', value: value, descriptionText: descriptionText, translatable: true]
+	sendEvent(name: 'status', value: value, descriptionText: descriptionText, translatable: true)
 }
 
 private getAccelerationResult(numValue) {

devicetypes/smartthings/smartsense-open-closed-sensor.src/smartsense-open-closed-sensor.groovy

@@ -119,7 +119,7 @@ private Map parseCatchAllMessage(String description) {
 				if (cluster.command == 0x07){
 					if (cluster.data[0] == 0x00) {
 						log.debug "TEMP REPORTING CONFIG RESPONSE" + cluster
-						resultMap = [name: "checkInterval", value: 60 * 12, displayed: false, data: [protocol: "zigbee", hubHardwareId: device.hub.hardwareID]]
+						sendEvent(name: "checkInterval", value: 60 * 12, displayed: false, data: [protocol: "zigbee", hubHardwareId: device.hub.hardwareID])
 					}
 					else {
 						log.warn "TEMP REPORTING CONFIG FAILED- error code:${cluster.data[0]}"

devicetypes/smartthings/smartsense-temp-humidity-sensor.src/smartsense-temp-humidity-sensor.groovy

@@ -103,7 +103,7 @@ private Map parseCatchAllMessage(String description) {
 				if (cluster.command == 0x07) {
 					if (cluster.data[0] == 0x00){
 						log.debug "TEMP REPORTING CONFIG RESPONSE" + cluster
-						resultMap = [name: "checkInterval", value: 60 * 12, displayed: false, data: [protocol: "zigbee", hubHardwareId: device.hub.hardwareID]]
+						sendEvent(name: "checkInterval", value: 60 * 12, displayed: false, data: [protocol: "zigbee", hubHardwareId: device.hub.hardwareID])
 					}
 					else {
 						log.warn "TEMP REPORTING CONFIG FAILED- error code:${cluster.data[0]}"

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

@@ -127,8 +127,8 @@ def configureHealthCheck() {
 
 def configure() {
     log.debug "configure()"
-    configureHealthCheck()
     zigbee.onOffConfig() + zigbee.levelConfig() + zigbee.onOffRefresh() + zigbee.levelRefresh()
+    configureHealthCheck()
 }
 
 def updated() {

devicetypes/smartthings/zwave-dimmer-switch-generic.src/zwave-dimmer-switch-generic.groovy

@@ -24,10 +24,6 @@ metadata {
 		fingerprint inClusters: "0x26", deviceJoinName: "Z-Wave Dimmer"
 		fingerprint mfr:"001D", prod:"1902", deviceJoinName: "Z-Wave Dimmer"
 		fingerprint mfr:"001D", prod:"1B03", model:"0334", deviceJoinName: "Leviton Universal Dimmer"
-		fingerprint mfr:"011A", prod:"0102", model:"0201", deviceJoinName: "Enerwave In-Wall Dimmer"
-		fingerprint mfr:"001D", prod:"1001", model:"0334", deviceJoinName: "Leviton 3-Speed Fan Controller"
-		fingerprint mfr:"001D", prod:"0602", model:"0334", deviceJoinName: "Leviton Magnetic Low Voltage Dimmer"
-		fingerprint mfr:"001D", prod:"0401", model:"0334", deviceJoinName: "Leviton 600W Incandescent Dimmer"
 	}
 
 	simulator {

smartapps/bravenel/rule-machine.src/rule-machine.groovy

@@ -1,623 +0,0 @@
-/**
- *  Rule Machine
- *
- *  Copyright 2015 Bruce Ravenel and Mike Maxwell
- *
- *  Version 1.6.5   1 Jan 2016
- *
- *	Version History
- *
- *	1.6.5	1 Jan 2016		Added version numbers to main page
- *	1.6.4	30 Dec 2015		Multi-commands
- *	1.6.3	26 Dec 2015		UI improvements and icon per Michael Struck
- *	1.6.2	25 Dec 2015		null parameter value patch in expert, maxwell
- *	1.6.1	24 Dec 2015		UI improvement
- *	1.6	23 Dec 2015		Added expert commands per Mike Maxwell
- *
- *  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.
- *
- */
-
-definition(
-	name: "Rule Machine",
-	singleInstance: true,
-	namespace: "bravenel",
-	author: "Bruce Ravenel and Mike Maxwell",
-	description: "Rule Machine",
-	category: "My Apps",
-	iconUrl: "https://raw.githubusercontent.com/bravenel/Rule-Trigger/master/smartapps/bravenel/RuleMachine.png",
-	iconX2Url: "https://raw.githubusercontent.com/bravenel/Rule-Trigger/master/smartapps/bravenel/RuleMachine%402x.png",
-	iconX3Url: "https://raw.githubusercontent.com/bravenel/Rule-Trigger/master/smartapps/bravenel/RuleMachine%402x.png"
-)
-
-preferences {
-	page(name: "mainPage")
-	page(name: "removePage")
-	//expert pages
-	page(name: "expert")
-	page(name: "generalApprovalPAGE")
-	page(name: "customCommandsPAGE")
-	page(name: "addCustomCommandPAGE")
-	page(name: "customParamsPAGE")
-}
-
-def mainPage() {
-    dynamicPage(name: "mainPage", title: "Installed Rules", install: true, uninstall: false, submitOnChange: true) {
-    	if(!state.setup) initialize(true)
-        section {
-            app(name: "childRules", appName: "Rule", namespace: "bravenel", title: "Create New Rule...", multiple: true)
-        }
-	section ("Expert Features") {
-		href( "expert", title: "", description: "Tap to create custom commands", state: "")
-        }
-        section ("Remove Rule Machine"){
-        	href "removePage", description: "Tap to remove Rule Machine ", title: ""
-        }
-        if(state.ver) section ("Version 1.6.5/" + state.ver) { }
-    }
-}
-
-def removePage() {
-	dynamicPage(name: "removePage", title: "Remove Rule Machine And All Rules", install: false, uninstall: true) {
-    	section ("WARNING!\n\nRemoving Rule Machine also removes all Rules\n") {
-        }
-    }
-}
-
-def installed() {
-    if(!state.setup) initialize(true) else initialize(false)
-}
-
-def updated() {
-    initialize(false)
-}
-
-def initialize(first) {
-	if(first) {
-		state.ruleState = [:]
-    		state.ruleSubscribers = [:]
-	}
-	childApps.each {child ->
-		if(child.name == "Rule") {
-			log.info "Installed Rules and Triggers: ${child.label}"
-			if(first) {
-				state.ruleState[child.label] = null
-				state.ruleSubscribers[child.label] = [:]
-			}
-		} 
-	}
-	state.setup = true
-}
-
-def ruleList(appLabel) {
-	def result = []
-	childApps.each { child ->
-		if(child.name == "Rule" && child.label != appLabel && state.ruleState[child.label] != null) result << child.label
-	}
-	return result
-}
-
-def subscribeRule(appLabel, ruleName, ruleTruth, childMethod) {
-//	log.debug "subscribe: $appLabel, $ruleName, $ruleTruth, $childMethod"
-	ruleName.each {name ->
-    	state.ruleSubscribers[name].each {if(it == appLabel) return}
-        if(state.ruleSubscribers[name] == null) state.ruleSubscribers[name] = ["$appLabel":ruleTruth]
-    	else state.ruleSubscribers[name] << ["$appLabel":ruleTruth]
-    }
-}
-
-def setRuleTruth(appLabel, ruleTruth) {
-//	log.debug "setRuleTruth1: $appLabel, $ruleTruth"
-	state.ruleState[appLabel] = ruleTruth
-	def thisList = state.ruleSubscribers[appLabel]
-	thisList.each {
-		if(it.value == null || "$it.value" == "$ruleTruth") {
-			childApps.each { child ->
-				if(child.label == it.key) child.ruleHandler(appLabel, ruleTruth)
-			}
-		}
-	}
-}
-
-def currentRule(appLabel) {
-//	log.debug "currentRule: $appLabel, ${state.ruleState[appLabel]}"
-	def result = state.ruleState[appLabel]
-}
-
-def childUninstalled() {
-//	log.debug "childUninstalled called"
-}
-
-def removeChild(appLabel) {
-//	log.debug "removeChild: $appLabel"
-	unSubscribeRule(appLabel)
-	if(state.ruleState[appLabel] != null) state.ruleState.remove(appLabel)
-	if(state.ruleSubscribers[appLabel] != null) state.ruleSubscribers.remove(appLabel)
-}
-
-def unSubscribeRule(appLabel) {
-//	log.debug "unSubscribeRule: $appLabel"
-	state.ruleSubscribers.each { rule ->
-        def newList = [:]
-        rule.value.each {list ->
-        	if(list.key != appLabel) newList << list
-        }
-        rule.value = newList
-    }
-}
-
-def runRule(rule, appLabel) {
-//	log.debug "runRule: $rule, $appLabel"
-	childApps.each { child ->
-		rule.each {
-			if(child.label == it) child.ruleEvaluator(appLabel)
-		}
-	}
-}
-
-/*****custom command specific pages	*****/
-def expert(){
-	dynamicPage(name: "expert", title: "Expert Features", uninstall: false, install: false) {
-		section(){
-			paragraph "${expertText()}"
-			//expert hrefs...
-			href( "customCommandsPAGE"
-				,title		: "Configure Custom Commands..."
-				,description: ""
-				,state		: anyCustom()
-			)
-		}
-	}
-}
-
-def generalApprovalPAGE(params){
-	def title = params.title
-	def method = params.method
-	def result
-	dynamicPage(name: "generalApprovalPAGE", title: title ){
-		section() {
-			if (method) {
-				result = app."${method}"()
-				paragraph "${result}"
-			}
-		}
-	}
-}
-
-def customCommandsPAGE() {
-	if (!state.lastCmdIDX) state.lastCmdIDX = 0
-	def savedCommands = getCommands()
-	dynamicPage(name: "customCommandsPAGE", title: "Custom Commands", uninstall: false, install: false) {
-		section(){
-			input(
-				name			: "devices"
-				,title			: "Test device"
-				,multiple		: false
-				,required		: false
-				,type			: "capability.actuator"
-				,submitOnChange	: true
-			)
-			if (settings.devices && savedCommands.size() != 0){
-				input(
-					name			: "testCmd"
-					,title			: "Select saved command to test"
-					,multiple		: false
-					,required		: false
-					,type			: "enum"
-					,options		: savedCommands
-					,submitOnChange	: true
-				)
-			}
-		}
-		def result = execCommand(settings.testCmd)
-		if (result) {
-			section("${result}"){
-			}
-		}
-		section(){
-		if (devices){
-				href( "addCustomCommandPAGE"
-					,title		: "New custom command..."
-					,description: ""
-					,state		: null
-				)
-			}
-        }
-		if (getCommands()){
-			section(){
-				input(
-					name			: "deleteCmds"
-					,title			: "Delete custom commands..."
-					,multiple		: true
-					,required		: false
-                    ,description	: ""
-					,type			: "enum"
-					,options		: getCommands()
-					,submitOnChange	: true
-				)
-				if (isValidCommand(deleteCmds)){
-					href( "generalApprovalPAGE"
-						,title			: "Delete command(s) now"
-						,description	: ""
-						,state			: null
-						,params			: [method:"deleteCommands",title:"Delete Command"]
-						,submitOnChange	: true
-					)
-				}
-			}
-		}
-	}
-}
-
-def addCustomCommandPAGE(){
-	def cmdLabel = getCmdLabel()
-	def complete = "" 
-	def test = false
-	def pageTitle = "Create new custom command for:\n${devices}" 
-	if (cmdLabel){
-		complete = "complete"
-		test = true
-	}
-	dynamicPage(name: "addCustomCommandPAGE", title: pageTitle, uninstall: false, install: false) {
-		section(){
-			input(
-		   		name			: "cCmd"
-				,title			: "Available device commands"
-				,multiple		: false
-				,required		: false
-				,type			: "enum"
-				,options		: getDeviceCommands()
-				,submitOnChange	: true
-			)
-			href( "customParamsPAGE"
-				,title: "Parameters"
-				,description: parameterLabel()
-				,state: null
-			)
-		}
-		if (test){
-			def result = execTestCommand()
-			section("Configured command: ${cmdLabel}\n${result}"){
-				if (result == "succeeded"){
-					if (!commandExists(cmdLabel)){
-						href( "generalApprovalPAGE"
-							,title		: "Save command now"
-							,description: ""
-							,state		: null
-							,params		: [method:"addCommand",title:"Add Command"]
-						)
-					}
-				} 
-			}
-		}
-	}
-}
-
-def customParamsPAGE(p){
-	def ct = settings.findAll{it.key.startsWith("cpType_")}
-	state.howManyP = ct.size() + 1
-	def howMany = state.howManyP
-	dynamicPage(name: "customParamsPAGE", title: "Select parameters", uninstall: false) {
-		if(howMany) {
-			for (int i = 1; i <= howMany; i++) {
-				def thisParam = "cpType_" + i
-				def myParam = ct.find {it.key == thisParam}
-				section("Parameter #${i}") {
-					getParamType(thisParam, i != howMany)
-					if(myParam) {
-						def pType = myParam.value
-						getPvalue(pType, i)
-					}
-				}
-			}
-		}
-	}
-}
-
-/***** child specific methods *****/
-
-def getCommandMap(cmdID){
-	return state.customCommands["${cmdID}"]
-}
-
-
-/***** local custom command specific methods *****/
-def anyCustom(){
-	def result = null
-	if (getCommands()) result = "complete"
-	return result
-}
-
-def getParamType(myParam,isLast){  
-	def myOptions = ["string", "number", "decimal"]
-	def result = input (
-					name			: myParam
-					,type			: "enum"
-					,title			: "parameter type"
-					,required		: isLast
-					,options		: myOptions
-					,submitOnChange	: true
-				)
-	return result
-}
-
-def getPvalue(myPtype, n){
-	def myVal = "cpVal_" + n
-	def result = null
-	if (myPtype == "string"){
-		result = input(
-					name		: myVal
-					,title		: "string value"
-					,type		: "text"
-					,required	: false
-				)
-	} else if (myPtype == "number"){
-		result = input(
-					name		: myVal
-					,title		: "integer value"
-					,type		: "number"
-					,required	: false
-				)
-	} else if (myPtype == "decimal"){
-		result = input(
-					name		: myVal
-					,title		: "decimal value"
-					,type		: "decimal"
-					,required	: false
-				)
-	}
-	return result
-}
-
-def getCmdLabel(){
-	def cmd
-	if (settings.cCmd) cmd = settings.cCmd.value
-	def cpTypes = settings.findAll{it.key.startsWith("cpType_")}.sort()
-	def result = null
-	if (cmd) {
-		result = "${cmd}("
-		if (cpTypes.size() == 0){
-			result = result + ")"
-		} else {
-        	def r = getParams(cpTypes)
-            if (r == "") result = r
-            else result = "${result}${r})"
-		}
-	}
-	return result
-}
-
-def getParams(cpTypes){
-	def result = ""
-	def cpValue
-	def badParam = false
-	cpTypes.each{ cpType ->
-		def i = cpType.key.replaceAll("cpType_","")
-		def cpVal = settings.find{it.key == "cpVal_${i}"}
-		if (cpVal){
-			cpValue = cpVal.value
-			if (cpType.value == "string"){
-				result = result + "'${cpValue}'," 
-			} else {
-				if (cpValue.isNumber()){
-					result = result + "${cpValue}," 
-				} else {
-					result = result + "[${cpValue}]: is not a number,"
-				}
-			}
-		} else {
-			badParam = true
-		}
-	}
-	if (badParam) result = ""
-	else result = result[0..-2]   
-	return result
-}
-
-def parameterLabel(){
-	def howMany = (state.howManyP ?: 1) - 1
-	def result = ""
-	if (howMany) {
-		for (int i = 1; i <= howMany; i++) {
-			result = result + parameterLabelN(i) + "\n"
-		}
-		result = result[0..-2]
-	}
-	return result
-}
-
-def parameterLabelN(i){
-	def result = ""
-	def cpType = settings.find{it.key == "cpType_${i}"}
-	def cpVal = settings.find{it.key == "cpVal_${i}"}
-	def cpValue
-	if (cpVal) cpValue = cpVal.value
-	else cpValue = "missing value"
-	if (cpType){
-		result = "p${i} - type:${cpType.value}, value:${cpValue}"
-	} 
-	return result
-}
-
-def getParamsAsList(cpTypes){
-	def result = []
-	cpTypes.each{ cpType ->
-		def i = cpType.key.replaceAll("cpType_","")
-		def cpVal = settings.find{it.key == "cpVal_${i}"}
-		if (cpVal){
-			if (cpType.value == "string"){
-				result << "${cpVal.value}" 
-			} else if (cpType.value == "decimal"){
-				result << cpVal.value.toBigDecimal()
-			} else {
-				result << cpVal.value.toInteger() 
-			}
-		} else {
-        	result << "missing value"
-        }
-	}
-	return result
-}
-
-def getCommands(){
-	def result = [] 
-	def cmdMaps = state.customCommands ?: []
-	cmdMaps.each{ cmd ->
-		def option = [(cmd.key):(cmd.value.text)]
-		result.push(option)
-	}
-	return result
-}
-
-def isValidCommand(cmdIDS){
-	def result = false
-	cmdIDS.each{ cmdID ->
-		def cmd = state.customCommands["${cmdID}"]
-		if (cmd) result = true
-	}
-	return result
-}
-
-def deleteCommands(){
-	def result
-	def cmdMaps = state.customCommands
-	if (deleteCmds.size == 1) result = "Command removed"
-	else result = "Commands removed"
-	deleteCmds.each{ it -> 
-		cmdMaps.remove(it)
-	}
-	return result
-}
-def commandExists(cmd){
-	def result = false
-	if (state.customCommands){
-		result = state.customCommands.find{ it.value.text == "${cmd}" }
-	}
-	return result
-}
-def addCommand(){
-	def result
-	def newCmd = getCmdLabel()
-	def found = commandExists(newCmd)
-	def cmdMaps = state.customCommands
-	//only update if not found...
-	if (!found) {
-		state.lastCmdIDX = state.lastCmdIDX + 1
-		def nextIDX = state.lastCmdIDX
-		def cmd = [text:"${newCmd}",cmd:"${cCmd}"]
-		def params = [:]
-		def cpTypes = settings.findAll{it.key.startsWith("cpType_")}.sort()
-		cpTypes.each{ cpType ->
-			def i = cpType.key.replaceAll("cpType_","")
-			def cpVal = settings.find{it.key == "cpVal_${i}"}
-			def param = ["type":"${cpType.value}","value":"${cpVal.value}"]
-			params.put(i, param)
-		}	
-		cmd.put("params",params)
-		if (cmdMaps) cmdMaps.put((nextIDX),cmd)
-		else state.customCommands = [(nextIDX):cmd]
-		result = "command: ${newCmd} was added"
-	} else {
-		result = "command: ${newCmd} was not added, it already exists."
-	}
-	return result
-}
-
-def execTestCommand(){
-	def result
-	def cTypes = settings.findAll{it.key.startsWith("cpType_")}
-	def p = getParamsAsList(cTypes.sort()) as Object[]
-	devices.each { device ->
-		try {
-			device."${cCmd}"(p)
-			result = "succeeded"
-		}
-		catch (IllegalArgumentException e){
-			def em = e as String
-			def ems = em.split(":")
-			ems = ems[2].replace(" [","").replace("]","")
-			ems = ems.replaceAll(", ","\n")
-			result = "failed, valid commands:\n${ems}"
-		}
-		catch (e){
-			result = "failed with:\n${e}"
-		}
-	}
-	return result
-}
-
-def execCommand(cmdID){
-	def result = ""
-	def pList = []
-	if (cmdID){
-		def cmdMap = state.customCommands["${cmdID}"] 
-		if (testCmd && cmdMap) {
-        	def params = cmdMap.params.sort()
-			params.each{ p ->
-				if (p.value.type == "string"){
-					pList << "${p.value.value}"
-       			} else if (p.value.type == "decimal"){
-		   			pList << p.value.value.toBigDecimal()
-				} else {
-					pList << p.value.value.toInteger()
-				}
-			}
-			def p = pList as Object[]
-			devices.each { device ->
-				try {
-					device."${cmdMap.cmd}"(p)
-					result = "Command succeeded"
-				}
-				catch (IllegalArgumentException e){
-					def em = e as String
-					def ems = em.split(":")
-					ems = ems[2].replace(" [","").replace("]","")
-					ems = ems.replaceAll(", ","\n")
-					result = "Command failed, valid commands:\n${ems}"
-				}
-				catch (e){
-					result = "failed with:\n${e}"
-				}
-			}
-			return result
-		}
-	}
-}
-
-def getDeviceCommands(){
-	def result = ""
-	devices.each { device ->
-		try {
-			device."xxx"()
-			result = "Command succeeded"
-		}
-		catch (IllegalArgumentException e){
-			def em = e as String
-			def ems = em.split(":")
-			ems = ems[2].replace(" [","").replace("]","")
-			result = ems.split(", ").collect{it as String}
-		}
-	}
-	return result
-}
-
-def isExpert(ver){
-	state.ver = ver
-	return getCommands().size() > 0
-}
-
-def expertText() {
-	def text = 
-		"Custom commands allows Rule Machine to control devices with custom capabilities. " +
-		"This includes dual dimmers and switches, ThingShields, FGBW controllers or any device you might build a " +
-		"custom SmartApp to utilize.\n\nCustom commands that are created and saved here will become available for use " +
-		"in any new or existing rules.\n\nAfter saving at least one command, look for 'Run custom device command' in your " + 
-		"'Select Actions' sections."
-}

smartapps/smartthings/life360-connect.src/life360-connect.groovy

@@ -289,12 +289,12 @@ def initializeLife360Connection() {
        		state.life360AccessToken = result.data.access_token
             return true;
    		}
-		log.info "Life360 initializeLife360Connection, response=${result.data}"
+		log.debug "Response=${result.data}"
         return false;
         
     }
     catch (e) {
-       log.error "Life360 initializeLife360Connection, error: $e"
+       log.debug e
        return false;
     }
 
@@ -656,7 +656,7 @@ def generateInitialEvent (member, childDevice) {
     
     try { // we are going to just ignore any errors
     
-    	log.info "Life360 generateInitialEvent($member, $childDevice)"
+    	log.debug "Generate Initial Event for New Device for Member = ${member.id}"
         
         def place = state.places.find{it.id==settings.place}
         
@@ -677,8 +677,6 @@ def generateInitialEvent (member, childDevice) {
         	// log.debug "Distance Away = ${distanceAway}"
   
   			boolean isPresent = (distanceAway <= placeRadius)
-
-			log.info "Life360 generateInitialEvent, member: ($memberLatitude, $memberLongitude), place: ($placeLatitude, $placeLongitude), radius: $placeRadius, dist: $distanceAway, present: $isPresent"
                 
         	// log.debug "External Id=${app.id}:${member.id}"
         
@@ -720,7 +718,7 @@ def haversine(lat1, lon1, lat2, lon2) {
 
 def placeEventHandler() {
 
-	log.info "Life360 placeEventHandler: params=$params, settings.place=$settings.place"
+	log.debug "In placeEventHandler method."
 
 	// the POST to this end-point will look like:
     // POST http://test.com/webhook?circleId=XXXX&placeId=XXXX&userId=XXXX&direction=arrive
@@ -731,6 +729,8 @@ def placeEventHandler() {
     def direction = params?.direction
     def timestamp = params?.timestamp
     
+    log.debug "Life360 Event: Circle: ${circleId}, Place: ${placeId}, User: ${userId}, Direction: ${direction}"
+
     if (placeId == settings.place) {
 
 		def presenceState = (direction=="in")
@@ -745,10 +745,10 @@ def placeEventHandler() {
 
 		if (deviceWrapper) {
 			deviceWrapper.generatePresenceEvent(presenceState)
-    		log.debug "Life360 event raised on child device: ${externalId}"
+    		log.debug "Event raised on child device: ${externalId}"
 		}
    		else {
-    		log.warn "Life360 couldn't find child device associated with inbound Life360 event."
+    		log.debug "Couldn't find child device associated with inbound Life360 event."
     	}
     }
 

smartapps/thehomeremote-homeremote/home-remote.src/home-remote.groovy

@@ -0,0 +1,799 @@
+/** *  Home Remote
+ *
+ *  Copyright 2015 The Home Remote
+ *
+ *  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.
+ *
+ */
+definition(
+    name: "Home Remote",
+    namespace: "thehomeremote.homeremote",
+    author: "The Home Remote",
+    description: "Web service that enables communication between the Home Remote app and a SmartThings hub.",
+    category: "My Apps",
+    iconUrl: "https://s3.amazonaws.com/smartapp-icons/Convenience/Cat-Convenience.png",
+    iconX2Url: "https://s3.amazonaws.com/smartapp-icons/Convenience/Cat-Convenience@2x.png",
+    iconX3Url: "https://s3.amazonaws.com/smartapp-icons/Convenience/Cat-Convenience@2x.png",
+    oauth: [displayName: "The Home Remote", displayLink: "http://thehomeremote.com/"])
+
+
+preferences {
+    section() {
+	input "accelerationSensors", "capability.accelerationSensor",title: "Acceleration Sensors", multiple: true, required: false
+	input "alarms", "capability.alarm",title: "Alarms", multiple: true, required: false
+	input "batteries", "capability.battery",title: "Batteries", multiple: true, required: false
+	input "beacons", "capability.beacon",title: "Beacons", multiple: true, required: false
+	input "buttonGroup", "capability.button",title: "Buttons", multiple: true, required: false
+	input "carbonMonoxideDetectors", "capability.carbonMonoxideDetector",title: "CO Detectors", multiple: true, required: false
+	input "colorControls", "capability.colorControl",title: "Color Lights", multiple: true, required: false
+	input "contactSensors", "capability.contactSensor",title: "Contact Sensors", multiple: true, required: false
+	input "doorControls", "capability.doorControl",title: "Door Controllers", multiple: true, required: false
+	input "energyMeters", "capability.energyMeter",title: "Energy Meters", multiple: true, required: false
+	input "illuminanceMeasurements", "capability.illuminanceMeasurement",title: "Illuminance Sensors", multiple: true, required: false
+	input "imageCaptures", "capability.imageCapture",title: "Cameras", multiple: true, required: false
+	input "locks", "capability.lock",title: "Locks", multiple: true, required: false
+	input "mediaControllers", "capability.mediaController",title: "Media Controllers", multiple: true, required: false
+	input "momentaries", "capability.momentary",title: "Momentary Buttons", multiple: true, required: false
+	input "motionSensors", "capability.motionSensor",title: "Motion Sensors", multiple: true, required: false
+	input "musicPlayers", "capability.musicPlayer",title: "Music Players", multiple: true, required: false
+	input "powerMeters", "capability.powerMeter",title: "Power Meters", multiple: true, required: false
+	input "presenceSensors", "capability.presenceSensor",title: "Presence Sensors", multiple: true, required: false
+	input "relativeHumidityMeasurements", "capability.relativeHumidityMeasurement",title: "Humidity Sensors", multiple: true, required: false
+	input "relaySwitches", "capability.relaySwitch",title: "Relays", multiple: true, required: false
+	input "signalStrengths", "capability.signalStrength",title: "Signal Strengths", multiple: true, required: false
+	input "sleepSensors", "capability.sleepSensor",title: "Sleep Sensors", multiple: true, required: false
+	input "smokeDetectors", "capability.smokeDetector",title: "Smoke Detectors", multiple: true, required: false
+	input "speechSyntheses", "capability.speechSynthesis",title: "Speech Syntheses", multiple: true, required: false
+	input "stepSensors", "capability.stepSensor",title: "Step Sensors", multiple: true, required: false
+	input "switches", "capability.switch",title: "Switches", multiple: true, required: false
+	input "switchLevels", "capability.switchLevel",title: "Dimmers", multiple: true, required: false
+	input "temperatureMeasurements", "capability.temperatureMeasurement",title: "Temperature Sensors", multiple: true, required: false
+	input "thermostats", "capability.thermostat",title: "Thermostats", multiple: true, required: false
+	input "threeAxes", "capability.threeAxis",title: "Three axis Sensors", multiple: true, required: false
+	input "tones", "capability.tone",title: "Tones", multiple: true, required: false
+	input "touchSensors", "capability.touchSensor",title: "Touch Sensors", multiple: true, required: false
+	input "valves", "capability.valve",title: "Valves", multiple: true, required: false
+	input "waterSensors", "capability.waterSensor",title: "Water Sensors", multiple: true, required: false
+    }
+}
+
+mappings {
+  path("/GetCurrentValues") {
+    action: [
+      GET: "getCurrentValues"
+    ]
+  }
+  path("/GetCurrentValuesWithDisplayName") {
+    action: [
+      GET: "getCurrentValuesWithDisplayName"
+    ]
+  }
+  path("/GetRoutines") {
+    action: [
+      GET: "getRoutines"
+    ]
+  }
+  path("/ExecuteCommand") {
+    action: [
+      PUT: "executeCommand"
+    ]
+  }
+  path("/ExecuteRoutine") {
+    action: [
+      PUT: "executeRoutine"
+    ]
+  }
+}
+
+def getCurrentValues() {
+    def resp = []    
+        
+ 	accelerationSensors.each {
+      resp << [id: it.id, capability: "AccelerationSensor", attribute: "acceleration", value: it.currentValue("acceleration")]
+    }
+
+	alarms.each {
+      resp << [id: it.id, capability: "Alarm", attribute: "alarm", value: it.currentValue("alarm")]
+    }
+
+	batteries.each {
+      resp << [id: it.id, capability: "Battery", attribute: "battery", value: it.currentValue("battery")]
+    }
+
+	beacons.each {
+      resp << [id: it.id, capability: "Beacon", attribute: "presence", value: it.currentValue("presence")]
+    }
+
+	buttonGroup.each {
+      resp << [id: it.id, capability: "Button", attribute: "button", value: it.currentValue("button")]
+    }
+
+	carbonMonoxideDetectors.each {
+      resp << [id: it.id, capability: "CarbonMonoxideDetector", attribute: "carbonMonoxide", value: it.currentValue("carbonMonoxide")]
+    }
+
+	colorControls.each {
+      resp << [id: it.id, capability: "ColorControl", attribute: "hue", value: it.currentValue("hue")]
+    }
+
+	colorControls.each {
+      resp << [id: it.id, capability: "ColorControl", attribute: "saturation", value: it.currentValue("saturation")]
+    }
+
+	colorControls.each {
+      resp << [id: it.id, capability: "ColorControl", attribute: "color", value: it.currentValue("color")]
+    }
+
+	contactSensors.each {
+      resp << [id: it.id, capability: "ContactSensor", attribute: "contact", value: it.currentValue("contact")]
+    }
+
+	doorControls.each {
+      resp << [id: it.id, capability: "DoorControl", attribute: "door", value: it.currentValue("door")]
+    }
+
+	energyMeters.each {
+      resp << [id: it.id, capability: "EnergyMeter", attribute: "energy", value: it.currentValue("energy")]
+    }
+
+	illuminanceMeasurements.each {
+      resp << [id: it.id, capability: "IlluminanceMeasurement", attribute: "illuminance", value: it.currentValue("illuminance")]
+    }
+
+	imageCaptures.each {
+      resp << [id: it.id, capability: "ImageCapture", attribute: "image", value: it.currentValue("image")]
+    }
+
+	locks.each {
+      resp << [id: it.id, capability: "Lock", attribute: "lock", value: it.currentValue("lock")]
+    }
+
+	mediaControllers.each {
+      resp << [id: it.id, capability: "MediaController", attribute: "activities", value: it.currentValue("activities")]
+    }
+
+	mediaControllers.each {
+      resp << [id: it.id, capability: "MediaController", attribute: "currentActivity", value: it.currentValue("currentActivity")]
+    }
+
+	motionSensors.each {
+      resp << [id: it.id, capability: "MotionSensor", attribute: "motion", value: it.currentValue("motion")]
+    }
+
+	musicPlayers.each {
+      resp << [id: it.id, capability: "MusicPlayer", attribute: "status", value: it.currentValue("status")]
+    }
+
+	musicPlayers.each {
+      resp << [id: it.id, capability: "MusicPlayer", attribute: "level", value: it.currentValue("level")]
+    }
+
+	musicPlayers.each {
+      resp << [id: it.id, capability: "MusicPlayer", attribute: "trackDescription", value: it.currentValue("trackDescription")]
+    }
+
+	musicPlayers.each {
+      resp << [id: it.id, capability: "MusicPlayer", attribute: "trackData", value: it.currentValue("trackData")]
+    }
+
+	musicPlayers.each {
+      resp << [id: it.id, capability: "MusicPlayer", attribute: "mute", value: it.currentValue("mute")]
+    }
+
+	powerMeters.each {
+      resp << [id: it.id, capability: "PowerMeter", attribute: "power", value: it.currentValue("power")]
+    }
+
+	presenceSensors.each {
+      resp << [id: it.id, capability: "PresenceSensor", attribute: "presence", value: it.currentValue("presence")]
+    }
+
+	relativeHumidityMeasurements.each {
+      resp << [id: it.id, capability: "RelativeHumidityMeasurement", attribute: "humidity", value: it.currentValue("humidity")]
+    }
+
+	relaySwitches.each {
+      resp << [id: it.id, capability: "RelaySwitch", attribute: "switch", value: it.currentValue("switch")]
+    }
+
+	signalStrengths.each {
+      resp << [id: it.id, capability: "SignalStrength", attribute: "lqi", value: it.currentValue("lqi")]
+    }
+
+	signalStrengths.each {
+      resp << [id: it.id, capability: "SignalStrength", attribute: "rssi", value: it.currentValue("rssi")]
+    }
+
+	sleepSensors.each {
+      resp << [id: it.id, capability: "SleepSensor", attribute: "sleeping", value: it.currentValue("sleeping")]
+    }
+
+	smokeDetectors.each {
+      resp << [id: it.id, capability: "SmokeDetector", attribute: "smoke", value: it.currentValue("smoke")]
+    }
+
+	stepSensors.each {
+      resp << [id: it.id, capability: "StepSensor", attribute: "steps", value: it.currentValue("steps")]
+    }
+
+	stepSensors.each {
+      resp << [id: it.id, capability: "StepSensor", attribute: "goal", value: it.currentValue("goal")]
+    }
+
+	switches.each {
+      resp << [id: it.id, capability: "Switch", attribute: "switch", value: it.currentValue("switch")]
+    }
+
+	switchLevels.each {
+      resp << [id: it.id, capability: "SwitchLevel", attribute: "level", value: it.currentValue("level")]
+    }
+
+	temperatureMeasurements.each {
+      resp << [id: it.id, capability: "TemperatureMeasurement", attribute: "temperature", value: it.currentValue("temperature")]
+    }
+
+	thermostats.each {
+      resp << [id: it.id, capability: "Thermostat", attribute: "temperature", value: it.currentValue("temperature")]
+    }
+
+	thermostats.each {
+      resp << [id: it.id, capability: "Thermostat", attribute: "heatingSetpoint", value: it.currentValue("heatingSetpoint")]
+    }
+
+	thermostats.each {
+      resp << [id: it.id, capability: "Thermostat", attribute: "coolingSetpoint", value: it.currentValue("coolingSetpoint")]
+    }
+
+	//Commented out on 7/23/2016.   This randomly started throwing number format exceptions with either my ecobee or Lyric thermostat.
+	//thermostats.each {
+    //  resp << [id: it.id, capability: "Thermostat", attribute: "thermostatSetpoint", value: it.currentValue("thermostatSetpoint")]
+    //}
+
+	thermostats.each {
+      resp << [id: it.id, capability: "Thermostat", attribute: "thermostatMode", value: it.currentValue("thermostatMode")]
+    }
+
+	thermostats.each {
+      resp << [id: it.id, capability: "Thermostat", attribute: "thermostatFanMode", value: it.currentValue("thermostatFanMode")]
+    }
+
+	thermostats.each {
+      resp << [id: it.id, capability: "Thermostat", attribute: "thermostatOperatingState", value: it.currentValue("thermostatOperatingState")]
+    }
+
+	threeAxes.each {
+      resp << [id: it.id, capability: "ThreeAxis", attribute: "threeAxis", value: it.currentValue("threeAxis")]
+    }
+
+	touchSensors.each {
+      resp << [id: it.id, capability: "TouchSensor", attribute: "touch", value: it.currentValue("touch")]
+    }
+
+	valves.each {
+      resp << [id: it.id, capability: "Valve", attribute: "contact", value: it.currentValue("contact")]
+    }
+
+	waterSensors.each {
+      resp << [id: it.id, capability: "WaterSensor", attribute: "water", value: it.currentValue("water")]
+    }
+   
+   	//resp << [id: 0, capability: "Heartbeat", attribute: "heartbeat", value: String.valueOf(state.heartbeat)]
+    
+    state.heartbeat = !state.heartbeat
+    
+    return resp
+}
+
+def getCurrentValuesWithDisplayName() {
+    def resp = []    
+        
+ 	accelerationSensors.each {
+      resp << [id: it.id, displayName: it.displayName, capability: "AccelerationSensor", attribute: "acceleration", value: it.currentValue("acceleration")]
+    }
+
+	alarms.each {
+      resp << [id: it.id, displayName: it.displayName, capability: "Alarm", attribute: "alarm", value: it.currentValue("alarm")]
+    }
+
+	batteries.each {
+      resp << [id: it.id, displayName: it.displayName, capability: "Battery", attribute: "battery", value: it.currentValue("battery")]
+    }
+
+	beacons.each {
+      resp << [id: it.id, displayName: it.displayName, capability: "Beacon", attribute: "presence", value: it.currentValue("presence")]
+    }
+
+	buttonGroup.each {
+      resp << [id: it.id, displayName: it.displayName, capability: "Button", attribute: "button", value: it.currentValue("button")]
+    }
+
+	carbonMonoxideDetectors.each {
+      resp << [id: it.id, displayName: it.displayName, capability: "CarbonMonoxideDetector", attribute: "carbonMonoxide", value: it.currentValue("carbonMonoxide")]
+    }
+
+	colorControls.each {
+      resp << [id: it.id, displayName: it.displayName, capability: "ColorControl", attribute: "hue", value: it.currentValue("hue")]
+    }
+
+	colorControls.each {
+      resp << [id: it.id, displayName: it.displayName, capability: "ColorControl", attribute: "saturation", value: it.currentValue("saturation")]
+    }
+
+	colorControls.each {
+      resp << [id: it.id, displayName: it.displayName, capability: "ColorControl", attribute: "color", value: it.currentValue("color")]
+    }
+
+	contactSensors.each {
+      resp << [id: it.id, displayName: it.displayName, capability: "ContactSensor", attribute: "contact", value: it.currentValue("contact")]
+    }
+
+	doorControls.each {
+      resp << [id: it.id, displayName: it.displayName, capability: "DoorControl", attribute: "door", value: it.currentValue("door")]
+    }
+
+	energyMeters.each {
+      resp << [id: it.id, displayName: it.displayName, capability: "EnergyMeter", attribute: "energy", value: it.currentValue("energy")]
+    }
+
+	illuminanceMeasurements.each {
+      resp << [id: it.id, displayName: it.displayName, capability: "IlluminanceMeasurement", attribute: "illuminance", value: it.currentValue("illuminance")]
+    }
+
+	imageCaptures.each {
+      resp << [id: it.id, displayName: it.displayName, capability: "ImageCapture", attribute: "image", value: it.currentValue("image")]
+    }
+
+	locks.each {
+      resp << [id: it.id, displayName: it.displayName, capability: "Lock", attribute: "lock", value: it.currentValue("lock")]
+    }
+
+	mediaControllers.each {
+      resp << [id: it.id, displayName: it.displayName, capability: "MediaController", attribute: "activities", value: it.currentValue("activities")]
+    }
+
+	mediaControllers.each {
+      resp << [id: it.id, displayName: it.displayName, capability: "MediaController", attribute: "currentActivity", value: it.currentValue("currentActivity")]
+    }
+
+	motionSensors.each {
+      resp << [id: it.id, displayName: it.displayName, capability: "MotionSensor", attribute: "motion", value: it.currentValue("motion")]
+    }
+
+	musicPlayers.each {
+      resp << [id: it.id, displayName: it.displayName, capability: "MusicPlayer", attribute: "status", value: it.currentValue("status")]
+    }
+
+	musicPlayers.each {
+      resp << [id: it.id, displayName: it.displayName, capability: "MusicPlayer", attribute: "level", value: it.currentValue("level")]
+    }
+
+	musicPlayers.each {
+      resp << [id: it.id, displayName: it.displayName, capability: "MusicPlayer", attribute: "trackDescription", value: it.currentValue("trackDescription")]
+    }
+
+	musicPlayers.each {
+      resp << [id: it.id, displayName: it.displayName, capability: "MusicPlayer", attribute: "trackData", value: it.currentValue("trackData")]
+    }
+
+	musicPlayers.each {
+      resp << [id: it.id, displayName: it.displayName, capability: "MusicPlayer", attribute: "mute", value: it.currentValue("mute")]
+    }
+
+	powerMeters.each {
+      resp << [id: it.id, displayName: it.displayName, capability: "PowerMeter", attribute: "power", value: it.currentValue("power")]
+    }
+
+	presenceSensors.each {
+      resp << [id: it.id, displayName: it.displayName, capability: "PresenceSensor", attribute: "presence", value: it.currentValue("presence")]
+    }
+
+	relativeHumidityMeasurements.each {
+      resp << [id: it.id, displayName: it.displayName, capability: "RelativeHumidityMeasurement", attribute: "humidity", value: it.currentValue("humidity")]
+    }
+
+	relaySwitches.each {
+      resp << [id: it.id, displayName: it.displayName, capability: "RelaySwitch", attribute: "switch", value: it.currentValue("switch")]
+    }
+
+	signalStrengths.each {
+      resp << [id: it.id, displayName: it.displayName, capability: "SignalStrength", attribute: "lqi", value: it.currentValue("lqi")]
+    }
+
+	signalStrengths.each {
+      resp << [id: it.id, displayName: it.displayName, capability: "SignalStrength", attribute: "rssi", value: it.currentValue("rssi")]
+    }
+
+	sleepSensors.each {
+      resp << [id: it.id, displayName: it.displayName, capability: "SleepSensor", attribute: "sleeping", value: it.currentValue("sleeping")]
+    }
+
+	smokeDetectors.each {
+      resp << [id: it.id, displayName: it.displayName, capability: "SmokeDetector", attribute: "smoke", value: it.currentValue("smoke")]
+    }
+
+	stepSensors.each {
+      resp << [id: it.id, displayName: it.displayName, capability: "StepSensor", attribute: "steps", value: it.currentValue("steps")]
+    }
+
+	stepSensors.each {
+      resp << [id: it.id, displayName: it.displayName, capability: "StepSensor", attribute: "goal", value: it.currentValue("goal")]
+    }
+
+	switches.each {
+      resp << [id: it.id, displayName: it.displayName, capability: "Switch", attribute: "switch", value: it.currentValue("switch")]
+    }
+
+	switchLevels.each {
+      resp << [id: it.id, displayName: it.displayName, capability: "SwitchLevel", attribute: "level", value: it.currentValue("level")]
+    }
+
+	temperatureMeasurements.each {
+      resp << [id: it.id, displayName: it.displayName, capability: "TemperatureMeasurement", attribute: "temperature", value: it.currentValue("temperature")]
+    }
+
+	thermostats.each {
+      resp << [id: it.id, displayName: it.displayName, capability: "Thermostat", attribute: "temperature", value: it.currentValue("temperature")]
+    }
+
+	thermostats.each {
+      resp << [id: it.id, displayName: it.displayName, capability: "Thermostat", attribute: "heatingSetpoint", value: it.currentValue("heatingSetpoint")]
+    }
+
+	thermostats.each {
+      resp << [id: it.id, displayName: it.displayName, capability: "Thermostat", attribute: "coolingSetpoint", value: it.currentValue("coolingSetpoint")]
+    }
+
+	//Commented out on 7/23/2016.   This randomly started throwing number format exceptions with either my ecobee or Lyric thermostat.
+	//thermostats.each {
+    //  resp << [id: it.id, displayName: it.displayName, capability: "Thermostat", attribute: "thermostatSetpoint", value: it.currentValue("thermostatSetpoint")]
+    //}
+
+	thermostats.each {
+      resp << [id: it.id, displayName: it.displayName, capability: "Thermostat", attribute: "thermostatMode", value: it.currentValue("thermostatMode")]
+    }
+
+	thermostats.each {
+      resp << [id: it.id, displayName: it.displayName, capability: "Thermostat", attribute: "thermostatFanMode", value: it.currentValue("thermostatFanMode")]
+    }
+
+	thermostats.each {
+      resp << [id: it.id, displayName: it.displayName, capability: "Thermostat", attribute: "thermostatOperatingState", value: it.currentValue("thermostatOperatingState")]
+    }
+
+	threeAxes.each {
+      resp << [id: it.id, displayName: it.displayName, capability: "ThreeAxis", attribute: "threeAxis", value: it.currentValue("threeAxis")]
+    }
+
+	touchSensors.each {
+      resp << [id: it.id, displayName: it.displayName, capability: "TouchSensor", attribute: "touch", value: it.currentValue("touch")]
+    }
+
+	valves.each {
+      resp << [id: it.id, displayName: it.displayName, capability: "Valve", attribute: "contact", value: it.currentValue("contact")]
+    }
+
+	waterSensors.each {
+      resp << [id: it.id, displayName: it.displayName, capability: "WaterSensor", attribute: "water", value: it.currentValue("water")]
+    }
+   
+    momentaries.each {
+      resp << [id: it.id, displayName: it.displayName, capability: "Momentary", attribute: "", value: ""]
+    }
+   
+    //resp << [id: 0, displayName: "Heartbeat", capability: "Heartbeat", attribute: "heartbeat", value: state.heartbeat]
+    
+    return resp
+}
+
+def getDevices(capability){
+
+	def result
+
+	switch (capability) {
+    	case "Alarm":
+        	result = alarms
+        	break
+    	case "ColorControl":
+        	result = colorControls
+        	break
+    	case "DoorControl":
+        	result = doorControls
+        	break
+        case "ImageCapture":
+        	result = imageCaptures
+        	break
+    	case "Lock":
+        	result = locks
+        	break
+        case "MediaController":
+        	result = mediaControllers
+        	break
+    	case "Momentary":
+        	result = momentaries
+        	break
+        case "MusicPlayer":
+        	result = musicPlayers
+        	break
+        case "RelaySwitch":
+        	result = relaySwitches
+        	break
+    	case "SpeechSynthesis":
+        	result = speechSyntheses
+        	break
+    	case "Switch":
+        	result = switches
+        	break
+        case "SwitchLevel":
+        	result = switchLevels
+        	break
+    	case "Thermostat":
+        	result = thermostats
+        	break
+		case "ThermostatCoolingSetpoint":
+        	result = thermostatCoolingSetpoints
+        	break
+    	case "ThermostatFanMode":
+        	result = thermostatFanModes
+        	break
+        case "ThermostatHeatingSetpoint":
+        	result = thermostatHeatingSetpoints
+        	break
+    	case "ThermostatMode":
+        	result = thermostatModes
+        	break
+    	case "Tone":
+        	result = tones
+        	break
+        case "Valve":
+        	result = valves
+        	break     
+    	default:
+        	result = valves
+	}
+	return result
+}
+
+def getDoorControlCommand(value){
+	def result
+	switch (value) {
+        case "closed":
+        	result = "close"
+        	break
+    	case "open":
+        	result = "open"
+        	break
+    	default:
+        	result = value
+	}    
+	return result
+}
+
+def getLockCommand(value){
+	def result
+	switch (value) {
+        case "locked":
+        	result = "lock"
+        	break
+    	case "unlocked":
+        	result = "unlock"
+        	break
+    	default:
+        	result = value
+	}    
+	return result
+}
+
+def getMuteCommand(value){
+	def result
+	switch (value) {
+        case "muted":
+        	result = "mute"
+        	break
+    	case "unmuted":
+        	result = "unmute"
+        	break
+    	default:
+        	result = value
+	}    
+	return result
+}
+
+def getContactCommand(value){
+	def result
+	switch (value) {
+        case "closed":
+        	result = "close"
+        	break
+    	case "open":
+        	result = "open"
+        	break
+    	default:
+        	result = value
+	}    
+	return result
+}
+
+def getRoutines() {
+	return location.helloHome?.getPhrases()*.label
+}
+
+def getThermostatFanModeCommand(value){
+	def result
+	switch (value) {
+        case "on":
+        	result = "fanOn"
+        	break
+    	case "auto":
+        	result = "fanAuto"
+        	break
+    	case "circulate":
+        	result = "fanCirculate"
+        	break
+    	default:
+        	result = value
+	}    
+	return result
+}
+
+void executeCommand() {    
+    def deviceId = request.JSON?.deviceId
+    def capability = request.JSON?.capability
+    def attribute = request.JSON?.attribute 
+    def value = request.JSON?.value    
+    if (deviceId) {
+		def devices = getDevices(capability)
+        def command
+        def valueIsParameter = false
+        def valueIsInteger = false
+        switch (attribute) {    	       	
+        	case "hue":
+        		command = "setHue"
+                valueIsParameter = true
+                valueIsInteger = true
+        		break
+    		case "saturation":
+        		command = "setSaturation"
+                valueIsParameter = true
+                valueIsInteger = true
+        		break
+    		case "color":
+        		command = "setColor"
+                def rgb = hexToRgb(value)
+                def hsl = rgbToHSL(rgb)
+                value = [hue:hsl.h.toInteger(), saturation:hsl.s.toInteger()]
+                valueIsParameter = true				
+        		break
+			case "level":
+        		command = "setLevel"
+                valueIsParameter = true
+                valueIsInteger = true
+        		break            
+        	case "heatingSetpoint":
+        		command = "setHeatingSetpoint"
+                valueIsParameter = true
+        		break    
+       		case "coolingSetpoint":
+        		command = "setCoolingSetpoint"
+                valueIsParameter = true
+        		break
+          	case "currentActivity":
+        		command = "startActivity"
+                valueIsParameter = true
+        		break  
+ 	  		case "door":
+        		command = getDoorControlCommand(value)
+        		break    
+      		case "lock":
+        		command = getLockCommand(value)
+        		break           
+      		case "mute":
+        		command = getMuteCommand(value)
+        		break         
+      		case "thermostatFanMode":
+        		command = getThermostatFanModeCommand(value)
+        		break         
+       		case "thermostatMode":
+        		if (value == "emergency heat") {
+                	command = "emergencyHeat"
+           		}
+                else
+                {
+                    command = value
+                }
+        		break     
+      		case "contact":
+        		command = getContactCommand(value)
+        		break
+    		default:
+        		command = value
+		}
+        devices.each {
+        	if (it.id == deviceId) {
+                // check that the device supports the specified command
+                // If not, return an error using httpError, providing a HTTP status code.
+            	if (!it.hasCommand(command)) {
+                	httpError(501, "$command is not a valid command for the device")
+            	}                
+                if(valueIsParameter){
+                	if(valueIsInteger){
+                		it."$command"(value as int)
+                	}
+                	else{
+                		it."$command"(value)
+                	}   
+                }
+                else{
+                	it."$command"()
+                }   
+           }       
+        }
+    }
+}
+
+void executeRoutine() {   
+	def routine = request.JSON?.routine
+    location.helloHome?.execute(routine)
+}
+
+def rgbToHSL(rgb) {
+	def r = rgb.r / 255
+    def g = rgb.g / 255
+    def b = rgb.b / 255
+    def h = 0
+    def s = 0
+    def l = 0
+    
+    def var_min = [r,g,b].min()
+    def var_max = [r,g,b].max()
+    def del_max = var_max - var_min
+    
+    l = (var_max + var_min) / 2
+    
+    if (del_max == 0) {
+            h = 0
+            s = 0
+    } else {
+    	if (l < 0.5) { s = del_max / (var_max + var_min) } 
+        else { s = del_max / (2 - var_max - var_min) }
+
+        def del_r = (((var_max - r) / 6) + (del_max / 2)) / del_max
+        def del_g = (((var_max - g) / 6) + (del_max / 2)) / del_max
+        def del_b = (((var_max - b) / 6) + (del_max / 2)) / del_max
+
+        if (r == var_max) { h = del_b - del_g } 
+        else if (g == var_max) { h = (1 / 3) + del_r - del_b } 
+        else if (b == var_max) { h = (2 / 3) + del_g - del_r }
+        
+		if (h < 0) { h += 1 }
+        if (h > 1) { h -= 1 }
+	}
+    def hsl = [:]    
+    hsl = [h: h * 100, s: s * 100, l: l]
+    
+    hsl
+}
+
+def hexToRgb(colorHex) {
+	def rrInt = Integer.parseInt(colorHex.substring(1,3),16)
+    def ggInt = Integer.parseInt(colorHex.substring(3,5),16)
+    def bbInt = Integer.parseInt(colorHex.substring(5,7),16)
+    
+    def colorData = [:]
+    colorData = [r: rrInt, g: ggInt, b: bbInt]
+    colorData
+}
+
+def installed() {
+	state.heartbeat = false
+}
+
+def updated() {
+	state.heartbeat = false
+}