Support new devices

switchbotContactSensor

@@ -70,4 +70,3 @@ def parse(body)
         sendEvent(name: "motion", value: ([true, "DETECTED"].contains(body.moveDetected)) ? "active" : "inactive")
     }
 }
-

switchbotEventsApp

@@ -157,15 +157,22 @@ def observeEvent()
 
 def processEvent(eventMap)
 {
-    if(!eventMap) { return }
-
     logDebug("incoming event: ${eventMap}")
 
+    if(!eventMap) { return }
+
     if("changeReport" != eventMap?.eventType) { return }
 
     // check whether we know about this type of device
     def devTypeInfo = deviceTypesMap.getAt(eventMap.context.deviceType)    
-    if(!devTypeInfo) { return }
+    if(!devTypeInfo) {
+        if (eventMap.context.lockState) {
+            // This is a Smart Lock Pro which doesn't include device type in the message
+            devTypeInfo = deviceTypesMap.getAt("WoLock")
+            logDebug("Received event with no device type, mapping to Smart Lock")
+        }
+        else return
+    }
 
     // build the event that we'll pass to the driver
     def newEvent = [:]
@@ -196,14 +203,16 @@ import groovy.transform.Field
     [
         WoContact: [name: "Contact Sensor", attrs: contactSensorAttrsMap],
         WoLock: [name: "Smart Lock"],
+        WoLockPro: [name: "Smart Lock"]
         WoMeter: [name: "Meter"],
         WoMeterPlus: [name: "Meter"],
         WoHub2: [name: "Meter"],
         WoIOSensor: [name: "Meter"],
         WoPlugJP: [name: "Plug Mini", attrs: commonSwitchAttrsMap], 
         WoPlugUS: [name: "Plug Mini", attrs: commonSwitchAttrsMap], 
         WoPresence: [name: "Motion Sensor", attrs: motionSensorAttrsMap],
-        WoStrip: [name: "Strip Light", attrs: commonSwitchAttrsMap],        
+        WoStrip: [name: "Strip Light", attrs: commonSwitchAttrsMap],
+        WoKeypadTouch: [name: "Keypad Touch"],
     ]
 
 static @Field allDevsAttrs = 

switchbotKeypadTouch

@@ -0,0 +1,310 @@
+/*
+
+Copyright 2024 - dsegall
+
+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.22 dsegall Added Keypad Touch
+
+*/
+
+import groovy.json.JsonBuilder
+import groovy.transform.Field
+
+import java.util.Calendar
+import javax.crypto.*
+import javax.crypto.spec.*
+
+import hubitat.helper.HexUtils
+
+@Field static final String PERMANENT = "permanent"
+@Field static final String TIMED = "timeLimit"
+@Field static final String DISPOSABLE = "disposable"
+@Field static final String EMERGENCY = "urgent"
+
+@Field static final String SUCCESS = "success"
+@Field static final String FAILED = "failed"
+@Field static final String TIMEOUT = "timeout"
+
+@Field static final String PASSCODE_NORMAL = "normal"
+@Field static final String PASSCODE_EXPIRED = "expired"
+
+@Field static final MILLISECONDS_IN_DAY = 86400000
+@Field static final MILLISECONDS_IN_HOUR = 3600000
+
+metadata
+{
+    definition(name: "SwitchBot Keypad Touch", namespace: "tomw", author: "dsegall", importUrl: "")
+    {
+        capability "Refresh"
+        capability "LockCodes"
+        capability "Initialize"
+
+        command "createKey", [[name: "Name*", type: "STRING"], [name: "Password*", type: "STRING"], [name: "Type", type: "ENUM", constraints: [PERMANENT, TIMED, DISPOSABLE, EMERGENCY]], [name: "Start Time", type: "STRING"], [name: "End Time", type: "STRING"]]
+        command "deleteKeyByName", [[name: "Name*", type: "STRING"]]
+    }
+
+    preferences
+    {
+        section
+        {
+            input name: "logEnable", type: "bool", title: "Enable debug logging", defaultValue: false
+            input name: "lockCodeEncryption", type: "bool", title: "Enable lock code encryption", defaultValue: false
+            input name: "deleteExpiredCodes", type: "bool", title: "Automatically delete expired codes", defaultValue: true
+        }
+    }
+}
+
+def logDebug(msg) 
+{
+    if (logEnable)
+    {
+        log.debug(msg)
+    }
+}
+
+def initialize()
+{
+    sendEvent(name: "codeLength", value: 12)
+    sendEvent(name: "maxCodes", value: 100)
+    refresh()
+}
+
+def updated() {
+    updateCodesAttr()
+}
+
+def refresh()
+{
+    readDeviceDetails()
+}
+
+def parse(body)
+{
+    if (logEnable)
+    logDebug("parse: ${body}")
+
+    if (body.result == "success") {
+        if (body.eventName == "createKey")
+            sendEvent(name: "codeChanged", value: "added")
+        else if (body.eventName == "deleteKey")
+            sendEvent(name: "codeChanged", value: "deleted")
+
+        atomicState.lastSuccessfulModificationTime = new Date()
+        logDebug("Scheduling refresh task...")
+        runIn(30000, "refresh")
+    }
+    else sendEvent(name: "codeChanged", value: "failed")
+}
+
+def writeDeviceCommand(command, parameter = "default", commandType = "command")
+{
+    def id = getParent()?.getId(device.getDeviceNetworkId())
+    if(id)
+    {
+        getParent()?.writeDeviceCommand(id, command, parameter, commandType)
+    }
+}
+
+def createKey(String name, String code, String type=PERMANENT, String startTimeS=null, String endTimeS=null) {
+    if (!atomicState.lockCodesByName.containsKey(name)) {
+        logDebug("createKey ${name}")
+        long startTime = 0
+        long endTime = 0
+        Date now = new Date()
+
+        if (type == TIMED && !startTimeS) {
+            startTime = now.getTime() + 5000
+        }
+
+        if (startTimeS) {
+            Calendar cal = timeToday(startTimeS)
+            Date date = cal.getTime()
+            startTime = date.getTime()
+            if (startTime < now.getTime())
+                startTime = now.getTime() + 5000
+        }
+
+        if (type == TIMED && !endTimeS) {
+            endTimeS = "23:59"
+        }
+
+        if (endTimeS) {
+            Calendar cal = timeToday(endTimeS)
+            Date date = cal.getTime()
+            endTime = date.getTime()
+            if (now.after(date)) {
+                if (startTimeS) startTime += MILLISECONDS_IN_DAY
+                endTime += MILLISECONDS_IN_DAY
+            }
+
+            if (startTimeS && endTime - startTime < MILLISECONDS_IN_HOUR)
+                endTime = startTime + MILLISECONDS_IN_HOUR + 60000
+        }
+
+      Map params = ["name": name, "type": type, "password": code, "startTime": startTime, "endTime": endTime]
+            try {
+              writeDeviceCommand("createKey", params)
+            }
+        catch (Exception e) {
+            logDebug("createKey failed: ${e.getMessage()}")
+        }
+    }
+}
+
+Calendar timeToday(String time) {
+    Calendar today = Calendar.getInstance()
+    today.set(Calendar.SECOND, 0)
+    today.set(Calendar.MILLISECOND, 0)
+    String[] parts = time.split(":")
+    today.set(Calendar.HOUR_OF_DAY, parts[0] as int)
+    today.set(Calendar.MINUTE, parts[1] as int)
+    return today
+}
+
+def deleteKey(String id) {
+     logDebug("deleteKey id=${id}")
+    try {
+         writeDeviceCommand("deleteKey", ["id": id])
+    }
+    catch (Exception e) {
+        logDebug("deleteKey failed: ${e.getMessage()}")
+    }
+}
+
+def deleteKeyByName(String name) {
+    Map lockCode = atomicState.lockCodesByName[name]
+    logDebug("deleteKeyByName found key ${lockCode}")
+    if (lockCode) {
+        deleteAndRemoveLockCode(lockCode)
+    }
+}
+
+def deleteAndRemoveLockCode(Map lockCode) {
+    if (lockCode) {
+        def newCodes = []
+        def newCodesByName = [:]
+
+        newCodes.addAll(atomicState.lockCodes)
+        newCodesByName.putAll(atomicState.lockCodesByName)
+        newCodes.remove(lockCode)
+        newCodesByName.remove(lockCode.name)
+        atomicState.lockCodes = newCodes
+        atomicState.lockCodesByName = newCodesByName
+        deleteKey(lockCode.id.toString())
+    }
+}
+
+def readDeviceDetails()
+{
+    if(!parent) { return }
+
+    devices = parent.readDevices()?.deviceList
+    details = devices?.find { it.deviceId == parent.getId(device.getDeviceNetworkId()) }
+
+    logDebug("Details=" + details)
+
+    atomicState.lockCodes = []
+    atomicState.lockCodesByName = [:]
+    def expiredCodes = []
+
+    def newCodes = []
+    def newCodesByName = [:]
+
+    logDebug("Details=" + details)
+    for (it in details?.keyList) {
+        logDebug("Code=" + it)
+        Map lockCode =  ["id": it.id, "name": it.name, "code": it.password, "iv": it.iv, "status": it.status]
+        newCodes << lockCode
+        newCodesByName[it.name] = lockCode
+        if (it.status == PASSCODE_EXPIRED)
+            expiredCodes << it.id
+    }
+
+    atomicState.lockCodes = newCodes
+    atomicState.lockCodesByName = newCodesByName
+
+    updateCodesAttr()
+
+    logDebug("Found ${expiredCodes.size()} expired codes")
+    if (!expiredCodes.isEmpty()) {
+        cleanExpiredCodes(expiredCodes)
+    }
+}
+
+def updateCodesAttr() {
+    sendEvent(name: "lockCodes", value: getCodes())
+}
+
+def cleanExpiredCodes(expiredCodes) {
+    boolean clean = deleteExpiredCodes == null ? true : deleteExpiredCodes
+    logDebug("cleanExpiredCodes=${clean} size=${expiredCodes.size}")
+    if (clean) {
+        for (code in expiredCodes) {
+            String codeStr = code.toString()
+            logDebug("Deleting expired code ${codeStr}")
+            deleteKey(codeStr)
+        }
+    }
+}
+
+def deleteCode(position) {
+    if (position >= 0 && position < atomicState.lockCodes.size() && atomicState.lockCodes[position])
+        deleteAndRemoveLockCode(atomicState.lockCodes[position])
+}
+
+def setCodeLength() {
+    // Not supported
+}
+
+def setCode(codeposition, pincode, name) {
+    deleteCode(codeposition)
+    createKey(name, pincode)
+}
+
+def getCodes() {
+    boolean encryptionEnabled=lockCodeEncryption == null ? false : lockCodeEncryption
+    def codes = [:]
+    int i = 0
+    for (it in atomicState.lockCodes) {
+        codes[i++] = ["name": it.name, "code": decryptPasscode(it.iv, it.code)]
+    }
+
+    String str = new JsonBuilder(codes).toString()
+    return encryptionEnabled ? encrypt(str) : str
+}
+
+def decryptPasscode(String iv, String encrypted) {
+    if (!parent) return
+    parent.cacheSecretKey()
+    String secretKey = parent.getDataValue("secretKey")
+     try {
+         byte[] ivBytes = HexUtils.hexStringToByteArray(iv)
+        def ivSpec = new IvParameterSpec(ivBytes)
+        def skeySpec = new SecretKeySpec(HexUtils.hexStringToByteArray(secretKey), "AES")
+
+        def cipher = Cipher.getInstance("AES/CBC/PKCS5Padding")
+        cipher.init(Cipher.DECRYPT_MODE, skeySpec, ivSpec)
+        byte[] original = cipher.doFinal(encrypted.decodeBase64())
+
+        return new String(original)
+    } catch (Exception ex) {
+        logDebug(ex)
+    }
+
+    return null
+}

switchbotMeter

@@ -18,6 +18,7 @@ limitations under the License.
 
 Change history:
 
+0.9.14 - dsegall - Added Battery capability
 0.9.13 - tomw - Added Contact Sensor and Motion Sensor support.
 0.9.12 - tomw - Added Smart Lock and webhook events support.
 0.9.0  - tomw - Initial release.
@@ -32,6 +33,7 @@ metadata
         capability "RelativeHumidityMeasurement"
         capability "Refresh"
         capability "TemperatureMeasurement"
+        capability "Battery"
     }
 }
 
@@ -70,5 +72,9 @@ def parse(body)
         def tempVal = degC ? body.temperature.toDouble() : celsiusToFahrenheit(body.temperature.toDouble())
         sendEvent(name: "temperature", value: tempVal?.toDouble())
     }
+    if(null != body.battery)
+    {
+        def battery = body.battery.toInteger()
+        sendEvent(name: "battery", value: battery)
+    }
 }
-

switchbotMotionSensor

@@ -61,4 +61,3 @@ def parse(body)
         sendEvent(name: "motion", value: ([true, "DETECTED"].contains(body.moveDetected)) ? "active" : "inactive")
     }
 }
-