hoffmation-base 3.0.3 → 3.1.1

package/lib/devices/devices.js

@@ -0,0 +1,374 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Devices = void 0;
+const hmIPDevices_1 = require("./hmIPDevices");
+const zigbee_1 = require("./zigbee");
+const logging_1 = require("../logging");
+const enums_1 = require("../enums");
+const shelly_1 = require("./shelly");
+const tuya_1 = require("./tuya");
+const IoBrokerDeviceInfo_1 = require("./IoBrokerDeviceInfo");
+const velux_1 = require("./velux");
+const smartGarden_1 = require("./smartGarden");
+const wledDevice_1 = require("./wledDevice");
+const jsObject_1 = require("./jsObject");
+class Devices {
+    constructor(pDeviceData, pRoomImportEnforcer, config) {
+        var _a;
+        // This forces import of rooms at correct timing, to allow devices to land in proper rooms.
+        pRoomImportEnforcer === null || pRoomImportEnforcer === void 0 ? void 0 : pRoomImportEnforcer.addRoomConstructor();
+        logging_1.ServerLogService.writeLog(enums_1.LogLevel.Info, 'Constructing devices now');
+        for (const cID in pDeviceData) {
+            const cDevConf = pDeviceData[cID];
+            if (!cDevConf.common || !cDevConf.common.name || typeof cDevConf.common.name === 'object' || !cDevConf.type) {
+                continue;
+            }
+            const cName = cDevConf.common.name;
+            if (cDevConf.type === 'channel') {
+                // Velux has the name in the root channel of a device
+                if (cName.indexOf('00-Velux') === 0) {
+                    Devices.processVeluxDevice(cDevConf);
+                }
+                continue;
+            }
+            if (cName.indexOf('00-HmIP') === 0) {
+                Devices.processHMIPDevice(cDevConf);
+            }
+            else if (cName.indexOf('00-Zigbee') === 0) {
+                Devices.processZigbeeDevice(cDevConf);
+            }
+            else if (cName.indexOf('00-WLED') === 0) {
+                Devices.processWledDevice(cDevConf);
+            }
+            else if (cName.indexOf('00-Shelly') === 0) {
+                Devices.processShellyDevice(cDevConf);
+            }
+            else if (cName.indexOf('00-Tuya') === 0) {
+                Devices.processTuyaDevice(cDevConf);
+            }
+            else if (cDevConf.type === 'device' && cName.indexOf('DEVICE_') === 0 && cID.indexOf('smartgarden') === 0) {
+                Devices.processSmartGardenDevice(cDevConf);
+            }
+            else if (cName.indexOf('00-EnergyManager') === 0 &&
+                cDevConf.type !== 'folder' &&
+                !((_a = config === null || config === void 0 ? void 0 : config.energyManager) === null || _a === void 0 ? void 0 : _a.disableJsEnergyManager)) {
+                logging_1.ServerLogService.writeLog(enums_1.LogLevel.Info, 'Found Energy-Manager in Device json.');
+                Devices.createEnergyManager(cDevConf);
+            }
+        }
+        hmIPDevices_1.HmIPDevice.checkMissing();
+        zigbee_1.ZigbeeDevice.checkMissing();
+        shelly_1.ShellyDevice.checkMissing();
+        tuya_1.TuyaDevice.checkMissing();
+    }
+    static midnightReset() {
+        // Nothing yet
+    }
+    static resetDetectionsToday() {
+        logging_1.ServerLogService.writeLog(enums_1.LogLevel.Info, "3 o'clock reset of motion sensors");
+        for (const dID in Devices.alLDevices) {
+            const d = Devices.alLDevices[dID];
+            if (d.deviceCapabilities.includes(enums_1.DeviceCapability.motionSensor)) {
+                d.log(enums_1.LogLevel.Debug, "3 o'clock reset of detections");
+                d.detectionsToday = 0;
+            }
+        }
+    }
+    static getBatteryInfo() {
+        logging_1.ServerLogService.writeLog(enums_1.LogLevel.Info, 'Getting Battery Info');
+        let data = [];
+        const result = [
+            'These are the battery values for each device. Device dependandt some are in volts, some in %',
+        ];
+        for (const key in this.alLDevices) {
+            const d = this.alLDevices[key];
+            if (!d.deviceCapabilities.includes(enums_1.DeviceCapability.batteryDriven)) {
+                continue;
+            }
+            if (d.batteryLevel !== undefined) {
+                data.push({ name: d.info.customName, amount: d.batteryLevel });
+            }
+        }
+        data = data.sort((a, b) => {
+            return a.amount - b.amount;
+        });
+        for (let i = 0; i < data.length; i++) {
+            result.push(`${data[i].amount}\t${data[i].name}`);
+        }
+        return result.join('\n');
+    }
+    static processShellyDevice(cDevConf) {
+        const shellyInfo = IoBrokerDeviceInfo_1.IoBrokerDeviceInfo.byDeviceConfig(cDevConf);
+        const fullName = `${Devices.IDENTIFIER_Shelly}-${shellyInfo.devID}`;
+        shellyInfo.allDevicesKey = fullName;
+        if (typeof Devices.alLDevices[fullName] !== 'undefined') {
+            return;
+        }
+        logging_1.ServerLogService.writeLog(enums_1.LogLevel.Trace, `Shelly ${shellyInfo.devID} with Type "${shellyInfo.deviceType}" doesn't exists --> create it`);
+        let d;
+        switch (shellyInfo.deviceType) {
+            case 'Trv':
+                d = new shelly_1.ShellyTrv(shellyInfo);
+                break;
+            case 'Actuator':
+                d = new shelly_1.ShellyActuator(shellyInfo);
+                break;
+            default:
+                logging_1.ServerLogService.writeLog(enums_1.LogLevel.Warn, `No shelly Device Type for ${shellyInfo.deviceType} defined`);
+                d = new shelly_1.ShellyDevice(shellyInfo, enums_1.DeviceType.unknown);
+        }
+        Devices.alLDevices[fullName] = d;
+    }
+    static processTuyaDevice(cDevConf) {
+        const tuyaInfo = IoBrokerDeviceInfo_1.IoBrokerDeviceInfo.byDeviceConfig(cDevConf);
+        const fullName = `${Devices.IDENTIFIER_TUYA}-${tuyaInfo.devID}`;
+        tuyaInfo.allDevicesKey = fullName;
+        if (typeof Devices.alLDevices[fullName] !== 'undefined') {
+            return;
+        }
+        logging_1.ServerLogService.writeLog(enums_1.LogLevel.Trace, `Tuya ${tuyaInfo.devID} with Type "${tuyaInfo.deviceType}" doesn't exists --> create it`);
+        let d;
+        switch (tuyaInfo.deviceType) {
+            case 'Opener':
+                d = new tuya_1.TuyaGarageOpener(tuyaInfo);
+                break;
+            default:
+                logging_1.ServerLogService.writeLog(enums_1.LogLevel.Warn, `No Tuya Device Type for ${tuyaInfo.deviceType} defined`);
+                d = new tuya_1.TuyaDevice(tuyaInfo, enums_1.DeviceType.unknown);
+        }
+        Devices.alLDevices[fullName] = d;
+    }
+    static processZigbeeDevice(cDevConf) {
+        const zigbeeInfo = IoBrokerDeviceInfo_1.IoBrokerDeviceInfo.byDeviceConfig(cDevConf);
+        const apiDevId = zigbeeInfo.devID.startsWith('0x') ? zigbeeInfo.devID.substring(2) : zigbeeInfo.devID;
+        const fullName = `zigbee-${apiDevId}`;
+        zigbeeInfo.allDevicesKey = fullName;
+        if (typeof Devices.alLDevices[fullName] !== 'undefined') {
+            return;
+        }
+        logging_1.ServerLogService.writeLog(enums_1.LogLevel.Trace, `${zigbeeInfo.devID} with Type "${zigbeeInfo.deviceType}" doesn't exists --> create it`);
+        let d;
+        switch (zigbeeInfo.deviceType) {
+            case 'AqaraMagnetContact':
+                d = new zigbee_1.ZigbeeAqaraMagnetContact(zigbeeInfo);
+                break;
+            case 'AqaraOpple3Switch':
+                d = new zigbee_1.ZigbeeAqaraOpple3Switch(zigbeeInfo);
+                break;
+            case 'AquaraMotion':
+                d = new zigbee_1.ZigbeeAquaraMotion(zigbeeInfo);
+                break;
+            case 'AquaraVibra':
+                d = new zigbee_1.ZigbeeAquaraVibra(zigbeeInfo);
+                break;
+            case 'AquaraWater':
+                d = new zigbee_1.ZigbeeAquaraWater(zigbeeInfo);
+                break;
+            case 'BlitzShp':
+                d = new zigbee_1.ZigbeeBlitzShp(zigbeeInfo);
+                break;
+            case 'HeimanSmoke':
+                d = new zigbee_1.ZigbeeHeimanSmoke(zigbeeInfo);
+                break;
+            case 'IkeaStecker':
+                d = new zigbee_1.ZigbeeIkeaSteckdose(zigbeeInfo);
+                break;
+            case 'IlluActuator':
+                d = new zigbee_1.ZigbeeIlluActuator(zigbeeInfo);
+                break;
+            case 'IlluDimmer':
+                d = new zigbee_1.ZigbeeIlluDimmer(zigbeeInfo);
+                break;
+            case 'OsramDimmer':
+                d = new zigbee_1.ZigbeeOsramDimmer(zigbeeInfo);
+                break;
+            case 'IlluLampe':
+                d = new zigbee_1.ZigbeeIlluLampe(zigbeeInfo);
+                break;
+            case 'IlluShutter':
+                d = new zigbee_1.ZigbeeIlluShutter(zigbeeInfo);
+                break;
+            case 'IlluLedRGBCCT':
+                d = new zigbee_1.ZigbeeIlluLedRGBCCT(zigbeeInfo);
+                break;
+            case 'Innr142C':
+                d = new zigbee_1.ZigbeeInnr142C(zigbeeInfo);
+                break;
+            case 'LinkindLedRgbCct':
+                d = new zigbee_1.ZigbeeLinkindLedRgbCct(zigbeeInfo);
+                break;
+            case 'SMaBiTMagnet':
+                d = new zigbee_1.ZigbeeSMaBiTMagnetContact(zigbeeInfo);
+                break;
+            case 'SonoffMotion':
+                d = new zigbee_1.ZigbeeSonoffMotion(zigbeeInfo);
+                break;
+            case 'SonoffTemp':
+                d = new zigbee_1.ZigbeeSonoffTemp(zigbeeInfo);
+                break;
+            case 'UbisysActuator':
+                d = new zigbee_1.ZigbeeUbisysActuator(zigbeeInfo);
+                break;
+            case 'UbisysLampe':
+                d = new zigbee_1.ZigbeeUbisysLampe(zigbeeInfo);
+                break;
+            case 'UbisysShutter':
+                d = new zigbee_1.ZigbeeUbisysShutter(zigbeeInfo);
+                break;
+            case 'IkeaShutter':
+                d = new zigbee_1.ZigbeeIkeaShutter(zigbeeInfo);
+                break;
+            case 'TuyaValve':
+                d = new zigbee_1.ZigbeeTuyaValve(zigbeeInfo);
+                break;
+            case 'TuyaMotion':
+                d = new zigbee_1.ZigbeeTuyaMotion(zigbeeInfo);
+                break;
+            case 'EuroHeater':
+                d = new zigbee_1.ZigbeeEuroHeater(zigbeeInfo);
+                break;
+            case 'SodaHandle':
+                d = new zigbee_1.ZigbeeSodaHandle(zigbeeInfo);
+                break;
+            default:
+                logging_1.ServerLogService.writeLog(enums_1.LogLevel.Warn, `No zigbee Device Type for ${zigbeeInfo.deviceType} defined`);
+                d = new zigbee_1.ZigbeeDevice(zigbeeInfo, enums_1.DeviceType.unknown);
+        }
+        Devices.alLDevices[fullName] = d;
+    }
+    static processVeluxDevice(cDevConf) {
+        velux_1.VeluxService.processVeluxDevice(cDevConf);
+    }
+    static processSmartGardenDevice(cDevConf) {
+        smartGarden_1.SmartGardenService.processSmartGardenDevice(cDevConf);
+    }
+    static processWledDevice(cDevConf) {
+        const wledIoBrokerDeviceInfo = IoBrokerDeviceInfo_1.IoBrokerDeviceInfo.byDeviceConfig(cDevConf);
+        const fullName = `${Devices.IDENTIFIER_WLED}-${wledIoBrokerDeviceInfo.devID}`;
+        wledIoBrokerDeviceInfo.allDevicesKey = fullName;
+        if (typeof Devices.alLDevices[fullName] !== 'undefined') {
+            return;
+        }
+        logging_1.ServerLogService.writeLog(enums_1.LogLevel.Trace, `${wledIoBrokerDeviceInfo.devID} with Type "${wledIoBrokerDeviceInfo.deviceType}" doesn't exists --> create it`);
+        Devices.alLDevices[fullName] = new wledDevice_1.WledDevice(wledIoBrokerDeviceInfo);
+    }
+    static processHMIPDevice(cDevConf) {
+        const hmIPInfo = IoBrokerDeviceInfo_1.IoBrokerDeviceInfo.byDeviceConfig(cDevConf);
+        const fullName = `${Devices.IDENTIFIER_HOMEMATIC}-${hmIPInfo.devID}`;
+        hmIPInfo.allDevicesKey = fullName;
+        if (typeof Devices.alLDevices[fullName] !== 'undefined') {
+            return;
+        }
+        logging_1.ServerLogService.writeLog(enums_1.LogLevel.Trace, `${hmIPInfo.devID} with Type "${hmIPInfo.deviceType}" doesn't exists --> create it`);
+        let d;
+        switch (hmIPInfo.deviceType) {
+            case 'Lampe':
+                d = new hmIPDevices_1.HmIpLampe(hmIPInfo);
+                break;
+            case 'Roll':
+            case 'Broll':
+                d = new hmIPDevices_1.HmIpRoll(hmIPInfo);
+                break;
+            case 'Beweg':
+                d = new hmIPDevices_1.HmIpBewegung(hmIPInfo);
+                break;
+            case 'Taster':
+                d = new hmIPDevices_1.HmIpTaster(hmIPInfo);
+                break;
+            case 'Wippe':
+                d = new hmIPDevices_1.HmIpWippe(hmIPInfo);
+                break;
+            case 'Praezenz':
+                d = new hmIPDevices_1.HmIpPraezenz(hmIPInfo);
+                break;
+            case 'Griff':
+                d = new hmIPDevices_1.HmIpGriff(hmIPInfo);
+                break;
+            case 'Thermostat':
+                d = new hmIPDevices_1.HmIpTherm(hmIPInfo);
+                break;
+            case 'Heizung':
+                d = new hmIPDevices_1.HmIpHeizung(hmIPInfo);
+                break;
+            case 'Tuer':
+                d = new hmIPDevices_1.HmIpTuer(hmIPInfo);
+                break;
+            case 'HeizGr':
+                d = new hmIPDevices_1.HmIpHeizgruppe(hmIPInfo);
+                break;
+            case 'AccessPoint':
+                d = new hmIPDevices_1.HmIpAccessPoint(hmIPInfo);
+                break;
+            default:
+                logging_1.ServerLogService.writeLog(enums_1.LogLevel.Warn, `No HmIP Device Type for ${hmIPInfo.deviceType} defined`);
+                d = new hmIPDevices_1.HmIPDevice(hmIPInfo, enums_1.DeviceType.unknown);
+        }
+        Devices.alLDevices[fullName] = d;
+    }
+    static createEnergyManager(cDevConf) {
+        if (Devices.energymanager !== undefined) {
+            return;
+        }
+        const devInfo = IoBrokerDeviceInfo_1.IoBrokerDeviceInfo.byStateJsSplit(cDevConf);
+        const fullName = `${Devices.IDENTIFIER_JS}-${devInfo.devID}`;
+        devInfo.allDevicesKey = fullName;
+        Devices.energymanager = new jsObject_1.JsObjectEnergyManager(devInfo);
+        Devices.alLDevices[fullName] = Devices.energymanager;
+    }
+}
+exports.Devices = Devices;
+/**
+ * A constant for the identifier of HM-IP Adapter devices
+ */
+Devices.IDENTIFIER_HOMEMATIC = 'hm-rpc';
+/**
+ * A constant for the identifier of JavaScript Adapter devices
+ */
+Devices.IDENTIFIER_JS = 'javascript';
+/**
+ * A constant for the identifier of Shelly Adapter devices
+ */
+Devices.IDENTIFIER_Shelly = 'shelly';
+/**
+ * A constant for the identifier of Tuya Adapter devices
+ */
+Devices.IDENTIFIER_TUYA = 'tuya';
+/**
+ * A constant for the identifier of Zigbee Adapter devices
+ */
+Devices.IDENTIFIER_ZIGBEE = 'zigbee';
+/**
+ * A constant for the identifier of Zigbee2Mqtt Adapter devices
+ */
+Devices.IDENTIFIER_ZIGBEE2MQTT = 'zigbee2mqtt';
+/**
+ * A constant for the identifier of WLED Adapter devices
+ */
+Devices.IDENTIFIER_WLED = 'wled';
+/**
+ * A constant for the identifier of SmartGarden devices.
+ */
+Devices.IDENTIFIER_SMART_GARDEN = 'smartgarden';
+/**
+ * A constant for the identifier of Velux Adapter devices.
+ */
+Devices.IDENTIFIER_VELUX = 'klf200';
+/**
+ * A Map containing all devices
+ */
+Devices.alLDevices = {};
+/**
+ * A reference to globally active energy manager
+ * @default undefined (no Energy-Manager)
+ */
+Devices.energymanager = undefined;
+/**
+ * A reference to the Dachs device
+ * @default undefined (no Dachs CHP)
+ */
+Devices.dachs = undefined;
+/**
+ * A reference to the temperature sensor measuring the warm water temperature
+ * @default undefined (no warm water temperature sensor)
+ */
+Devices.temperatureWarmWater = undefined;

