switchbotSystem

/*

Copyright 2020 - tomw

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.

-------------------------------------------

Change history:

0.9.21 - tomw -
    Added temperature, humidity, and lightLevel support for Hub 2 (in SwitchBot Meter driver).
    Added Indoor/Outdoor Thermo-Hygrometer (in SwitchBot Meter driver).
0.9.20 - tomw - Added Blind Tilt support.
0.9.18 - tomw - Added Color Bulb support (in SwitchBot Strip Light driver).
0.9.15 - tomw - Added Plug Mini support.
0.9.14 - tomw - API v1.1 support.
0.9.13 - tomw - Added Contact Sensor and Motion Sensor support.
0.9.12 - tomw - Added Smart Lock and webhook events support.
0.9.11 - tomw - Added Strip Light support.
0.9.10 - tomw - Added MeterPlus support.
0.9.6  - tomw - Added Humidifier support.
0.9.3  - tomw - Modified child device creation to reduce confusion around grouped Curtain devices.
0.9.0  - tomw - Initial release.

*/

metadata
{
    definition(name: "SwitchBot System", namespace: "tomw", author: "tomw", importUrl: "")
    {
        capability "Actuator"
        capability "Initialize"
        capability "Refresh"
        
        command "createChildDevices"
        command "deleteChildDevices"
        
        command "cacheHttpParams"
        command "cacheToken"
        
        command "parse", ["eventMap"]
        
        command "executeScene", ["sceneId"]
        
        attribute "commStatus", "string"        
    }
}

preferences
{
    section
    {
        input "openToken", "text", title: "Token (from SwitchBot app)", required: true
        input "secretKey", "text", title: "Secret Key (leave blank to use API v1.0; required for API v1.1)", required: false
        input "refreshInterval", "number", title: "Polling refresh interval in seconds (caution: 1000 operation limit per day)", defaultValue: 300
        input name: "logEnable", type: "bool", title: "Enable debug logging", defaultValue: false
    }
}

import groovy.transform.Field
static @Field gComponentFlag = "gComponent"

def logDebug(msg) 
{
    if (logEnable)
    {
        log.debug(msg)
    }
}

def initialize()
{
    sendEvent(name: "commStatus", value: "unknown")
    
    try
    {
        readDevices()
        readScenes()
        refresh()
    }
    catch (Exception e)
    {
        logDebug("initialize() failed: ${e.message}")
        return
    }
}

def updated()
{
    configure()
}

def configure()
{
    state.clear
    
    initialize()
}

def refresh()
{
    unschedule(refresh)
    
    for(child in getChildDevices())
    {
        if(child.getDataValue(gComponentFlag))
        {
            // This is a Generic Component type.  Do something special.
            def devStatus = readDeviceStatus(getId(child.getDeviceNetworkId()))?.body
            // TODO: finish the steps to pass this to parse() on the child if this ever gets used
            continue
        }
        
        // This is a custom device type.  Pass the refresh() down.
        child.refresh()
    }
    
    runIn(refreshInterval ?: 300, refresh)
}

def uninstalled()
{
    unschedule()
}

def checkCommStatus()
{
    switch(device.currentValue("commStatus"))
    {
        case "active":
            logDebug("checkCommStatus() success")
            return true
        
        case "error":
        case "inactive":
        case "unknown":
        default:
            logDebug("checkCommStatus() failed")
            return false
    }
}

def cacheToken()
{
    // workaround to support app that isn't this driver's parent
    updateDataValue("token", openToken)
}

def cacheHttpParams()
{
    // workaround to support app that isn't this driver's parent
    updateDataValue("params", groovy.json.JsonOutput.toJson(genParamsMain("")))
}

def parse(Map eventMap)
{
    findChildDevice(eventMap.deviceId, eventMap.deviceType)?.parse(eventMap)
}

def refreshFromParent(child)
{
    if(!child)
    {
        return
    }
    
    try
    {
        def id = getId(child.getDeviceNetworkId())
        def respData = readDeviceStatus(id)
        
        if(!respData)
        {
            return
        }
        
        getChildDevice(child.getDeviceNetworkId())?.parse(respData.body)
    }
    catch (Exception e)
    {
        log.debug "refresh() failed: ${e.message}"
    }
}

