MSA-1338: I believe this should replace the current app on the app store "TCP Bulbs (connect)" as it's a more reliable integration.

I did a couple of things to make this more reliable:
1.  I re-fetch the authorization token every 5 minutes
2.  If a request fails, I again re-try to fetch the token and re-submit the request
3.  I try again on 400 errors in addition to 500 and 401 errors.

Code is all open source under Apache 2.0 license hosted at github at https://github.com/mmacaula/tcp-bulbs

devicetypes/smartthings/-.src/-.groovy

@@ -1,294 +0,0 @@
-/**
- *  Copyright 2015 SmartThings
- *
- *  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
- *  in compliance with the License. You may obtain a copy of the License at:
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed
- *  on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License
- *  for the specific language governing permissions and limitations under the License.
- *
- */
-metadata {
-	definition (name: "재부재 센서", namespace: "smartthings", author: "김성훈") {
-		capability "Tone"
-		capability "Actuator"
-		capability "Signal Strength"
-		capability "Presence Sensor"
-		capability "Sensor"
-		capability "Battery"
-
-		fingerprint profileId: "FC01", deviceId: "019A"
-		fingerprint profileId: "FC01", deviceId: "0131", inClusters: "0000,0003", outClusters: "0003"
-		fingerprint profileId: "FC01", deviceId: "0131", inClusters: "0000", outClusters: "0006"
-	}
-
-	simulator {
-		status "present": "presence: 1"
-		status "not present": "presence: 0"
-		status "battery": "battery: 27, batteryDivisor: 0A, rssi: 100, lqi: 64"
-	}
-
-	preferences {
-		section {
-			image(name: 'educationalcontent', multiple: true, images: [
-				"http://cdn.device-gse.smartthings.com/Arrival/Arrival1.jpg",
-				"http://cdn.device-gse.smartthings.com/Arrival/Arrival2.jpg"
-				])
-		}
-	}
-
-	tiles {
-		standardTile("presence", "device.presence", width: 2, height: 2, canChangeBackground: true) {
-			state "present", labelIcon:"st.presence.tile.present", backgroundColor:"#53a7c0"
-			state "not present", labelIcon:"st.presence.tile.not-present", backgroundColor:"#ebeef2"
-		}
-		standardTile("beep", "device.beep", decoration: "flat") {
-			state "beep", label:'', action:"tone.beep", icon:"st.secondary.beep", backgroundColor:"#ffffff"
-		}
-		valueTile("battery", "device.battery", decoration: "flat", inactiveLabel: false) {
-			state "battery", label:'${currentValue}% battery', unit:""/*, backgroundColors:[
-				[value: 5, color: "#BC2323"],
-				[value: 10, color: "#D04E00"],
-				[value: 15, color: "#F1D801"],
-				[value: 16, color: "#FFFFFF"]
-			]*/
-		}
-		/*
-		valueTile("lqi", "device.lqi", decoration: "flat", inactiveLabel: false) {
-			state "lqi", label:'${currentValue}% signal', unit:""
-		}
-		*/
-		
-		main "presence"
-		details(["presence", "beep", "battery"/*, "lqi"*/])
-	}
-}
-
-def beep() {
-	/*
-	You can make the speaker turn on for 0.5-second beeps by sending some CLI commands:
-
-		Command: send raw, wait 7, send raw, wait 7, send raw
-		Future: new packet type "st.beep"
-
-		raw 0xFC05 {15 0A 11 00 00 15 01}
-		send 0x2F7F 2 2
-
-	where "0xABCD" is the node ID of the Smart Tag, everything else above is a constant. Except
-	the "15 01" at the end of the first raw command, that sets the speaker's period (reciprocal
-	of frequency). You can play with this value up or down to experiment with loudness as the
-	loudness will be strongly dependent upon frequency and the enclosure that it's in. Note that
-	"15 01" represents the hex number 0x0115 so a lower frequency is "16 01" (longer period) and
-	a higher frequency is "14 01" (shorter period). Note that since the tag only checks its parent
-	for messages every 5 seconds (while at rest) or every 3 seconds (while in motion) it will take
-	up to this long from the time you send the message to the time you hear a sound.
-	*/
-
-	[
-		"raw 0xFC05 {15 0A 11 00 00 15 01}",
-		"delay 7000",
-		"raw 0xFC05 {15 0A 11 00 00 15 01}",
-		"delay 7000",
-		"raw 0xFC05 {15 0A 11 00 00 15 01}",
-		"delay 7000",
-		"raw 0xFC05 {15 0A 11 00 00 15 01}",
-		"delay 7000",
-		"raw 0xFC05 {15 0A 11 00 00 15 01}"
-	]
-}
-
-def parse(String description) {
-	def results
-	if (isBatteryMessage(description)) {
-		results = parseBatteryMessage(description)
-	}
-	else {
-		results = parsePresenceMessage(description)
-	}
-
-	log.debug "Parse returned $results.descriptionText"
-	results
-}
-
-private Map parsePresenceMessage(String description) {
-	def name = parseName(description)
-	def value = parseValue(description)
-	def linkText = getLinkText(device)
-	def descriptionText = parseDescriptionText(linkText, value, description)
-	def handlerName = getState(value)
-	def isStateChange = isStateChange(device, name, value)
-
-	def results = [
-		name: name,
-		value: value,
-		unit: null,
-		linkText: linkText,
-		descriptionText: descriptionText,
-		handlerName: handlerName,
-		isStateChange: isStateChange,
-		displayed: displayed(description, isStateChange)
-	]
-
-	results
-}
-
-private String parseName(String description) {
-	if (description?.startsWith("presence: ")) {
-		return "presence"
-	}
-	null
-}
-
-private String parseValue(String description) {
-	if (description?.startsWith("presence: "))
-	{
-		if (description?.endsWith("1"))
-		{
-			return "present"
-		}
-		else if (description?.endsWith("0"))
-		{
-			return "not present"
-		}
-	}
-
-	description
-}
-
-private parseDescriptionText(String linkText, String value, String description) {
-	switch(value) {
-		case "present": return "$linkText has arrived"
-		case "not present": return "$linkText has left"
-		default: return value
-	}
-}
-
-private getState(String value) {
-	def state = value
-	if (value == "present") {
-		state = "arrived"
-	}
-	else if (value == "not present") {
-		state = "left"
-	}
-
-	state
-}
-
-private Boolean isBatteryMessage(String description) {
-	// "raw:36EF1C, dni:36EF, battery:1B, rssi:, lqi:"
-	description ==~ /.*battery:.*rssi:.*lqi:.*/
-}
-
-private List parseBatteryMessage(String description) {
-	def results = []
-	def parts = description.split(',')
-	parts.each { part ->
-		part = part.trim()
-		if (part.startsWith('battery:')) {
-			def batteryResult = getBatteryResult(part, description)
-			if (batteryResult) {
-				results << batteryResult
-			}
-		}
-		else if (part.startsWith('rssi:')) {
-			def rssiResult = getRssiResult(part, description)
-			if (rssiResult) {
-				results << rssiResult
-			}
-		}
-		else if (part.startsWith('lqi:')) {
-			def lqiResult = getLqiResult(part, description)
-			if (lqiResult) {
-				results << lqiResult
-			}
-		}
-	}
-
-	results
-}
-
-private getBatteryResult(part, description) {
-	def batteryDivisor = description.split(",").find {it.split(":")[0].trim() == "batteryDivisor"} ? description.split(",").find {it.split(":")[0].trim() == "batteryDivisor"}.split(":")[1].trim() : null
-	def name = "battery"
-	def value = zigbee.parseSmartThingsBatteryValue(part, batteryDivisor)
-	def unit = "%"
-	def linkText = getLinkText(device)
-	def descriptionText = "$linkText battery was ${value}${unit}"
-	def isStateChange = isStateChange(device, name, value)
-
-	[
-		name: name,
-		value: value,
-		unit: unit,
-		linkText: linkText,
-		descriptionText: descriptionText,
-		handlerName: name,
-		isStateChange: isStateChange,
-		//displayed: displayed(description, isStateChange)
-		displayed: false
-	]
-}
-
-private getRssiResult(part, description) {
-	def name = "rssi"
-	def parts = part.split(":")
-	if (parts.size() != 2) return null
-
-	def valueString = parts[1].trim()
-	def valueInt = Integer.parseInt(valueString, 16)
-	def value = (valueInt - 128).toString()
-	def linkText = getLinkText(device)
-	def descriptionText = "$linkText was $value dBm"
-	def isStateChange = isStateChange(device, name, value)
-
-	[
-		name: name,
-		value: value,
-		unit: "dBm",
-		linkText: linkText,
-		descriptionText: descriptionText,
-		handlerName: null,
-		isStateChange: isStateChange,
-		//displayed: displayed(description, isStateChange)
-		displayed: false
-	]
-}
-
-/**
- * Use LQI (Link Quality Indicator) as a measure of signal strength. The values
- * are 0 to 255 (0x00 to 0xFF) and higher values represent higher signal
- * strength. Return as a percentage of 255.
- *
- * Note: To make the signal strength indicator more accurate, we could combine
- * LQI with RSSI.
- */
-private getLqiResult(part, description) {
-	def name = "lqi"
-	def parts = part.split(":")
-	if (parts.size() != 2) return null
-
-	def valueString = parts[1].trim()
-	def valueInt = Integer.parseInt(valueString, 16)
-	def percentageOf = 255
-	def value = Math.round((valueInt / percentageOf * 100)).toString()
-	def unit = "%"
-	def linkText = getLinkText(device)
-	def descriptionText = "$linkText Signal (LQI) was ${value}${unit}"
-	def isStateChange = isStateChange(device, name, value)
-
-	[
-		name: name,
-		value: value,
-		unit: unit,
-		linkText: linkText,
-		descriptionText: descriptionText,
-		handlerName: null,
-		isStateChange: isStateChange,
-		//displayed: displayed(description, isStateChange)
-		displayed: false
-	]
-}

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

