MSA-1588: my home monitoring

MSA-1587: New Device Handle for Osram Lightify Light(ZLL)

devicetypes/keybounce/lannouncer-alerter.src/lannouncer-alerter.groovy

@@ -0,0 +1,360 @@
+/**
+ *  LANnouncer Alerter (Formerly LANdroid - but Google didn't like that much.)
+ *
+ *  Requires the LANnouncer android app; https://play.google.com/store/apps/details?id=com.keybounce.lannouncer
+ *  See http://www.keybounce.com/LANdroidHowTo/LANdroid.html for full downloads and instructions.
+ *  SmartThings thread: https://community.smartthings.com/t/android-as-a-speech-alarm-device-released/30282/12
+ *  
+ * Note: Only Siren and Strobe from the U.I. or Alarm capabilities default to continuous.
+ *
+ *  Version 1.25 22 July 2016
+ * 
+ *
+ *  Copyright 2015-2016 Tony McNamara
+ *
+ *  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.
+ *
+ * To Do: Add string return to Image Capture attribute
+ *
+ */
+
+metadata {
+    definition (name: "LANnouncer Alerter", namespace: "KeyBounce", author: "Tony McNamara") {
+        capability "Alarm"
+        capability "Speech Synthesis"
+        capability "Notification"
+        capability "Tone"
+        capability "Image Capture"
+        attribute  "LANdroidSMS","string"
+        /* Per http://docs.smartthings.com/en/latest/device-type-developers-guide/overview.html#actuator-and-sensor */
+        capability "Sensor"
+        capability "Actuator"
+
+        // Custom Commands
+        /** Retrieve image, formatted for SmartThings, from camera by name. */
+        command "chime"
+        command "doorbell"
+        command "ipCamSequence", ["number"]
+        command "retrieveAndWait", ["string"]
+        command "retrieveFirstAndWait"
+        command "retrieveSecondAndWait"
+    }
+    preferences {
+        input("DeviceLocalLan", "string", title:"Android IP Address", description:"Please enter your tablet's I.P. address", defaultValue:"" , required: false, displayDuringSetup: true)
+        input("DevicePort", "string", title:"Android Port", description:"Port the Android device listens on", defaultValue:"1035", required: false, displayDuringSetup: true)
+        input("ReplyOnEmpty", "bool", title:"Say Nothing", description:"When no speech is found, announce LANdroid?  (Needed for the speech and notify tiles to work)", defaultValue: true, displayDuringSetup: true)
+        input("AlarmContinuous", "bool", title:"Continuous Alarm (vs 10 sec.)", description: "When on, the alarm will sound until Stop is issued.", defaultValue: false, displayDuringSetup: true)
+    }
+
+    simulator {
+        // reply messages
+        ["strobe","siren","both","off"].each 
+            {
+                reply "$it": "alarm:$it"
+            }
+    }
+
+    tiles {
+        standardTile("alarm", "device.alarm", width: 2, height: 2) {
+            state "off", label:'off', action:'alarm.both', icon:"st.alarm.alarm.alarm", backgroundColor:"#ffffff"
+            state "strobe", label:'strobe!', action:'alarm.off', icon:"st.Lighting.light11", backgroundColor:"#e86d13"
+            state "siren", label:'siren!', action:'alarm.off', icon:"st.alarm.alarm.alarm", backgroundColor:"#e86d13"
+            state "both", label:'alarm!', action:'alarm.off', icon:"st.alarm.alarm.alarm", backgroundColor:"#e86d13"
+        }
+        standardTile("strobe", "device.alarm", inactiveLabel: false, decoration: "flat") {
+            state "default", label:'', action:"alarm.strobe", icon:"st.secondary.strobe"
+        }
+        
+        standardTile("siren", "device.alarm", inactiveLabel: false, decoration: "flat") {
+            state "default", label:'', action:"alarm.siren", icon:"st.secondary.siren"
+        }
+        standardTile("off", "device.alarm", inactiveLabel: false, decoration: "flat") {
+            state "default", label:'Off', action:"alarm.off", icon:"st.quirky.spotter.quirky-spotter-sound-off"
+        }       
+        
+        /* Apparently can't show image attributes on tiles. */
+        standardTile("take", "device.image", width: 1, height: 1, canChangeIcon: false, canChangeBackground: false) 
+        {
+            state "take", label: "Take", action: "Image Capture.take", icon: "st.camera.camera", backgroundColor: "#FFFFFF", nextState:"taking"
+            state "taking", label:'Taking', action: "", icon: "st.camera.take-photo", backgroundColor: "#53a7c0"
+            state "image", label: "Take", action: "Image Capture.take", icon: "st.camera.camera", backgroundColor: "#FFFFFF", nextState:"taking"
+        }
+
+        
+        standardTile("speak", "device.speech", inactiveLabel: false, decoration: "flat") 
+        {
+            state "default", label:'Speak', action:"Speech Synthesis.speak", icon:"st.Electronics.electronics13"
+        }
+        standardTile("toast", "device.notification", inactiveLabel: false, decoration: "flat") {
+            state "default", label:'Notify', action:"notification.deviceNotification", icon:"st.Kids.kids1"
+        }
+        standardTile("beep", "device.tone", inactiveLabel: false, decoration: "flat") {
+            state "default", label:'Tone', action:"tone.beep", icon:"st.Entertainment.entertainment2"
+        }
+        carouselTile("cameraDetails", "device.image", width: 3, height: 2) { }
+
+        main (["alarm", "take"]);
+        details(["alarm","strobe","siren","off","speak", "take","toast","beep", "cameraDetails"]);
+    }
+}
+
+/** Generally matches TTSServer/app/build.gradle */
+String getVersion() {return "24 built July 2016";}
+
+
+/** Alarm Capability, Off.
+ *  Turns off both the strobe and the alarm.
+ *  Necessary when in continuous mode. 
+ */
+def off() {
+    log.debug "Executing 'off'"
+    sendEvent(name:"alarm", value:"off")
+    def command="&ALARM=STOP&FLASH=STOP&"+getDoneString();
+    return sendCommands(command)
+}
+
+/** Alarm Capability: Strobe
+ *  Flashes the camera light, if any.
+ */
+def strobe() {
+    log.debug "Executing 'strobe'"
+    // For illustration, switch to siren and sendEvent after.
+    def command= (AlarmContinuous?"&FLASH=CONTINUOUS&":"&FLASH=STROBE&")+getDoneString();
+    // def command=(AlarmContinuous?"&ALARM=SIREN:CONTINUOUS&":"&ALARM=SIREN&")+getDoneString();
+    def hubAction = sendCommands(command)
+    sendEvent(name:"alarm", value:"strobe")
+    return hubAction;
+}
+
+/** Alarm Capability: Siren 
+ *  Sounds the siren, either continuous or for a brief period, depending on setting.
+ *  If continuous, Stop should be called later.
+ */
+def siren() {
+    log.debug "Executing 'siren'"
+    sendEvent(name:"alarm", value:"siren")
+    def command=(AlarmContinuous?"&ALARM=SIREN:CONTINUOUS&":"&ALARM=SIREN&")+getDoneString();
+    return sendCommands(command);
+}
+
+/** Tone Capability: Beep
+ *  Sounds a short beep
+ */
+def beep() {
+    log.debug "Executing 'beep'"
+    def command="&ALARM=CHIME&"+getDoneString()
+    return sendCommands(command);
+}
+
+def both() {
+    log.debug "Executing 'both'"
+    sendEvent(name:"alarm", value:"both")
+    def command="&ALARM=ON&FLASH=ON&"+getDoneString()
+    if (AlarmContinuous)
+    {
+        command="&ALARM=SIREN:CONTINUOUS&FLASH=CONTINUOUS&"+getDoneString()
+    }
+    return sendCommands(command);
+}
+
+/** speechSynthesis Capability: Speak
+ */
+def speak(toSay) {
+    log.debug "Executing 'speak'"
+    if (!toSay?.trim()) {
+        if (ReplyOnEmpty) {
+            toSay = "LANnouncer Version ${version}"
+        }
+    }
+
+    if (toSay?.trim()) {
+        def command="&SPEAK="+toSay+"&"+getDoneString()
+        return sendCommands(command)
+    }
+}
+
+/** Notification capability: deviceNotification
+ */
+def deviceNotification(toToast) {
+    log.debug "Executing notification with "+toToast
+    if (!toToast?.trim()) {
+        if (ReplyOnEmpty) {
+            toToast = "LANnouncer Version ${version}";
+        }
+    }
+    if (toToast?.trim()) {
+        def command="&TOAST="+toToast+"&"+getDoneString()
+        return sendCommands(command)
+    }
+}    
+
+def chime() {
+    log.debug "Executing 'chime'"
+    // TODO: handle 'siren' command
+    def command="&ALARM=CHIME&"+getDoneString()
+    return sendCommands(command)
+}
+
+def doorbell() {
+    log.debug "Executing 'doorbell'"
+    // TODO: handle 'siren' command
+    def command="&ALARM=DOORBELL&"+getDoneString()
+    return sendCommands(command)
+}
+
+def ipCamSequence(cameraNumber) {
+    def camera = (cameraNumber==1?"FIRST":"SECOND");
+    def command="&RETRIEVESEQ="+cameraNumber+"&"+getDoneString()
+    return sendIPCommand(command, true)
+}
+
+
+def retrieveFirstAndWait() {
+    retrieveAndWait("FIRST");
+}
+def retrieveSecondAndWait() {
+    retrieveAndWait("SECOND");
+}
+def retrieveAndWait(cameraName) {
+    log.info("Requesting image from camera ${cameraName}");
+    def command="&RETRIEVE="+cameraName+"&STSHRINK=TRUE&"+getDoneString()
+    return sendIPCommand(command, true)
+}
+
+
+def take() {
+    // This won't result in received file. Can't handle large or binaries in hub.
+    log.debug "Executing 'take'"
+    def command="&PHOTO=BACK&STSHRINK=TRUE&"+getDoneString()
+    return sendIPCommand(command, true)
+}
+
+/** Send to IP and to SMS as appropriate 
+ *  The caller MUST return the value, which is the hubAction.
+ *  As of version 1.25, does not "send" the command so much as 
+ *  request that the calling service send it.
+ */
+private sendCommands(command) {
+    log.info "Command request: "+command
+    sendSMSCommand(command)
+    return sendIPCommand(command)
+}
+
+/** Prepares the hubAction to be executed.
+ *  Pre-V25, this was executed in-line.  
+ *  Now it is returned, not executed, and must be returned up the calling chain.
+ */
+private sendIPCommand(commandString, sendToS3 = false) {
+    log.info "Sending command "+ commandString+" to "+DeviceLocalLan+":"+DevicePort
+    if (DeviceLocalLan?.trim()) {
+        def hosthex = convertIPtoHex(DeviceLocalLan)
+        def porthex = convertPortToHex(DevicePort)
+        device.deviceNetworkId = "$hosthex:$porthex"
+
+        def headers = [:] 
+        headers.put("HOST", "$DeviceLocalLan:$DevicePort")
+
+        def method = "GET"
+
+        def hubAction = new physicalgraph.device.HubAction(
+            method: method,
+            path: "/"+commandString,
+            headers: headers
+            );
+        if (sendToS3 == true)
+        {
+            hubAction.options = [outputMsgToS3:true];
+        }
+        log.debug hubAction
+        return hubAction;
+    }
+}
+
+private sendSMSCommand(commandString) {
+    def preface = "+@TTSSMS@+"
+    def smsValue = preface+"&"+commandString
+    state.lastsmscommand = smsValue
+    sendEvent(name: "LANdroidSMS", value: smsValue, isStateChange: true)
+    /*
+    if (SMSPhone?.trim()) {
+        sendSmsMessage(SMSPhone, preface+"&"+commandString)
+    }
+    */
+}
+
+private String getDoneString() {
+    return "@DONE@"
+}
+
+def parse(String description) {
+    log.debug "Parsing '${description}'"
+    def map = parseLanMessage(description);
+    log.debug "As LAN: " + map;
+    if ((map.headers) && (map.headers.'Content-Type' != null) && (map.headers.'Content-Type'.contains("image/jpeg")) )
+    {   //  Store the file
+      if(map.body) 
+      {
+            storeImage(getPictureName(), map.body);
+      }
+    }
+/* 'index:0F, mac:0073E023A13A, ip:C0A80114, port:040B, requestId:f9036fb2-9637-40b8-b2c5-71ba5a09fd3e, bucket:smartthings-device-conn-temp, key:fc8e3dfd-5035-40a2-8adc-a312926f9034' */
+
+    else if (map.bucket && map.key)
+    { //    S3 pointer; retrieve image from it to store.
+        try {
+            def s3ObjectContent; // Needed for scope of try-catch
+            def imageBytes = getS3Object(map.bucket, map.key + ".jpg")
+
+            if(imageBytes)
+            {
+                log.info ("Got image bytes; saving them.")
+                s3ObjectContent = imageBytes.getObjectContent()
+                def bytes = new ByteArrayInputStream(s3ObjectContent.bytes)
+                storeImage(getPictureName(), bytes)
+            }
+        }
+        catch(Exception e) 
+        {
+            log.error e
+        }
+        finally {
+            //explicitly close the stream
+            if (s3ObjectContent) { s3ObjectContent.close() }
+        }        
+    }
+}
+
+
+// Image Capture handling
+/* Note that images are stored in https://graph.api.smartthings.com/api/s3/smartthings-smartsense-camera/[IMAGE-ID4], 
+ * where [IMAGE-ID] is listed in the IDE under My Devices > [Camera] > Current States: Image. That page is updated as pictures are taken.
+ */
+
+
+private getPictureName() {
+    def pictureUuid = java.util.UUID.randomUUID().toString().replaceAll('-', '')
+    log.debug pictureUuid
+    def picName = device.deviceNetworkId.replaceAll(':', '') + "_$pictureUuid" + ".jpg"
+    return picName
+}
+
+
+private String convertIPtoHex(ipAddress) { 
+    String hex = ipAddress.tokenize( '.' ).collect {  String.format( '%02X', it.toInteger() ) }.join()
+    log.debug "IP address entered is $ipAddress and the converted hex code is $hex"
+    return hex
+
+}
+
+private String convertPortToHex(port) {
+    String hexport = port.toString().format( '%04X', port.toInteger() )
+    log.debug hexport
+    return hexport
+}

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

