| #!/usr/bin/env python |
| |
| |
| # |
| # Copyright (c) 2013-2017 Nest Labs, Inc. |
| # All rights reserved. |
| # |
| # 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. |
| # |
| |
| # |
| # @file |
| # Python interface for Weave Device Manager |
| # |
| |
| """Weave Device Manager interface |
| """ |
| |
| import functools |
| import sys |
| import os |
| import re |
| import copy |
| import binascii |
| import datetime |
| import time |
| from threading import Thread, Lock, Event |
| from ctypes import * |
| from plugins.weave.Weave import Weave |
| |
| __all__ = [ 'WeaveDeviceManager', 'NetworkInfo', 'DeviceManagerException', 'DeviceError', 'DeviceManagerError' ] |
| |
| NetworkType_WiFi = 1 |
| NetworkType_Thread = 2 |
| |
| WiFiMode_AdHoc = 1 |
| WiFiMode_Managed = 2 |
| |
| WiFiRole_Station = 1 |
| WiFiRole_AccessPoint = 2 |
| |
| WiFiSecurityType_None = 1 |
| WiFiSecurityType_WEP = 2 |
| WiFiSecurityType_WPAPersonal = 3 |
| WiFiSecurityType_WPA2Personal = 4 |
| WiFiSecurityType_WPA2MixedPersonal = 5 |
| WiFiSecurityType_WPAEnterprise = 6 |
| WiFiSecurityType_WPA2Enterprise = 7 |
| WiFiSecurityType_WPA2MixedEnterprise = 8 |
| |
| RendezvousMode_EnableWiFiRendezvousNetwork = 0x0001 |
| RendezvousMode_Enable802154RendezvousNetwork = 0x0002 |
| RendezvousMode_EnableFabricRendezvousAddress = 0x0004 |
| |
| TargetFabricId_AnyFabric = 0xFFFFFFFFFFFFFFFF |
| TargetFabricId_NotInFabric = 0 |
| |
| TargetDeviceMode_Any = 0x00000000 # Locate all devices regardless of mode. |
| TargetDeviceMode_UserSelectedMode = 0x00000001 # Locate all devices in 'user-selected' mode -- i.e. where the device has |
| # has been directly identified by a user, e.g. by pressing a button. |
| |
| TargetVendorId_Any = 0xFFFF |
| |
| TargetProductId_Any = 0xFFFF |
| |
| TargetDeviceId_Any = 0xFFFFFFFFFFFFFFFF |
| |
| DeviceFeature_HomeAlarmLinkCapable = 0x00000001 # Indicates a Nest Protect that supports connection to a home alarm panel |
| DeviceFeature_LinePowered = 0x00000002 # Indicates a device that requires line power |
| |
| SystemTest_ProductList = { 'thermostat' : 0x235A000A, |
| 'topaz' : 0x235A0003} |
| |
| def _VoidPtrToByteArray(ptr, len): |
| if ptr: |
| v = bytearray(len) |
| memmove((c_byte * len).from_buffer(v), ptr, len) |
| return v |
| else: |
| return None |
| |
| def _ByteArrayToVoidPtr(array): |
| if array != None: |
| return cast( (c_byte * len(array)) .from_buffer_copy(array), c_void_p) |
| else: |
| return c_void_p(0) |
| |
| def _IsByteArrayAllZeros(array): |
| for i in range(len(array)): |
| if (array[i] != 0): |
| return False |
| return True |
| |
| def _ByteArrayToHex(array): |
| return binascii.hexlify(bytes(array)) |
| |
| class NetworkInfo: |
| def __init__(self, networkType=None, networkId=None, wifiSSID=None, wifiMode=None, wifiRole=None, |
| wifiSecurityType=None, wifiKey=None, |
| threadNetworkName=None, threadExtendedPANId=None, threadNetworkKey=None, |
| wirelessSignalStrength=None): |
| self.NetworkType = networkType |
| self.NetworkId = networkId |
| self.WiFiSSID = wifiSSID |
| self.WiFiMode = wifiMode |
| self.WiFiRole = wifiRole |
| self.WiFiSecurityType = wifiSecurityType |
| self.WiFiKey = wifiKey |
| self.ThreadNetworkName = threadNetworkName |
| self.ThreadExtendedPANId = threadExtendedPANId |
| self.ThreadNetworkKey = threadNetworkKey |
| self.WirelessSignalStrength = wirelessSignalStrength |
| |
| def Print(self, prefix=""): |
| print "%sNetwork Type: %s" % (prefix, NetworkTypeToString(self.NetworkType)) |
| if self.NetworkId != None: |
| print "%sNetwork Id: %d" % (prefix, self.NetworkId) |
| if self.WiFiSSID != None: |
| print "%sWiFi SSID: \"%s\"" % (prefix, self.WiFiSSID) |
| if self.WiFiMode != None: |
| print "%sWiFi Mode: %s" % (prefix, WiFiModeToString(self.WiFiMode)) |
| if self.WiFiRole != None: |
| print "%sWiFi Role: %s" % (prefix, WiFiRoleToString(self.WiFiRole)) |
| if self.WiFiSecurityType != None: |
| print "%sWiFi Security Type: %s" % (prefix, WiFiSecurityTypeToString(self.WiFiSecurityType)) |
| if self.WiFiKey != None: |
| print "%sWiFi Key: %s" % (prefix, self.WiFiKey) |
| if self.ThreadNetworkName != None: |
| print "%sThread Network Name: \"%s\"" % (prefix, self.ThreadNetworkName) |
| if self.ThreadExtendedPANId != None: |
| print "%sThread Extended PAN Id: %s" % (prefix, _ByteArrayToHex(self.ThreadExtendedPANId)) |
| if self.ThreadNetworkKey != None: |
| print "%sThread Network Key: %s" % (prefix, _ByteArrayToHex(self.ThreadNetworkKey)) |
| if self.WirelessSignalStrength != None: |
| print "%sWireless Signal Strength: %s" % (prefix, self.WirelessSignalStrength) |
| |
| def SetField(self, name, val): |
| name = name.lower(); |
| if (name == 'networktype' or name == 'network-type' or name == 'type'): |
| self.NetworkType = ParseNetworkType(val) |
| elif (name == 'networkid' or name == 'network-id' or name == 'id'): |
| self.NetworkId = int(val) |
| elif (name == 'wifissid' or name == 'wifi-ssid' or name == 'ssid'): |
| self.WiFiSSID = val |
| elif (name == 'wifimode' or name == 'wifi-mode'): |
| self.WiFiMode = ParseWiFiMode(val) |
| elif (name == 'wifirole' or name == 'wifi-role'): |
| self.WiFiRole = ParseWiFiRole(val) |
| elif (name == 'wifisecuritytype' or name == 'wifi-security-type' or name == 'securitytype' or name == 'security-type' or name == 'wifi-security' or name == 'security'): |
| self.WiFiSecurityType = ParseSecurityType(val) |
| elif (name == 'wifikey' or name == 'wifi-key' or name == 'key'): |
| self.WiFiKey = val |
| elif (name == 'threadnetworkname' or name == 'thread-network-name' or name == 'thread-name'): |
| self.ThreadNetworkName = val |
| elif (name == 'threadextendedpanid' or name == 'thread-extended-pan-id' or name == 'pan-id'): |
| self.ThreadExtendedPANId = val |
| elif (name == 'threadnetworkkey' or name == 'thread-network-key' or name == 'thread-key'): |
| self.ThreadNetworkKey = val |
| elif (name == 'wirelesssignalstrength' or name == 'wireless-signal-strength'): |
| self.WirelessSignalStrength = val |
| else: |
| raise Exception("Invalid NetworkInfo field: " + str(name)) |
| |
| class DeviceDescriptor: |
| def __init__(self, deviceId=None, fabricId=None, vendorId=None, productId=None, productRevision=None, |
| manufacturingYear=None, manufacturingMonth=None, manufacturingDay=None, |
| primary802154MACAddress=None, primaryWiFiMACAddress=None, |
| serialNumber=None, softwareVersion=None, rendezvousWiFiESSID=None, pairingCode=None, |
| pairingCompatibilityVersionMajor=None, pairingCompatibilityVersionMinor=None, |
| deviceFeatures=None): |
| self.DeviceId = deviceId |
| self.FabricId = fabricId |
| self.VendorId = vendorId |
| self.ProductId = productId |
| self.ProductRevision = productRevision |
| self.ManufacturingYear = manufacturingYear |
| self.ManufacturingMonth = manufacturingMonth |
| self.ManufacturingDay = manufacturingDay |
| self.Primary802154MACAddress = primary802154MACAddress |
| self.PrimaryWiFiMACAddress = primaryWiFiMACAddress |
| self.SerialNumber = serialNumber |
| self.SoftwareVersion = softwareVersion |
| self.RendezvousWiFiESSID = rendezvousWiFiESSID |
| self.PairingCode = pairingCode |
| self.PairingCompatibilityVersionMajor = pairingCompatibilityVersionMajor |
| self.PairingCompatibilityVersionMinor = pairingCompatibilityVersionMinor |
| self.DeviceFeatures = [ ] |
| if deviceFeatures != None: |
| featureVal = 1 |
| while featureVal != 0x80000000: |
| if (deviceFeatures & featureVal) == featureVal: |
| self.DeviceFeatures.append(featureVal) |
| featureVal <<= 1 |
| |
| def Print(self, prefix=""): |
| if self.DeviceId != None: |
| print "%sDevice Id: %016X" % (prefix, self.DeviceId) |
| if self.FabricId != None: |
| print "%sFabrid Id: %016X" % (prefix, self.FabricId) |
| if self.VendorId != None: |
| print "%sVendor Id: %X" % (prefix, self.VendorId) |
| if self.ProductId != None: |
| print "%sProduct Id: %X" % (prefix, self.ProductId) |
| if self.ProductRevision != None: |
| print "%sProduct Revision: %X" % (prefix, self.ProductRevision) |
| if self.SerialNumber != None: |
| print "%sSerial Number: %s" % (prefix, self.SerialNumber) |
| if self.SoftwareVersion != None: |
| print "%sSoftware Version: %s" % (prefix, self.SoftwareVersion) |
| if self.ManufacturingYear != None and self.ManufacturingMonth != None: |
| if self.ManufacturingDay != None: |
| print "%sManufacturing Date: %04d/%02d/%02d" % (prefix, self.ManufacturingYear, self.ManufacturingMonth, self.ManufacturingDay) |
| else: |
| print "%sManufacturing Date: %04d/%02d" % (prefix, self.ManufacturingYear, self.ManufacturingMonth) |
| if self.Primary802154MACAddress != None: |
| print "%sPrimary 802.15.4 MAC Address: %s" % (prefix, _ByteArrayToHex(self.Primary802154MACAddress)) |
| if self.PrimaryWiFiMACAddress != None: |
| print "%sPrimary WiFi MAC Address: %s" % (prefix, _ByteArrayToHex(self.PrimaryWiFiMACAddress)) |
| if self.RendezvousWiFiESSID != None: |
| print "%sRendezvous WiFi ESSID: %s" % (prefix, self.RendezvousWiFiESSID) |
| if self.PairingCode != None: |
| print "%sPairing Code: %s" % (prefix, self.PairingCode) |
| if self.PairingCompatibilityVersionMajor != None: |
| print "%sPairing Compatibility Major Id: %X" % (prefix, self.PairingCompatibilityVersionMajor) |
| if self.PairingCompatibilityVersionMinor != None: |
| print "%sPairing Compatibility Minor Id: %X" % (prefix, self.PairingCompatibilityVersionMinor) |
| if self.DeviceFeatures != None: |
| print "%sDevice Features: %s" % (prefix, " ".join([DeviceFeatureToString(val) for val in self.DeviceFeatures])) |
| |
| |
| class DeviceManagerException(Exception): |
| pass |
| |
| class DeviceManagerError(DeviceManagerException): |
| def __init__(self, err, msg=None): |
| self.err = err |
| if msg != None: |
| self.msg = msg |
| else: |
| self.msg = "Device Manager Error %ld" % (err) |
| |
| def __str__(self): |
| return self.msg |
| |
| class DeviceError(DeviceManagerException): |
| def __init__(self, profileId, statusCode, systemErrorCode, msg=None): |
| self.profileId = profileId |
| self.statusCode = statusCode |
| self.systemErrorCode = systemErrorCode |
| if (msg == None): |
| if (systemErrorCode): |
| return "[ %08X:%d ] (system err %d)" % (profileId, statusCode, systemErrorCode) |
| else: |
| return "[ %08X:%d ]" % (profileId, statusCode) |
| self.message = msg |
| |
| def __str__(self): |
| return "Device Error: " + self.message |
| |
| |
| class _DeviceStatusStruct(Structure): |
| _fields_ = [ |
| ("ProfileId", c_uint32), |
| ("StatusCode", c_uint16), |
| ("SysErrorCode", c_uint32) |
| ] |
| |
| |
| class _IdentifyDeviceCriteriaStruct(Structure): |
| _fields_ = [ |
| ("TargetFabricId", c_uint64), |
| ("TargetModes", c_uint32), |
| ("TargetVendorId", c_uint16), |
| ("TargetProductId", c_uint16), |
| ("TargetDeviceId", c_uint64) |
| ] |
| |
| class _NetworkInfoStruct(Structure): |
| _fields_ = [ |
| ('NetworkType', c_int32), # The type of network. |
| ('NetworkId', c_int64), # network id assigned to the network by the device, -1 if not specified. |
| ('WiFiSSID', c_char_p), # The WiFi SSID. |
| ('WiFiMode', c_int32), # The operating mode of the WiFi network. |
| ('WiFiRole', c_int32), # The role played by the device on the WiFi network. |
| ('WiFiSecurityType', c_int32), # The WiFi security type. |
| ('WiFiKey', c_void_p), # The WiFi key, or NULL if not specified. |
| ('WiFiKeyLen', c_uint32), # The length in bytes of the WiFi key. |
| ('ThreadNetworkName', c_char_p), # The name of the Thread network. |
| ('ThreadExtendedPANId', c_void_p), # The Thread extended PAN id (8 bytes). |
| ('ThreadNetworkKey', c_void_p), # The Thread master network key. |
| ('ThreadNetworkKeyLen', c_uint32), # The length in bytes of the Thread master network key. |
| ('WirelessSignalStrength', c_int16),# The signal strength of the network, or INT16_MIN if not available/applicable. |
| ('Hidden', c_bool) # Whether or not the network is hidden. |
| ] |
| |
| def toNetworkInfo(self): |
| return NetworkInfo( |
| networkType = self.NetworkType if self.NetworkType != -1 else None, |
| networkId = self.NetworkId if self.NetworkId != -1 else None, |
| wifiSSID = self.WiFiSSID, |
| wifiMode = self.WiFiMode if self.WiFiMode != -1 else None, |
| wifiRole = self.WiFiRole if self.WiFiRole != -1 else None, |
| wifiSecurityType = self.WiFiSecurityType if self.WiFiSecurityType != -1 else None, |
| wifiKey = _VoidPtrToByteArray(self.WiFiKey, self.WiFiKeyLen), |
| threadNetworkName = self.ThreadNetworkName, |
| threadExtendedPANId = _VoidPtrToByteArray(self.ThreadExtendedPANId, 8), |
| threadNetworkKey = _VoidPtrToByteArray(self.ThreadNetworkKey, self.ThreadNetworkKeyLen), |
| wirelessSignalStrength = self.WirelessSignalStrength if self.WirelessSignalStrength != -32768 else None |
| ) |
| |
| @classmethod |
| def fromNetworkInfo(cls, networkInfo): |
| networkInfoStruct = cls() |
| networkInfoStruct.NetworkType = networkInfo.NetworkType if networkInfo.NetworkType != None else -1 |
| networkInfoStruct.NetworkId = networkInfo.NetworkId if networkInfo.NetworkId != None else -1 |
| networkInfoStruct.WiFiSSID = networkInfo.WiFiSSID |
| networkInfoStruct.WiFiMode = networkInfo.WiFiMode if networkInfo.WiFiMode != None else -1 |
| networkInfoStruct.WiFiRole = networkInfo.WiFiRole if networkInfo.WiFiRole != None else -1 |
| networkInfoStruct.WiFiSecurityType = networkInfo.WiFiSecurityType if networkInfo.WiFiSecurityType != None else -1 |
| networkInfoStruct.WiFiKey = _ByteArrayToVoidPtr(networkInfo.WiFiKey) |
| networkInfoStruct.WiFiKeyLen = len(networkInfo.WiFiKey) if (networkInfo.WiFiKey != None) else 0 |
| networkInfoStruct.ThreadNetworkName = networkInfo.ThreadNetworkName |
| networkInfoStruct.ThreadExtendedPANId = _ByteArrayToVoidPtr(networkInfo.ThreadExtendedPANId) |
| networkInfoStruct.ThreadNetworkKey = _ByteArrayToVoidPtr(networkInfo.ThreadNetworkKey) |
| networkInfoStruct.ThreadNetworkKeyLen = len(networkInfo.ThreadNetworkKey) if (networkInfo.ThreadNetworkKey != None) else 0 |
| networkInfoStruct.WirelessSignalStrength = networkInfo.WirelessSignalStrength if networkInfo.WirelessSignalStrength != None else -32768 |
| return networkInfoStruct |
| |
| class _DeviceDescriptorStruct(Structure): |
| _fields_ = [ |
| ('DeviceId', c_uint64), # Weave device id (0 = not present) |
| ('FabricId', c_uint64), # Id of Weave fabric to which the device belongs (0 = not present) |
| ('DeviceFeatures', c_uint32), # Bit field indicating support for specific device features. |
| ('VendorId', c_uint16), # Device vendor id (0 = not present) |
| ('ProductId', c_uint16), # Device product id (0 = not present) |
| ('ProductRevision', c_uint16), # Device product revision (0 = not present) |
| ('ManufacturingYear', c_uint16), # Year of device manufacture (valid range 2001 - 2099, 0 = not present) |
| ('ManufacturingMonth', c_ubyte), # Month of device manufacture (1 = January, 0 = not present) |
| ('ManufacturingDay', c_ubyte), # Day of device manufacture (0 = not present) |
| ('Primary802154MACAddress', c_ubyte * 8), # MAC address for primary 802.15.4 interface (big-endian, all zeros = not present) |
| ('PrimaryWiFiMACAddress', c_ubyte * 6), # MAC address for primary WiFi interface (big-endian, all zeros = not present) |
| ('SerialNumber', c_char * 33), # Serial number of device (nul terminated, 0 length = not present) |
| ('SoftwareVersion', c_char * 33), # Version of software running on the device (nul terminated, 0 length = not present) |
| ('RendezvousWiFiESSID', c_char * 33), # ESSID for pairing WiFi network (nul terminated, 0 length = not present) |
| ('PairingCode', c_char * 17), # Device pairing code (nul terminated, 0 length = not present) |
| ('PairingCompatibilityVersionMajor', c_uint16), # Pairing software compatibility major version |
| ('PairingCompatibilityVersionMinor', c_uint16), # Pairing software compatibility minor version |
| ] |
| |
| def toDeviceDescriptor(self): |
| return DeviceDescriptor( |
| deviceId = self.DeviceId if self.DeviceId != 0 else None, |
| fabricId = self.FabricId if self.FabricId != 0 else None, |
| vendorId = self.VendorId if self.VendorId != 0 else None, |
| productId = self.ProductId if self.ProductId != 0 else None, |
| productRevision = self.ProductRevision if self.ProductRevision != 0 else None, |
| manufacturingYear = self.ManufacturingYear if self.ManufacturingYear != 0 else None, |
| manufacturingMonth = self.ManufacturingMonth if self.ManufacturingMonth != 0 else None, |
| manufacturingDay = self.ManufacturingDay if self.ManufacturingDay != 0 else None, |
| primary802154MACAddress = bytearray(self.Primary802154MACAddress) if not _IsByteArrayAllZeros(self.Primary802154MACAddress) else None, |
| primaryWiFiMACAddress = bytearray(self.PrimaryWiFiMACAddress) if not _IsByteArrayAllZeros(self.PrimaryWiFiMACAddress) else None, |
| serialNumber = self.SerialNumber if len(self.SerialNumber) != 0 else None, |
| softwareVersion = self.SoftwareVersion if len(self.SoftwareVersion) != 0 else None, |
| rendezvousWiFiESSID = self.RendezvousWiFiESSID if len(self.RendezvousWiFiESSID) != 0 else None, |
| pairingCode = self.PairingCode if len(self.PairingCode) != 0 else None, |
| pairingCompatibilityVersionMajor = self.PairingCompatibilityVersionMajor, |
| pairingCompatibilityVersionMinor = self.PairingCompatibilityVersionMinor, |
| deviceFeatures = self.DeviceFeatures) |
| |
| class AlarmHushResponse: |
| def __init__(self, hushResult, length, conditions): |
| self.hushResult = hushResult |
| self.Conditions = [ ] |
| for x in range(0, length): |
| self.Conditions.append(conditions[x]) |
| |
| def Print(self, prefix=""): |
| print "%sHush Result: %s" % (prefix, _dmLib.nl_Weave_DeviceManager_AlarmHushResultToString(self.hushResult)) |
| for c in self.Conditions: |
| print "%s[%s]: [%s]" % (prefix, _dmLib.nl_Weave_DeviceManager_AlarmSourceToString(c), _dmLib.nl_Weave_DeviceManager_AlarmStateToString(c)) |
| |
| # Library path name. Can be overriden my module user. |
| |
| class WeaveDeviceMgrPath(Weave): |
| def __init__(self): |
| Weave.__init__(self) |
| self.quiet = False |
| self.LibPath = Weave.getWeaveWeaveDeviceMgrLibPath(self); |
| |
| def getLibPath(self): |
| return self.LibPath |
| |
| pyweavepath = WeaveDeviceMgrPath() |
| |
| dmLibName = os.path.join(pyweavepath.getLibPath()) |
| |
| # If the script binding library does not exist at the same level as |
| # this module, then search for it one level up. Otherwise, rely on the |
| # system dynamic loader to find it for us (via LD_LIBRARY_PATH or |
| # DYLD_LIBRARY_PATH. |
| |
| if not os.path.exists(dmLibName): |
| (dmLibDir, dmLibFile) = os.path.split(dmLibName) |
| dmLibName = os.path.normpath(os.path.join(dmLibDir, "..", dmLibFile)) |
| if not os.path.exists(dmLibName): |
| dmLibName = dmLibFile |
| |
| |
| _dmLib = None |
| _CompleteFunct = CFUNCTYPE(None, c_void_p, c_void_p) |
| _IdentifyDeviceCompleteFunct = CFUNCTYPE(None, c_void_p, c_void_p, POINTER(_DeviceDescriptorStruct)) |
| _PairTokenCompleteFunct = CFUNCTYPE(None, c_void_p, c_void_p, c_void_p, c_uint32) |
| _UnpairTokenCompleteFunct = CFUNCTYPE(None, c_void_p, c_void_p) |
| _NetworkScanCompleteFunct = CFUNCTYPE(None, c_void_p, c_void_p, c_uint16, POINTER(_NetworkInfoStruct)) |
| _AddNetworkCompleteFunct = CFUNCTYPE(None, c_void_p, c_void_p, c_uint32) |
| _GetNetworksCompleteFunct = CFUNCTYPE(None, c_void_p, c_void_p, c_uint16, POINTER(_NetworkInfoStruct)) |
| _GetCameraAuthDataCompleteFunct = CFUNCTYPE(None, c_void_p, c_void_p, c_char_p, c_char_p) |
| _GetRendezvousModeCompleteFunct = CFUNCTYPE(None, c_void_p, c_void_p, c_uint16) |
| _GetFabricConfigCompleteFunct = CFUNCTYPE(None, c_void_p, c_void_p, c_void_p, c_uint32) |
| _ErrorFunct = CFUNCTYPE(None, c_void_p, c_void_p, c_ulong, POINTER(_DeviceStatusStruct)) |
| _GetBleEventFunct = CFUNCTYPE(c_void_p) |
| _WriteBleCharacteristicFunct = CFUNCTYPE(c_bool, c_void_p, c_void_p, c_void_p, c_void_p, c_uint16) |
| _HushCompleteFunct = CFUNCTYPE(None, c_void_p, c_void_p, c_uint8, c_uint8, POINTER(c_uint8)) |
| _SubscribeBleCharacteristicFunct = CFUNCTYPE(c_bool, c_void_p, c_void_p, c_void_p, c_bool) |
| _CloseBleFunct = CFUNCTYPE(c_bool, c_void_p) |
| _GetActiveLocaleCompleteFunct = CFUNCTYPE(None, c_void_p, c_void_p, c_char_p) |
| _GetAvailableLocalesCompleteFunct = CFUNCTYPE(None, c_void_p, c_void_p, c_uint16, POINTER(c_char_p)) |
| _ThermostatGetEntryKeyCompleteFunct = CFUNCTYPE(None, c_void_p, c_void_p, c_char_p) |
| _ThermostatSystemTestStatusCompleteFunct = CFUNCTYPE(None, c_void_p, c_void_p, c_uint64) |
| _DeviceEnumerationResponseFunct = CFUNCTYPE(None, c_void_p, POINTER(_DeviceDescriptorStruct), c_char_p) |
| |
| # This is a fix for WEAV-429. Jay Logue recommends revisiting this at a later |
| # date to allow for truely multiple instances so this is temporary. |
| def _singleton(cls): |
| instance = cls() |
| instance.__call__ = lambda: instance |
| return instance |
| |
| @_singleton |
| class WeaveDeviceManager: |
| |
| def __init__(self, startNetworkThread=True): |
| self.devMgr = None |
| self.callbackRes = None |
| self.networkThread = None |
| self.networkThreadRunable = False |
| self.networkLock = Lock() |
| self.completeEvent = Event() |
| |
| self._InitLib() |
| |
| devMgr = c_void_p(None) |
| res = _dmLib.nl_Weave_DeviceManager_NewDeviceManager(pointer(devMgr)) |
| if (res != 0): |
| raise self._ErrorToException(res) |
| |
| self.devMgr = devMgr |
| |
| def HandleComplete(devMgr, reqState): |
| self.callbackRes = True |
| self.completeEvent.set() |
| |
| def HandleError(devMgr, reqState, err, devStatusPtr): |
| self.callbackRes = self._ErrorToException(err, devStatusPtr) |
| self.completeEvent.set() |
| |
| def HandleDeviceEnumerationResponse(devMgr, deviceDescPtr, deviceAddrStr): |
| print " Enumerated device IP: %s" % (deviceAddrStr) |
| deviceDescPtr.contents.toDeviceDescriptor().Print(" ") |
| |
| self.cbHandleComplete = _CompleteFunct(HandleComplete) |
| self.cbHandleError = _ErrorFunct(HandleError) |
| self.cbHandleDeviceEnumerationResponse = _DeviceEnumerationResponseFunct(HandleDeviceEnumerationResponse) |
| self.blockingCB = None # set by other modules(BLE) that require service by thread while thread blocks. |
| self.cbHandleBleEvent = None # set by other modules (BLE) that provide event callback to Weave. |
| self.cbHandleBleWriteChar = None |
| self.cbHandleBleSubscribeChar = None |
| self.cbHandleBleClose = None |
| |
| if (startNetworkThread): |
| self.StartNetworkThread() |
| |
| def __del__(self): |
| if (self.devMgr != None): |
| _dmLib.nl_Weave_DeviceManager_DeleteDeviceManager(self.devMgr) |
| |
| def DriveBleIO(self): |
| # perform asynchronous write to pipe in IO thread's select() to wake for BLE input |
| res = _dmLib.nl_Weave_DeviceManager_WakeForBleIO() |
| if (res != 0): |
| raise self._ErrorToException(res) |
| |
| def SetBleEventCB(self, bleEventCB): |
| if (self.devMgr != None): |
| self.cbHandleBleEvent = _GetBleEventFunct(bleEventCB) |
| _dmLib.nl_Weave_DeviceManager_SetBleEventCB(self.cbHandleBleEvent) |
| |
| def SetBleWriteCharCB(self, bleWriteCharCB): |
| if (self.devMgr != None): |
| self.cbHandleBleWriteChar = _WriteBleCharacteristicFunct(bleWriteCharCB) |
| _dmLib.nl_Weave_DeviceManager_SetBleWriteCharacteristic(self.cbHandleBleWriteChar) |
| |
| def SetBleSubscribeCharCB(self, bleSubscribeCharCB): |
| if (self.devMgr != None): |
| self.cbHandleBleSubscribeChar = _SubscribeBleCharacteristicFunct(bleSubscribeCharCB) |
| _dmLib.nl_Weave_DeviceManager_SetBleSubscribeCharacteristic(self.cbHandleBleSubscribeChar) |
| |
| def SetBleCloseCB(self, bleCloseCB): |
| if (self.devMgr != None): |
| self.cbHandleBleClose = _CloseBleFunct(bleCloseCB) |
| _dmLib.nl_Weave_DeviceManager_SetBleClose(self.cbHandleBleClose) |
| |
| def StartNetworkThread(self): |
| if (self.networkThread != None): |
| return |
| |
| def RunNetworkThread(): |
| while (self.networkThreadRunable): |
| self.networkLock.acquire() |
| _dmLib.nl_Weave_DeviceManager_DriveIO(50) |
| self.networkLock.release() |
| time.sleep(0.005) |
| |
| self.networkThread = Thread(target=RunNetworkThread, name="WeaveNetworkThread") |
| self.networkThread.daemon = True |
| self.networkThreadRunable = True |
| self.networkThread.start() |
| |
| def StopNetworkThread(self): |
| if (self.networkThread != None): |
| self.networkThreadRunable = False |
| self.networkThread.join() |
| self.networkThread = None |
| |
| def IsConnected(self): |
| return self._CallDevMgr( |
| lambda: _dmLib.nl_Weave_DeviceManager_IsConnected(self.devMgr) |
| ) |
| |
| def DeviceId(self): |
| return self._CallDevMgr( |
| lambda: _dmLib.nl_Weave_DeviceManager_DeviceId(self.devMgr) |
| ) |
| |
| def DeviceAddress(self): |
| return self._CallDevMgr( |
| lambda: _dmLib.nl_Weave_DeviceManager_DeviceAddress(self.devMgr) |
| ) |
| |
| def SetRendezvousAddress(self, addr): |
| res = self._CallDevMgr( |
| lambda: _dmLib.nl_Weave_DeviceManager_SetRendezvousAddress(self.devMgr, addr) |
| ) |
| if (res != 0): |
| raise self._ErrorToException(res) |
| |
| def SetConnectTimeout(self, timeoutMS): |
| res = self._CallDevMgr( |
| lambda: _dmLib.nl_Weave_DeviceManager_SetConnectTimeout(self.devMgr, timeoutMS) |
| ) |
| if (res != 0): |
| raise self._ErrorToException(res) |
| |
| def SetAutoReconnect(self, autoReconnect): |
| res = self._CallDevMgr( |
| lambda: _dmLib.nl_Weave_DeviceManager_SetAutoReconnect(self.devMgr, autoReconnect) |
| ) |
| if (res != 0): |
| raise self._ErrorToException(res) |
| |
| def SetRendezvousLinkLocal(self, RendezvousLinkLocal): |
| res = self._CallDevMgr( |
| lambda: _dmLib.nl_Weave_DeviceManager_SetRendezvousLinkLocal(self.devMgr, RendezvousLinkLocal) |
| ) |
| if (res != 0): |
| raise self._ErrorToException(res) |
| |
| def StartDeviceEnumeration(self, targetFabricId=TargetFabricId_AnyFabric, |
| targetModes=TargetDeviceMode_Any, |
| targetVendorId=TargetVendorId_Any, |
| targetProductId=TargetProductId_Any, |
| targetDeviceId=TargetDeviceId_Any): |
| |
| deviceCriteria = _IdentifyDeviceCriteriaStruct() |
| deviceCriteria.TargetFabricId = targetFabricId |
| deviceCriteria.TargetModes = targetModes |
| deviceCriteria.TargetVendorId = targetVendorId |
| deviceCriteria.TargetProductId = targetProductId |
| deviceCriteria.TargetDeviceId = targetDeviceId |
| |
| self._CallDevMgr( |
| lambda: _dmLib.nl_Weave_DeviceManager_StartDeviceEnumeration(self.devMgr, deviceCriteria, self.cbHandleDeviceEnumerationResponse, self.cbHandleError) |
| ) |
| |
| def StopDeviceEnumeration(self): |
| res = self._CallDevMgr( |
| lambda: _dmLib.nl_Weave_DeviceManager_StopDeviceEnumeration(self.devMgr) |
| ) |
| |
| def ConnectDevice(self, deviceId, deviceAddr=None, |
| pairingCode=None, accessToken=None): |
| |
| if (pairingCode != None and accessToken != None): |
| raise ValueError('Must specify only one of pairingCode or accessToken when calling WeaveDeviceManager.ConnectDevice') |
| |
| if (pairingCode == None and accessToken == None): |
| self._CallDevMgrAsync( |
| lambda: _dmLib.nl_Weave_DeviceManager_ConnectDevice_NoAuth(self.devMgr, deviceId, deviceAddr, self.cbHandleComplete, self.cbHandleError) |
| ) |
| elif (pairingCode != None): |
| self._CallDevMgrAsync( |
| lambda: _dmLib.nl_Weave_DeviceManager_ConnectDevice_PairingCode(self.devMgr, deviceId, deviceAddr, pairingCode, self.cbHandleComplete, self.cbHandleError) |
| ) |
| else: |
| accessTokenBuf = cast( (c_byte * len(accessToken)) .from_buffer_copy(accessToken), c_void_p) |
| self._CallDevMgrAsync( |
| lambda: _dmLib.nl_Weave_DeviceManager_ConnectDevice_AccessToken(self.devMgr, deviceId, deviceAddr, accessTokenBuf, len(accessToken), self.cbHandleComplete, self.cbHandleError) |
| ) |
| |
| def RendezvousDevice(self, pairingCode=None, accessToken=None, |
| targetFabricId=TargetFabricId_AnyFabric, |
| targetModes=TargetDeviceMode_Any, |
| targetVendorId=TargetVendorId_Any, |
| targetProductId=TargetProductId_Any, |
| targetDeviceId=TargetDeviceId_Any): |
| |
| if (pairingCode != None and accessToken != None): |
| raise ValueError('Must specify only one of pairingCode or accessToken when calling WeaveDeviceManager.RendezvousDevice') |
| |
| deviceCriteria = _IdentifyDeviceCriteriaStruct() |
| deviceCriteria.TargetFabricId = targetFabricId |
| deviceCriteria.TargetModes = targetModes |
| deviceCriteria.TargetVendorId = targetVendorId |
| deviceCriteria.TargetProductId = targetProductId |
| deviceCriteria.TargetDeviceId = targetDeviceId |
| |
| if (pairingCode == None and accessToken == None): |
| self._CallDevMgrAsync( |
| lambda: _dmLib.nl_Weave_DeviceManager_RendezvousDevice_NoAuth(self.devMgr, deviceCriteria, self.cbHandleComplete, self.cbHandleError) |
| ) |
| elif (pairingCode != None): |
| self._CallDevMgrAsync( |
| lambda: _dmLib.nl_Weave_DeviceManager_RendezvousDevice_PairingCode(self.devMgr, pairingCode, deviceCriteria, self.cbHandleComplete, self.cbHandleError) |
| ) |
| else: |
| accessTokenBuf = cast( (c_byte * len(accessToken)) .from_buffer_copy(accessToken), c_void_p) |
| self._CallDevMgrAsync( |
| lambda: _dmLib.nl_Weave_DeviceManager_RendezvousDevice_AccessToken(self.devMgr, accessTokenBuf, len(accessToken), deviceCriteria, self.cbHandleComplete, self.cbHandleError) |
| ) |
| |
| def TestBle(self, connObj, count, duration, delay, ack, size, rx): |
| res = self._CallDevMgr( |
| lambda: _dmLib.nl_Weave_DeviceManager_TestBle(self.devMgr, connObj, self.cbHandleComplete, self.cbHandleError, count, duration, delay, ack, size, rx) |
| ) |
| if (res != 0): |
| raise self._ErrorToException(res) |
| |
| def TestResultBle(self, connObj, local): |
| res = self._CallDevMgr( |
| lambda: _dmLib.nl_Weave_DeviceManager_TestResultBle(self.devMgr, connObj, local) |
| ) |
| if (res != 0): |
| raise self._ErrorToException(res) |
| |
| def TestAbortBle(self, connObj): |
| res = self._CallDevMgr( |
| lambda: _dmLib.nl_Weave_DeviceManager_TestAbortBle(self.devMgr, connObj) |
| ) |
| if (res != 0): |
| raise self._ErrorToException(res) |
| |
| def TxTimingBle(self, connObj, enabled, remote): |
| res = self._CallDevMgr( |
| lambda: _dmLib.nl_Weave_DeviceManager_TxTimingBle(self.devMgr, connObj, enabled, remote) |
| ) |
| if (res != 0): |
| raise self._ErrorToException(res) |
| |
| def ConnectBle(self, bleConnection, pairingCode=None, accessToken=None): |
| if (pairingCode != None and accessToken != None): |
| raise ValueError('Must specify only one of pairingCode or accessToken when calling WeaveDeviceManager.ConnectBle') |
| |
| if (pairingCode == None and accessToken == None): |
| self._CallDevMgrAsync( |
| lambda: _dmLib.nl_Weave_DeviceManager_ConnectBle_NoAuth(self.devMgr, bleConnection, self.cbHandleComplete, self.cbHandleError) |
| ) |
| elif (pairingCode != None): |
| self._CallDevMgrAsync( |
| lambda: _dmLib.nl_Weave_DeviceManager_ConnectBle_PairingCode(self.devMgr, bleConnection, pairingCode, self.cbHandleComplete, self.cbHandleError) |
| ) |
| else: |
| accessTokenBuf = cast( (c_byte * len(accessToken)) .from_buffer_copy(accessToken), c_void_p) |
| self._CallDevMgrAsync( |
| lambda: _dmLib.nl_Weave_DeviceManager_ConnectBle_AccessToken(self.devMgr, bleConnection, accessTokenBuf, len(accessToken), self.cbHandleComplete, self.cbHandleError) |
| ) |
| |
| def PassiveRendezvousDevice(self, pairingCode=None, accessToken=None): |
| if (pairingCode != None and accessToken != None): |
| raise ValueError('Must specify only one of pairingCode or accessToken when calling WeaveDeviceManager.PassiveRendezvousDevice') |
| |
| if (pairingCode == None and accessToken == None): |
| self._CallDevMgrAsync( |
| lambda: _dmLib.nl_Weave_DeviceManager_PassiveRendezvousDevice_NoAuth(self.devMgr, self.cbHandleComplete, self.cbHandleError) |
| ) |
| elif (pairingCode != None): |
| self._CallDevMgrAsync( |
| lambda: _dmLib.nl_Weave_DeviceManager_PassiveRendezvousDevice_PairingCode(self.devMgr, pairingCode, self.cbHandleComplete, self.cbHandleError) |
| ) |
| else: |
| accessTokenBuf = cast( (c_byte * len(accessToken)) .from_buffer_copy(accessToken), c_void_p) |
| self._CallDevMgrAsync( |
| lambda: _dmLib.nl_Weave_DeviceManager_PassiveRendezvousDevice_AccessToken(self.devMgr, accessTokenBuf, len(accessToken), self.cbHandleComplete, self.cbHandleError) |
| ) |
| |
| def RemotePassiveRendezvous(self, rendezvousDeviceAddr=None, pairingCode=None, accessToken=None, rendezvousTimeout=None, inactivityTimeout=None): |
| if rendezvousDeviceAddr == None: |
| rendezvousDeviceAddr = "::" |
| |
| if (pairingCode == None and accessToken == None): |
| self._CallDevMgrAsync( |
| lambda: _dmLib.nl_Weave_DeviceManager_RemotePassiveRendezvous_NoAuth(self.devMgr, rendezvousDeviceAddr, rendezvousTimeout, inactivityTimeout, self.cbHandleComplete, self.cbHandleError) |
| ) |
| elif (pairingCode != None): |
| self._CallDevMgrAsync( |
| lambda: _dmLib.nl_Weave_DeviceManager_RemotePassiveRendezvous_PASEAuth(self.devMgr, rendezvousDeviceAddr, pairingCode, rendezvousTimeout, inactivityTimeout, self.cbHandleComplete, self.cbHandleError) |
| ) |
| else: |
| accessTokenBuf = cast( (c_byte * len(accessToken)) .from_buffer_copy(accessToken), c_void_p) |
| self._CallDevMgrAsync( |
| lambda: _dmLib.nl_Weave_DeviceManager_RemotePassiveRendezvous_CASEAuth(self.devMgr, rendezvousDeviceAddr, accessTokenBuf, len(accessToken), rendezvousTimeout, inactivityTimeout, self.cbHandleComplete, self.cbHandleError) |
| ) |
| |
| def ReconnectDevice(self): |
| self._CallDevMgrAsync( |
| lambda: _dmLib.nl_Weave_DeviceManager_ReconnectDevice(self.devMgr, self.cbHandleComplete, self.cbHandleError) |
| ) |
| |
| def Close(self): |
| self._CallDevMgr( |
| lambda: _dmLib.nl_Weave_DeviceManager_Close(self.devMgr) |
| ) |
| |
| def EnableConnectionMonitor(self, interval, timeout): |
| self._CallDevMgrAsync( |
| lambda: _dmLib.nl_Weave_DeviceManager_EnableConnectionMonitor(self.devMgr, interval, timeout, self.cbHandleComplete, self.cbHandleError) |
| ) |
| |
| def DisableConnectionMonitor(self): |
| self._CallDevMgrAsync( |
| lambda: _dmLib.nl_Weave_DeviceManager_DisableConnectionMonitor(self.devMgr, self.cbHandleComplete, self.cbHandleError) |
| ) |
| |
| def IdentifyDevice(self): |
| def HandleIdentifyDeviceComplete(devMgr, reqState, deviceDescPtr): |
| self.callbackRes = deviceDescPtr.contents.toDeviceDescriptor() |
| self.completeEvent.set() |
| |
| cbHandleIdentifyDeviceComplete = _IdentifyDeviceCompleteFunct(HandleIdentifyDeviceComplete) |
| |
| return self._CallDevMgrAsync( |
| lambda: _dmLib.nl_Weave_DeviceManager_IdentifyDevice(self.devMgr, cbHandleIdentifyDeviceComplete, self.cbHandleError) |
| ) |
| |
| def PairToken(self, pairingToken): |
| def HandlePairTokenComplete(devMgr, reqState, tokenPairingBundlePtr, tokenPairingBundleLen): |
| self.callbackRes = _VoidPtrToByteArray(tokenPairingBundlePtr, tokenPairingBundleLen) |
| self.completeEvent.set() |
| |
| cbHandlePairTokenComplete = _PairTokenCompleteFunct(HandlePairTokenComplete) |
| |
| pairingTokenBuf = cast( (c_byte * len(pairingToken)) .from_buffer_copy(pairingToken), c_void_p) |
| |
| return self._CallDevMgrAsync( |
| lambda: _dmLib.nl_Weave_DeviceManager_PairToken(self.devMgr, pairingTokenBuf, len(pairingToken), cbHandlePairTokenComplete, self.cbHandleError) |
| ) |
| |
| def UnpairToken(self): |
| def HandleUnpairTokenComplete(devMgr, reqState): |
| self.callbackRes = True |
| self.completeEvent.set() |
| |
| cbHandleUnpairTokenComplete = _UnpairTokenCompleteFunct(HandleUnpairTokenComplete) |
| |
| return self._CallDevMgrAsync( |
| lambda: _dmLib.nl_Weave_DeviceManager_UnpairToken(self.devMgr, cbHandleUnpairTokenComplete, self.cbHandleError) |
| ) |
| |
| def ScanNetworks(self, networkType): |
| def HandleScanNetworksComplete(devMgr, reqState, netCount, netInfoPtr): |
| self.callbackRes = [ netInfoPtr[i].toNetworkInfo() for i in range(netCount) ] |
| self.completeEvent.set() |
| |
| cbHandleScanNetworksComplete = _NetworkScanCompleteFunct(HandleScanNetworksComplete) |
| |
| return self._CallDevMgrAsync( |
| lambda: _dmLib.nl_Weave_DeviceManager_ScanNetworks(self.devMgr, networkType, cbHandleScanNetworksComplete, self.cbHandleError) |
| ) |
| |
| def GetNetworks(self, getFlags): |
| def HandleGetNetworksComplete(devMgr, reqState, netCount, netInfoPtr): |
| self.callbackRes = [ netInfoPtr[i].toNetworkInfo() for i in range(netCount) ] |
| self.completeEvent.set() |
| |
| cbHandleGetNetworksComplete = _GetNetworksCompleteFunct(HandleGetNetworksComplete) |
| |
| return self._CallDevMgrAsync( |
| lambda: _dmLib.nl_Weave_DeviceManager_GetNetworks(self.devMgr, getFlags, cbHandleGetNetworksComplete, self.cbHandleError) |
| ) |
| |
| def GetCameraAuthData(self, nonce): |
| def HandleGetCameraAuthDataComplete(devMgr, reqState, macAddress, signedCameraPayload): |
| self.callbackRes = [ macAddress, signedCameraPayload ] |
| self.completeEvent.set() |
| |
| cbHandleGetCameraAuthDataComplete = _GetCameraAuthDataCompleteFunct(HandleGetCameraAuthDataComplete) |
| |
| return self._CallDevMgrAsync( |
| lambda: _dmLib.nl_Weave_DeviceManager_GetCameraAuthData(self.devMgr, nonce, cbHandleGetCameraAuthDataComplete, self.cbHandleError) |
| ) |
| |
| def AddNetwork(self, networkInfo): |
| def HandleAddNetworkComplete(devMgr, reqState, networkId): |
| self.callbackRes = networkId |
| self.completeEvent.set() |
| |
| cbHandleAddNetworkComplete = _AddNetworkCompleteFunct(HandleAddNetworkComplete) |
| |
| networkInfoStruct = _NetworkInfoStruct.fromNetworkInfo(networkInfo) |
| |
| return self._CallDevMgrAsync( |
| lambda: _dmLib.nl_Weave_DeviceManager_AddNetwork(self.devMgr, networkInfoStruct, cbHandleAddNetworkComplete, self.cbHandleError) |
| ) |
| |
| def UpdateNetwork(self, networkInfo): |
| networkInfoStruct = _NetworkInfoStruct.fromNetworkInfo(networkInfo) |
| |
| self._CallDevMgrAsync( |
| lambda: _dmLib.nl_Weave_DeviceManager_UpdateNetwork(self.devMgr, networkInfoStruct, self.cbHandleComplete, self.cbHandleError) |
| ) |
| |
| def RemoveNetwork(self, networkId): |
| self._CallDevMgrAsync( |
| lambda: _dmLib.nl_Weave_DeviceManager_RemoveNetwork(self.devMgr, networkId, self.cbHandleComplete, self.cbHandleError) |
| ) |
| |
| def EnableNetwork(self, networkId): |
| self._CallDevMgrAsync( |
| lambda: _dmLib.nl_Weave_DeviceManager_EnableNetwork(self.devMgr, networkId, self.cbHandleComplete, self.cbHandleError) |
| ) |
| |
| def DisableNetwork(self, networkId): |
| self._CallDevMgrAsync( |
| lambda: _dmLib.nl_Weave_DeviceManager_DisableNetwork(self.devMgr, networkId, self.cbHandleComplete, self.cbHandleError) |
| ) |
| |
| def TestNetworkConnectivity(self, networkId): |
| self._CallDevMgrAsync( |
| lambda: _dmLib.nl_Weave_DeviceManager_TestNetworkConnectivity(self.devMgr, networkId, self.cbHandleComplete, self.cbHandleError) |
| ) |
| |
| def GetRendezvousMode(self): |
| def HandleGetRendezvousModeComplete(devMgr, reqState, modeFlags): |
| self.callbackRes = modeFlags |
| self.completeEvent.set() |
| |
| cbHandleGetRendezvousModeComplete = _GetRendezvousModeCompleteFunct(HandleGetRendezvousModeComplete) |
| |
| return self._CallDevMgrAsync( |
| lambda: _dmLib.nl_Weave_DeviceManager_GetRendezvousMode(self.devMgr, cbHandleGetRendezvousModeComplete, self.cbHandleError) |
| ) |
| |
| def SetRendezvousMode(self, modeFlags): |
| self._CallDevMgrAsync( |
| lambda: _dmLib.nl_Weave_DeviceManager_SetRendezvousMode(self.devMgr, modeFlags, self.cbHandleComplete, self.cbHandleError) |
| ) |
| |
| def GetLastNetworkProvisioningResult(self): |
| self._CallDevMgrAsync( |
| lambda: _dmLib.nl_Weave_DeviceManager_GetLastNetworkProvisioningResult(self.devMgr, self.cbHandleComplete, self.cbHandleError) |
| ) |
| |
| def CreateFabric(self): |
| self._CallDevMgrAsync( |
| lambda: _dmLib.nl_Weave_DeviceManager_CreateFabric(self.devMgr, self.cbHandleComplete, self.cbHandleError) |
| ) |
| |
| def LeaveFabric(self): |
| self._CallDevMgrAsync( |
| lambda: _dmLib.nl_Weave_DeviceManager_LeaveFabric(self.devMgr, self.cbHandleComplete, self.cbHandleError) |
| ) |
| |
| def GetFabricConfig(self): |
| def HandleGetFabricConfigComplete(devMgr, reqState, fabricConfigPtr, fabricConfigLen): |
| self.callbackRes = _VoidPtrToByteArray(fabricConfigPtr, fabricConfigLen) |
| self.completeEvent.set() |
| |
| cbHandleGetFabricConfigComplete = _GetFabricConfigCompleteFunct(HandleGetFabricConfigComplete) |
| |
| return self._CallDevMgrAsync( |
| lambda: _dmLib.nl_Weave_DeviceManager_GetFabricConfig(self.devMgr, cbHandleGetFabricConfigComplete, self.cbHandleError) |
| ) |
| |
| def JoinExistingFabric(self, fabricConfig): |
| self._CallDevMgrAsync( |
| lambda: _dmLib.nl_Weave_DeviceManager_JoinExistingFabric(self.devMgr, _ByteArrayToVoidPtr(fabricConfig), len(fabricConfig), |
| self.cbHandleComplete, self.cbHandleError) |
| ) |
| |
| def Ping(self): |
| self._CallDevMgrAsync( |
| lambda: _dmLib.nl_Weave_DeviceManager_Ping(self.devMgr, self.cbHandleComplete, self.cbHandleError) |
| ) |
| |
| def Hush(self, proximityVerificationCode, challenge, keyId, key): |
| def HandleHushComplete(devMgr, reqState, hushResult, length, conditions): |
| self.callbackRes = AlarmHushResponse(hushResult, length, conditions) |
| self.completeEvent.set() |
| |
| cbHandleHushComplete = _HushCompleteFunct(HandleHushComplete) |
| |
| keyBuf = cast( (c_byte * len(key)) .from_buffer_copy(key), c_void_p) |
| |
| return self._CallDevMgrAsync( |
| lambda: _dmLib.nl_Weave_DeviceManager_Hush(self.devMgr, proximityVerificationCode, challenge, keyId, keyBuf, len(key), cbHandleHushComplete, self.cbHandleError) |
| ) |
| |
| def RegisterServicePairAccount(self, serviceId, accountId, serviceConfig, pairingToken, pairingInitData): |
| serviceConfigBuf = cast( (c_byte * len(serviceConfig)) .from_buffer_copy(serviceConfig), c_void_p) |
| pairingTokenBuf = cast( (c_byte * len(pairingToken)) .from_buffer_copy(pairingToken), c_void_p) |
| pairingInitDataBuf = cast( (c_byte * len(pairingInitData)) .from_buffer_copy(pairingInitData), c_void_p) |
| |
| self._CallDevMgrAsync( |
| lambda: _dmLib.nl_Weave_DeviceManager_RegisterServicePairAccount(self.devMgr, serviceId, accountId, |
| serviceConfigBuf, len(serviceConfig), |
| pairingTokenBuf, len(pairingToken), |
| pairingInitDataBuf, len(pairingInitData), |
| self.cbHandleComplete, self.cbHandleError) |
| ) |
| |
| def UpdateService(self, serviceId, serviceConfig): |
| serviceConfigBuf = cast( (c_byte * len(serviceConfig)) .from_buffer_copy(serviceConfig), c_void_p) |
| |
| self._CallDevMgrAsync( |
| lambda: _dmLib.nl_Weave_DeviceManager_UpdateService(self.devMgr, serviceId, serviceConfigBuf, len(serviceConfig), |
| self.cbHandleComplete, self.cbHandleError) |
| ) |
| |
| def UnregisterService(self, serviceId): |
| self._CallDevMgrAsync( |
| lambda: _dmLib.nl_Weave_DeviceManager_UnregisterService(self.devMgr, serviceId, self.cbHandleComplete, self.cbHandleError) |
| ) |
| |
| def ArmFailSafe(self, armMode, failSafeToken): |
| self._CallDevMgrAsync( |
| lambda: _dmLib.nl_Weave_DeviceManager_ArmFailSafe(self.devMgr, armMode, failSafeToken, self.cbHandleComplete, self.cbHandleError) |
| ) |
| |
| def DisarmFailSafe(self): |
| self._CallDevMgrAsync( |
| lambda: _dmLib.nl_Weave_DeviceManager_DisarmFailSafe(self.devMgr, self.cbHandleComplete, self.cbHandleError) |
| ) |
| |
| def ResetConfig(self, resetFlags): |
| self._CallDevMgrAsync( |
| lambda: _dmLib.nl_Weave_DeviceManager_ResetConfig(self.devMgr, resetFlags, self.cbHandleComplete, self.cbHandleError) |
| ) |
| |
| def CloseEndpoints(self): |
| self._CallDevMgr( |
| lambda: _dmLib.nl_Weave_DeviceManager_CloseEndpoints() |
| ) |
| def Shutdown(self): |
| self._CallDevMgr( |
| lambda: _dmLib.nl_Weave_DeviceManager_Shutdown() |
| ) |
| |
| def SetLogFilter(self, category): |
| self._CallDevMgr( |
| lambda: _dmLib.nl_Weave_DeviceManager_SetLogFilter(category) |
| ) |
| |
| def GetLogFilter(self): |
| self._CallDevMgr( |
| lambda: _dmLib.nl_Weave_DeviceManager_GetLogFilter() |
| ) |
| |
| def SetBlockingCB(self, blockingCB): |
| self.blockingCB = blockingCB |
| |
| def GetActiveLocale(self): |
| def HandleGetActiveLocaleComplete(devMgr, reqState, activeLocale): |
| self.callbackRes = activeLocale |
| self.completeEvent.set() |
| |
| cbHandleGetActiveLocaleComplete = _GetActiveLocaleCompleteFunct(HandleGetActiveLocaleComplete) |
| |
| return self._CallDevMgrAsync( |
| lambda: _dmLib.nl_Weave_DeviceManager_GetActiveLocale(self.devMgr, cbHandleGetActiveLocaleComplete, self.cbHandleError) |
| ) |
| |
| def SetActiveLocale(self, locale): |
| self._CallDevMgrAsync( |
| lambda: _dmLib.nl_Weave_DeviceManager_SetActiveLocale(self.devMgr, locale, self.cbHandleComplete, self.cbHandleError) |
| ) |
| |
| def GetAvailableLocales(self): |
| def HandleGetAvailableLocalesComplete(devMgr, reqState, localeCount, localeList): |
| self.callbackRes = [ localeList[i] for i in range(localeCount) ] |
| self.completeEvent.set() |
| |
| cbHandleGetAvailableLocalesComplete = _GetAvailableLocalesCompleteFunct(HandleGetAvailableLocalesComplete) |
| |
| return self._CallDevMgrAsync( |
| lambda: _dmLib.nl_Weave_DeviceManager_GetAvailableLocales(self.devMgr, cbHandleGetAvailableLocalesComplete, self.cbHandleError) |
| ) |
| |
| def StartSystemTest(self, profileId, testId): |
| self._CallDevMgrAsync( |
| lambda: _dmLib.nl_Weave_DeviceManager_StartSystemTest(self.devMgr, profileId, testId, self.cbHandleComplete, self.cbHandleError) |
| ) |
| |
| def StopSystemTest(self): |
| self._CallDevMgrAsync( |
| lambda: _dmLib.nl_Weave_DeviceManager_StopSystemTest(self.devMgr, self.cbHandleComplete, self.cbHandleError) |
| ) |
| |
| def ThermostatGetEntryKey(self): |
| def HandleThermostatGetEntryKeyComplete(devMgr, reqState, entryKey): |
| self.callbackRes = entryKey |
| self.completeEvent.set() |
| |
| cbHandleThermostatGetEntryKeyComplete = _ThermostatGetEntryKeyCompleteFunct(HandleThermostatGetEntryKeyComplete) |
| |
| return self._CallDevMgrAsync( |
| lambda: _dmLib.nl_Weave_DeviceManager_ThermostatGetEntryKey(self.devMgr, cbHandleThermostatGetEntryKeyComplete, self.cbHandleError) |
| ) |
| |
| def ThermostatSystemTestStatus(self): |
| def HandleThermostatSystemTestStatusComplete(devMgr, reqState, systemTestStatus): |
| self.callbackRes = systemTestStatus |
| self.completeEvent.set() |
| |
| cbHandleThermostatSystemTestStatusComplete = _ThermostatSystemTestStatusCompleteFunct(HandleThermostatSystemTestStatusComplete) |
| |
| return self._CallDevMgrAsync( |
| lambda: _dmLib.nl_Weave_DeviceManager_ThermostatSystemTestStatus(self.devMgr, cbHandleThermostatSystemTestStatusComplete, self.cbHandleError) |
| ) |
| |
| # ----- Private Members ----- |
| def _InitLib(self): |
| global _dmLib |
| if (_dmLib == None): |
| _dmLib = CDLL(dmLibName) |
| _dmLib.nl_Weave_DeviceManager_Init.argtypes = [ ] |
| _dmLib.nl_Weave_DeviceManager_Init.restype = c_uint32 |
| |
| _dmLib.nl_Weave_DeviceManager_Shutdown.argtypes = [ ] |
| _dmLib.nl_Weave_DeviceManager_Shutdown.restype = c_uint32 |
| |
| _dmLib.nl_Weave_DeviceManager_NewDeviceManager.argtypes = [ POINTER(c_void_p) ] |
| _dmLib.nl_Weave_DeviceManager_NewDeviceManager.restype = c_uint32 |
| |
| _dmLib.nl_Weave_DeviceManager_DeleteDeviceManager.argtypes = [ c_void_p ] |
| _dmLib.nl_Weave_DeviceManager_DeleteDeviceManager.restype = c_uint32 |
| |
| _dmLib.nl_Weave_DeviceManager_Close.argtypes = [ c_void_p ] |
| _dmLib.nl_Weave_DeviceManager_Close.restype = None |
| |
| _dmLib.nl_Weave_DeviceManager_DriveIO.argtypes = [ c_uint32 ] |
| _dmLib.nl_Weave_DeviceManager_DriveIO.restype = c_uint32 |
| |
| _dmLib.nl_Weave_DeviceManager_WakeForBleIO.argtypes = [ ] |
| _dmLib.nl_Weave_DeviceManager_WakeForBleIO.restype = c_uint32 |
| |
| _dmLib.nl_Weave_DeviceManager_SetBleEventCB.argtypes = [ _GetBleEventFunct ] |
| _dmLib.nl_Weave_DeviceManager_SetBleEventCB.restype = c_uint32 |
| |
| _dmLib.nl_Weave_DeviceManager_SetBleWriteCharacteristic.argtypes = [ _WriteBleCharacteristicFunct ] |
| _dmLib.nl_Weave_DeviceManager_SetBleWriteCharacteristic.restype = c_uint32 |
| |
| _dmLib.nl_Weave_DeviceManager_SetBleSubscribeCharacteristic.argtypes = [ _SubscribeBleCharacteristicFunct ] |
| _dmLib.nl_Weave_DeviceManager_SetBleSubscribeCharacteristic.restype = c_uint32 |
| |
| _dmLib.nl_Weave_DeviceManager_SetBleClose.argtypes = [ _CloseBleFunct ] |
| _dmLib.nl_Weave_DeviceManager_SetBleClose.restype = c_uint32 |
| |
| _dmLib.nl_Weave_DeviceManager_IsConnected.argtypes = [ c_void_p ] |
| _dmLib.nl_Weave_DeviceManager_IsConnected.restype = c_bool |
| |
| _dmLib.nl_Weave_DeviceManager_DeviceId.argtypes = [ c_void_p ] |
| _dmLib.nl_Weave_DeviceManager_DeviceId.restype = c_uint64 |
| |
| _dmLib.nl_Weave_DeviceManager_DeviceAddress.argtypes = [ c_void_p ] |
| _dmLib.nl_Weave_DeviceManager_DeviceAddress.restype = c_char_p |
| |
| _dmLib.nl_Weave_DeviceManager_StartDeviceEnumeration.argtypes = [ c_void_p, POINTER(_IdentifyDeviceCriteriaStruct), _DeviceEnumerationResponseFunct, _ErrorFunct ] |
| _dmLib.nl_Weave_DeviceManager_StartDeviceEnumeration.restype = c_uint32 |
| |
| _dmLib.nl_Weave_DeviceManager_StopDeviceEnumeration.argtypes = [ c_void_p ] |
| _dmLib.nl_Weave_DeviceManager_StopDeviceEnumeration.restype = None |
| |
| _dmLib.nl_Weave_DeviceManager_ConnectDevice_NoAuth.argtypes = [ c_void_p, c_uint64, c_char_p, _CompleteFunct, _ErrorFunct ] |
| _dmLib.nl_Weave_DeviceManager_ConnectDevice_NoAuth.restype = c_uint32 |
| |
| _dmLib.nl_Weave_DeviceManager_ConnectDevice_PairingCode.argtypes = [ c_void_p, c_uint64, c_char_p, c_char_p, _CompleteFunct, _ErrorFunct ] |
| _dmLib.nl_Weave_DeviceManager_ConnectDevice_PairingCode.restype = c_uint32 |
| |
| _dmLib.nl_Weave_DeviceManager_ConnectDevice_AccessToken.argtypes = [ c_void_p, c_uint64, c_char_p, c_void_p, c_uint32, _CompleteFunct, _ErrorFunct ] |
| _dmLib.nl_Weave_DeviceManager_ConnectDevice_AccessToken.restype = c_uint32 |
| |
| _dmLib.nl_Weave_DeviceManager_RendezvousDevice_NoAuth.argtypes = [ c_void_p, POINTER(_IdentifyDeviceCriteriaStruct), _CompleteFunct, _ErrorFunct ] |
| _dmLib.nl_Weave_DeviceManager_RendezvousDevice_NoAuth.restype = c_uint32 |
| |
| _dmLib.nl_Weave_DeviceManager_RendezvousDevice_PairingCode.argtypes = [ c_void_p, c_char_p, POINTER(_IdentifyDeviceCriteriaStruct), _CompleteFunct, _ErrorFunct ] |
| _dmLib.nl_Weave_DeviceManager_RendezvousDevice_PairingCode.restype = c_uint32 |
| |
| _dmLib.nl_Weave_DeviceManager_RendezvousDevice_AccessToken.argtypes = [ c_void_p, c_void_p, c_uint32, POINTER(_IdentifyDeviceCriteriaStruct), _CompleteFunct, _ErrorFunct ] |
| _dmLib.nl_Weave_DeviceManager_RendezvousDevice_AccessToken.restype = c_uint32 |
| |
| _dmLib.nl_Weave_DeviceManager_PassiveRendezvousDevice_NoAuth.argtypes = [ c_void_p, _CompleteFunct, _ErrorFunct ] |
| _dmLib.nl_Weave_DeviceManager_PassiveRendezvousDevice_NoAuth.restype = c_uint32 |
| |
| _dmLib.nl_Weave_DeviceManager_PassiveRendezvousDevice_PairingCode.argtypes = [ c_void_p, c_char_p, _CompleteFunct, _ErrorFunct ] |
| _dmLib.nl_Weave_DeviceManager_PassiveRendezvousDevice_PairingCode.restype = c_uint32 |
| |
| _dmLib.nl_Weave_DeviceManager_PassiveRendezvousDevice_AccessToken.argtypes = [ c_void_p, c_void_p, c_uint32, _CompleteFunct, _ErrorFunct ] |
| _dmLib.nl_Weave_DeviceManager_PassiveRendezvousDevice_AccessToken.restype = c_uint32 |
| |
| _dmLib.nl_Weave_DeviceManager_TestBle.argtypes = [ c_void_p, c_void_p, _CompleteFunct, _ErrorFunct, c_uint32, c_uint32, c_uint16, c_uint8, c_uint16, c_bool ] |
| _dmLib.nl_Weave_DeviceManager_TestBle.restype = c_uint32 |
| _dmLib.nl_Weave_DeviceManager_TestResultBle.argtypes = [ c_void_p, c_void_p, c_bool ] |
| _dmLib.nl_Weave_DeviceManager_TestResultBle.restype = c_uint32 |
| _dmLib.nl_Weave_DeviceManager_TestAbortBle.argtypes = [ c_void_p, c_void_p ] |
| _dmLib.nl_Weave_DeviceManager_TestAbortBle.restype = c_uint32 |
| _dmLib.nl_Weave_DeviceManager_TxTimingBle.argtypes = [ c_void_p, c_void_p, c_bool, c_bool ] |
| _dmLib.nl_Weave_DeviceManager_TxTimingBle.restype = c_uint32 |
| |
| _dmLib.nl_Weave_DeviceManager_ConnectBle_NoAuth.argtypes = [ c_void_p, c_void_p, _CompleteFunct, _ErrorFunct ] |
| _dmLib.nl_Weave_DeviceManager_ConnectBle_NoAuth.restype = c_uint32 |
| |
| _dmLib.nl_Weave_DeviceManager_ConnectBle_PairingCode.argtypes = [ c_void_p, c_void_p, c_char_p, _CompleteFunct, _ErrorFunct ] |
| _dmLib.nl_Weave_DeviceManager_ConnectBle_PairingCode.restype = c_uint32 |
| |
| _dmLib.nl_Weave_DeviceManager_ConnectBle_AccessToken.argtypes = [ c_void_p, c_void_p, c_void_p, c_uint32, _CompleteFunct, _ErrorFunct ] |
| _dmLib.nl_Weave_DeviceManager_ConnectBle_AccessToken.restype = c_uint32 |
| |
| _dmLib.nl_Weave_DeviceManager_RemotePassiveRendezvous_CASEAuth.argtypes = [ c_void_p, c_char_p, c_char_p, c_uint32, c_uint16, c_uint16, _CompleteFunct, _ErrorFunct ] |
| _dmLib.nl_Weave_DeviceManager_RemotePassiveRendezvous_CASEAuth.restype = c_uint32 |
| |
| _dmLib.nl_Weave_DeviceManager_RemotePassiveRendezvous_PASEAuth.argtypes = [ c_void_p, c_char_p, c_char_p, c_uint16, c_uint16, _CompleteFunct, _ErrorFunct ] |
| _dmLib.nl_Weave_DeviceManager_RemotePassiveRendezvous_PASEAuth.restype = c_uint32 |
| |
| _dmLib.nl_Weave_DeviceManager_RemotePassiveRendezvous_NoAuth.argtypes = [ c_void_p, c_char_p, c_uint16, c_uint16, _CompleteFunct, _ErrorFunct ] |
| _dmLib.nl_Weave_DeviceManager_RemotePassiveRendezvous_NoAuth.restype = c_uint32 |
| |
| _dmLib.nl_Weave_DeviceManager_ReconnectDevice.argtypes = [ c_void_p, _CompleteFunct, _ErrorFunct ] |
| _dmLib.nl_Weave_DeviceManager_ReconnectDevice.restype = c_uint32 |
| |
| _dmLib.nl_Weave_DeviceManager_EnableConnectionMonitor.argtypes = [ c_void_p, c_uint16, c_uint16, _CompleteFunct, _ErrorFunct ] |
| _dmLib.nl_Weave_DeviceManager_EnableConnectionMonitor.restype = c_uint32 |
| |
| _dmLib.nl_Weave_DeviceManager_DisableConnectionMonitor.argtypes = [ c_void_p, _CompleteFunct, _ErrorFunct ] |
| _dmLib.nl_Weave_DeviceManager_DisableConnectionMonitor.restype = c_uint32 |
| |
| _dmLib.nl_Weave_DeviceManager_IdentifyDevice.argtypes = [ c_void_p, _IdentifyDeviceCompleteFunct, _ErrorFunct ] |
| _dmLib.nl_Weave_DeviceManager_IdentifyDevice.restype = c_uint32 |
| |
| _dmLib.nl_Weave_DeviceManager_PairToken.argtypes = [ c_void_p, c_void_p, c_uint32, _PairTokenCompleteFunct, _ErrorFunct ] |
| _dmLib.nl_Weave_DeviceManager_PairToken.restype = c_uint32 |
| |
| _dmLib.nl_Weave_DeviceManager_UnpairToken.argtypes = [ c_void_p, _UnpairTokenCompleteFunct, _ErrorFunct ] |
| _dmLib.nl_Weave_DeviceManager_UnpairToken.restype = c_uint32 |
| |
| _dmLib.nl_Weave_DeviceManager_ScanNetworks.argtypes = [ c_void_p, c_int, _NetworkScanCompleteFunct, _ErrorFunct ] |
| _dmLib.nl_Weave_DeviceManager_ScanNetworks.restype = c_uint32 |
| |
| _dmLib.nl_Weave_DeviceManager_GetNetworks.argtypes = [ c_void_p, c_int, _GetNetworksCompleteFunct, _ErrorFunct ] |
| _dmLib.nl_Weave_DeviceManager_GetNetworks.restype = c_uint32 |
| |
| _dmLib.nl_Weave_DeviceManager_GetCameraAuthData.argtypes = [ c_void_p, c_char_p, _GetCameraAuthDataCompleteFunct, _ErrorFunct ] |
| _dmLib.nl_Weave_DeviceManager_GetCameraAuthData.restype = c_uint32 |
| |
| _dmLib.nl_Weave_DeviceManager_AddNetwork.argtypes = [ c_void_p, POINTER(_NetworkInfoStruct), _AddNetworkCompleteFunct, _ErrorFunct ] |
| _dmLib.nl_Weave_DeviceManager_AddNetwork.restype = c_uint32 |
| |
| _dmLib.nl_Weave_DeviceManager_UpdateNetwork.argtypes = [ c_void_p, POINTER(_NetworkInfoStruct), _CompleteFunct, _ErrorFunct ] |
| _dmLib.nl_Weave_DeviceManager_UpdateNetwork.restype = c_uint32 |
| |
| _dmLib.nl_Weave_DeviceManager_RemoveNetwork.argtypes = [ c_void_p, c_uint32, _CompleteFunct, _ErrorFunct ] |
| _dmLib.nl_Weave_DeviceManager_RemoveNetwork.restype = c_uint32 |
| |
| _dmLib.nl_Weave_DeviceManager_EnableNetwork.argtypes = [ c_void_p, c_uint32, _CompleteFunct, _ErrorFunct ] |
| _dmLib.nl_Weave_DeviceManager_EnableNetwork.restype = c_uint32 |
| |
| _dmLib.nl_Weave_DeviceManager_DisableNetwork.argtypes = [ c_void_p, c_uint32, _CompleteFunct, _ErrorFunct ] |
| _dmLib.nl_Weave_DeviceManager_DisableNetwork.restype = c_uint32 |
| |
| _dmLib.nl_Weave_DeviceManager_TestNetworkConnectivity.argtypes = [ c_void_p, c_uint32, _CompleteFunct, _ErrorFunct ] |
| _dmLib.nl_Weave_DeviceManager_TestNetworkConnectivity.restype = c_uint32 |
| |
| _dmLib.nl_Weave_DeviceManager_GetRendezvousMode.argtypes = [ c_void_p, _GetRendezvousModeCompleteFunct, _ErrorFunct ] |
| _dmLib.nl_Weave_DeviceManager_GetRendezvousMode.restype = c_uint32 |
| |
| _dmLib.nl_Weave_DeviceManager_SetRendezvousMode.argtypes = [ c_void_p, c_uint16, _CompleteFunct, _ErrorFunct ] |
| _dmLib.nl_Weave_DeviceManager_SetRendezvousMode.restype = c_uint32 |
| |
| _dmLib.nl_Weave_DeviceManager_GetLastNetworkProvisioningResult.argtypes = [ c_void_p, _CompleteFunct, _ErrorFunct ] |
| _dmLib.nl_Weave_DeviceManager_GetLastNetworkProvisioningResult.restype = c_uint32 |
| |
| _dmLib.nl_Weave_DeviceManager_CreateFabric.argtypes = [ c_void_p, _CompleteFunct, _ErrorFunct ] |
| _dmLib.nl_Weave_DeviceManager_CreateFabric.restype = c_uint32 |
| |
| _dmLib.nl_Weave_DeviceManager_LeaveFabric.argtypes = [ c_void_p, _CompleteFunct, _ErrorFunct ] |
| _dmLib.nl_Weave_DeviceManager_LeaveFabric.restype = c_uint32 |
| |
| _dmLib.nl_Weave_DeviceManager_GetFabricConfig.argtypes = [ c_void_p, _GetFabricConfigCompleteFunct, _ErrorFunct ] |
| _dmLib.nl_Weave_DeviceManager_GetFabricConfig.restype = c_uint32 |
| |
| _dmLib.nl_Weave_DeviceManager_JoinExistingFabric.argtypes = [ c_void_p, c_void_p, c_uint32, _CompleteFunct, _ErrorFunct ] |
| _dmLib.nl_Weave_DeviceManager_JoinExistingFabric.restype = c_uint32 |
| |
| _dmLib.nl_Weave_DeviceManager_Ping.argtypes = [ c_void_p, _CompleteFunct, _ErrorFunct ] |
| _dmLib.nl_Weave_DeviceManager_Ping.restype = c_uint32 |
| |
| _dmLib.nl_Weave_DeviceManager_Hush.argtypes = [ c_void_p, c_uint32, c_uint32, c_uint16, c_void_p, c_uint16, _HushCompleteFunct, _ErrorFunct ] |
| _dmLib.nl_Weave_DeviceManager_Hush.restype = c_uint32 |
| |
| _dmLib.nl_Weave_DeviceManager_SetRendezvousAddress.argtypes = [ c_void_p, c_char_p ] |
| _dmLib.nl_Weave_DeviceManager_SetRendezvousAddress.restype = c_uint32 |
| |
| _dmLib.nl_Weave_DeviceManager_SetConnectTimeout.argtypes = [ c_void_p, c_uint32 ] |
| _dmLib.nl_Weave_DeviceManager_SetConnectTimeout.restype = c_uint32 |
| |
| _dmLib.nl_Weave_DeviceManager_SetAutoReconnect.argtypes = [ c_void_p, c_bool ] |
| _dmLib.nl_Weave_DeviceManager_SetAutoReconnect.restype = c_uint32 |
| |
| _dmLib.nl_Weave_DeviceManager_SetRendezvousLinkLocal.argtypes = [ c_void_p, c_bool ] |
| _dmLib.nl_Weave_DeviceManager_SetRendezvousLinkLocal.restype = c_uint32 |
| |
| _dmLib.nl_Weave_DeviceManager_RegisterServicePairAccount.argtypes = [ c_void_p, c_uint64, c_char_p, c_void_p, c_uint32, c_void_p, c_uint32, c_void_p, c_uint32, _CompleteFunct, _ErrorFunct ] |
| _dmLib.nl_Weave_DeviceManager_RegisterServicePairAccount.restype = c_uint32 |
| |
| _dmLib.nl_Weave_DeviceManager_UpdateService.argtypes = [ c_void_p, c_uint64, c_void_p, c_uint32, _CompleteFunct, _ErrorFunct ] |
| _dmLib.nl_Weave_DeviceManager_UpdateService.restype = c_uint32 |
| |
| _dmLib.nl_Weave_DeviceManager_UnregisterService.argtypes = [ c_void_p, c_uint64, _CompleteFunct, _ErrorFunct ] |
| _dmLib.nl_Weave_DeviceManager_UnregisterService.restype = c_uint32 |
| |
| _dmLib.nl_Weave_DeviceManager_ArmFailSafe.argtypes = [ c_void_p, c_uint8, c_uint32, _CompleteFunct, _ErrorFunct ] |
| _dmLib.nl_Weave_DeviceManager_ArmFailSafe.restype = c_uint32 |
| |
| _dmLib.nl_Weave_DeviceManager_DisarmFailSafe.argtypes = [ c_void_p, _CompleteFunct, _ErrorFunct ] |
| _dmLib.nl_Weave_DeviceManager_DisarmFailSafe.restype = c_uint32 |
| |
| _dmLib.nl_Weave_DeviceManager_ResetConfig.argtypes = [ c_void_p, c_uint16, _CompleteFunct, _ErrorFunct ] |
| _dmLib.nl_Weave_DeviceManager_ResetConfig.restype = c_uint32 |
| |
| _dmLib.nl_Weave_DeviceManager_ErrorToString.argtypes = [ c_uint32 ] |
| _dmLib.nl_Weave_DeviceManager_ErrorToString.restype = c_char_p |
| |
| _dmLib.nl_Weave_DeviceManager_StatusReportToString.argtypes = [ c_uint32, c_uint16 ] |
| _dmLib.nl_Weave_DeviceManager_StatusReportToString.restype = c_char_p |
| |
| _dmLib.nl_Weave_DeviceManager_GetLogFilter.argtypes = [ ] |
| _dmLib.nl_Weave_DeviceManager_GetLogFilter.restype = c_uint8 |
| |
| _dmLib.nl_Weave_DeviceManager_SetLogFilter.argtypes = [ c_uint8 ] |
| _dmLib.nl_Weave_DeviceManager_SetLogFilter.restype = None |
| |
| _dmLib.nl_Weave_DeviceManager_CloseEndpoints.argtypes = [ ] |
| _dmLib.nl_Weave_DeviceManager_CloseEndpoints.restype = c_uint32 |
| |
| _dmLib.nl_Weave_DeviceManager_AlarmSourceToString.argtypes = [ c_uint8 ] |
| _dmLib.nl_Weave_DeviceManager_AlarmSourceToString.restype = c_char_p |
| |
| _dmLib.nl_Weave_DeviceManager_AlarmStateToString.argtypes = [ c_uint8 ] |
| _dmLib.nl_Weave_DeviceManager_AlarmStateToString.restype = c_char_p |
| |
| _dmLib.nl_Weave_DeviceManager_AlarmHushResultToString.argtypes = [ c_uint8 ] |
| _dmLib.nl_Weave_DeviceManager_AlarmHushResultToString.restype = c_char_p |
| |
| _dmLib.nl_Weave_DeviceManager_GetActiveLocale.argtypes = [ c_void_p, _GetActiveLocaleCompleteFunct, _ErrorFunct ] |
| _dmLib.nl_Weave_DeviceManager_GetActiveLocale.restype = c_uint32 |
| |
| _dmLib.nl_Weave_DeviceManager_GetAvailableLocales.argtypes = [ c_void_p, _GetAvailableLocalesCompleteFunct, _ErrorFunct ] |
| _dmLib.nl_Weave_DeviceManager_GetAvailableLocales.restype = c_uint32 |
| |
| _dmLib.nl_Weave_DeviceManager_SetActiveLocale.argtypes = [ c_void_p, c_char_p, _CompleteFunct, _ErrorFunct ] |
| _dmLib.nl_Weave_DeviceManager_SetActiveLocale.restype = c_uint32 |
| |
| _dmLib.nl_Weave_DeviceManager_ThermostatGetEntryKey.argtypes = [ c_void_p, _ThermostatGetEntryKeyCompleteFunct, _ErrorFunct ] |
| _dmLib.nl_Weave_DeviceManager_ThermostatGetEntryKey.restype = c_uint32 |
| |
| _dmLib.nl_Weave_DeviceManager_ThermostatSystemTestStatus.argtypes = [ c_void_p, _ThermostatSystemTestStatusCompleteFunct, _ErrorFunct ] |
| _dmLib.nl_Weave_DeviceManager_ThermostatSystemTestStatus.restype = c_uint32 |
| |
| _dmLib.nl_Weave_DeviceManager_StartSystemTest.argtypes = [ c_void_p, c_uint32, c_uint32, _CompleteFunct, _ErrorFunct ] |
| _dmLib.nl_Weave_DeviceManager_StartSystemTest.restype = c_uint32 |
| |
| _dmLib.nl_Weave_DeviceManager_StopSystemTest.argtypes = [ c_void_p, _CompleteFunct, _ErrorFunct ] |
| _dmLib.nl_Weave_DeviceManager_StopSystemTest.restype = c_uint32 |
| |
| res = _dmLib.nl_Weave_DeviceManager_Init() |
| if (res != 0): |
| raise self._ErrorToException(res) |
| |
| def _CallDevMgr(self, callFunct): |
| # throw error if op in progress |
| self.callbackRes = None |
| self.completeEvent.clear() |
| with self.networkLock: |
| res = callFunct() |
| self.completeEvent.set() |
| return res |
| |
| def _CallDevMgrAsync(self, callFunct): |
| # throw error if op in progress |
| self.callbackRes = None |
| self.completeEvent.clear() |
| with self.networkLock: |
| res = callFunct() |
| |
| if (res != 0): |
| self.completeEvent.set() |
| raise self._ErrorToException(res) |
| while (not self.completeEvent.isSet()): |
| if self.blockingCB: |
| self.blockingCB() |
| |
| self.completeEvent.wait(0.05) |
| if (isinstance(self.callbackRes, DeviceManagerException)): |
| raise self.callbackRes |
| return self.callbackRes |
| |
| def _ErrorToException(self, err, devStatusPtr=None): |
| if (err == 4044 and devStatusPtr): |
| devStatus = devStatusPtr.contents |
| msg = _dmLib.nl_Weave_DeviceManager_StatusReportToString(devStatus.ProfileId, devStatus.StatusCode) |
| sysErrorCode = devStatus.SysErrorCode if (devStatus.SysErrorCode != 0) else None |
| if (sysErrorCode != None): |
| msg = msg + " (system err %d)" % (sysErrorCode) |
| return DeviceError(devStatus.ProfileId, devStatus.StatusCode, sysErrorCode, msg) |
| else: |
| return DeviceManagerError(err, _dmLib.nl_Weave_DeviceManager_ErrorToString(err)) |
| |
| |
| def NetworkTypeToString(val): |
| if (val == NetworkType_WiFi): |
| return "WiFi" |
| if (val == NetworkType_Thread): |
| return "Thread" |
| if (val != None): |
| return "UNKNOWN (" + str(val)+ ")" |
| return None |
| |
| def ParseNetworkType(val): |
| if isinstance(val, (int, long)): |
| return val |
| val = val.lower() |
| if (val == "wifi"): |
| return NetworkType_WiFi |
| if (val == "thread"): |
| return NetworkType_Thread |
| raise Exception("Invalid network type: " + str(val)) |
| |
| def WiFiModeToString(val): |
| if (val == WiFiMode_AdHoc): |
| return "AdHoc" |
| if (val == WiFiMode_Managed): |
| return "Managed" |
| if (val != None): |
| return "Unknown (" + str(val)+ ")" |
| return None |
| |
| def ParseWiFiMode(val): |
| if isinstance(val, (int, long)): |
| return val |
| val = val.lower() |
| if (val == "adhoc" or val == "ad-hoc"): |
| return WiFiMode_AdHoc |
| if (val == "managed"): |
| return WiFiMode_Managed |
| raise Exception("Invalid Wifi mode: " + str(val)) |
| |
| def WiFiRoleToString(val): |
| if (val == WiFiRole_Station): |
| return "Station" |
| if (val == WiFiRole_AccessPoint): |
| return "AccessPoint" |
| if (val != None): |
| return "Unknown (" + str(val)+ ")" |
| return None |
| |
| def ParseWiFiRole(val): |
| if isinstance(val, (int, long)): |
| return val |
| val = val.lower() |
| if (val == "station"): |
| return WiFiRole_Station |
| if (val == "accesspoint" or val == "access-point"): |
| return WiFiRole_AccessPoint |
| raise Exception("Invalid Wifi role: " + str(val)) |
| |
| def WiFiSecurityTypeToString(val): |
| if (val == WiFiSecurityType_None): |
| return "None" |
| if (val == WiFiSecurityType_WEP): |
| return "WEP" |
| if (val == WiFiSecurityType_WPAPersonal): |
| return "WPA" |
| if (val == WiFiSecurityType_WPA2Personal): |
| return "WPA2" |
| if (val == WiFiSecurityType_WPA2MixedPersonal): |
| return "WPA2Mixed" |
| if (val == WiFiSecurityType_WPAEnterprise): |
| return "WPAEnterprise" |
| if (val == WiFiSecurityType_WPA2Enterprise): |
| return "WPA2Enterprise" |
| if (val == WiFiSecurityType_WPA2MixedEnterprise): |
| return "WPA2MixedEnterprise" |
| if (val != None): |
| return "Unknown (" + str(val)+ ")" |
| return None |
| |
| def ParseSecurityType(val): |
| val = val.lower() |
| if (val == 'none'): |
| return WiFiSecurityType_None |
| if (val == 'wep'): |
| return WiFiSecurityType_WEP |
| if (val == 'wpa' or val == 'wpapersonal' or val == 'wpa-personal'): |
| return WiFiSecurityType_WPAPersonal |
| if (val == 'wpa2' or val == 'wpa2personal' or val == 'wpa2-personal'): |
| return WiFiSecurityType_WPA2Personal |
| if (val == 'wpa2mixed' or val == 'wpa2-mixed' or val == 'wpa2mixedpersonal' or val == 'wpa2-mixed-personal'): |
| return WiFiSecurityType_WPA2MixedPersonal |
| if (val == 'wpaenterprise' or val == 'wpa-enterprise'): |
| return WiFiSecurityType_WPAEnterprise |
| if (val == 'wpa2enterprise' or val == 'wpa2-enterprise'): |
| return WiFiSecurityType_WPA2Enterprise |
| if (val == 'wpa2mixedenterprise' or val == 'wpa2-mixed-enterprise'): |
| return WiFiSecurityType_WPA2MixedEnterprise |
| raise Exception("Invalid Wifi security type: " + str(val)) |
| |
| def DeviceFeatureToString(val): |
| if (val == DeviceFeature_HomeAlarmLinkCapable): |
| return "HomeAlarmLinkCapable" |
| if (val == DeviceFeature_LinePowered): |
| return "LinePowered" |
| return "0x%08X" % (val) |