@@ -21,6 +21,7 @@ metadata {
         attribute "tamper", "enum", ["detected", "clear"]
         attribute "heatAlarm", "enum", ["overheat detected", "clear", "rapid temperature rise", "underheat detected"]
         fingerprint deviceId: "0x0701", inClusters: "0x5E, 0x86, 0x72, 0x5A, 0x59, 0x85, 0x73, 0x84, 0x80, 0x71, 0x56, 0x70, 0x31, 0x8E, 0x22, 0x9C, 0x98, 0x7A", outClusters: "0x20, 0x8B"
+        fingerprint mfr:"010F", prod:"0C02", model:"1002"
     }
     simulator {
         //battery

devicetypes/smartthings/hue-white-ambiance-bulb/hue-white-ambiance-bulb.groovy

@@ -0,0 +1,110 @@
+/**
+ *  Hue White Ambiance Bulb
+ *
+ *  Philips Hue Type "Color Temperature Light"
+ *
+ *  Author: SmartThings
+ */
+
+// for the UI
+metadata {
+    // Automatically generated. Make future change here.
+    definition (name: "Hue White Ambiance Bulb", namespace: "smartthings", author: "SmartThings") {
+        capability "Switch Level"
+        capability "Actuator"
+        capability "Color Temperature"
+        capability "Switch"
+        capability "Refresh"
+
+        command "refresh"
+    }
+
+    simulator {
+        // TODO: define status and reply messages here
+    }
+
+    tiles (scale: 2){
+        multiAttributeTile(name:"rich-control", type: "lighting", width: 6, height: 4, canChangeIcon: true){
+            tileAttribute ("device.switch", key: "PRIMARY_CONTROL") {
+                attributeState "on", label:'${name}', action:"switch.off", icon:"st.lights.philips.hue-single", backgroundColor:"#79b821", nextState:"turningOff"
+                attributeState "off", label:'${name}', action:"switch.on", icon:"st.lights.philips.hue-single", backgroundColor:"#ffffff", nextState:"turningOn"
+                attributeState "turningOn", label:'${name}', action:"switch.off", icon:"st.lights.philips.hue-single", backgroundColor:"#79b821", nextState:"turningOff"
+                attributeState "turningOff", label:'${name}', action:"switch.on", icon:"st.lights.philips.hue-single", backgroundColor:"#ffffff", nextState:"turningOn"
+            }
+            tileAttribute ("device.level", key: "SLIDER_CONTROL") {
+                attributeState "level", action:"switch level.setLevel", range:"(0..100)"
+            }
+        }
+
+        controlTile("colorTempSliderControl", "device.colorTemperature", "slider", width: 4, height: 2, inactiveLabel: false, range:"(2000..6500)") {
+            state "colorTemperature", action:"color temperature.setColorTemperature"
+        }
+
+        valueTile("colorTemp", "device.colorTemperature", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
+            state "colorTemperature", label: '${currentValue} K'
+        }
+
+        standardTile("refresh", "device.refresh", height: 2, width: 2, inactiveLabel: false, decoration: "flat") {
+            state "default", label:"", action:"refresh.refresh", icon:"st.secondary.refresh"
+        }
+
+        main(["rich-control"])
+        details(["rich-control", "colorTempSliderControl", "colorTemp", "refresh"])
+    }
+}
+
+// parse events into attributes
+def parse(description) {
+    log.debug "parse() - $description"
+    def results = []
+
+    def map = description
+    if (description instanceof String)  {
+        log.debug "Hue Ambience Bulb stringToMap - ${map}"
+        map = stringToMap(description)
+    }
+
+    if (map?.name && map?.value) {
+        results << createEvent(name: "${map?.name}", value: "${map?.value}")
+    }
+    results
+}
+
+// handle commands
+void on() {
+    log.trace parent.on(this)
+    sendEvent(name: "switch", value: "on")
+}
+
+void off() {
+    log.trace parent.off(this)
+    sendEvent(name: "switch", value: "off")
+}
+
+void setLevel(percent) {
+    log.debug "Executing 'setLevel'"
+    if (percent != null && percent >= 0 && percent <= 100) {
+        parent.setLevel(this, percent)
+        sendEvent(name: "level", value: percent)
+        sendEvent(name: "switch", value: "on")
+    } else {
+        log.warn "$percent is not 0-100"
+    }
+}
+
+void setColorTemperature(value) {
+    if (value) {
+        log.trace "setColorTemperature: ${value}k"
+        parent.setColorTemperature(this, value)
+        sendEvent(name: "colorTemperature", value: value)
+        sendEvent(name: "switch", value: "on")
+    } else {
+        log.warn "Invalid color temperature"
+    }
+}
+
+void refresh() {
+    log.debug "Executing 'refresh'"
+    parent.manualRefresh()
+}
+

devicetypes/smartthings/smartsense-motion-sensor.src/.st-ignore

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

devicetypes/smartthings/smartsense-motion-sensor.src/README.md

@@ -0,0 +1,30 @@
+# Smartsense Motion Sensor
+
+
+
+Works with: 
+
+* [Samsung SmartThings Motion Sensor](https://shop.smartthings.com/#!/products/samsung-smartthings-motion-sensor)
+
+## Table of contents
+
+* [Capabilities](#capabilities)
+* [Health]($health)
+
+## Capabilities
+
+* **Configuration** - _configure()_ command called when device is installed or device preferences updated
+* **Motion Sensor** - can detect motion
+* **Battery** - defines device uses a battery
+* **Refresh** - _refresh()_ command for status updates
+* **Health Check** - indicates ability to get device health notifications
+
+## Device Health
+
+A Category C2 motion sensor that has 120min check-in interval
+
+
+
+
+
+

devicetypes/wackford/tcp-bulb.src/tcp-bulb.groovy

@@ -13,14 +13,14 @@
  *				Documented Header
  *
  *  Change 2:	2014-03-15
- *				Fixed bug where we weren't coming on when changing
+ *				Fixed bug where we weren't coming on when changing 
  *				levels down.
  *
- *  Change 3:   2014-04-02 (lieberman)
+ *  Change 3:   2014-04-02 (lieberman)	
  *              Changed sendEvent() to createEvent() in parse()
  *
  *  Change 4:	2014-04-12 (wackford)
- *				Added current power usage tile
+ *				Added current power usage tile 
  *
  *  Change 5:	2014-09-14 (wackford)
  *				a. Changed createEvent() to sendEvent() in parse() to
@@ -33,7 +33,7 @@
  *				b. added refresh on udate
  *				c. added uninstallFromChildDevice to handle removing from settings
  *				d. Changed to allow bulb to 100%, was possible to get past logic at 99
- *
+ * 
  *  Change 7:	2014-11-09 (wackford)
  *				a. Added bulbpower calcs to device. TCP is broken
  *				b. Changed to set dim level first then on. Much easier on the eys coming from bright.
@@ -42,7 +42,7 @@
  *                       Code
  *****************************************************************
  */
-// for the UI
+ // for the UI
 metadata {
 	definition (name: "TCP Bulb", namespace: "wackford", author: "Todd Wackford") {
 		capability "Switch"
@@ -52,28 +52,26 @@ metadata {
 		capability "Switch Level"
 
 		attribute "stepsize", "string"
-
+        
 		command "levelUp"
 		command "levelDown"
-		command "on"
-		command "off"
-		command "setBulbPower"
+        command "on"
+        command "off"
+        command "setBulbPower"
 	}
 
 	simulator {
 		// TODO: define status and reply messages here
 	}
-
-	preferences {
+    
+    preferences {
 		input "stepsize", "number", title: "Step Size", description: "Dimmer Step Size", defaultValue: 5
 	}
-
+    
 	tiles {
 		standardTile("switch", "device.switch", width: 2, height: 2, canChangeIcon: true) {
-			state "on", label:'${name}', action:"switch.off", icon:"st.switches.switch.on", backgroundColor:"#79b821", nextState:"turningOff"
-			state "off", label:'${name}', action:"switch.on", icon:"st.switches.switch.off", backgroundColor:"#ffffff", nextState:"turningOn"
-			state "turningOn", label:'${name}', action:"switch.off", icon:"st.switches.switch.on", backgroundColor:"#79b821", nextState:"turningOff"
-			state "turningOff", label:'${name}', action:"switch.on", icon:"st.switches.switch.off", backgroundColor:"#ffffff", nextState:"turningOn"
+			state "on", label:'${name}', action:"off", icon:"st.switches.light.on", backgroundColor:"#79b821"
+			state "off", label:'${name}', action:"on", icon:"st.switches.light.off", backgroundColor:"#ffffff"
 		}
 		controlTile("levelSliderControl", "device.level", "slider", height: 1, width: 2, inactiveLabel: false) {
 			state "level", action:"switch level.setLevel"
@@ -84,15 +82,15 @@ metadata {
 		valueTile("level", "device.level", inactiveLabel: false, decoration: "flat") {
 			state "level", label: 'Level ${currentValue}%'
 		}
-		standardTile("lUp", "device.switchLevel", inactiveLabel: false,decoration: "flat", canChangeIcon: false) {
-			state "default", action:"levelUp", icon:"st.illuminance.illuminance.bright"
-		}
-		standardTile("lDown", "device.switchLevel", inactiveLabel: false,decoration: "flat", canChangeIcon: false) {
-			state "default", action:"levelDown", icon:"st.illuminance.illuminance.light"
-		}
-		valueTile( "power", "device.power", inactiveLabel: false, decoration: "flat") {
-			state "power", label: '${currentValue} Watts'
-		}
+        standardTile("lUp", "device.switchLevel", inactiveLabel: false,decoration: "flat", canChangeIcon: false) {
+            state "default", action:"levelUp", icon:"st.illuminance.illuminance.bright"
+        }
+        standardTile("lDown", "device.switchLevel", inactiveLabel: false,decoration: "flat", canChangeIcon: false) {
+            state "default", action:"levelDown", icon:"st.illuminance.illuminance.light"
+        }
+        valueTile( "power", "device.power", inactiveLabel: false, decoration: "flat") {
+            state "power", label: '${currentValue} Watts'
+        }
 
 		main(["switch"])
 		details(["switch", "lUp", "lDown", "levelSliderControl", "level" , "power", "refresh" ])
@@ -103,10 +101,10 @@ metadata {
 def parse(description) {
 	//log.debug "parse() - $description"
 	def results = []
-
-	if ( description == "updated" )
-		return
-
+	
+    if ( description == "updated" )
+    	return
+        
 	if (description?.name && description?.value)
 	{
 		results << createEvent(name: "${description?.name}", value: "${description?.value}")
@@ -116,73 +114,73 @@ def parse(description) {
 // handle commands
 def setBulbPower(value) {
 	state.bulbPower = value
-	log.debug "In child with bulbPower of ${state.bulbPower}"
+    log.debug "In child with bulbPower of ${state.bulbPower}"
 }
 
 def on() {
 	log.debug "Executing 'on'"
-	sendEvent(name:"switch",value:on)
+    sendEvent(name:"switch",value:on)
 	parent.on(this)
 
 	def levelSetting = device.latestValue("level") as Float ?: 1.0
-	def bulbPowerMax = device.latestValue("setBulbPower") as Float
-	def calculatedPower = bulbPowerMax * (levelSetting / 100)
-	sendEvent(name: "power", value: calculatedPower.round(1))
-
-	if (device.latestValue("level") == null) {
+    //def bulbPowerMax = device.latestValue("setBulbPower") as Float
+    //def calculatedPower = bulbPowerMax * (levelSetting / 100)
+    //sendEvent(name: "power", value: calculatedPower.round(1))
+    
+    if (device.latestValue("level") == null) {
 		sendEvent( name: "level", value: 1.0 )
-	}
+    }
 }
 
 def off() {
 	log.debug "Executing 'off'"
-	sendEvent(name:"switch",value:off)
+    sendEvent(name:"switch",value:off)
 	parent.off(this)
-	sendEvent(name: "power", value: 0.0)
+    sendEvent(name: "power", value: 0.0)
 }
 
 def levelUp() {
 	def level = device.latestValue("level") as Integer ?: 0
-	def step = state.stepsize as float
-
-	level+= step
-
-	if ( level > 100 )
-		level = 100
-
-	setLevel(level)
+    def step = state.stepsize as float
+    
+    level+= step
+    
+    if ( level > 100 )
+    	level = 100
+    
+    setLevel(level)
 }
 
 def levelDown() {
 	def level = device.latestValue("level") as Integer ?: 0
-	def step = state.stepsize as float
-
-	level-= step
-
+    def step = state.stepsize as float
+    
+    level-= step
+    
 	if ( level <  1 )
-		level = 1
-
-	setLevel(level)
+    	level = 1
+    
+    setLevel(level)
 }
 
 def setLevel(value) {
 	log.debug "in setLevel with value: ${value}"
 	def level = value as Integer
-
-	sendEvent( name: "level", value: level )
-	sendEvent( name: "switch.setLevel", value:level )
+    
+    sendEvent( name: "level", value: level )
+    sendEvent( name: "switch.setLevel", value:level )
 	parent.setLevel( this, level )
+    
 
-
-	if (( level > 0 ) && ( level <= 100 ))
-		on()
-	else
-		off()
-
-	def levelSetting = level as float
-	def bulbPowerMax = device.latestValue("setBulbPower") as float
-	def calculatedPower = bulbPowerMax * (levelSetting / 100)
-	sendEvent(name: "power", value: calculatedPower.round(1))
+    if (( level > 0 ) && ( level <= 100 ))
+    	on()
+    else
+    	off()
+    
+    //def levelSetting = level as float
+    //def bulbPowerMax = device.latestValue("setBulbPower") as float
+    //def calculatedPower = bulbPowerMax * (levelSetting / 100)
+    //sendEvent(name: "power", value: calculatedPower.round(1))
 }
 
 def poll() {
@@ -200,29 +198,29 @@ def installed() {
 }
 
 def updated() {
-	initialize()
-	refresh()
+    initialize()
+    refresh()
 }
 
 def initialize() {
 	if ( !settings.stepsize )
-		state.stepsize = 10 //set the default stepsize
-	else
-		state.stepsize = settings.stepsize
+        state.stepsize = 10 //set the default stepsize
+    else
+    	state.stepsize = settings.stepsize
 }
 
 /*******************************************************************************
- Method :uninstalled(args)
- (args) :none
- returns:Nothing
- ERRORS :No error handling is done
-
- Purpose:This is standard ST method.
- Gets called when "remove" is selected in child device "preferences"
- tile. It also get's called when "deleteChildDevice(child)" is
- called from parent service manager app.
- *******************************************************************************/
+	Method :uninstalled(args)
+    (args) :none
+    returns:Nothing
+    ERRORS :No error handling is done
+    
+    Purpose:This is standard ST method.
+    		Gets called when "remove" is selected in child device "preferences" 
+    		tile. It also get's called when "deleteChildDevice(child)" is 
+            called from parent service manager app.
+*******************************************************************************/
 def uninstalled() {
 	log.debug "Executing 'uninstall' in device type"
-	parent.uninstallFromChildDevice(this)
+    parent.uninstallFromChildDevice(this)
 }

smartapps/mmacaula/tcp-bulbs-more-reliable.src/tcp-bulbs-more-reliable.groovy

@@ -0,0 +1,679 @@
+/**
+ *  TCP Bulbs (Connect)
+ *
+ *  Copyright 2014 Todd Wackford
+ *
+ *  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.
+ *
+ */
+
+import java.security.MessageDigest;
+
+private apiUrl() { "https://tcp.greenwavereality.com/gwr/gop.php?" }
+
+definition(
+    name: "TCP Bulbs - more reliable",
+    namespace: "mmacaula",
+    author: "Mike Macaulay",
+    description: "Connect your TCP bulbs to SmartThings using Cloud to Cloud integration. You must create a remote login acct on TCP Mobile App.",
+    category: "SmartThings Labs",
+    iconUrl: "https://s3.amazonaws.com/smartapp-icons/Partner/tcp.png",
+    iconX2Url: "https://s3.amazonaws.com/smartapp-icons/Partner/tcp@2x.png",
+    singleInstance: true
+)
+
+
+preferences {
+    def msg = """Tap 'Next' after you have entered in your TCP Mobile remote credentials.
+
+Once your credentials are accepted, SmartThings will scan your TCP installation for Bulbs."""
+
+    page(name: "selectDevices", title: "Connect Your TCP Lights to SmartThings", install: false, uninstall: true, nextPage: "chooseBulbs") {
+        section("TCP Connected Remote Credentials") {
+            input "username", "text", title: "Enter TCP Remote Email/UserName", required: true
+            input "password", "password", title: "Enter TCP Remote Password", required: true
+            paragraph msg
+        }
+    }
+
+    page(name: "chooseBulbs", title: "Choose Bulbs to Control With SmartThings", content: "initialize")
+}
+
+def installed() {
+    debugOut "Installed with settings: ${settings}"
+
+    unschedule()
+    unsubscribe()
+
+    setupBulbs()
+
+    log.debug "schedule every 5 minutes syncronizeDevices)"
+    runEvery5Minutes(syncronizeDevices)
+}
+
+def updated() {
+    debugOut "Updated with settings: ${settings}"
+
+    unschedule()
+
+    setupBulbs()
+
+    log.debug "schedule update every 5 minutes syncronizeDevices)"
+    runEvery5Minutes(syncronizeDevices)
+}
+
+def uninstalled()
+{
+    unschedule() //in case we have hanging runIn()'s
+}
+
+private removeChildDevices(delete)
+{
+    debugOut "deleting ${delete.size()} bulbs"
+    debugOut "deleting ${delete}"
+    delete.each {
+        deleteChildDevice(it.device.deviceNetworkId)
+    }
+}
+
+def uninstallFromChildDevice(childDevice)
+{
+    def errorMsg = "uninstallFromChildDevice was called and "
+    if (!settings.selectedBulbs) {
+        debugOut errorMsg += "had empty list passed in"
+        return
+    }
+
+    def dni = childDevice.device.deviceNetworkId
+
+    if ( !dni ) {
+        debugOut errorMsg += "could not find dni of device"
+        return
+    }
+
+    def newDeviceList = settings.selectedBulbs - dni
+    app.updateSetting("selectedBulbs", newDeviceList)
+
+    debugOut errorMsg += "completed succesfully"
+}
+
+
+def setupBulbs() {
+    debugOut "In setupBulbs"
+
+    def bulbs = state.devices
+    def deviceFile = "TCP Bulb"
+
+    selectedBulbs.each { did ->
+        //see if this is a selected bulb and install it if not already
+        def d = getChildDevice(did)
+
+        if(!d) {
+            def newBulb = bulbs.find { (it.did) == did }
+            d = addChildDevice("wackford", deviceFile, did, null, [name: "${newBulb?.name}", label: "${newBulb?.name}", completedSetup: true])
+
+            /*if ( isRoom(did) ) { //change to the multi light group icon for a room device
+                d.setIcon("switch", "on",  "st.lights.multi-light-bulb-on")
+                d.setIcon("switch", "off",  "st.lights.multi-light-bulb-off")
+                d.save()
+            }*/
+
+        } else {
+            debugOut "We already added this device"
+        }
+    }
+
+    // Delete any that are no longer in settings
+    def delete = getChildDevices().findAll { !selectedBulbs?.contains(it.deviceNetworkId) }
+    removeChildDevices(delete)
+
+    //we want to ensure syncronization between rooms and bulbs
+    //syncronizeDevices()
+}
+
+def initialize() {
+
+    atomicState.token = ""
+
+    getToken()
+
+    if ( atomicState.token == "error" ) {
+        return dynamicPage(name:"chooseBulbs", title:"TCP Login Failed!\r\nTap 'Done' to try again", nextPage:"", install:false, uninstall: false) {
+            section("") {}
+        }
+    } else {
+        "we're good to go"
+        debugOut "We have Token."
+    }
+
+    //getGatewayData() //we really don't need anything from the gateway
+
+    deviceDiscovery()
+
+    def options = devicesDiscovered() ?: []
+
+    def msg = """Tap 'Done' after you have selected the desired devices."""
+
+    return dynamicPage(name:"chooseBulbs", title:"TCP and SmartThings Connected!", nextPage:"", install:true, uninstall: true) {
+        section("Tap Below to View Device List") {
+            input "selectedBulbs", "enum", required:false, title:"Select Bulb/Fixture", multiple:true, options:options
+            paragraph msg
+        }
+    }
+}
+
+def deviceDiscovery() {
+    def data = "<gip><version>1</version><token>${atomicState.token}</token></gip>"
+
+    def Params = [
+        cmd: "RoomGetCarousel",
+        data: "${data}",
+        fmt: "json"
+    ]
+
+    def cmd = toQueryString(Params)
+
+    def rooms = ""
+    log.debug 'trying to discover devices'
+    apiPost(cmd) { response ->
+        rooms = response.data.gip.room
+    }
+
+    debugOut "rooms data = ${rooms}"
+
+    def devices = []
+    def bulbIndex = 1
+    def lastRoomName = null
+    def deviceList = []
+
+    if ( rooms[1] == null ) {
+        def roomId = rooms.rid
+        def roomName = rooms.name
+        devices  = rooms.device
+        if ( devices[1] != null ) {
+            debugOut "Room Device Data: did:${roomId} roomName:${roomName}"
+            //deviceList += ["name" : "${roomName}", "did" : "${roomId}", "type" : "room"]
+            devices.each({
+                debugOut "Bulb Device Data: did:${it?.did} room:${roomName} BulbName:${it?.name}"
+                deviceList += ["name" : "${roomName} ${it?.name}", "did" : "${it?.did}", "type" : "bulb"]
+            })
+        } else {
+            debugOut "Bulb Device Data: did:${it?.did} room:${roomName} BulbName:${it?.name}"
+            deviceList += ["name" : "${roomName} ${it?.name}", "did" : "${it?.did}", "type" : "bulb"]
+        }
+    } else {
+        rooms.each({
+            devices  = it.device
+            def roomName = it.name
+            if ( devices[1] != null ) {
+                def roomId = it?.rid
+                debugOut "Room Device Data: did:${roomId} roomName:${roomName}"
+                //deviceList += ["name" : "${roomName}", "did" : "${roomId}", "type" : "room"]
+                devices.each({
+                    debugOut "Bulb Device Data: did:${it?.did} room:${roomName} BulbName:${it?.name}"
+                    deviceList += ["name" : "${roomName} ${it?.name}", "did" : "${it?.did}", "type" : "bulb"]
+                })
+            } else {
+                debugOut "Bulb Device Data: did:${devices?.did} room:${roomName} BulbName:${devices?.name}"
+                deviceList += ["name" : "${roomName} ${devices?.name}", "did" : "${devices?.did}", "type" : "bulb"]
+            }
+        })
+    }
+    devices = ["devices" : deviceList]
+    state.devices = devices.devices
+}
+
+Map devicesDiscovered() {
+    def devices =  state.devices
+    def map = [:]
+    if (devices instanceof java.util.Map) {
+        devices.each {
+            def value = "${it?.name}"
+            def key = it?.did
+            map["${key}"] = value
+        }
+    } else { //backwards compatable
+        devices.each {
+            def value = "${it?.name}"
+            def key = it?.did
+            map["${key}"] = value
+        }
+    }
+    map
+}
+
+def getGatewayData() {
+    debugOut "In getGatewayData"
+
+    def data = "<gip><version>1</version><token>${atomicState.token}</token></gip>"
+
+    def qParams = [
+        cmd: "GatewayGetInfo",
+        data: "${data}",
+        fmt: "json"
+    ]
+
+    def cmd = toQueryString(qParams)
+
+    apiPost(cmd) { response ->
+        debugOut "the gateway reponse is ${response.data.gip.gateway}"
+    }
+
+}
+
+def getToken(Closure callback) {
+
+    atomicState.token = ""
+
+    if (password) {
+        def hashedPassword = generateMD5(password)
+
+        def data = "<gip><version>1</version><email>${username}</email><password>${hashedPassword}</password></gip>"
+
+        def qParams = [
+            cmd : "GWRLogin",
+            data: "${data}",
+            fmt : "json"
+        ]
+
+        def cmd = toQueryString(qParams)
+
+        apiPost(cmd) { response ->
+            def status = response.data.gip.rc
+
+            //sendNotificationEvent("Get token status ${status}")
+
+            if (status != "200") {//success code = 200
+                def errorText = response.data.gip.error
+                debugOut "Error logging into TCP Gateway. Error = ${errorText}"
+                atomicState.token = "error"
+            } else {
+                atomicState.token = response.data.gip.token
+                if(callback){
+                    callback.call()
+                }
+            }
+        }
+    } else {
+        log.warn "Unable to log into TCP Gateway. Error = Password is null"
+        atomicState.token = "error"
+    }
+}
+
+def apiPost(String data, Integer retryCount = 0, Closure callback) {
+    debugOut "In apiPost with data: ${data}"
+    def params = [
+        uri: apiUrl(),
+        body: data
+    ]
+
+    httpPost(params) {
+        response ->
+            def rc = response.data.gip.rc
+
+            if ( rc == "200" ) {
+                debugOut ("Return Code = ${rc} = Command Succeeded.")
+                callback.call(response)
+
+            }  else if ( rc.startsWith("4") || rc.startsWith("5") ) {
+                debugOut "Return Code = ${rc} = Error: Something happened!" //Error code from gateway
+                sendNotificationEvent("Return Code = ${rc} = Error: Something happened!  Retry # ${retryCount}" )
+                log.debug "Refreshing Token"
+                 if(retryCount > 5){
+                    // give up, send a notification
+                    sendNotificationEvent("TCP Lighting is having Communication Errors. Error code = ${rc}. Gave up after ${retryCount} tries")
+                }
+                getToken({  ->
+                    def updatedTokenData = data.replaceFirst("<token>[^<]*</token>", '<token>${atomicState.token}</token>')
+                    // try again if we got our token
+                    sendNotificationEvent('re-fetched token, trying again')
+
+                    apiPost(updatedTokenData, retryCount++, callback)
+                })
+                //callback.call(response) //stubbed out so getToken works (we had race issue)
+
+            } else {
+                log.error "Return Code = ${rc} = Error!" //Error code from gateway
+                sendNotificationEvent("TCP Lighting is having Communication Errors. Error code = ${rc}. Check that TCP Gateway is online")
+                callback.call(response)
+            }
+    }
+}
+
+
+//this is not working. TCP power reporting is broken. Leave it here for future fix
+def calculateCurrentPowerUse(deviceCapability, usePercentage) {
+    debugOut "In calculateCurrentPowerUse()"
+
+    debugOut "deviceCapability: ${deviceCapability}"
+    debugOut "usePercentage: ${usePercentage}"
+
+    def calcPower = usePercentage * 1000
+    def reportPower = calcPower.round(1) as String
+
+    debugOut "report power = ${reportPower}"
+
+    return reportPower
+}
+
+def generateSha256(String s) {
+
+    MessageDigest digest = MessageDigest.getInstance("SHA-256")
+    digest.update(s.bytes)
+    new BigInteger(1, digest.digest()).toString(16).padLeft(40, '0')
+}
+
+def generateMD5(String s) {
+    MessageDigest digest = MessageDigest.getInstance("MD5")
+    digest.update(s.bytes);
+    new BigInteger(1, digest.digest()).toString(16).padLeft(32, '0')
+}
+
+String toQueryString(Map m) {
+    return m.collect { k, v -> "${k}=${URLEncoder.encode(v.toString())}" }.sort().join("&")
+}
+
+def checkDevicesOnline(bulbs) {
+    debugOut "In checkDevicesOnline()"
+
+    def onlineBulbs = []
+    def thisBulb = []
+
+    bulbs.each {
+        def dni = it?.did
+        thisBulb = it
+
+        def data = "<gip><version>1</version><token>${atomicState.token}</token><did>${dni}</did></gip>"
+
+        def qParams = [
+            cmd: "DeviceGetInfo",
+            data: "${data}",
+            fmt: "json"
+        ]
+
+        def cmd = toQueryString(qParams)
+
+        def bulbData = []
+
+        apiPost(cmd) { response ->
+            bulbData = response.data.gip
+        }
+
+        if ( bulbData?.offline == "1" ) {
+            debugOut "${it?.name} is offline with offline value of ${bulbData?.offline}"
+
+        } else {
+            debugOut "${it?.name} is online with offline value of ${bulbData?.offline}"
+            onlineBulbs += thisBulb
+        }
+    }
+    return onlineBulbs
+}
+
+def syncronizeDevices() {
+    debugOut "In syncronizeDevices"
+
+    def update = getChildDevices().findAll { selectedBulbs?.contains(it.deviceNetworkId) }
+
+    update.each {
+        def dni = getChildDevice( it.deviceNetworkId )
+        debugOut "dni = ${dni}"
+
+        if (isRoom(dni)) {
+            pollRoom(dni)
+        } else {
+            poll(dni)
+        }
+    }
+    getToken()
+
+}
+
+boolean isRoom(dni) {
+    def device = state.devices.find() {(( it.type == 'room') && (it.did == "${dni}"))}
+}
+
+boolean isBulb(dni) {
+    def device = state.devices.find() {(( it.type == 'bulb') && (it.did == "${dni}"))}
+}
+
+def debugEvent(message, displayEvent) {
+
+    def results = [
+        name: "appdebug",
+        descriptionText: message,
+        displayed: displayEvent
+    ]
+    log.debug "Generating AppDebug Event: ${results}"
+    sendEvent (results)
+
+}
+
+def debugOut(msg) {
+    log.debug msg
+    //sendNotificationEvent(msg) //Uncomment this for troubleshooting only
+}
+
+
+/**************************************************************************
+ Child Device Call In Methods
+ **************************************************************************/
+def on(childDevice) {
+    debugOut "On request from child device"
+
+    def dni = childDevice.device.deviceNetworkId
+    def data = ""
+    def cmd = ""
+
+    if ( isRoom(dni) ) { // this is a room, not a bulb
+        data = "<gip><version>1</version><token>$atomicState.token</token><rid>${dni}</rid><type>power</type><value>1</value></gip>"
+        cmd = "RoomSendCommand"
+    } else {
+        data = "<gip><version>1</version><token>$atomicState.token</token><did>${dni}</did><type>power</type><value>1</value></gip>"
+        cmd = "DeviceSendCommand"
+    }
+
+    def qParams = [
+        cmd: cmd,
+        data: "${data}",
+        fmt: "json"
+    ]
+
+    cmd = toQueryString(qParams)
+
+    apiPost(cmd) { response ->
+        debugOut "ON result: ${response.data}"
+    }
+
+    //we want to ensure syncronization between rooms and bulbs
+    //runIn(2, "syncronizeDevices")
+}
+
+def off(childDevice) {
+    debugOut "Off request from child device"
+
+    def dni = childDevice.device.deviceNetworkId
+    def data = ""
+    def cmd = ""
+
+    if ( isRoom(dni) ) { // this is a room, not a bulb
+        data = "<gip><version>1</version><token>$atomicState.token</token><rid>${dni}</rid><type>power</type><value>0</value></gip>"
+        cmd = "RoomSendCommand"
+    } else {
+        data = "<gip><version>1</version><token>$atomicState.token</token><did>${dni}</did><type>power</type><value>0</value></gip>"
+        cmd = "DeviceSendCommand"
+    }
+
+    def qParams = [
+        cmd: cmd,
+        data: "${data}",
+        fmt: "json"
+    ]
+
+    cmd = toQueryString(qParams)
+
+    apiPost(cmd) { response ->
+        debugOut "${response.data}"
+    }
+
+    //we want to ensure syncronization between rooms and bulbs
+    //runIn(2, "syncronizeDevices")
+}
+
+def setLevel(childDevice, value) {
+    debugOut "setLevel request from child device"
+
+    def dni = childDevice.device.deviceNetworkId
+    def data = ""
+    def cmd = ""
+
+    if ( isRoom(dni) ) { // this is a room, not a bulb
+        data = "<gip><version>1</version><token>${atomicState.token}</token><rid>${dni}</rid><type>level</type><value>${value}</value></gip>"
+        cmd = "RoomSendCommand"
+    } else {
+        data = "<gip><version>1</version><token>${atomicState.token}</token><did>${dni}</did><type>level</type><value>${value}</value></gip>"
+        cmd = "DeviceSendCommand"
+    }
+
+    def qParams = [
+        cmd: cmd,
+        data: "${data}",
+        fmt: "json"
+    ]
+
+    cmd = toQueryString(qParams)
+
+    apiPost(cmd) { response ->
+        debugOut "${response.data}"
+    }
+
+    //we want to ensure syncronization between rooms and bulbs
+    //runIn(2, "syncronizeDevices")
+}
+
+// Really not called from child, but called from poll() if it is a room
+def pollRoom(dni) {
+    debugOut "In pollRoom"
+    def data = ""
+    def cmd = ""
+    def roomDeviceData = []
+
+    data = "<gip><version>1</version><token>${atomicState.token}</token><rid>${dni}</rid><fields>name,power,control,status,state</fields></gip>"
+    cmd = "RoomGetDevices"
+
+    def qParams = [
+        cmd: cmd,
+        data: "${data}",
+        fmt: "json"
+    ]
+
+    cmd = toQueryString(qParams)
+
+    apiPost(cmd) { response ->
+        roomDeviceData = response.data.gip
+    }
+
+    debugOut "Room Data: ${roomDeviceData}"
+
+    def totalPower = 0
+    def totalLevel = 0
+    def cnt = 0
+    def onCnt = 0 //used to tally on/off states
+
+    roomDeviceData.device.each({
+        if ( getChildDevice(it.did) ) {
+            totalPower += it.other.bulbpower.toInteger()
+            totalLevel += it.level.toInteger()
+            onCnt += it.state.toInteger()
+            cnt += 1
+        }
+    })
+
+    def avgLevel = totalLevel/cnt
+    def usingPower = totalPower * (avgLevel / 100) as float
+    def room = getChildDevice( dni )
+
+    //the device is a room but we use same type file
+    sendEvent( dni, [name: "setBulbPower",value:"${totalPower}"] ) //used in child device calcs
+
+    //if all devices in room are on, room is on
+    if ( cnt == onCnt ) { // all devices are on
+        sendEvent( dni, [name: "switch",value:"on"] )
+        sendEvent( dni, [name: "power",value:usingPower.round(1)] )
+
+    } else { //if any device in room is off, room is off
+        sendEvent( dni, [name: "switch",value:"off"] )
+        sendEvent( dni, [name: "power",value:0.0] )
+    }
+
+    debugOut "Room Using Power: ${usingPower.round(1)}"
+}
+
+def poll(childDevice) {
+    debugOut "In poll() with ${childDevice}"
+
+
+    def dni = childDevice.device.deviceNetworkId
+
+    def bulbData = []
+    def data = ""
+    def cmd = ""
+
+    if ( isRoom(dni) ) { // this is a room, not a bulb
+        pollRoom(dni)
+        return
+    }
+
+    data = "<gip><version>1</version><token>${atomicState.token}</token><did>${dni}</did></gip>"
+    cmd = "DeviceGetInfo"
+
+    def qParams = [
+        cmd: cmd,
+        data: "${data}",
+        fmt: "json"
+    ]
+
+    cmd = toQueryString(qParams)
+
+    apiPost(cmd) { response ->
+        bulbData = response.data.gip
+        debugOut "This Bulbs Data Return = ${bulbData}"
+
+        def bulb = getChildDevice( dni )
+
+        //set the devices power max setting to do calcs within the device type
+        if ( bulbData.other.bulbpower )
+            sendEvent( dni, [name: "setBulbPower",value:"${bulbData.other.bulbpower}"] )
+
+        if (( bulbData.state == "1" ) && ( bulb?.currentValue("switch") != "on" ))
+            sendEvent( dni, [name: "switch",value:"on"] )
+
+        if (( bulbData.state == "0" ) && ( bulb?.currentValue("switch") != "off" ))
+            sendEvent( dni, [name: "switch",value:"off"] )
+
+        //if ( bulbData.level != bulb?.currentValue("level")) {
+        //    sendEvent( dni, [name: "level",value: "${bulbData.level}"] )
+        //    sendEvent( dni, [name: "setLevel",value: "${bulbData.level}"] )
+        //}
+
+        if (( bulbData.state == "1" ) && ( bulbData.other.bulbpower )) {
+            def levelSetting = bulbData.level as float
+            def bulbPowerMax = bulbData.other.bulbpower as float
+            def calculatedPower = bulbPowerMax * (levelSetting / 100)
+            sendEvent( dni, [name: "power", value: calculatedPower.round(1)] )
+        }
+
+        if (( bulbData.state == "0" ) && ( bulbData.other.bulbpower ))
+            sendEvent( dni, [name: "power", value: 0.0] )
+
+    }
+
+
+}

smartapps/prempoint-com/prempoint.src/prempoint.groovy

@@ -1,345 +0,0 @@
-/**
- *  SmartThings service for Prempoint
- *
- *  Author: Prempoint Inc. (c) 2016
- *   
- */
-definition(
-    name: "Prempoint",
-    namespace: "prempoint.com",
-    author: "Prempoint Inc.",
-    description: "SmartThings service for Prempoint",
-    category: "Connections",
-    iconUrl: "http://www.prempoint.com/images/social_app_emblem_50x50.png",
-    iconX2Url: "http://www.prempoint.com/images/social_app_emblem_100x100.png",
-    iconX3Url: "http://www.prempoint.com/images/social_app_emblem_150x150.png",
-    oauth: [displayName: "Prempoint", displayLink: "http://www.prempoint.com/"])
-
-preferences {
-	section("Allow Prempoint to Control & Access These Things...") {
-		input "switches", "capability.switch", title: "Which Switches?", multiple: true, required: false
-        input "locks", "capability.lock", title: "Which Locks?", multiple: true, required: false
-        input "garagedoors", "capability.garageDoorControl", title: "Which Garage Doors?", multiple: true, required: false
-        //input "doors", "capability.doorControl", title: "Which Doors?", multiple: true, required: false
-        input "cameras", "capability.imageCapture", title: "Which Cameras?", multiple: true, required: false
-	}
-}
-
-mappings {
-	path("/list") {
-		action: [
-			GET: "listDevices"
-		]
-	}
-	path("/switches") {
-		action: [
-			GET: "listSwitches"
-		]
-	}
-	path("/switches/:id") {
-		action: [
-			GET: "showSwitch"
-		]
-	}
-    path("/switches/:id/:command") {
-		action: [
-			GET: "updateSwitch"
-		]
-	}
-	path("/switches/:id/:command/:level") {
-		action: [
-			GET: "updateSwitch"
-		]
-	}
-	path("/locks") {
-		action: [
-			GET: "listLocks"
-		]
-	}
-	path("/locks/:id") {
-		action: [
-			GET: "showLock"
-		]
-	}
-	path("/locks/:id/:command") {
-		action: [
-			GET: "updateLock"
-		]
-	}
-    path("/doors/:id") {
-		action: [
-			GET: "showDoor"
-		]
-	}
-   	path("/doors/:id/:command") {
-		action: [
-			GET: "updateDoor"
-		]
-	}
-	path("/garagedoors/:id") {
-		action: [
-			GET: "showGarageDoor"
-		]
-	}
-   	path("/garagedoors/:id/:command") {
-		action: [
-			GET: "updateGarageDoor"
-		]
-	}
-    path("/cameras/:id") {
-		action: [
-			GET: "showCamera"
-		]
-	}  
-    path("/cameras/:id/:command") {
-		action: [
-			GET: "updateCamera"
-		]
-	}  
-}
-
-def installed() {}
-
-def updated() {}
-
-def listDevices() {
-	log.debug "entering listDevices"
-    //return listSwitches() + listLocks() + listGarageDoors() + listDoors() + listCameras()
-    return listSwitches() + listLocks() + listGarageDoors() + listCameras()
-}
-
-//switches
-def listSwitches() {
-    log.debug "entering listSwitches"
-	switches.collect{showDevice(it,"switch")}
-}
-
-def showSwitch() {
-	log.debug "entering showSwitches"
-	show(switches, "switch")
-}
-
-def updateSwitch() {
-	log.debug "entering updateSwitches"
-	update(switches, "switch")
-}
-
-//locks
-def listLocks() {
-	log.debug "entering listLocks"
-	locks.collect{showDevice(it,"lock")}
-}
-
-def showLock() {
-	log.debug "entering showLock"
-	show(locks, "lock")
-}
-
-def updateLock() {
-	log.debug "entering updateLock"
-	update(locks, "lock")
-}
-
-//doors
-def listDoors() {
-	log.debug "entering listDoors"
-	locks.collect{showDevice(it,"door")}
-}
-
-def showDoor() {
-	log.debug "entering showDoors"
-	show(doors, "door")
-}
-
-def updateDoor() {
-	log.debug "entering updateDoor"
-	update(doors, "door")
-}
-
-//garagedoors
-def listGarageDoors() {
-	log.debug "entering listGarageDoors"
-	locks.collect{showDevice(it,"garagedoor")}
-}
-
-def showGarageDoor() {
-	log.debug "entering showGarageDoors"
-	show(garagedoors, "garagedoor")
-}
-
-def updateGarageDoor() {
-	log.debug "entering updateGarageDoor"
-	update(gargedoors, "garagedoor")
-}
-
-//cameras
-def listCameras() {
-	log.debug "entering listCameras"
-	cameras.collect{showDevice(it,"image")}
-}
-
-def showCamera() {
-	log.debug "entering showCameras"
-	show(cameras, "camera")
-}
-
-def updateCamera() {
-	log.debug "entering updateCamera"
-	update(cameras, "camera")
-}
-
-def deviceHandler(evt) {}
-
-private update(devices, type) {
-	def rc = null
-
-	//def command = request.JSON?.command
-    def command = params.command
-    
-    log.debug "update, request: params: ${params}, devices: $devices.id type=$type command=$command"
-    
-    // Process the command.
-	if (command) 
-    {
-		def dev = devices.find { it.id == params.id }
-		if (!dev) {
-			httpError(404, "Device not found: $params.id")
-		} else if (type == "switch") {
-			switch(command) {
-			    case "on":
-			    	rc = dev.on()
-			    	break
-			    case "off":
-			    	rc = dev.off()
-			    	break
-			    default:
-			    	httpError(400, "Device command=$command is not a valid for device=$it.id $dev")
-			}
-		} else if (type == "lock") {
-			switch(command) {
-			    case "lock":
-			    	rc = dev.lock()
-			    	break
-			    case "unlock":
-			    	rc = dev.unlock()
-			    	break
-			    default:
-			    	httpError(400, "Device command=$command is not a valid for device:=$it.id $dev")
-			}
-		} else if (type == "door") {
-			switch(command) {
-			    case "open":
-			    	rc = dev.open()
-			    	break
-			    case "close":
-			    	rc = dev.close()
-			    	break
-			    default:
-			    	httpError(400, "Device command=$command is not a valid for device=$it.id $dev")
-			}
-		} else if (type == "garagedoor") {
-			switch(command) {
-			    case "open":
-			    	rc = dev.open()
-			    	break
-			    case "close":
-			    	rc = dev.close()
-			    	break
-			    default:
-			    	httpError(400, "Device command=$command is not a valid for device=$it.id $dev")
-			}
-		} else if (type == "camera") {
-			switch(command) {
-			    case "take":
-			    	rc = dev.take()
-			    	log.debug "Device command=$command device=$it.id $dev current image=$it.currentImage"
-			    	break
-			    default:
-			    	httpError(400, "Device command=$command is not a valid for device=$it.id $dev")
-			}
-		}
-
-		log.debug "executed device=$it.id $dev command=$command rc=$rc"
-        
-        // Check that the device is a switch that is currently on, supports 'setLevel"
-        // and that a level was specified.
-        int level = params.level ? params.level as int : -1;
-        if ((type == "switch") && (dev.currentValue('switch') == "on") && hasLevel(dev) && (level != -1)) {            
-            log.debug "device about to setLevel=$level"
-            dev.setLevel(level);
-        }
-        
-        // Show the device info if necessary.
-        if (rc == null) {
-        	rc = showDevice(dev, type)
-        }
-	}
-    
-    return rc
-}
-
-private show(devices, type) {
-	def dev = devices.find { it.id == params.id }
-	if (!dev) {
-		httpError(404, "Device not found")
-	} else { 
-        // Show the device info.
-        showDevice(dev, type)
-	}
-}
-
-private showDevice(it, type) {
-	def props = null
-
-	// Get the current state for the device type.
-	def state = [it.currentState(type)]
-    
-	// Check that whether the a switch device with level support is located and update the returned device type.
-    def devType =  type
-    
-    if (type == "switch" && hasLevel(it)) {
-    	// Assign "switchWithLevel" to device type.
-    	devType = "switchWithLevel"
-        // Add the level state.
-        def levelState = it.currentState("level")
-        if (levelState) {
-        	state.add(levelState)
-        }
-    }
-    
-    log.debug "device label=$it.label type=$devType"
-    
-    // Assign the device item properties if appropriate.
-    if (it) {
-    	props = [id: it.id, label: it.label, type: devType, state: state]
-        // Add the hub information to the device properties
-        // if appropriate.
-        if (it.hub) {
-        	props.put("location", it.hub.hub.location)
-        }
-        if (it.currentImage) {
-        	props.put("currentImage", it.currentImage)
-        }
-    }
-    
-    return props
-}
-
-private hasLevel(device) {
-    // Default return value.
-    def rc = false;
-
-	// Get the device supported commands.
-    def supportedCommands = device.supportedCommands
-    
-    // Check to see if the "setLevel" was found and assign
-    // the appropriate return value.
-    if (supportedCommands) {
-        // Find the "setLevel" command. 
-        rc = supportedCommands.toString().indexOf("setLevel") != -1
-    }
-    
-    log.debug "hasLevel device label=$device.label supportedCommands=$supportedCommands rc=$rc"
-            
-    return rc
-}

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

@@ -30,6 +30,7 @@ definition(
 preferences {
 	page(name:"mainPage", title:"Hue Device Setup", content:"mainPage", refreshTimeout:5)
 	page(name:"bridgeDiscovery", title:"Hue Bridge Discovery", content:"bridgeDiscovery", refreshTimeout:5)
+	page(name:"bridgeDiscoveryFailed", title:"Bridge Discovery Failed", content:"bridgeDiscoveryFailed", refreshTimeout:0)
 	page(name:"bridgeBtnPush", title:"Linking with your Hue", content:"bridgeLinking", refreshTimeout:5)
 	page(name:"bulbDiscovery", title:"Hue Device Setup", content:"bulbDiscovery", refreshTimeout:5)
 }
@@ -53,12 +54,21 @@ def bridgeDiscovery(params=[:])
 	def options = bridges ?: []
 	def numFound = options.size() ?: 0
 
-	if (numFound == 0 && state.bridgeRefreshCount > 25) {
-    	log.trace "Cleaning old bridges memory"
-    	state.bridges = [:]
-        state.bridgeRefreshCount = 0
-        app.updateSetting("selectedHue", "")
-    }
+	if (numFound == 0) {
+		if (state.bridgeRefreshCount == 25) {
+			log.trace "Cleaning old bridges memory"
+			state.bridges = [:]
+			app.updateSetting("selectedHue", "")
+		} else if (state.bridgeRefreshCount > 100) {
+			// five minutes have passed, give up
+			// there seems to be a problem going back from discovey failed page in some instances (compared to pressing next)
+			// however it is probably a SmartThings settings issue
+			state.bridges = [:]
+			app.updateSetting("selectedHue", "")
+			state.bridgeRefreshCount = 0
+			return bridgeDiscoveryFailed()
+		}
+	}
 
 	ssdpSubscribe()
 
@@ -79,6 +89,13 @@ def bridgeDiscovery(params=[:])
 	}
 }
 
+def bridgeDiscoveryFailed() {
+	return dynamicPage(name:"bridgeDiscoveryFailed", title: "Bridge Discovery Failed", nextPage: "bridgeDiscovery") {
+		section("Failed to discover any Hue Bridges. Please confirm that the Hue Bridge is connected to the same network as your SmartThings Hub, and that it has power.") {
+		}
+	}
+}
+
 def bridgeLinking()
 {
 	int linkRefreshcount = !state.linkRefreshcount ? 0 : state.linkRefreshcount as int
@@ -88,19 +105,15 @@ def bridgeLinking()
 	def nextPage = ""
 	def title = "Linking with your Hue"
     def paragraphText
-    def hueimage = null
 	if (selectedHue) {
 		paragraphText = "Press the button on your Hue Bridge to setup a link. "
-        hueimage = "http://huedisco.mediavibe.nl/wp-content/uploads/2013/09/pair-bridge.png"
     } else {
     	paragraphText = "You haven't selected a Hue Bridge, please Press \"Done\" and select one before clicking next."
-        hueimage = null
     }
 	if (state.username) { //if discovery worked
 		nextPage = "bulbDiscovery"
 		title = "Success!"
 		paragraphText = "Linking to your hub was a success! Please click 'Next'!"
-        hueimage = null
 	}
 
 	if((linkRefreshcount % 2) == 0 && !state.username) {
@@ -110,8 +123,6 @@ def bridgeLinking()
 	return dynamicPage(name:"bridgeBtnPush", title:title, nextPage:nextPage, refreshInterval:refreshInterval) {
 		section("") {
 			paragraph """${paragraphText}"""
-            if (hueimage != null)
-            	image "${hueimage}"
 		}
 	}
 }
@@ -135,13 +146,14 @@ def bulbDiscovery() {
 	if((bulbRefreshCount % 5) == 0) {
 		discoverHueBulbs()
 	}
+	def selectedBridge = state.bridges.find { key, value -> value?.serialNumber?.equalsIgnoreCase(selectedHue) }
+	def title = selectedBridge?.value?.name ?: "Find bridges"
 
 	return dynamicPage(name:"bulbDiscovery", title:"Bulb Discovery Started!", nextPage:"", refreshInterval:refreshInterval, install:true, uninstall: true) {
 		section("Please wait while we discover your Hue Bulbs. Discovery can take five minutes or more, so sit back and relax! Select your device below once discovered.") {
 			input "selectedBulbs", "enum", required:false, title:"Select Hue Bulbs (${numFound} found)", multiple:true, options:bulboptions
 		}
 		section {
-			def title = getBridgeIP() ? "Hue bridge (${getBridgeIP()})" : "Find bridges"
 			href "bridgeDiscovery", title: title, description: "", state: selectedHue ? "complete" : "incomplete", params: [override: true]
 
 		}
@@ -323,6 +335,8 @@ private getDeviceType(hueType) {
 		return "Hue Bulb"
 	else if (hueType?.equalsIgnoreCase("Color Light"))
 		return "Hue Bloom"
+	else if (hueType?.equalsIgnoreCase("Color Temperature Light"))
+		return "Hue White Ambiance Bulb"
 	else
 		return null
 }
@@ -346,26 +360,29 @@ def addBulbs() {
 			def newHueBulb
 			if (bulbs instanceof java.util.Map) {
 				newHueBulb = bulbs.find { (app.id + "/" + it.value.id) == dni }
-                if (newHueBulb != null) {
-                    d = addChildBulb(dni, newHueBulb?.value?.type, newHueBulb?.value?.name, newHueBulb?.value?.hub)
+
+				if (newHueBulb != null) {
+					d = addChildBulb(dni, newHueBulb?.value?.type, newHueBulb?.value?.name, newHueBulb?.value?.hub)
 					if (d) {
 						log.debug "created ${d.displayName} with id $dni"
+						d.completedSetup = true
 						d.refresh()
 					}
-                } else {
-                	log.debug "$dni in not longer paired to the Hue Bridge or ID changed"
-                }
+				} else {
+					log.debug "$dni in not longer paired to the Hue Bridge or ID changed"
+				}
 			} else {
-            	//backwards compatable
+			 	//backwards compatable
 				newHueBulb = bulbs.find { (app.id + "/" + it.id) == dni }
 				d = addChildBulb(dni, "Extended Color Light", newHueBulb?.value?.name, newHueBulb?.value?.hub)
+				d?.completedSetup = true
 				d?.refresh()
 			}
 		} else {
 			log.debug "found ${d.displayName} with id $dni already exists, type: '$d.typeName'"
 			if (bulbs instanceof java.util.Map) {
 				// Update device type if incorrect
-            	def newHueBulb = bulbs.find { (app.id + "/" + it.value.id) == dni }
+				def newHueBulb = bulbs.find { (app.id + "/" + it.value.id) == dni }
 				upgradeDeviceType(d, newHueBulb?.value?.type)
 			}
 		}
@@ -397,6 +414,7 @@ def addBridge() {
             }
         	if (newbridge) {
 				d = addChildDevice("smartthings", "Hue Bridge", selectedHue, vbridge.value.hub)
+				d?.completedSetup = true
  				log.debug "created ${d.displayName} with id ${d.deviceNetworkId}"
                 def childDevice = getChildDevice(d.deviceNetworkId)
                 childDevice.sendEvent(name: "serialNumber", value: vbridge.value.serialNumber)
@@ -484,7 +502,21 @@ void bridgeDescriptionHandler(physicalgraph.device.HubResponse hubResponse) {
 		def bridges = getHueBridges()
 		def bridge = bridges.find {it?.key?.contains(body?.device?.UDN?.text())}
 		if (bridge) {
-			bridge.value << [name:body?.device?.friendlyName?.text(), serialNumber:body?.device?.serialNumber?.text(), verified: true]
+			// serialNumber from API is in format of 0017882413ad (mac address), however on the actual bridge only last six
+			// characters are printed on the back so using that to identify bridge
+			def idNumber = body?.device?.serialNumber?.text()
+			if (idNumber?.size() >= 6)
+				idNumber = idNumber[-6..-1].toUpperCase()
+
+			// usually in form of bridge name followed by (ip), i.e. defaults to Philips Hue (192.168.1.2)
+			// replace IP with serial number to make it easier for user to identify
+			def name = body?.device?.friendlyName?.text()
+			def index = name?.indexOf('(')
+			if (index != -1) {
+				name = name.substring(0,index)
+				name += " ($idNumber)"
+			}
+			bridge.value << [name:name, serialNumber:body?.device?.serialNumber?.text(), verified: true]
 		} else {
 			log.error "/description.xml returned a bridge that didn't exist"
 		}

smartapps/smartthings/turn-it-on-for-1-minutes.src/turn-it-on-for-1-minutes.groovy

@@ -1,56 +0,0 @@
-/**
- *  Copyright 2015 SmartThings
- *
- *  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
- *  in compliance with the License. You may obtain a copy of the License at:
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed
- *  on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License
- *  for the specific language governing permissions and limitations under the License.
- *
- *  Turn It On For 5 Minutes
- *  Turn on a switch when a contact sensor opens and then turn it back off 5 minutes later.
- *
- *  Author: SmartThings
- */
-definition(
-    name: "Turn It On For 1 Minutes",
-    namespace: "smartthings",
-    author: "mr.kim",
-    description: "When a SmartSense Multi is opened, a switch will be turned on, and then turned off after 5 minutes.",
-    category: "Safety & Security",
-    iconUrl: "https://s3.amazonaws.com/smartapp-icons/Meta/light_contact-outlet.png",
-    iconX2Url: "https://s3.amazonaws.com/smartapp-icons/Meta/light_contact-outlet@2x.png"
-)
-
-preferences {
-	section("When it opens..."){
-		input "contact1", "capability.contactSensor"
-	}
-	section("Turn on a switch for 5 minutes..."){
-		input "switch1", "capability.switch"
-	}
-}
-
-def installed() {
-	log.debug "Installed with settings: ${settings}"
-	subscribe(contact1, "contact.open", contactOpenHandler)
-}
-
-def updated(settings) {
-	log.debug "Updated with settings: ${settings}"
-	unsubscribe()
-	subscribe(contact1, "contact.open", contactOpenHandler)
-}
-
-def contactOpenHandler(evt) {
-	switch1.on()
-	def fiveMinuteDelay = 60 * 1
-	runIn(fiveMinuteDelay, turnOffSwitch)
-}
-
-def turnOffSwitch() {
-	switch1.off()
-}

smartapps/smartthings/ubi.src/ubi.groovy

@@ -107,8 +107,8 @@ mappings {
 	path("/locks") {
 		action: [
 			GET: "listLocks",
-			PUT: "updateLock",
-			POST: "updateLock"
+			PUT: "updateLocks",
+			POST: "updateLocks"
 		]
 	}
 	path("/locks/:id") {
@@ -442,31 +442,87 @@ def executePhrase() {
 }
 
 private void updateAll(devices) {
+	def type = params.param1
 	def command = request.JSON?.command
-	if (command)
-	{
-		command = command.toLowerCase()
-		devices."$command"()
+	if (!devices) {
+		httpError(404, "Devices not found")
+	}
+	if (command){
+		devices.each { device ->
+			executeCommand(device, type, command)
+		}
 	}
 }
 
 private void update(devices) {
 	log.debug "update, request: ${request.JSON}, params: ${params}, devices: $devices.id"
-	//def command = request.JSON?.command
-	def command = params.command
-	if (command)
-	{
-		command = command.toLowerCase()
-		def device = devices.find { it.id == params.id }
-		if (!device)
-		{
+	def type = params.param1
+	def command = request.JSON?.command
+	def device = devices?.find { it.id == params.id }
+
+	if (!device) {
 			httpError(404, "Device not found")
-		}
-		else
-		{
-			device."$command"()
-		}
 	}
+
+	if (command) {
+		executeCommand(device, type, command)
+	}
+}
+
+/**
+ * Validating the command passed by the user based on capability.
+ * @return boolean
+ */
+def validateCommand(device, deviceType, command) {
+	def capabilityCommands = getDeviceCapabilityCommands(device.capabilities)
+	def currentDeviceCapability = getCapabilityName(deviceType)
+	if (capabilityCommands[currentDeviceCapability]) {
+		return command in capabilityCommands[currentDeviceCapability] ? true : false
+	} else {
+		// Handling other device types here, which don't accept commands
+		httpError(400, "Bad request.")
+	}
+}
+
+/**
+ * Need to get the attribute name to do the lookup. Only
+ * doing it for the device types which accept commands
+ * @return attribute name of the device type
+ */
+def getCapabilityName(type) {
+    switch(type) {
+		case "switches":
+			return "Switch"
+		case "locks":
+			return "Lock"
+		default:
+			return type
+	}
+}
+
+/**
+ * Constructing the map over here of
+ * supported commands by device capability
+ * @return a map of device capability -> supported commands
+ */
+def getDeviceCapabilityCommands(deviceCapabilities) {
+	def map = [:]
+	deviceCapabilities.collect {
+		map[it.name] = it.commands.collect{ it.name.toString() }
+	}
+	return map
+}
+
+/**
+ * Validates and executes the command
+ * on the device or devices
+ */
+def executeCommand(device, type, command) {
+	if (validateCommand(device, type, command)) {
+		device."$command"()
+	} else {
+		httpError(403, "Access denied. This command is not supported by current capability.")
+	}	
 }
 
 private show(devices, type) {