package/lib/devices/espresense/detectedBluetoothDevice.d.ts

@@ -0,0 +1,42 @@
+import { DeviceCapability, DeviceType, LogDebugType, LogLevel } from '../../enums';
+import { iBaseDevice, iBluetoothTrackingSettings } from '../../interfaces';
+import { DeviceInfo } from '../DeviceInfo';
+import { TrackedDistanceData } from './trackedDistanceData';
+import { iBluetoothDetector } from '../../interfaces/baseDevices/iBluetoothDetector';
+export declare class DetectedBluetoothDevice implements iBaseDevice {
+    id: string;
+    /** @inheritDoc */
+    settings: undefined;
+    /**
+     * A Map matching the distances to the trackers identified by {@link iBluetoothDetector.id}
+     */
+    distanceMap: Map<string, TrackedDistanceData>;
+    /** @inheritDoc */
+    readonly deviceCapabilities: DeviceCapability[];
+    /** @inheritDoc */
+    deviceType: DeviceType;
+    /** @inheritDoc */
+    info: DeviceInfo;
+    /**
+     * The last room the device was guessed to be in {@link iRoomBase.roomName}
+     */
+    lastRoom: string | undefined;
+    /**
+     * If the device is currently present
+     */
+    present: boolean;
+    constructor(id: string, settings?: iBluetoothTrackingSettings);
+    get customName(): string;
+    get name(): string;
+    updateDistance(tracker: iBluetoothDetector, distance: number): void;
+    log(level: LogLevel, message: string, debugType?: LogDebugType): void;
+    toJSON(): Partial<iBaseDevice>;
+    getDistance(id: string, maxAge?: number): TrackedDistanceData | undefined;
+    getDistances(maxAge?: number): Array<TrackedDistanceData>;
+    getDistanceReport(maxAge?: number): string;
+    static getOrCreate(devName: string): DetectedBluetoothDevice;
+    private static deviceKeyBySettings;
+    persistDeviceInfo(): void;
+    loadDeviceSettings(): void;
+    guessRoom(): void;
+}

