homebridge-lg-airco/src/lg/lg-airco-controller.js

Homebridge plugin to control a Smart Thinq enabled LG airco unit. Makes use of WideQ => https://github.com/sampsyo/wideq

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.LgAircoController = void 0;
const wideq_adapter_1 = require("./wideq-adapter");
const controller_1 = require("./controller");
class LgAircoController extends controller_1.Controller {
    constructor(airCooler, updateInterval, storagePath, debugEnabled, debugLogger) {
        super();
        this.adapter = new wideq_adapter_1.WideqAdapter(airCooler.country, airCooler.language, storagePath, debugEnabled, debugLogger);
        this.airCooler = airCooler;
        this.update();
        setInterval(async () => {
            await this.update();
        }, updateInterval);
    }
    async update() {
        const status = await this.adapter.getStatus(this.airCooler.deviceId);
        if (status) {
            this.powerDraw = await this.adapter.getCurrentPowerUsage(this.airCooler.deviceId);
            this.isOn = status.isOn;
            this.mode = status.mode;
            this.currentTemperatureInCelsius = status.currentTempInCelsius;
            this.targetTemperatureInCelsius = status.targetTempInCelsius;
            this.targetCoolingTemperatureInCelsius = status.targetTempInCelsius;
            this.targetHeatingTemperatureInCelsius = status.targetTempInCelsius;
            this.fanSpeed = status.fanSpeed;
        }
    }
    isPoweredOn() {
        return this.isOn;
    }
    async setPowerState(powerOn) {
        if (this.isOn !== powerOn) {
            const succeeded = await this.adapter.setPowerOnOff(this.airCooler.deviceId, powerOn);
            if (succeeded) {
                this.isOn = powerOn;
            }
            else {
                throw new Error('Could not change isOn state of the AC unit!');
            }
        }
    }
    getMode() {
        return this.mode;
    }
    async setMode(newTargetMode) {
        if (this.mode !== newTargetMode) {
            const succeeded = await this.adapter.setMode(this.airCooler.deviceId, newTargetMode);
            if (succeeded) {
                this.isOn = true;
                this.mode = newTargetMode;
            }
            else {
                throw new Error('Could not change operational mode of the AC unit!');
            }
            await this.setTargetTemperatureInCelsius(this.mode === wideq_adapter_1.Mode.COOL ? this.targetCoolingTemperatureInCelsius : this.targetHeatingTemperatureInCelsius);
        }
        else {
            await this.setPowerState(true);
        }
    }
    getCurrentTemperatureInCelsius() {
        return this.currentTemperatureInCelsius;
    }
    getTargetCoolingTemperatureInCelsius() {
        return this.targetCoolingTemperatureInCelsius;
    }
    setTargetCoolingTemperatureInCelsius(newTargetCoolingTemperatureInCelsius) {
        if (this.targetCoolingTemperatureInCelsius !== newTargetCoolingTemperatureInCelsius) {
            this.isOn = true;
            this.targetCoolingTemperatureInCelsius = newTargetCoolingTemperatureInCelsius;
            if (this.mode === wideq_adapter_1.Mode.COOL) {
                this.setTargetTemperatureInCelsius(this.targetCoolingTemperatureInCelsius);
            }
        }
    }
    getTargetHeatingTemperatureInCelsius() {
        return this.targetHeatingTemperatureInCelsius;
    }
    setTargetHeatingTemperatureInCelsius(newTargetHeatingTemperatureInCelsius) {
        if (this.targetHeatingTemperatureInCelsius !== newTargetHeatingTemperatureInCelsius) {
            this.isOn = true;
            this.targetHeatingTemperatureInCelsius = newTargetHeatingTemperatureInCelsius;
            if (this.mode === wideq_adapter_1.Mode.HEAT) {
                this.setTargetTemperatureInCelsius(this.targetHeatingTemperatureInCelsius);
            }
        }
    }
    async setTargetTemperatureInCelsius(newTargetTemperatureInCelsius) {
        if (this.targetTemperatureInCelsius !== newTargetTemperatureInCelsius) {
            const succeeded = await this.adapter.setTargetTemperature(this.airCooler.deviceId, newTargetTemperatureInCelsius);
            if (succeeded) {
                this.isOn = true;
                this.targetTemperatureInCelsius = newTargetTemperatureInCelsius;
            }
            else {
                throw new Error('Could not set new target temperature of the AC unit!');
            }
        }
    }
    getVerticalSwingMode() {
        return this.swingModeV;
    }
    async setVerticalSwingMode(newVerticalSwingMode) {
        if (this.swingModeV !== newVerticalSwingMode) {
            const succeeded = await this.adapter.setSwingModeV(this.airCooler.deviceId, newVerticalSwingMode);
            if (succeeded) {
                this.isOn = true;
                this.swingModeV = newVerticalSwingMode;
            }
            else {
                throw new Error('Could not set new vertical swing mode of the AC unit!');
            }
        }
    }
    getHorizontalSwingMode() {
        return this.swingModeH;
    }
    async setHorizontalSwingMode(newHorizontalSwingMode) {
        if (this.swingModeH !== newHorizontalSwingMode) {
            const succeeded = await this.adapter.setSwingModeH(this.airCooler.deviceId, newHorizontalSwingMode);
            if (succeeded) {
                this.isOn = true;
                this.swingModeH = newHorizontalSwingMode;
            }
            else {
                throw new Error('Could not set new horizontal swing mode of the AC unit!');
            }
        }
    }
    getFanSpeed() {
        return this.fanSpeed;
    }
    async setFanSpeed(newFanSpeed) {
        if (this.fanSpeed !== newFanSpeed) {
            const succeeded = await this.adapter.setFanSpeed(this.airCooler.deviceId, newFanSpeed);
            if (succeeded) {
                this.isOn = true;
                this.fanSpeed = newFanSpeed;
            }
            else {
                throw new Error('Could not set new fan speed of the AC unit!');
            }
        }
    }
}
exports.LgAircoController = LgAircoController;
//# sourceMappingURL=lg-airco-controller.js.map