def createChildDevices()
{
    def devices = getDevices()

    if(!devices)
    {
        return
    }
    
    for(it in devices?.deviceList)
    {
        logDebug("device = ${it}")
        
        if(it.deviceType == "Hub 2")
        {
            // the Hub 2 has temp/humidity that reports the same as a Meter
            it.deviceType = "Meter"
        }
        
        if(["MeterPlus", "WoIOSensor"].contains(it.deviceType))
        {
            // MeterPlus and Indoor/Outdoor sensor uses same API as Meter
            it.deviceType = "Meter"
        }
        
        if(["Plug Mini (US)", "Plug Mini (JP)"].contains(it.deviceType)) { it.deviceType = "Plug Mini" }        
        if(it.deviceType == "Color Bulb") { it.deviceType = "Strip Light" }        
        if(it.deviceType == "Curtain3") { it.deviceType = "Curtain" }
        
        if((it.deviceId && it.deviceName && it.deviceType) && !findChildDevice(it.deviceId, it.deviceType))
        {
            if(["Curtain", "Blind Tilt"].contains(it.deviceType))
            {
                // only create children for ungrouped Curtains and group masters
                if(!((it.group != true) || (it.master == true)))
                {
                    continue
                }
            }
            
            createChildDevice(it.deviceName, it.deviceId, it.deviceType)
        }
    }
    
    devices?.infraredRemoteList?.each
    {
        logDebug("device = ${it}")
        if((it.deviceId && it.deviceName && it.remoteType) && !findChildDevice(it.deviceId, it.remoteType))
        {
            createChildDevice(it.deviceName, it.deviceId, "IR Device")
        }
    }
}

def deleteChildDevices()
{
    for(child in getChildDevices())
    {
        deleteChildDevice(child.deviceNetworkId)
    }
}

def childName(name, deviceType)
{
    return "${name.toString()}-${deviceType.toString()}"
}

def childDni(id, deviceType)
{
    return "${id.toString()}-${deviceType.toString()}"
}

def getId(dni)
{
    // the logic here has to match childDni()
    
    def splitDni = dni?.split('-')
    
    if(splitDni)
    {
        def id = ""
        splitDni.eachWithIndex()
        { it, i ->
            if(i < (splitDni.size() - 1))
            {
                id = id + it + "-"
            }
        }
        return id.substring(0, id.length() - 1)
    }                                                           
}

def findChildDevice(id, deviceType)
{
    return getChildDevice(childDni(id, deviceType))
}

def createChildDevice(name, id, deviceType)
{
    try
    {
        def customDevTypes = ["Bot", "Curtain", "Meter", "IR Device", "Humidifier", "Strip Light", "Smart Lock", "Motion Sensor", "Contact Sensor", "Plug Mini", "Blind Tilt"]
        def genericDevTypes = []
        
        deviceType = deviceType.toString()
        
        if(["Hub Mini"].contains(deviceType))
        {
            // unsupported child type, so bail out
            return
        }
        
        if(!(customDevTypes + genericDevTypes).contains(deviceType))
        {
            logDebug("createChildDevice: deviceType not supported")
            throw new Exception("deviceType not supported")
        }
        
        def virtDevType = ((customDevTypes.contains(deviceType)) ? "SwitchBot " : "Generic Component ") + deviceType
        def virtDevData = [name: childName(name, deviceType), label: childName(name, deviceType), isComponent: false]
        
        if(virtDevType.contains("Generic Component"))
        {
            def child = addChildDevice("hubitat", virtDevType, childDni(id, deviceType), virtDevData)
            
            // mark this device with a unique data value so that we can tell the difference easily between Generic Component and custom types
            child?.updateDataValue(gComponentFlag, "yes")
            
            return child
        }
        else
        {
            return addChildDevice(virtDevType, childDni(id, deviceType), virtDevData)
        }
    }
    catch (Exception e)
    {
        logDebug("createChildDevice() failed: ${e.message}")
        return
    }
}

def readDevices()
{
    try
    {
        def resp = httpGetExec(genParamsMain("devices"), true)
        
        if(resp)
        {
            setDevices(resp?.data?.body)
        }
        
        sendEvent(name: "commStatus", value: "good")
    }
    catch (Exception e)
    {
        logDebug("readDevices() failed: ${e.message}")
        sendEvent(name: "commStatus", value: "error")
        
        throw(e)
    }
        
}

def setDevices(devices)
{
    state.devices = devices
}

def getDevices()
{
    return state.devices
}