package/lib/devices/espresense/detectedBluetoothDevice.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DetectedBluetoothDevice = void 0;
+const enums_1 = require("../../enums");
+const DeviceInfo_1 = require("../DeviceInfo");
+const devices_1 = require("../devices");
+const trackedDistanceData_1 = require("./trackedDistanceData");
+const logging_1 = require("../../logging");
+const utils_1 = require("../../utils");
+const services_1 = require("../../services");
+const api_1 = require("../../api");
+const trilaterationPointDistance_1 = require("./trilaterationPointDistance");
+const trilateration_1 = require("./trilateration");
+const settings_service_1 = require("../../settings-service");
+class DetectedBluetoothDevice {
+    constructor(id, settings) {
+        this.id = id;
+        /** @inheritDoc */
+        this.settings = undefined;
+        /**
+         * A Map matching the distances to the trackers identified by {@link iBluetoothDetector.id}
+         */
+        this.distanceMap = new Map();
+        /** @inheritDoc */
+        this.deviceCapabilities = [enums_1.DeviceCapability.trackableDevice];
+        /** @inheritDoc */
+        this.deviceType = enums_1.DeviceType.TrackableDevice;
+        /** @inheritDoc */
+        this.info = new DeviceInfo_1.DeviceInfo();
+        /**
+         * The last room the device was guessed to be in {@link iRoomBase.roomName}
+         */
+        this.lastRoom = undefined;
+        /**
+         * If the device is currently present
+         */
+        this.present = false;
+        if (settings === undefined) {
+            return;
+        }
+        this.info.customName = settings.customName;
+        this.info.allDevicesKey = DetectedBluetoothDevice.deviceKeyBySettings(settings);
+        if (settings.activeTracking) {
+            devices_1.Devices.alLDevices[this.info.allDevicesKey] = this;
+            this.persistDeviceInfo();
+            this.loadDeviceSettings();
+        }
+    }
+    get customName() {
+        return this.info.customName;
+    }
+    get name() {
+        var _a;
+        return (_a = this.info.customName) !== null && _a !== void 0 ? _a : `Unknown ${this.id}`;
+    }
+    updateDistance(tracker, distance) {
+        var _a;
+        const trackedDistance = (_a = this.distanceMap.get(tracker.id)) !== null && _a !== void 0 ? _a : new trackedDistanceData_1.TrackedDistanceData(tracker);
+        trackedDistance.update(distance);
+        this.distanceMap.set(tracker.id, trackedDistance);
+    }
+    log(level, message, debugType = enums_1.LogDebugType.None) {
+        logging_1.ServerLogService.writeLog(level, `${this.name}: ${message}`, {
+            debugType: debugType,
+            room: '',
+            deviceId: this.info.allDevicesKey,
+            deviceName: this.name,
+        });
+    }
+    toJSON() {
+        return utils_1.Utils.jsonFilter(this);
+    }
+    getDistance(id, maxAge = 120) {
+        const data = this.distanceMap.get(id);
+        if (data === undefined) {
+            return undefined;
+        }
+        return data.isOutdated(maxAge) ? undefined : data;
+    }
+    getDistances(maxAge = 120) {
+        const result = [];
+        for (const data of this.distanceMap.values()) {
+            if (data.isOutdated(maxAge)) {
+                continue;
+            }
+            result.push(data);
+        }
+        return result;
+    }
+    getDistanceReport(maxAge = 120) {
+        var _a;
+        const dataPoints = this.getDistances(maxAge);
+        const result = [`Distances for ${this.info.customName}`];
+        for (const data of dataPoints) {
+            result.push(`${data.trackerName}: ${utils_1.Utils.round((_a = data.distance) !== null && _a !== void 0 ? _a : -99, 2)}m updated ${new Date(data.lastUpdate).toLocaleTimeString('de-DE')}`);
+            utils_1.Utils.nowTime();
+        }
+        return result.join('\n');
+    }
+    static getOrCreate(devName) {
+        var _a, _b;
+        const settings = (_a = settings_service_1.SettingsService.settings.espresense) === null || _a === void 0 ? void 0 : _a.deviceMap[devName];
+        if (settings === undefined) {
+            return new DetectedBluetoothDevice(devName);
+        }
+        const dev = api_1.API.getDevice(this.deviceKeyBySettings(settings));
+        return (_b = dev) !== null && _b !== void 0 ? _b : new DetectedBluetoothDevice(devName, settings);
+    }
+    static deviceKeyBySettings(settings) {
+        return `trackedDevice-${settings.customName}`;
+    }
+    persistDeviceInfo() {
+        utils_1.Utils.guardedTimeout(() => {
+            var _a;
+            (_a = services_1.Persistence.dbo) === null || _a === void 0 ? void 0 : _a.addDevice(this);
+        }, 5000, this);
+    }
+    loadDeviceSettings() {
+        // Nothing
+    }
+    guessRoom() {
+        const distances = [];
+        for (const key of this.distanceMap.keys()) {
+            const tracker = api_1.API.getDevice(key);
+            if (tracker === undefined || tracker.position === undefined) {
+                continue;
+            }
+            const distance = this.getDistance(key, 60);
+            if ((distance === null || distance === void 0 ? void 0 : distance.distance) === undefined) {
+                continue;
+            }
+            distances.push(new trilaterationPointDistance_1.TrilaterationPointDistance(tracker.position.ownPoint.coordinateName, distance.distance));
+        }
+        if (distances.length === 0) {
+            this.present = false;
+            return; // No distances, no guess
+        }
+        this.present = true;
+        this.log(enums_1.LogLevel.Debug, `Guessing room from ${distances.length} distance(s).`, enums_1.LogDebugType.Trilateration);
+        this.lastRoom = trilateration_1.Trilateration.checkRoom(distances);
+    }
+}
+exports.DetectedBluetoothDevice = DetectedBluetoothDevice;

