MSA-1859: For pc control

DVCSMP-2399 Added Zooz ZEN20 DTH

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

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

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

@@ -0,0 +1,43 @@
+# Aeon Multisensor Gen5
+
+Cloud Execution
+
+Works with: 
+
+* [Aeon Labs MultiSensor (Gen 5)](https://www.smartthings.com/works-with-smartthings/sensors/aeon-labs-multisensor-gen-5)
+
+## 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
+* **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 (Gen 5) 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 (Gen 5) Troubleshooting Tips](https://support.smartthings.com/hc/en-us/articles/206157226-Aeon-Labs-MultiSensor-Gen-5-)

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

@@ -20,10 +20,12 @@ metadata {
 		capability "Configuration"
 		capability "Sensor"
 		capability "Battery"
+		capability "Health Check"
 
 		command "configureAfterSecure"
 
 		fingerprint deviceId: "0x0701", inClusters: "0x5E,0x86,0x72,0x59,0x85,0x73,0x71,0x84,0x80,0x30,0x31,0x70,0x98,0x7A", outClusters:"0x5A"
+		fingerprint mfr:"0086", prod:"0102", model:"004A", deviceJoinName: "Aeon Labs MultiSensor (Gen 5)"
 	}
 
 	simulator {
@@ -98,6 +100,11 @@ 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 parse(String description)
 {
 	def result = null
@@ -244,6 +251,13 @@ def configureAfterSecure() {
     secureSequence(request) + ["delay 20000", zwave.wakeUpV1.wakeUpNoMoreInformation().format()]
 }
 
+/**
+ * PING is used by Device-Watch in attempt to reach the Device
+ * */
+def ping() {
+	secure(zwave.batteryV1.batteryGet())
+}
+
 def configure() {
 	// log.debug "configure()"
     //["delay 30000"] + secure(zwave.securityV1.securityCommandsSupportedGet())

devicetypes/smartthings/aeon-siren.src/.st-ignore

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

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

@@ -0,0 +1,37 @@
+# Aeon Siren
+
+Cloud Execution
+
+Works with: 
+
+* [Aeon Labs Siren (Gen 5)](https://www.smartthings.com/works-with-smartthings/aeon-labs/aeon-labs-siren-gen-5)
+
+## Table of contents
+
+* [Capabilities](#capabilities)
+* [Health](#device-health)
+
+## Capabilities
+
+* **Actuator** - represents that a Device has commands
+* **Alarm** - allows for interacting with devices that serve as alarms
+* **Switch** - can detect state (possible values: on/off)
+* **Health Check** - indicates ability to get device health notifications
+
+## Device Health
+
+Aeon Labs Siren (Gen 5) 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 Siren (Gen 5) Troubleshooting Tips](https://support.smartthings.com/hc/en-us/articles/204555240-Aeon-Labs-Siren-Gen-5-)

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

@@ -20,10 +20,11 @@ metadata {
 	capability "Actuator"
 	capability "Alarm"
 	capability "Switch"
+	capability "Health Check"
 
 	command "test"
 
-	fingerprint deviceId: "0x1005", inClusters: "0x5E,0x98"
+	fingerprint deviceId: "0x1005", inClusters: "0x5E,0x98", deviceJoinName: "Aeon Labs Siren (Gen 5)"
  }
 
  simulator {
@@ -58,6 +59,9 @@ 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])
+
 	if(!state.sound) state.sound = 1
 	if(!state.volume) state.volume = 3
 
@@ -148,3 +152,10 @@ def test() {
 private secure(physicalgraph.zwave.Command cmd) {
 	zwave.securityV1.securityMessageEncapsulation().encapsulate(cmd).format()
 }
+
+/**
+ * PING is used by Device-Watch in attempt to reach the Device
+ * */
+def ping() {
+	secure(zwave.basicV1.basicGet())
+}

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

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

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

@@ -0,0 +1,39 @@
+# FortrezZ Water Valve
+
+Cloud Execution
+
+Works with: 
+
+* [FortrezZ Water Valve](https://www.smartthings.com/works-with-smartthings/other/fortrezz-water-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
+* **Refresh** - _refresh()_ command for status updates
+* **Sensor** - detects sensor events
+
+## Device Health
+
+FortrezZ Water Valve 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:
+* [FortrezZ Water Valve Troubleshooting Tips](https://support.smartthings.com/hc/en-us/articles/202088434-FortrezZ-Water-Valve-Shutoff)

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

@@ -14,11 +14,13 @@
 metadata {
 	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"
 	}
 
 	// simulator metadata
@@ -48,6 +50,11 @@ 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 parse(String description) {
 	log.trace description
 	def result = null
@@ -76,6 +83,13 @@ def close() {
 	zwave.switchBinaryV1.switchBinarySet(switchValue: 0xFF).format()
 }
 
+/**
+ * PING is used by Device-Watch in attempt to reach the Device
+ * */
+def ping() {
+	refresh()
+}
+
 def refresh() {
 	zwave.switchBinaryV1.switchBinaryGet().format()
 }

devicetypes/smartthings/logitech-harmony-hub-c2c.src/logitech-harmony-hub-c2c.groovy

@@ -7,6 +7,7 @@ metadata {
 	definition (name: "Logitech Harmony Hub C2C", namespace: "smartthings", author: "SmartThings") {
 		capability "Media Controller"
         capability "Refresh"
+		capability "Health Check"
         
         command "activityoff"   
         command "alloff" 
@@ -38,6 +39,16 @@ metadata {
 	}
 }
 
+def installed() {
+	log.debug "installed()"
+	sendEvent(name: "DeviceWatch-Enroll", value: JsonOutput.toJson([protocol: "cloud", scheme:"untracked"]), displayed: false)
+}
+
+def updated() {
+	log.debug "updated()"
+	sendEvent(name: "DeviceWatch-Enroll", value: JsonOutput.toJson([protocol: "cloud", scheme:"untracked"]), displayed: false)
+}
+
 def startActivity(String activityId) {
 	log.debug "Executing 'Start Activity'"
 	log.trace parent.activity("$device.deviceNetworkId-$activityId","start")    
@@ -58,6 +69,10 @@ def poll() {
 	log.trace parent.poll()
 }
 
+def ping() {
+	refresh()
+}
+
 def refresh() {
 	log.debug "Executing 'Refresh'"
 	log.trace parent.poll()

devicetypes/smartthings/plant-link.src/.st-ignore

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

devicetypes/smartthings/plant-link.src/README.md

@@ -0,0 +1,35 @@
+# Plant Link
+
+Cloud Execution
+
+Works with: 
+
+* [OSO Technologies PlantLink Soil Moisture Sensor](https://www.smartthings.com/works-with-smartthings/oso-technologies/oso-technologies-plantlink-soil-moisture-sensor)
+
+## Table of contents
+
+* [Capabilities](#capabilities)
+* [Health](#device-health)
+* [Troubleshooting](#troubleshooting)
+
+## Capabilities
+
+* **Relative Humidity Measurement** - allows reading the relative humidity from devices that support it
+* **Sensor** - detects sensor events
+* **Battery** - defines device uses a battery
+* **Health Check** - indicates ability to get device health notifications
+
+## Device Health
+
+Plant Link sensor is a Z-wave sleepy device and checks in every 15 minutes.
+Device-Watch allows 2 check-in misses from device plus some lag time. So Check-in interval = (2*15 + 2)mins = 32 mins.
+
+* __122min__ checkInterval
+
+## Troubleshooting
+
+If the device doesn't pair when trying from the SmartThings mobile app, it is possible that the sensor is out of range.
+Pairing needs to be tried again by placing the sensor closer to the hub.
+Instructions related to pairing, resetting and removing the different motion sensors from SmartThings can be found in the following links
+for the different models:
+* [OSO Technologies PlantLink Soil Moisture Sensor Troubleshooting Tips](https://support.smartthings.com/hc/en-us/articles/206868986-PlantLink-Soil-Moisture-Sensor)

devicetypes/smartthings/plant-link.src/plant-link.groovy

@@ -21,8 +21,10 @@ metadata {
 		capability "Relative Humidity Measurement"
 		capability "Battery"
 		capability "Sensor"
+		capability "Health Check"
 
 		fingerprint profileId: "0104", inClusters: "0000,0003,0405,FC08", outClusters: "0003"
+		fingerprint endpoint: "1", profileId: "0104", inClusters: "0000,0001,0003,0B04", outClusters: "0003", manufacturer: "", model: "", deviceJoinName: "OSO Technologies PlantLink Soil Moisture Sensor"
 	}
 
 	tiles {
@@ -48,6 +50,11 @@ metadata {
 	}
 }
 
+def updated() {
+	// Device-Watch allows 2 check-in misses from device
+	sendEvent(name: "checkInterval", value: 2 * 15 * 60 + 2 * 60, displayed: false, data: [protocol: "zigbee", hubHardwareId: device.hub.hardwareID])
+}
+
 // Parse incoming device messages to generate events
 def parse(String description) {
 	log.debug "Parse description $description"

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

@@ -107,6 +107,12 @@ def parse(String description) {
 				}
 			}
 		}
+	} else if (map.name == "temperature") {
+		if (tempOffset) {
+			map.value = (int) map.value + (int) tempOffset
+		}
+		map.descriptionText = temperatureScale == 'C' ? '{{ device.displayName }} was {{ value }}°C' : '{{ device.displayName }} was {{ value }}°F'
+		map.translatable = true
 	}
 
 	log.debug "Parse returned $map"

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

@@ -113,6 +113,12 @@ def parse(String description) {
 				map = getMotionResult(value)
 			}
 		}
+	} else if (map.name == "temperature") {
+		if (tempOffset) {
+			map.value = (int) map.value + (int) tempOffset
+		}
+		map.descriptionText = temperatureScale == 'C' ? '{{ device.displayName }} was {{ value }}°C' : '{{ device.displayName }} was {{ value }}°F'
+		map.translatable = true
 	}
 
 	log.debug "Parse returned $map"

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

@@ -52,7 +52,7 @@ metadata {
 	tiles(scale: 2) {
 		multiAttributeTile(name:"contact", type: "generic", width: 6, height: 4){
 			tileAttribute ("device.contact", key: "PRIMARY_CONTROL") {
-				attributeState "open", label:'${name}', icon:"st.contact.contact.open", backgroundColor:"##e86d13"
+				attributeState "open", label:'${name}', icon:"st.contact.contact.open", backgroundColor:"#e86d13"
 				attributeState "closed", label:'${name}', icon:"st.contact.contact.closed", backgroundColor:"#00a0dc"
 			}
 		}

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

@@ -95,6 +95,12 @@ def parse(String description) {
 				}
 			}
 		}
+	} else if (map.name == "temperature") {
+		if (tempOffset) {
+			map.value = (int) map.value + (int) tempOffset
+		}
+		map.descriptionText = temperatureScale == 'C' ? '{{ device.displayName }} was {{ value }}°C' : '{{ device.displayName }} was {{ value }}°F'
+		map.translatable = true
 	}
 
 	log.debug "Parse returned $map"

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

@@ -88,6 +88,12 @@ def parse(String description) {
 				log.warn "TEMP REPORTING CONFIG FAILED- error code: ${descMap.data[0]}"
 			}
 		}
+	} else if (map.name == "temperature") {
+		if (tempOffset) {
+			map.value = (int) map.value + (int) tempOffset
+		}
+		map.descriptionText = temperatureScale == 'C' ? '{{ device.displayName }} was {{ value }}°C' : '{{ device.displayName }} was {{ value }}°F'
+		map.translatable = true
 	}
 
 	log.debug "Parse returned $map"

devicetypes/smartthings/zooz-power-strip-outlet.src/zooz-power-strip-outlet.groovy

@@ -0,0 +1,41 @@
+/**
+ *  Zooz Power Strip Outlet
+ *
+ *  Copyright 2017 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.
+ *
+ */
+metadata {
+	definition (name: "Zooz Power Strip Outlet", namespace: "smartthings", author: "SmartThings") {
+		capability "Switch"
+		capability "Actuator"
+		capability "Sensor"
+	}
+
+	tiles {
+		multiAttributeTile(name:"switch", type: "lighting", width: 6, height: 4, canChangeIcon: true){
+			tileAttribute ("device.switch", key: "PRIMARY_CONTROL") {
+				attributeState "off", label: '${name}', action: "switch.on", icon: "st.switches.switch.off", backgroundColor: "#ffffff", nextState:"turningOn"
+				attributeState "on", 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:"#00A0DC", nextState:"turningOff"
+				attributeState "turningOff", label:'${name}', action:"switch.on", icon:"st.switches.switch.off", backgroundColor:"#ffffff", nextState:"turningOn"
+			}
+		}
+	}
+}
+
+void on() {
+	parent.childOn(device.deviceNetworkId)
+}
+
+void off() {
+	parent.childOff(device.deviceNetworkId)
+}

devicetypes/smartthings/zooz-power-strip.src/zooz-power-strip.groovy

@@ -0,0 +1,210 @@
+/**
+ *  Zooz ZEN20 Power Strip Outlet
+ *
+ *  Implementation of the Zooz ZEN20 power strip that uses the new composite device capabilities to provide individual
+ *  control of each outlet from SmartApps as well as the mobile app. Incorporates contributions from:
+ *
+ *  Eric Maycock (https://github.com/erocm123/SmartThingsPublic/blob/master/devicetypes/erocm123/zooz-power-strip.src/zooz-power-strip.groovy)
+ *  Robert Vandervoort (https://github.com/robertvandervoort/SmartThings/blob/master/zooZ-Strip-ZEN20/device_type-zooZ-strip-ZEN20_v1.0)
+ *
+ *  Copyright 2017 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.
+ *
+ */
+metadata {
+	definition (name: "Zooz Power Strip", namespace: "smartthings", author: "SmartThings") {
+		capability "Switch"
+		capability "Refresh"
+		capability "Actuator"
+		capability "Sensor"
+
+		fingerprint manufacturer: "015D", prod: "0651", model: "F51C", deviceJoinName: "Zooz ZEN 20 Power Strip"
+	}
+
+	tiles {
+		multiAttributeTile(name:"switch", type: "lighting", width: 6, height: 4, canChangeIcon: true){
+			tileAttribute ("device.switch", key: "PRIMARY_CONTROL") {
+				attributeState "off", label: '${name}', action: "switch.on", icon: "st.switches.switch.off", backgroundColor: "#ffffff", nextState:"turningOn"
+				attributeState "on", 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:"#00A0DC", nextState:"turningOff"
+				attributeState "turningOff", label:'${name}', action:"switch.on", icon:"st.switches.switch.off", backgroundColor:"#ffffff", nextState:"turningOn"
+			}
+		}
+		childDeviceTiles("outlets")
+		standardTile("refresh", "device.switch", width: 1, height: 1, inactiveLabel: false, decoration: "flat") {
+			state "default", label:'', action:"refresh.refresh", icon:"st.secondary.refresh"
+		}
+	}
+}
+
+/////////////////////////////
+// Installation and update //
+/////////////////////////////
+def installed() {
+	createChildDevices()
+}
+
+def updated() {
+	if (!childDevices) {
+		createChildDevices()
+	}
+	else if (device.label != state.oldLabel) {
+		childDevices.each {
+			def newLabel = "${device.displayName} (CH${channelNumber(it.deviceNetworkId)})"
+			it.setLabel(newLabel)
+		}
+		state.oldLabel = device.label
+	}
+}
+
+
+//////////////////////
+// Event Generation //
+//////////////////////
+def parse(String description) {
+	trace "parse('$description')"
+	def result = []
+	if (description.startsWith("Err")) {
+		result = createEvent(descriptionText:description, isStateChange:true)
+	} else if (description != "updated") {
+		def cmd = zwave.parse(description, [0x60: 3, 0x32: 3, 0x25: 1, 0x20: 1])
+		if (cmd) {
+			result += zwaveEvent(cmd, 1)
+		}
+		else {
+			log.warn "Unparsed description $description"
+		}
+	}
+	result
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.multichannelv3.MultiChannelCmdEncap cmd, ep) {
+	def encapsulatedCommand = cmd.encapsulatedCommand([0x32: 3, 0x25: 1, 0x20: 1])
+	if (encapsulatedCommand) {
+		zwaveEvent(encapsulatedCommand, cmd.sourceEndPoint as Integer)
+	}
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.basicv1.BasicReport cmd, endpoint) {
+	trace "zwaveEvent(physicalgraph.zwave.commands.basicv1.BasicReport $cmd, $endpoint)"
+	zwaveBinaryEvent(cmd, endpoint)
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.switchbinaryv1.SwitchBinaryReport cmd, endpoint) {
+	trace "zwaveEvent(physicalgraph.zwave.commands.switchbinaryv1.SwitchBinaryReport $cmd, $endpoint)"
+	zwaveBinaryEvent(cmd, endpoint)
+}
+
+def zwaveBinaryEvent(cmd, endpoint) {
+	def result = []
+	def children = childDevices
+	def childDevice = children.find{it.deviceNetworkId.endsWith("$endpoint")}
+	childDevice.sendEvent(name: "switch", value: cmd.value ? "on" : "off")
+
+	if (cmd.value) {
+		// One on and the strip is on
+		result << createEvent(name: "switch", value: "on")
+	} else {
+		// All off and the strip is off
+		if (! children.any { it.currentValue("switch") == "on" }) {
+			result  << createEvent(name: "switch", value: "off")
+		}
+	}
+	result
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.manufacturerspecificv2.ManufacturerSpecificReport cmd, ep) {
+	updateDataValue("MSR", String.format("%04X-%04X-%04X", cmd.manufacturerId, cmd.productTypeId, cmd.productId))
+	return null
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.versionv1.VersionReport cmd, ep) {
+	trace "applicationVersion $cmd.applicationVersion"
+}
+
+def zwaveEvent(physicalgraph.zwave.Command cmd, ep) {
+	log.warn("${device.displayName}: Unhandled ${cmd}" + (ep ? " from endpoint $ep" : ""))
+}
+
+/////////////////////////////
+// Installation and update //
+/////////////////////////////
+def on() {
+	def cmds = []
+	def cmd = zwave.switchBinaryV1.switchBinarySet(switchValue: 0xFF)
+	cmds << zwave.multiChannelV3.multiChannelCmdEncap(bitAddress: true, destinationEndPoint:0x1F).encapsulate(cmd).format()
+	cmds << "delay 400"
+	cmds.addAll(refresh())
+	return cmds
+}
+
+def off() {
+	def cmds = []
+	def cmd = zwave.switchBinaryV1.switchBinarySet(switchValue: 0x00)
+	cmds << zwave.multiChannelV3.multiChannelCmdEncap(bitAddress: true, destinationEndPoint:0x1F).encapsulate(cmd).format()
+	cmds << "delay 400"
+	cmds.addAll(refresh())
+	return cmds
+}
+
+//////////////////////
+// Child Device API //
+//////////////////////
+void childOn(String dni) {
+	onOffCmd(0xFF, channelNumber(dni))
+}
+
+void childOff(String dni) {
+	onOffCmd(0, channelNumber(dni))
+}
+
+def refresh() {
+	def cmds = (1..5).collect { endpoint ->
+		encap(zwave.switchBinaryV1.switchBinaryGet(), endpoint)
+	}
+	delayBetween(cmds, 100)
+}
+
+///////////////////
+// Local Methods //
+///////////////////
+private channelNumber(String dni) {
+	dni.split("-ep")[-1] as Integer
+}
+
+private void onOffCmd(value, endpoint = null) {
+	def actions = [
+			new physicalgraph.device.HubAction(encap(zwave.basicV1.basicSet(value: value), endpoint)),
+			new physicalgraph.device.HubAction(encap(zwave.switchBinaryV1.switchBinaryGet(), endpoint)),
+	]
+	sendHubCommand(actions, 500)
+}
+
+private void createChildDevices() {
+	state.oldLabel = device.label
+	for (i in 1..5) {
+		addChildDevice("Zooz Power Strip Outlet", "${device.deviceNetworkId}-ep${i}", null,
+				[completedSetup: true, label: "${device.displayName} (CH${i})",
+				 isComponent: true, componentName: "ch$i", componentLabel: "Channel $i"])
+	}
+}
+
+private encap(cmd, endpoint) {
+	if (endpoint) {
+		zwave.multiChannelV3.multiChannelCmdEncap(destinationEndPoint:endpoint).encapsulate(cmd).format()
+	} else {
+		cmd.format()
+	}
+}
+
+private trace(msg) {
+	//log.trace(msg)
+}

devicetypes/smartthings/zwave-garage-door-opener.src/.st-ignore

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

devicetypes/smartthings/zwave-garage-door-opener.src/README.md

@@ -0,0 +1,41 @@
+# Z-wave Garage Door Opener
+
+Cloud Execution
+
+Works with: 
+
+* [Linear GoControl Garage Door Opener](https://www.smartthings.com/works-with-smartthings/other/linear-gocontrol-garage-door-opener)
+
+## Table of contents
+
+* [Capabilities](#capabilities)
+* [Health](#device-health)
+* [Troubleshooting](#troubleshooting)
+
+## Capabilities
+
+* **Actuator** - represents that a Device has commands
+* **Door Control** - allow for the control of a door
+* **Garage Door Control** - allow for the control of a garage door
+* **Health Check** - indicates ability to get device health notifications
+* **Contact Sensor** - can detect contact (with possible values - open/closed)
+* **Refresh** - _refresh()_ command for status updates
+* **Sensor** - detects sensor events
+
+## Device Health
+
+Linear GoControl Garage Door Opener 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:
+* [Linear GoControl Garage Door Opener Troubleshooting Tips](https://support.smartthings.com/hc/en-us/articles/204831116-GoControl-Linear-Garage-Door-Opener-GD00Z-4-)

devicetypes/smartthings/zwave-garage-door-opener.src/zwave-garage-door-opener.groovy

@@ -18,12 +18,14 @@ metadata {
 		capability "Actuator"
 		capability "Door Control"
 		capability "Garage Door Control"
+		capability "Health Check"
 		capability "Contact Sensor"
 		capability "Refresh"
 		capability "Sensor"
 
 		fingerprint deviceId: "0x4007", inClusters: "0x98"
 		fingerprint deviceId: "0x4006", inClusters: "0x98"
+		fingerprint mfr:"014F", prod:"4744", model:"3030", deviceJoinName: "Linear GoControl Garage Door Opener"
 	}
 
 	simulator {
@@ -63,6 +65,11 @@ metadata {
 
 import physicalgraph.zwave.commands.barrieroperatorv1.*
 
+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 parse(String description) {
 	def result = null
 	if (description.startsWith("Err")) {
@@ -287,6 +294,13 @@ def close() {
 	secure(zwave.barrierOperatorV1.barrierOperatorSet(requestedBarrierState: BarrierOperatorSet.REQUESTED_BARRIER_STATE_CLOSE))
 }
 
+/**
+ * PING is used by Device-Watch in attempt to reach the Device
+ * */
+def ping() {
+	refresh()
+}
+
 def refresh() {
 	secure(zwave.barrierOperatorV1.barrierOperatorGet())
 }

devicetypes/smartthings/zwave-lock.src/.st-ignore

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

devicetypes/smartthings/zwave-lock.src/README.md

@@ -0,0 +1,45 @@
+# Z-Wave Switch
+
+Cloud Execution
+
+Works with: 
+
+* [Yale Key Free Touchscreen Deadbolt (YRD240)](https://www.smartthings.com/works-with-smartthings/yale/yale-key-free-touchscreen-deadbolt-yrd240)
+
+
+## Table of contents
+
+* [Capabilities](#capabilities)
+* [Health](#device-health)
+* [Troubleshooting](#Troubleshooting)
+
+## Capabilities
+
+* **Actuator** - represents that a Device has commands
+* **Battery** - defines device uses a battery
+* **Lock** - allows for the control of a lock device
+* **Lock Codes** - allows for the lock code control of a lock device
+* **Polling** - represents that poll() can be implemented for the device
+* **Refresh** - _refresh()_ command for status updates
+* **Sensor** - detects sensor events
+* **Health Check** - indicates ability to get device health notifications
+
+## Device Health
+
+Z-Wave Locks are 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:
+* [General Z-Wave/ZigBee Yale Lock Troubleshooting](https://support.smartthings.com/hc/en-us/articles/205138400-How-to-connect-Yale-locks)
+
+

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

@@ -20,11 +20,13 @@ metadata {
 		capability "Sensor"
 		capability "Lock Codes"
 		capability "Battery"
+		capability "Health Check"
 
 		command "unlockwtimeout"
 
 		fingerprint deviceId: "0x4003", inClusters: "0x98"
 		fingerprint deviceId: "0x4004", inClusters: "0x98"
+		fingerprint mfr:"0129", prod:"0002", model:"0000", deviceJoinName: "Yale Key Free Touchscreen Deadbolt"
 	}
 
 	simulator {
@@ -67,6 +69,8 @@ import physicalgraph.zwave.commands.doorlockv1.*
 import physicalgraph.zwave.commands.usercodev1.*
 
 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])
 	try {
 		if (!state.init) {
 			state.init = true
@@ -504,6 +508,13 @@ def unlockwtimeout() {
 	lockAndCheck(DoorLockOperationSet.DOOR_LOCK_MODE_DOOR_UNSECURED_WITH_TIMEOUT)
 }
 
+/**
+ * PING is used by Device-Watch in attempt to reach the Device
+ * */
+def ping() {
+	refresh()
+}
+
 def refresh() {
 	def cmds = [secure(zwave.doorLockV1.doorLockOperationGet())]
 	if (state.assoc == zwaveHubNodeId) {

devicetypes/smartthings/zwave-metering-switch.src/zwave-metering-switch.groovy

@@ -22,10 +22,12 @@ metadata {
 		capability "Configuration"
 		capability "Sensor"
 		capability "Light"
+		capability "Health Check"
 
 		command "reset"
 
 		fingerprint inClusters: "0x25,0x32"
+		fingerprint mfr:"0086", prod:"0003", model:"0012", deviceJoinName: "Aeon Labs Micro Smart Switch 2E"
 	}
 
 	// simulator metadata
@@ -73,6 +75,8 @@ 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])
 	try {
 		if (!state.MSR) {
 			response(zwave.manufacturerSpecificV2.manufacturerSpecificGet().format())
@@ -179,6 +183,14 @@ def poll() {
 	])
 }
 
+/**
+ * PING is used by Device-Watch in attempt to reach the Device
+ * */
+def ping() {
+	log.debug "ping() called"
+	refresh()
+}
+
 def refresh() {
 	delayBetween([
 		zwave.switchBinaryV1.switchBinaryGet().format(),

devicetypes/smartthings/zwave-siren.src/.st-ignore

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

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

@@ -0,0 +1,42 @@
+# Z-wave Siren
+
+Cloud Execution
+
+Works with: 
+
+* [FortrezZ Siren Strobe Alarm](https://www.smartthings.com/works-with-smartthings/other/fortrezz-water-valve)
+
+## Table of contents
+
+* [Capabilities](#capabilities)
+* [Health](#device-health)
+* [Troubleshooting](#troubleshooting)
+
+## Capabilities
+
+* **Actuator** - represents that a Device has commands
+* **Alarm** - allows for interacting with devices that serve as alarms
+* **Battery** - defines device uses a battery
+* **Health Check** - indicates ability to get device health notifications
+* **Polling** - represents that poll() can be implemented for the device
+* **Refresh** - _refresh()_ command for status updates
+* **Sensor** - detects sensor events
+* **Switch** - can detect state (possible values: on/off)
+
+## Device Health
+
+FortrezZ Siren Strobe Alarm 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:
+* [FortrezZ Siren Strobe Alarm Troubleshooting Tips](https://support.smartthings.com/hc/en-us/articles/202294760-FortrezZ-Siren-Strobe-Alarm)

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

@@ -20,6 +20,7 @@ metadata {
 		capability "Actuator"
         capability "Alarm"
         capability "Battery"
+		capability "Health Check"
         capability "Polling"
         capability "Refresh"
         capability "Sensor"
@@ -27,6 +28,7 @@ metadata {
 
 
 		fingerprint inClusters: "0x20,0x25,0x86,0x80,0x85,0x72,0x71"
+		fingerprint mfr:"0084", prod:"0313", model:"010B", deviceJoinName: "FortrezZ Siren Strobe Alarm"
 	}
 
 	simulator {
@@ -58,6 +60,11 @@ 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 createEvents(physicalgraph.zwave.commands.batteryv1.BatteryReport cmd) {
 	def map = [ name: "battery", unit: "%" ]
 	if (cmd.batteryLevel == 0xFF) {
@@ -119,6 +126,13 @@ def both() {
 	on()
 }
 
+/**
+ * PING is used by Device-Watch in attempt to reach the Device
+ * */
+def ping() {
+	refresh()
+}
+
 def refresh() {
 	log.debug "sending battery refresh command"
 	zwave.batteryV1.batteryGet().format()

devicetypes/smartthings/zwave-smoke-alarm.src/.st-ignore

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

devicetypes/smartthings/zwave-smoke-alarm.src/README.md

@@ -0,0 +1,40 @@
+# Z-wave Smoke Alarm
+
+Cloud Execution
+
+Works with: 
+
+* [First Alert Smoke Detector and Carbon Monoxide Alarm (ZCOMBO)](https://www.smartthings.com/works-with-smartthings/sensors/first-alert-smoke-detector-and-carbon-monoxide-alarm-zcombo)
+
+## Table of contents
+
+* [Capabilities](#capabilities)
+* [Health](#device-health)
+* [Battery](#battery-specification)
+* [Troubleshooting](#troubleshooting)
+
+## Capabilities
+
+* **Smoke Detector** - measure smoke and optionally carbon monoxide levels
+* **Carbon Monoxide Detector** - measure carbon monoxide levels
+* **Sensor** - detects sensor events
+* **Battery** - defines device uses a battery
+* **Health Check** - indicates ability to get device health notifications
+
+## Device Health
+
+First Alert Smoke Detector and Carbon Monoxide Alarm (ZCOMBO) is a Z-wave sleepy device and checks in every 1 hour.
+Device-Watch allows 2 check-in misses from device plus some lag time. So Check-in interval = (2*60 + 2)mins = 122 mins.
+
+* __122min__ checkInterval
+
+## Battery Specification
+
+Two AA 1.5V batteries are required.
+
+## 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:
+* [First Alert Smoke Detector and Carbon Monoxide Alarm (ZCOMBO) Troubleshooting Tips](https://support.smartthings.com/hc/en-us/articles/201581984-First-Alert-Smoke-Detector-and-Carbon-Monoxide-Alarm-ZCOMBO-)

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

@@ -17,10 +17,12 @@ metadata {
 		capability "Carbon Monoxide Detector"
 		capability "Sensor"
 		capability "Battery"
+		capability "Health Check"
 
 		attribute "alarmState", "string"
 
 		fingerprint deviceId: "0xA100", inClusters: "0x20,0x80,0x70,0x85,0x71,0x72,0x86"
+		fingerprint mfr:"0138", prod:"0001", model:"0002", deviceJoinName: "First Alert Smoke Detector and Carbon Monoxide Alarm (ZCOMBO)"
 	}
 
 	simulator {
@@ -51,6 +53,11 @@ metadata {
 	}
 }
 
+def updated(){
+// Device checks in every hour, this interval allows us to miss one check-in notification before marking offline
+	sendEvent(name: "checkInterval", value: 2 * 60 * 60 + 2 * 60, displayed: false, data: [protocol: "zwave", hubHardwareId: device.hub.hardwareID])
+}
+
 def parse(String description) {
 	def results = []
 	if (description.startsWith("Err")) {
@@ -65,7 +72,6 @@ def parse(String description) {
 	return results
 }
 
-
 def createSmokeOrCOEvents(name, results) {
 	def text = null
 	switch (name) {

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

@@ -20,6 +20,7 @@ metadata {
 		capability "Configuration"
 		capability "Polling"
 		capability "Sensor"
+		capability "Health Check"
 		
 		attribute "thermostatFanState", "string"
 
@@ -30,6 +31,7 @@ metadata {
 
 		fingerprint deviceId: "0x08"
 		fingerprint inClusters: "0x43,0x40,0x44,0x31"
+		fingerprint mfr:"0039", prod:"0011", model:"0001", deviceJoinName: "Honeywell Z-Wave Thermostat"
 	}
 
 	// simulator metadata
@@ -123,6 +125,11 @@ 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 parse(String description)
 {
 	def map = createEvent(zwaveEvent(zwave.parse(description, [0x42:1, 0x43:2, 0x31: 3])))
@@ -393,6 +400,14 @@ 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"
+	poll()
+}
+
 def configure() {
 	delayBetween([
 		zwave.thermostatModeV2.thermostatModeSupportedGet().format(),

smartapps/smartthings/logitech-harmony-connect.src/logitech-harmony-connect.groovy

@@ -511,6 +511,10 @@ def pollResponse(response, data) {
 			if (ResponseValues) {
         def map = [:]
         ResponseValues.hubs.each {
+        // Device-Watch relies on the Logitech Harmony Cloud to get the Device state.
+        def isAlive = it.value.status
+        def d = getChildDevice("harmony-${it.key}")
+        d?.sendEvent(name: "DeviceWatch-DeviceStatus", value: isAlive!=504? "online":"offline", displayed: false, isStateChange: true)
         if (it.value.message == "OK") {
               map["${it.key}"] = "${it.value.response.data.currentAvActivity},${it.value.response.data.activityStatus}"
               def hub = getChildDevice("harmony-${it.key}")

smartapps/torick-net/smartthingstostart.src/smartthingstostart.groovy

@@ -0,0 +1,373 @@
+/**
+ *  SmartThingsToStart REST Api
+ *
+ *  Copyright 2017 Dr1rrb
+ *
+ *  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: "SmartThingsToStart",
+	namespace: "torick.net",
+	author: "Dr1rrb",
+	description: "SmartThingsToStart REST Api",
+	category: "My Apps",
+	iconUrl: "http://smartthingstostartproxy.azurewebsites.net/Assets/AppLogo.png",
+	iconX2Url: "http://smartthingstostartproxy.azurewebsites.net/Assets/AppLogo@2X.png",
+	iconX3Url: "http://smartthingstostartproxy.azurewebsites.net/Assets/AppLogo@3X.png",
+	oauth: true)
+
+
+preferences {
+	section("Control these devices") {
+		input "switches", "capability.switch", title: "Select switches", multiple: true, required: false
+		input "bubls", "capability.bulb", title: "Select bubls", hideWhenEmpty: true, multiple: true, required: false
+		input "lights", "capability.light", title: "Select lights", hideWhenEmpty: true, multiple: true, required: false
+		input "outlets", "capability.outlet", title: "Select outlets", hideWhenEmpty: true, multiple: true, required: false
+		input "relaySwitches", "capability.relaySwitch", title: "Select relay switches", hideWhenEmpty: true, multiple: true, required: false
+	}
+}
+
+mappings {
+	path("/infos") {
+		action: [GET: "retreiveServerInfos"]
+  	}
+    path("/items") {
+		action: [GET: "retreiveDevicesAndRoutines"]
+  	}
+	path("/device/:id") {
+		action: [GET: "retreiveDevice"]
+	}
+	path("/device/:id/subscription/:subscriptionId") {
+		action: [
+			PUT: "updateOrCreateSubscription",
+			POST: "updateOrCreateSubscription",
+		]
+	}
+    // TODO
+	//path("/device/:id/unsubscribe") {
+	//	action: [POST: "unsubscribeFromDevice"]
+	//}
+	path("/device/:id/:command") {
+		action: [ PUT: "updateDevice" ]
+	}
+    path("/routine/:id/execute") {
+		action: [PUT: "executeRoutine"]
+	}
+}
+
+// Region: App lifecycle
+def installed() {
+	log.debug "Installed with settings: ${settings}"
+
+	initialize()
+}
+
+def updated() {
+	log.debug "Updated with settings: ${settings}"
+
+	unsubscribe()
+    //state.pushChannels = [:]
+	initialize()
+}
+
+def initialize() {
+	def channels = state.pushChannels = state.pushChannels ?: [:];
+	channels.each 
+	{ 
+		def device = findDevice(it.key);
+		if (device != null)
+		{
+			subscribeToDevice(device);
+		}
+	}
+}
+
+
+// Region: Http request handlers
+def retreiveServerInfos()
+{
+	return [version: 1]
+}
+
+def retreiveDevicesAndRoutines() {
+	def details = params.details == "true" ? true : false;
+
+	return [
+		devices: getDevices().collect { getDeviceInfos(it, details) }, 
+		routines: location.helloHome?.getPhrases().collect { getRoutineInfos(it, details) }
+	];
+}
+
+def retreiveDevice() {
+	def device = getDevice(params.id);
+	def details = params.details == "true" ? true : false;
+	
+	return getDeviceInfos(device, details);
+}
+
+def updateOrCreateSubscription() {
+	def device = getDevice(params.id);
+	def channelUri = notNull("channelUri", request.JSON?.channelUri);
+	def token = notNull("token", request.JSON?.token);
+	
+	log.debug "Subscribing to device '${device.id}' (target: '${channelUri}' / token: '${token}')"
+
+	// Get or create the push notification channel from / into the local state
+	def subscriptionId = params.subscriptionId ?: UUID.randomUUID().toString() ;
+	def allSubscriptions = state.pushChannels ?: (state.pushChannels = [:]);
+	def deviceSubscriptions = allSubscriptions[device.id] ?: (allSubscriptions[device.id] = []);
+	def subscription = deviceSubscriptions.find { it.id == subscriptionId };
+	if (subscription == null)
+	{
+		deviceSubscriptions << [
+			id: subscriptionId,
+			deviceId: device.id,
+			channelUri: channelUri,
+			token: token
+		];
+	}
+	else
+	{
+		subscription["channelUri"] = channelUri;
+		subscription["token"]  = token;
+	}
+	
+	log.debug "Active subscriptions: \n" + state.pushChannels.collect { "** Device ${it.key} **\n" + it.value.collect{c -> "- - - > ${c.channelUri} : ${c.token.substring(0, 10)}..."}.join('\n') + "\n***************************" }.join('\n\n')
+	
+	// (Re)create the subscription(s)
+	subscribeToDevice(device)
+
+	return [subscriptionId: subscriptionId];
+}
+
+def subscribeToDevice(device)
+{
+	log.debug "Subscribing to device '${device.id}'"
+
+	unsubscribe(device);
+	subscribe(device, "switch", switchStateChanged)
+
+	if (device.hasCapability("Color Control"))
+	{
+		log.debug "Device '${device.id}' has also the color capability. Subscribe to it."
+		subscribe(device, "color", colorStateChanged)
+	}
+}
+
+def switchStateChanged(eventArgs) { sendPushNotification("switch", eventArgs) }
+def colorStateChanged(eventArgs) { sendPushNotification("color", eventArgs) }
+
+def updateDevice() {
+	def device = getDevice(params.id)
+	def command = notNull("command", params.command)
+	
+	log.debug "Executing '${command}' on device '${device.id}'."
+	
+	switch(command) {
+		case "on":
+		case "On":
+			device.on()
+			break
+
+		case "off":
+		case "Off":
+			device.off()
+			break
+
+		case "toggle":
+		case "Toggle":
+			if (device.currentSwitch == "on")
+				device.off();
+			else
+				device.on();
+			break;
+
+		default:
+			httpError(501, "'${command}' is not a valid command for '${device.id}'")
+	}
+	
+	return getDeviceInfos(device);
+}
+
+def executeRoutine() {
+	def routine = getRoutine(params.id);
+    log.debug "Executing routine '${routine.id}' (${routine.label})"
+    
+    location.helloHome?.execute(routine.id)
+}
+
+// Region: Get device
+def getDevices()
+{
+	return switches
+		+ bubls
+		+ lights
+		+ outlets
+		+ relaySwitches;
+}
+
+def findDevice(deviceId)
+{
+	notNull("deviceId", deviceId);
+	
+	return getDevices().find { it.id == deviceId };
+}
+
+def getDevice(deviceId)
+{
+	def device = findDevice(deviceId);
+	if (device == null)
+	{
+		httpError(404, "Device '${deviceId}' not found.")
+	}
+	return device;
+}
+
+// Region: Get routine
+def findRoutine(routineId)
+{
+	return location.helloHome?.getPhrases().find{ it.id == routineId};
+}
+
+def getRoutine(routineId)
+{
+	def routine = findRoutine(routineId);
+	if (routine == null)
+	{
+		httpError(404, "Routine '${routineId}' not found.")
+	}
+	return routine;
+}
+
+// Region: Parameters assertion helpers
+def notNull(parameterName, value)
+{
+	if(value == null || value == "")
+	{
+		httpError(404, "Missing parameter '${parameterName}'.")
+	}
+	return value;
+}
+
+// Region: Get infos
+def getDeviceInfos(device, details = false)
+{
+   	def infos = [
+		id: device.id,
+		name: device.displayName,
+		state: device.currentValue("switch"),
+        color: device.currentValue("color"),
+        hue: device.currentValue("hue"),
+        saturation: device.currentValue("saturation"),
+		capabilities: device.capabilities.collect { getCapabilityInfos(it, details) }
+	]
+	
+	if (details)
+	{
+		infos["attributes"] = device.supportedAttributes.collect { getAttributeInfos(it, details) }
+		infos["commands"] = device.supportedCommands.collect { getCommandInfos(it, details) }
+	}
+	
+	return infos;
+}
+
+def getCapabilityInfos(capablity, details = false)
+{
+	def infos = [name: capablity.name]
+	
+	if(details)
+	{
+		infos["attributes"] = capablity.attributes.collect { getAttributeInfos(it, details) }
+		infos["commands"] = capablity.commands.collect { getCommandInfos(it, details) }
+	}
+	
+	return infos;
+}
+
+def getCommandInfos(command, details = false)
+{
+	return [
+		name: command.name, 
+		arguments: command.arguments
+	]
+}
+
+def getAttributeInfos(attribute, details = false)
+{
+	return [
+		name: attribute.name, 
+		arguments: attribute.dataType,
+		values: attribute.values
+	]
+}
+
+def getRoutineInfos(routine, details = false)
+{
+	def infos = [
+    	id: routine.id,
+        name: routine.label
+	];
+    
+    if (details)
+    {
+    	infos["hasSecureActions"] = routine.hasSecureActions;
+        infos["action"] = routine.action;
+    }
+    
+    return infos;
+}
+
+// Region: Push notification
+def sendPushNotification(capability, eventArgs)
+{
+	def deviceId = eventArgs.deviceId;
+	log.debug "Received notification for '${capability}' for device '${deviceId}'.";
+	
+	def subscriptions = state.pushChannels.get(deviceId);
+	if (subscriptions == null || subscriptions.empty)
+	{
+		log.error "No subscription found for device ${deviceId}, unsubscribing!";
+		unsubscribe(eventArgs.device);
+		
+		return;
+	}
+
+	subscriptions.groupBy { it.channelUri }.each { sendPushNotification(capability, eventArgs, it.key, it.value) }
+}
+
+def sendPushNotification(capability, eventArgs, channelUri, subscriptions)
+{
+	try {
+		def request = [
+			uri: channelUri,
+			//headers: [name: "Authorization", value: "Bearer ${subscription.token}"],
+			body: [
+				location: [
+					id: eventArgs.locationId,
+				],
+				device: getDeviceInfos(eventArgs.device),
+				event: [
+					source: capability, 
+					date: eventArgs.isoDate, 
+					value: eventArgs.value,
+					name: eventArgs.name,
+				],
+				subscriptions: subscriptions.collect { [id: it.id, token: it.token] }
+			]
+		]
+		
+		// Async post is still in beta stage ...
+		httpPostJson(request) { resp -> log.debug "response: ${resp.status}." }
+		
+	} catch (e) {
+		log.error "Failed to push notification: ${e}"
+	}
+}