@@ -27,6 +27,10 @@ metadata {
         fingerprint profileId: "C05E", inClusters: "0000, 0003, 0004, 0005, 0006, 0008, 0300", outClusters: "0019"
         fingerprint profileId: "C05E", inClusters: "0000, 0003, 0004, 0005, 0006, 0008, 0300, 1000", outClusters: "0019"
         fingerprint profileId: "C05E", inClusters: "0000, 0003, 0004, 0005, 0006, 0008, 0300, 1000", outClusters: "0019", "manufacturer":"OSRAM", "model":"Classic A60 RGBW", deviceJoinName: "OSRAM LIGHTIFY LED Classic A60 RGBW"
+        fingerprint profileId: "C05E", inClusters: "0000, 0003, 0004, 0005, 0006, 0008, 0300, 0B04, FC0F", outClusters: "0019", manufacturer: "OSRAM", model: "PAR 16 50 RGBW - LIGHTIFY", deviceJoinName: "OSRAM LIGHTIFY RGBW PAR 16 50"
+        fingerprint profileId: "C05E", inClusters: "0000,0003,0004,0005,0006,0008,0300,1000,FC0F", outClusters: "0019", manufacturer: "OSRAM", model: "Flex RGBW", deviceJoinName: "OSRAM LIGHTIFY Flex RGBW"
+        fingerprint profileId: "C05E", inClusters: "0000,0003,0004,0005,0006,0008,0300,1000,FC0F", outClusters: "0019", manufacturer: "OSRAM", model: "Gardenpole RGBW-Lightify", deviceJoinName: "OSRAM LIGHTIFY Gardenpole RGBW"
+        fingerprint profileId: "C05E", inClusters: "0000,0003,0004,0005,0006,0008,0300,1000,FC0F", outClusters: "0019", manufacturer: "OSRAM", model: "LIGHTIFY Outdoor Flex RGBW", deviceJoinName: "OSRAM LIGHTIFY Outdoor Flex RGBW"
     }
 
     // UI tile definitions

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

