Modifying 'Publish a SmartApp for OpenT2T - Remove support for multiple subscriptions to a single device.'

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

@@ -1,360 +0,0 @@
-/**
- *  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,10 +27,6 @@ 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,7 +32,6 @@ 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

@@ -0,0 +1,662 @@
+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]
+}