package/lib/devices/espresense/espresenseDevice.d.ts

@@ -0,0 +1,60 @@
+import { iRoomBase, iRoomDevice, iTrilaterationBasePoint } from '../../interfaces';
+import { iBluetoothDetector } from '../../interfaces/baseDevices/iBluetoothDetector';
+import { DeviceCapability, DeviceType, LogDebugType, LogLevel } from '../../enums';
+import { ProximityCallback } from './proximityCallback';
+import { DeviceInfo } from '../DeviceInfo';
+export declare class EspresenseDevice implements iRoomDevice, iBluetoothDetector {
+    /** @inheritDoc */
+    readonly position: iTrilaterationBasePoint;
+    /** @inheritDoc */
+    settings: undefined;
+    /** @inheritDoc */
+    readonly deviceCapabilities: DeviceCapability[];
+    /** @inheritDoc */
+    deviceType: DeviceType;
+    /**
+     * The name of this device
+     */
+    readonly name: string;
+    private deviceMap;
+    private proximityCallbackMap;
+    /**
+     * Creates a new instance of the EspresenseDevice class
+     * @param name - The desired name of the device
+     * @param roomName - The name of the room this device is in {@link iRoomBase.roomName}
+     * @param x - The x coordinate of the device in the house
+     * @param y - The y coordinate of the device in the house
+     * @param z - The z coordinate of the device in the house
+     */
+    constructor(name: string, roomName: string, x: number, y: number, z: number);
+    /** @inheritDoc */
+    get customName(): string;
+    protected _info: DeviceInfo;
+    /** @inheritDoc */
+    get info(): DeviceInfo;
+    /** @inheritDoc */
+    get id(): string;
+    /** @inheritDoc */
+    get room(): iRoomBase | undefined;
+    /** @inheritDoc */
+    distanceOfDevice(deviceName: string, maxAge?: number): number | undefined;
+    /** @inheritDoc */
+    isDevicePresent(deviceName: string, maxDistance: number, maxAge?: number): boolean;
+    /**
+     * Updates the device with the given state
+     * @param devName - The name of the bluetooth device
+     * @param state - The state containing the json-formatted distance data
+     */
+    update(devName: string, state: ioBroker.State): void;
+    /** @inheritDoc */
+    log(level: LogLevel, message: string, debugType?: LogDebugType): void;
+    /** @inheritDoc */
+    toJSON(): Partial<iRoomDevice>;
+    /** @inheritDoc */
+    persistDeviceInfo(): void;
+    /** @inheritDoc */
+    loadDeviceSettings(): void;
+    /** @inheritDoc */
+    addProximityCallback(cb: ProximityCallback): void;
+    private addDeviceTracking;
+}