@@ -32,6 +32,7 @@ metadata {
 
         fingerprint profileId: "C05E", inClusters: "0000, 0003, 0004, 0005, 0006, 0008, 0300, 1000, 0B04, FC0F", outClusters: "0019", "manufacturer":"OSRAM", "model":"Classic A60 TW", deviceJoinName: "OSRAM LIGHTIFY LED Classic A60 Tunable White"
         fingerprint profileId: "C05E", inClusters: "0000, 0003, 0004, 0005, 0006, 0008, 0300, 1000, FC0F", outClusters: "0019", "manufacturer":"OSRAM", "model":"PAR16 50 TW", deviceJoinName: "OSRAM LIGHTIFY LED PAR16 50 Tunable White"
+        fingerprint profileId: "C05E", inClusters: "0000, 0003, 0004, 0005, 0006, 0008, 0300, 1000, 0B04, FC0F", outClusters: "0019", manufacturer: "OSRAM", model: "Classic B40 TW - LIGHTIFY", deviceJoinName: "OSRAM LIGHTIFY Classic B40 Tunable White"
     }
 
     // UI tile definitions

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

@@ -1,662 +0,0 @@
-import javax.crypto.Mac;
-import javax.crypto.spec.SecretKeySpec;
-import java.security.InvalidKeyException;
-
-/**
- *  OpenT2T SmartApp Test
- *
- *  Copyright 2016 OpenT2T
- *
- *  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: "OpenT2T SmartApp Test",
-	namespace: "opent2t",
-	author: "OpenT2T",
-	description: "Test app to test end to end SmartThings scenarios via OpenT2T",
-	category: "SmartThings Labs",
-	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")
-
-/** --------------------+---------------+-----------------------+------------------------------------
- *  Device Type         | Attribute Name| Commands              | Attribute Values
- *  --------------------+---------------+-----------------------+------------------------------------
- *  switches            | switch        | on, off               | on, off
- *  motionSensors       | motion        |                       | active, inactive
- *  contactSensors      | contact       |                       | open, closed
- *  presenceSensors     | presence      |                       | present, 'not present'
- *  temperatureSensors  | temperature   |                       | <numeric, F or C according to unit>
- *  accelerationSensors | acceleration  |                       | active, inactive
- *  waterSensors        | water         |                       | wet, dry
- *  lightSensors        | illuminance   |                       | <numeric, lux>
- *  humiditySensors     | humidity      |                       | <numeric, percent>
- *  locks               | lock          | lock, unlock          | locked, unlocked
- *  garageDoors         | door          | open, close           | unknown, closed, open, closing, opening
- *  cameras             | image         | take                  | <String>
- *  thermostats         | thermostat    | setHeatingSetpoint,   | temperature, heatingSetpoint, coolingSetpoint,
- *	                    |				| setCoolingSetpoint,   | thermostatSetpoint, thermostatMode,
- *                      |				| off, heat, cool, auto,| thermostatFanMode, thermostatOperatingState
- *                      |				| emergencyHeat,        |
- *                      |				| setThermostatMode,    |
- *                      |				| fanOn, fanAuto,       |
- *                      |				| fanCirculate,         |
- *                      |				| setThermostatFanMode  |
- *  --------------------+---------------+-----------------------+------------------------------------
- */
-
-//Device Inputs
-preferences {
-	section("Allow OpenT2T to control these things...") {
-		input "contactSensors", "capability.contactSensor", title: "Which Contact Sensors", multiple: true, required: false, hideWhenEmpty: true
-		input "garageDoors", "capability.garageDoorControl", title: "Which Garage Doors?", multiple: true, required: false, hideWhenEmpty: true
- 		input "locks", "capability.lock", title: "Which Locks?", multiple: true, required: false, hideWhenEmpty: true
-		input "cameras", "capability.videoCapture", title: "Which Cameras?",  multiple: true, required: false, hideWhenEmpty: true
-		input "motionSensors", "capability.motionSensor", title: "Which Motion Sensors?", multiple: true, required: false, hideWhenEmpty: true
-		input "presenceSensors", "capability.presenceSensor", title: "Which Presence Sensors", multiple: true, required: false, hideWhenEmpty: true
-		input "switches", "capability.switch", title: "Which Switches and Lights?", multiple: true, required: false, hideWhenEmpty: true
-		input "thermostats", "capability.thermostat", title: "Which Thermostat?", multiple: true, required: false, hideWhenEmpty: true
-		input "waterSensors", "capability.waterSensor", title: "Which Water Leak Sensors?", multiple: true, required: false, hideWhenEmpty: true
-	}
-}
-
-def getInputs() {
-	def inputList = []
-	inputList += contactSensors?: []
-	inputList += garageDoors?: []
-	inputList += locks?: []
-	inputList += cameras?: []
-	inputList += motionSensors?: []
-	inputList += presenceSensors?: []
-	inputList += switches?: []
-	inputList += thermostats?: []
-	inputList += waterSensors?: []
-    return inputList
-}
-
-//API external Endpoints
-mappings {
-	path("/devices") {
-		action: [
-			GET: "getDevices"
-		]
-	}
-	path("/devices/:id") {
-		action: [
-			GET: "getDevice"
-		]
-	}
-	path("/update/:id") {
-		action: [
-		  PUT: "updateDevice"
-		]
-	}
-	path("/deviceSubscription") {
-		action: [
-		  POST: "registerDeviceChange",
-		  DELETE: "unregisterDeviceChange"
-		]
-	}
-    path("/locationSubscription") {
-		action: [
-		  POST: "registerDeviceGraph",
-		  DELETE: "unregisterDeviceGraph"
-		]
-	}
-}
-
-def installed() {
-	log.debug "Installing with settings: ${settings}"
-	initialize()
-}
-
-def updated() {
-	log.debug "Updating with settings: ${settings}"
-	
-    //Initialize state variables if didn't exist.
-    if( state.deviceSubscriptionMap == null ){
-		state.deviceSubscriptionMap = [:]
-		log.debug "deviceSubscriptionMap created."
-	}
-    if( state.locationSubscriptionMap == null ){
-		state.locationSubscriptionMap = [:]
-		log.debug "locationSubscriptionMap created."
-	}
-    if(state.verificationKeyMap == null){
-    	state.verificationKeyMap = [:]
-		log.debug "verificationKeyMap created."
-    }
-    
-	unsubscribe()
-	registerAllDeviceSubscriptions()
-}
-
-def initialize() {
-	log.debug "Initializing with settings: ${settings}"
-	state.deviceSubscriptionMap = [:]
-	log.debug "deviceSubscriptionMap created."
-    state.locationSubscriptionMap = [:]
-	log.debug "locationSubscriptionMap created."
-    state.verificationKeyMap = [:]
-	log.debug "verificationKeyMap created."
-    registerAllDeviceSubscriptions()
-}
-
-/*** Subscription Functions  ***/
-
-//Subscribe events for all devices
-def registerAllDeviceSubscriptions() {
-	registerChangeHandler(inputs)
-}
-
-//Subscribe to events from a list of devices
-def registerChangeHandler(myList) {
-	myList.each { myDevice ->
-		def theAtts = myDevice.supportedAttributes
-		theAtts.each {att ->
-			subscribe(myDevice, att.name, deviceEventHandler)
-			log.info "Registering for ${myDevice.displayName}.${att.name}"
-		}
-	}
-}
-
-//Endpoints function: Subscribe to events from a specific device
-def registerDeviceChange() {
-	def subscriptionEndpt = params.subscriptionURL
-	def deviceId = params.deviceId
-   	def myDevice = findDevice(deviceId)
-    
-	if( myDevice == null ){
-		httpError(404, "Cannot find device with device ID ${deviceId}.")
-	}
-    
-	def theAtts = myDevice.supportedAttributes
-	try {
-		theAtts.each {att ->
-			subscribe(myDevice, att.name, deviceEventHandler)
-		}
-        log.info "Subscribing for ${myDevice.displayName}"
-
-        if(subscriptionEndpt != null){
-			if(state.deviceSubscriptionMap[deviceId] == null){
-				state.deviceSubscriptionMap.put(deviceId, [subscriptionEndpt])
-				log.info "Added subscription URL: ${subscriptionEndpt} for ${myDevice.displayName}"
-			} else if (!state.deviceSubscriptionMap[deviceId].contains(subscriptionEndpt)){
-				// state.deviceSubscriptionMap[deviceId] << subscriptionEndpt
-                // For now, we will only have one subscription endpoint per device
-				state.deviceSubscriptionMap.remove(deviceId)
-				state.deviceSubscriptionMap.put(deviceId, [subscriptionEndpt])
-				log.info "Added subscription URL: ${subscriptionEndpt} for ${myDevice.displayName}"
-			}
-            
-            if(params.key != null){
-            	state.verificationKeyMap[subscriptionEndpt] = params.key
-				log.info "Added verification key: ${params.key} for ${subscriptionEndpt}"
-            }
-        }
-	} catch (e) {
-		httpError(500, "something went wrong: $e")
-	}
-
-	log.info "Current subscription map is ${state.deviceSubscriptionMap}"
-    log.info "Current verification key map is ${state.verificationKeyMap}"
-	return ["succeed"]
-}
-
-//Endpoints function: Unsubscribe to events from a specific device
-def unregisterDeviceChange() {
-	def subscriptionEndpt = params.subscriptionURL
-	def deviceId = params.deviceId
-	def myDevice = findDevice(deviceId)
-    
-	if( myDevice == null ){
-		httpError(404, "Cannot find device with device ID ${deviceId}.")
-	}
-    
-	try {
-		if(subscriptionEndpt != null && subscriptionEndpt != "undefined"){
-			if (state.deviceSubscriptionMap[deviceId]?.contains(subscriptionEndpt)){
-				if(state.deviceSubscriptionMap[deviceId].size() == 1){
-					state.deviceSubscriptionMap.remove(deviceId)
-				} else {
-					state.deviceSubscriptionMap[deviceId].remove(subscriptionEndpt)
-				}
-                state.verificationKeyMap.remove(subscriptionEndpt)
-				log.info "Removed subscription URL: ${subscriptionEndpt} for ${myDevice.displayName}"
-			}
-        } else {
-			state.deviceSubscriptionMap.remove(deviceId)
-			log.info "Unsubscriping for ${myDevice.displayName}"
-		}
-	} catch (e) {
-		httpError(500, "something went wrong: $e")
-	}
-
-	log.info "Current subscription map is ${state.deviceSubscriptionMap}"
-    log.info "Current verification key map is ${state.verificationKeyMap}"
-}
-
-//Endpoints function: Subscribe to device additiona/removal updated in a location
-def registerDeviceGraph() {
-	def subscriptionEndpt = params.subscriptionURL
-    
-    if (subscriptionEndpt != null && subscriptionEndpt != "undefined"){
-        subscribe(location, "DeviceCreated", locationEventHandler, [filterEvents: false])
-        subscribe(location, "DeviceUpdated", locationEventHandler, [filterEvents: false])
-        subscribe(location, "DeviceDeleted", locationEventHandler, [filterEvents: false])
-
-    	if(state.locationSubscriptionMap[location.id] == null){
-            state.locationSubscriptionMap.put(location.id, [subscriptionEndpt])
-			log.info "Added subscription URL: ${subscriptionEndpt} for Location ${location.name}"
-        }else if (!state.locationSubscriptionMap[location.id].contains(subscriptionEndpt)){
-            state.locationSubscriptionMap[location.id] << subscriptionEndpt
-			log.info "Added subscription URL: ${subscriptionEndpt} for Location ${location.name}"
-        }
-        
-        if(params.key != null){
-            state.verificationKeyMap[subscriptionEndpt] = params.key
-			log.info "Added verification key: ${params.key} for ${subscriptionEndpt}"
-        }
-        
-        log.info "Current location subscription map is ${state.locationSubscriptionMap}"
-        log.info "Current verification key map is ${state.verificationKeyMap}"
-        return ["succeed"]
-    } else {
-        httpError(400, "missing input parameter: subscriptionURL")
-    }
-}
-
-//Endpoints function: Unsubscribe to events from a specific device
-def unregisterDeviceGraph() {
-	def subscriptionEndpt = params.subscriptionURL
-    
-	try {
-		if(subscriptionEndpt != null && subscriptionEndpt != "undefined"){
-			if (state.locationSubscriptionMap[location.id]?.contains(subscriptionEndpt)){
-				if(state.locationSubscriptionMap[location.id].size() == 1){
-					state.locationSubscriptionMap.remove(location.id)
-				} else {
-					state.locationSubscriptionMap[location.id].remove(subscriptionEndpt)
-				}
-                state.verificationKeyMap.remove(subscriptionEndpt)
-				log.info "Removed subscription URL: ${subscriptionEndpt} for Location ${location.name}"
-			}
-        }else{
-        	httpError(400, "missing input parameter: subscriptionURL")
-        }
-	} catch (e) {
-		httpError(500, "something went wrong: $e")
-	}
-
-	log.info "Current location subscription map is ${state.locationSubscriptionMap}"
-    log.info "Current verification key map is ${state.verificationKeyMap}"
-}
-
-//When events are triggered, send HTTP post to web socket servers
-def deviceEventHandler(evt) {
-	def evtDevice = evt.device
-	def evtDeviceType = getDeviceType(evtDevice)
-	def deviceData = [];
-   	
-    if(evt.data != null){
-		def evtData = parseJson(evt.data)
-		log.info "Received event for ${evtDevice.displayName}, data: ${evtData},  description: ${evt.descriptionText}"
-	}
-    
-    if(evtDeviceType == "thermostat") {
-		deviceData = [name: evtDevice.displayName, id: evtDevice.id, status:evtDevice.status, deviceType:evtDeviceType, manufacturer:evtDevice.manufacturerName, model:evtDevice.modelName, attributes: deviceAttributeList(evtDevice, evtDeviceType), locationMode: getLocationModeInfo(), locationId: location.id ]
-	} else {
-		deviceData = [name: evtDevice.displayName, id: evtDevice.id, status:evtDevice.status, deviceType:evtDeviceType, manufacturer:evtDevice.manufacturerName, model:evtDevice.modelName, attributes: deviceAttributeList(evtDevice, evtDeviceType), locationId: location.id ]
-	}
-    
-    def params = [ body: deviceData ]
-    
-	//send event to all subscriptions urls
-	log.debug "Current subscription urls for ${evtDevice.displayName} is ${state.deviceSubscriptionMap[evtDevice.id]}"
-	state.deviceSubscriptionMap[evtDevice.id].each {
-		params.uri = "${it}"
-        if(state.verificationKeyMap[it] != null ){
-        	def key = state.verificationKeyMap[it]
-            params.header = [Signature: ComputHMACValue(key, groovy.json.JsonOutput.toJson(params.body))]
-        }
-		log.trace "POST URI: ${params.uri}"
-        log.trace "Header: ${params.header}"
-		log.trace "Payload: ${params.body}"
-		try{
-			httpPostJson(params) { resp ->
-				log.trace "response status code: ${resp.status}"
-				log.trace "response data: ${resp.data}"
-			}
-		} catch (e) {
-			log.error "something went wrong: $e"
-		}
-	}
-}
-
-def locationEventHandler(evt) {
-	log.info "Received event for location ${location.name}/${location.id}, Event: ${evt.name}, description: ${evt.descriptionText}, apiServerUrl: ${apiServerUrl("")}"
-    switch(evt.name){
-    	case "DeviceCreated":
-        case "DeviceDeleted":
-        	def evtDevice = evt.device
-            def evtDeviceType = getDeviceType(evtDevice)
-            def params = [ body: [ eventType:evt.name, deviceId: evtDevice.id, locationId: location.id ] ]
-            
-            if (evt.name == "DeviceDeleted" && state.deviceSubscriptionMap[deviceId] != null){
-            	state.deviceSubscriptionMap.remove(evtDevice.id)
-            }
-        
-            state.locationSubscriptionMap[location.id].each {
-                params.uri = "${it}"
-                if(state.verificationKeyMap[it] != null ){
-                    def key = state.verificationKeyMap[it]
-                    params.header = [Signature: ComputHMACValue(key, groovy.json.JsonOutput.toJson(params.body))]
-                }
-                log.trace "POST URI: ${params.uri}"
-				log.trace "Header: ${params.header}"
-                log.trace "Payload: ${params.body}"
-                try{
-                    httpPostJson(params) { resp ->
-                        log.trace "response status code: ${resp.status}"
-                        log.trace "response data: ${resp.data}"
-                    }
-                } catch (e) {
-                    log.error "something went wrong: $e"
-                }
-            }
-    	case "DeviceUpdated":
-        default:
-        break
-    }
-}
-
-private ComputHMACValue(key, data){
-	try {
-        SecretKeySpec secretKeySpec = new SecretKeySpec(key.getBytes("UTF-8"), "HmacSHA1")
-		Mac mac = Mac.getInstance("HmacSHA1")
-		mac.init(secretKeySpec)
-		byte[] digest = mac.doFinal(data.getBytes("UTF-8"))
-		return byteArrayToString(digest)
-	} catch (InvalidKeyException e) {  
-     	log.error "Invalid key exception while converting to HMac SHA1"
-	}
-}
-
-private def byteArrayToString(byte[] data) {
-	BigInteger bigInteger = new BigInteger(1, data)
-    String hash = bigInteger.toString(16)
-	return hash
-}
-
-/*** Device Query/Update Functions  ***/
-
-//Endpoints function: return all device data in json format
-def getDevices() {
-	def deviceData = [] 
-	inputs?.each {
-		def deviceType = getDeviceType(it)
-		if(deviceType == "thermostat") {
-			deviceData << [name: it.displayName, id: it.id, status:it.status, deviceType:deviceType, manufacturer:it.manufacturerName, model:it.modelName, attributes: deviceAttributeList(it, deviceType), locationMode: getLocationModeInfo()]
-		} else {
-			deviceData << [name: it.displayName, id: it.id, status:it.status, deviceType:deviceType, manufacturer:it.manufacturerName, model:it.modelName, attributes: deviceAttributeList(it, deviceType)]
-		} 
-	}
- 
-	log.debug "getDevices, return: ${deviceData}"
-	return deviceData
-}
-
-//Endpoints function: get device data
-def getDevice() {	
-	def it = findDevice(params.id)
-	def deviceType = getDeviceType(it)
-	def device
-	if(deviceType == "thermostat") {
-		device = [name: it.displayName, id: it.id, status:it.status, deviceType:deviceType, manufacturer:it.manufacturerName, model:it.modelName, attributes: deviceAttributeList(it,deviceType), locationMode: getLocationModeInfo()]
-	} else {
-		device = [name: it.displayName, id: it.id, status:it.status, deviceType:deviceType, manufacturer:it.manufacturerName, model:it.modelName, attributes: deviceAttributeList(it, deviceType)]
-	}
-
-	log.debug "getDevice, return: ${device}"
-	return device
-}
-
-//Endpoints function: update device data
-void updateDevice() {	
-	def device = findDevice(params.id)
-	request.JSON.each {   
-		def command = it.key
-		def value = it.value
-		if (command){
-			def commandList = mapDeviceCommands(command, value)
-			command = commandList[0]
-			value = commandList[1]
-			
-			if (command == "setAwayMode") {
-				log.info "Setting away mode to ${value}"
-				if (location.modes?.find {it.name == value}) {
-					location.setMode(value)
-				}
-			}else if (command == "thermostatSetpoint"){
-				switch(device.currentThermostatMode){
-					case "cool":
-						log.info "Update: ${device.displayName}, [${command}, ${value}]"
-						device.setCoolingSetpoint(value)
-						break
-					case "heat":
-					case "emergency heat":
-						log.info "Update: ${device.displayName}, [${command}, ${value}]"
-						device.setHeatingSetpoint(value)
-						break
-					default:
-						httpError(501, "this mode: ${device.currentThermostatMode} does not allow changing thermostat setpoint.")
-						break
-				}
-			}else if (!device) {
-				log.error "updateDevice, Device not found"
-				httpError(404, "Device not found")
-			} else if (!device.hasCommand(command)) {
-				log.error "updateDevice, Device does not have the command"
-				httpError(404, "Device does not have such command")
-			} else {
-				if (command == "setColor") {
-					log.info "Update: ${device.displayName}, [${command}, ${value}]"
-					device."$command"(hex: value)
-				} else if(value.isNumber()) {
-					def intValue = value as Integer
-					log.info "Update: ${device.displayName}, [${command}, ${intValue}(int)]"
-					device."$command"(intValue)
-				} else if (value){
-					log.info "Update: ${device.displayName}, [${command}, ${value}]"
-					device."$command"(value)
-				} else {
-					log.info "Update: ${device.displayName}, [${command}]"
-					device."$command"()
-				}
-			}
-		}
-	}
-}
-
-/*** Private Functions ***/
-
-//Return current location mode info
-private getLocationModeInfo() {
-	return [mode: location.mode, supported: location.modes.name]
-}
-
-//Map each device to a type given it's capabilities
-private getDeviceType(device) {
-	def deviceType
-	def capabilities = device.capabilities
-	log.debug "capabilities: [${device}, ${capabilities}]"
-	log.debug "supported commands: [${device}, ${device.supportedCommands}]"
-    
-	//Loop through the device capability list to determine the device type.
-	capabilities.each {capability ->
-		switch(capability.name.toLowerCase())
-		{
-			case "switch":
-				deviceType = "switch"
-
-				//If the device also contains "Switch Level" capability, identify it as a "light" device.
-				if (capabilities.any{it.name.toLowerCase() == "switch level"}){
-                	
-                    //If the device also contains "Power Meter" capability, identify it as a "dimmerSwitch" device.
-                    if (capabilities.any{it.name.toLowerCase() == "power meter"}){
-                        deviceType = "dimmerSwitch"
-                        return deviceType
-                    } else {
-                        deviceType = "light"
-                        return deviceType
-                    }
-                }
-				break
-			case "garageDoorControl":
-				deviceType = "garageDoor"
-				return deviceType
-			case "lock":
-				deviceType = "lock"
-				return deviceType
-			case "video camera":
-				deviceType = "camera"
-				return deviceType
-			case "thermostat":
-				deviceType = "thermostat"
-				return deviceType    
-			case "acceleration sensor":
-			case "contact sensor":
-			case "motion sensor":
-			case "presence sensor":
-			case "water sensor":
-				deviceType = "genericSensor"
-				return deviceType
-			default:
-				break
-		}
-	}
-	return deviceType
-}
-
-//Return a specific device give the device ID.
-private findDevice(deviceId) {
-	return inputs?.find { it.id == deviceId }
-}
- 
-//Return a list of device attributes
-private deviceAttributeList(device, deviceType) {
-	def attributeList = [:]
-	def allAttributes = device.supportedAttributes
-	allAttributes.each { attribute ->
-        	try {
-			def currentState = device.currentState(attribute.name)
-            		if(currentState != null ){
-                		switch(attribute.name){
-                    		case 'temperature':
-                        		attributeList.putAll([ (attribute.name): currentState.value, 'temperatureScale':location.temperatureScale ])
-                        		break;
-	                    	default:
-        	                	attributeList.putAll([(attribute.name): currentState.value ])
-                	        	break;
-                		}
-                		if( deviceType == "genericSensor" ){
-                    			def key = attribute.name + "_lastUpdated"
-                			attributeList.putAll([ (key): currentState.isoDate ])
-                		}
-	            	} else {
-            			attributeList.putAll([ (attribute.name): null ]);
-            		}
-		} catch(e) {
-			attributeList.putAll([ (attribute.name): null ]);
-		}
-	}
-    return attributeList
-}
-
-//Map device command and value. 
-//input command and value are from UWP,
-//returns resultCommand and resultValue that corresponds with function and value in SmartApps
-private mapDeviceCommands(command, value) {
-	log.debug "mapDeviceCommands: [${command}, ${value}]"
-	def resultCommand = command
-	def resultValue = value
-	switch (command) {
-		case "switch":
-			if (value == 1 || value == "1" || value == "on") {
-				resultCommand = "on"
-				resultValue = ""
-			} else if (value == 0 || value == "0" || value == "off") {
-				resultCommand = "off"
-				resultValue = ""
-			}
-			break
-		// light attributes
-		case "level":
-			resultCommand = "setLevel"
-			resultValue = value
-			break
-		case "hue":
-			resultCommand = "setHue"
-			resultValue = value
-			break
-		case "saturation":
-			resultCommand = "setSaturation"
-			resultValue = value
-			break
-		case "colorTemperature":
-			resultCommand = "setColorTemperature"
-			resultValue = value
-			break
-		case "color":	
-			resultCommand = "setColor"
-			resultValue = value
-		// thermostat attributes
-		case "hvacMode":
-			resultCommand = "setThermostatMode"
-			resultValue = value
-			break
-		case "fanMode":
-			resultCommand = "setThermostatFanMode"
-			resultValue = value
-			break
-		case "awayMode":
-			resultCommand = "setAwayMode"
-			resultValue = value
-			break
-		case "coolingSetpoint":
-			resultCommand = "setCoolingSetpoint"
-			resultValue = value
-			break
-		case "heatingSetpoint":	
-			resultCommand = "setHeatingSetpoint"
-			resultValue = value
-			break
-		case "thermostatSetpoint":
-			resultCommand = "thermostatSetpoint"
-			resultValue = value
-			break
-		// lock attributes
-		case "locked":
-			if (value == 1 || value == "1" || value == "lock") {
-				resultCommand = "lock"
-				resultValue = ""
-			}
-			else if (value == 0 || value == "0" || value == "unlock") {
-				resultCommand = "unlock"
-				resultValue = ""
-			}
-			break
-		default:
-			break
-	 }
-	 
-	 return [resultCommand,resultValue]
-}