def readScenes()
{
    try
    {
        def resp = httpGetExec(genParamsMain("scenes"), true)
        
        if(resp)
        {
            setScenes(resp?.data?.body)
        }
        
        sendEvent(name: "commStatus", value: "good")
    }
    catch (Exception e)
    {
        logDebug("readScenes() failed: ${e.message}")
        sendEvent(name: "commStatus", value: "error")
        
        throw(e)
    }
        
}

def setScenes(scenes)
{
    state.scenes = scenes
}

def getScenes()
{
    return state.scenes
}

def executeScene(sceneId)
{
    try
    {
        return httpExec("POST", genParamsMain("scenes/${sceneId}/execute"), true)?.data
    }
    catch (Exception e)
    {
        logDebug("executeScene failed: ${e.message}")
        throw(e)
    }
}

def writeDeviceCommand(id, command, parameter, commandType)
{
    try
    {
        def body = [command: command, parameter: parameter, commandType: commandType]
        body = groovy.json.JsonOutput.toJson(body)
        
        return httpExec("POST", genParamsMain("devices/${id}/commands", body), true)?.data
    }
    catch (Exception e)
    {
        logDebug("writeDeviceCommand failed: ${e.message}")
        throw(e)
    }
}

def readDeviceStatus(id)
{
    try
    {
        def resp = httpExec("GET", genParamsMain("devices/${id}/status"), true)?.data
        return resp
    }
    catch (Exception e)
    {
        logDebug("readDeviceStatus failed: ${e.message}")
        throw(e)
    }
}

def getBaseURI()
{
    return "https://api.switch-bot.com/"
}

def isOldApi()
{
    // if the secretKey wasn't specified, this is likely a v1.0 API user
    //  this affects the HTTP headers needed for authentication as well as the path
    return ["", null].contains(secretKey)
}

def genParamsMain(suffix, body = null)
{    
    def oldApi = isOldApi()    
    
    def apiVerStr = oldApi ? "v1.0/" : "v1.1/"

    def params =
        [
            uri: getBaseURI() + apiVerStr + suffix,
            headers:
            [
                'Authorization' : openToken,
                'Content-Type' : 'application/json; charset=utf8'
            ]
        ]
    
    if(!oldApi)
    {
        params.headers += calcSignv11()
    }
    
    if(body)
    {
        params['body'] = body
    }
 
    return params
}

def calcSignv11()
{
    def t = (new Date().getTime())?.toString()
    def nonce = ""
    def data = openToken + t + nonce
    
    return [ t: t, sign: hmac_sha256(secretKey, data)?.toUpperCase(), nonce: nonce ]
}

def hmac_sha256(String secretKey, String data)
{
    def mac = javax.crypto.Mac.getInstance("HmacSHA256")
    def secretKeySpec = new javax.crypto.spec.SecretKeySpec(secretKey.getBytes(), "HmacSHA256")
    
    mac.init(secretKeySpec)    
    def sign = mac.doFinal(data.getBytes())
    
    // send it back as a Base64 string
    return org.apache.commons.codec.binary.Base64.encodeBase64String(sign)
}

def httpGetExec(params, throwToCaller = false)
{
    logDebug("httpGetExec(${params})")
    
    try
    {
        def result
        httpGet(params)
        { resp ->
            if (resp)
            {
                logDebug("resp.data = ${resp.data}")
                result = resp
            }
        }
        return result
    }
    catch (Exception e)
    {
        logDebug("httpGetExec() failed: ${e.message}")
        //logDebug("status = ${e.getResponse().getStatus().toInteger()}")
        if(throwToCaller)
        {
            throw(e)
        }
    }
}

def httpPostExec(params, throwToCaller = false)
{
    logDebug("httpPostExec(${params})")
    
    try
    {
        def result
        httpPost(params)
        { resp ->
            if (resp)
            {
                logDebug("resp.data = ${resp.data}")
                result = resp
            }
        }
        return result
    }
    catch (Exception e)
    {
        logDebug("httpPostExec() failed: ${e.message}")
        //logDebug("status = ${e.getResponse().getStatus().toInteger()}")
        if(throwToCaller)
        {
            throw(e)
        }
    }
}

def httpExec(operation, params, throwToCaller = false)
{
    def res
    
    switch(operation)
    {
        default:
            logDebug("unsupported Http operation")
        
            if(throwToCaller)
            {
                throw new Exception("unsupported Http operation")
            }
            break
        
        case "POST":
            res = httpPostExec(params, throwToCaller)
            break
        
        case "GET":
            res = httpGetExec(params, throwToCaller)
            break
    }
    
    return res
}