iobroker.loxone 3.0.1 → 4.0.0

package/src/controls/InfoOnlyDigital.ts

@@ -0,0 +1,95 @@
+import type { Control } from '../structure-file';
+import type { ControlType } from './control-base';
+import { ControlBase } from './control-base';
+
+/**
+ * Handler for InfoOnlyDigital controls.
+ */
+export class InfoOnlyDigital extends ControlBase {
+    /**
+     * Loads the control and sets up state objects and event handlers.
+     *
+     * @param type The type of the control ('device' or 'channel').
+     * @param uuid The unique identifier of the control.
+     * @param control The control data from the structure file.
+     */
+    async loadAsync(type: ControlType, uuid: string, control: Control): Promise<void> {
+        await this.updateObjectAsync(uuid, {
+            type: type,
+            common: {
+                name: control.name,
+                role: 'switch',
+            },
+            native: { control },
+        });
+
+        await this.loadOtherControlStatesAsync(control.name, uuid, control.states, ['active']);
+
+        if (!('states' in control) || !('active' in control.states)) {
+            return;
+        }
+
+        await this.createBooleanControlStateObjectAsync(control.name, uuid, control.states, 'active', 'indicator');
+
+        if (!('details' in control)) {
+            return;
+        }
+
+        if ('text' in control.details) {
+            const text: any = control.details.text;
+            await this.updateStateObjectAsync(
+                `${uuid}.active-text`,
+                {
+                    name: `${control.name}: active as text`,
+                    read: true,
+                    write: false,
+                    type: 'string',
+                    role: 'text',
+                    // TODO: re-add: smartIgnore: true,
+                },
+                control.states.active,
+                async (name: string, value: any) => {
+                    await this.setStateAck(name, value == 1 ? text.on : text.off);
+                },
+            );
+        }
+
+        if ('image' in control.details) {
+            const image: any = control.details.image;
+            await this.updateStateObjectAsync(
+                `${uuid}.active-image`,
+                {
+                    name: `${control.name}: active as image`,
+                    read: true,
+                    write: false,
+                    type: 'string',
+                    role: 'text',
+                    // TODO: re-add: smartIgnore: true,
+                },
+                control.states.active,
+                async (name: string, value: any) => {
+                    await this.setStateAck(name, value == 1 ? image.on : image.off);
+                },
+            );
+        }
+
+        if ('color' in control.details) {
+            const color: any = control.details.color;
+            await this.updateStateObjectAsync(
+                `${uuid}.active-color`,
+                {
+                    name: `${control.name}: active as color`,
+                    read: true,
+                    write: false,
+                    type: 'string',
+                    role: 'text',
+                    // TODO: re-add: smartIgnore: true,
+                },
+                control.states.active,
+                async (name: string, value: any) => {
+                    await this.setStateAck(name, value == 1 ? color.on : color.off);
+                },
+            );
+        }
+    }
+}

package/src/controls/InfoOnlyText.ts

@@ -0,0 +1,52 @@
+import type { Control } from '../structure-file';
+import type { ControlType } from './control-base';
+import { ControlBase } from './control-base';
+
+/**
+ * Handler for InfoOnlyText controls.
+ */
+export class InfoOnlyText extends ControlBase {
+    /**
+     * Loads the control and sets up state objects and event handlers.
+     *
+     * @param type The type of the control ('device' or 'channel').
+     * @param uuid The unique identifier of the control.
+     * @param control The control data from the structure file.
+     */
+    async loadAsync(type: ControlType, uuid: string, control: Control): Promise<void> {
+        await this.updateObjectAsync(uuid, {
+            type: type,
+            common: {
+                name: control.name,
+                role: 'info',
+            },
+            native: { control },
+        });
+
+        await this.loadOtherControlStatesAsync(control.name, uuid, control.states, ['text']);
+
+        await this.createSimpleControlStateObjectAsync(control.name, uuid, control.states, 'text', 'string', 'text');
+
+        if (!('details' in control)) {
+            return;
+        }
+
+        if ('format' in control.details) {
+            await this.updateStateObjectAsync(
+                `${uuid}.text-formatted`,
+                {
+                    name: `${control.name}: formatted value`,
+                    read: true,
+                    write: false,
+                    type: 'string',
+                    role: 'text',
+                    // TODO: re-add: smartIgnore: true,
+                },
+                control.states.value,
+                async (name: string, value: any) => {
+                    await this.setFormattedStateAck(name, value, control.details.format as string);
+                },
+            );
+        }
+    }
+}

package/{build/controls/Intercom.js → src/controls/Intercom.ts}

@@ -1,9 +1,19 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Intercom = void 0;
-const control_base_1 = require("./control-base");
-class Intercom extends control_base_1.ControlBase {
-    async loadAsync(type, uuid, control) {
+import type { Control } from '../structure-file';
+import type { ControlType } from './control-base';
+import { ControlBase } from './control-base';
+
+/**
+ * Handler for Intercom controls.
+ */
+export class Intercom extends ControlBase {
+    /**
+     * Loads the control and sets up state objects and event handlers.
+     *
+     * @param type The type of the control ('device' or 'channel').
+     * @param uuid The unique identifier of the control.
+     * @param control The control data from the structure file.
+     */
+    async loadAsync(type: ControlType, uuid: string, control: Control): Promise<void> {
         await this.updateObjectAsync(uuid, {
             type: type,
             common: {
@@ -12,20 +22,26 @@ class Intercom extends control_base_1.ControlBase {
             },
             native: { control },
         });
+
         await this.loadOtherControlStatesAsync(control.name, uuid, control.states, [
             'bell',
             'lastBellEvents',
             'version',
         ]);
+
         await this.createBooleanControlStateObjectAsync(control.name, uuid, control.states, 'bell', 'indicator');
         await this.createListControlStateObjectAsync(control.name, uuid, control.states, 'lastBellEvents');
         await this.createSimpleControlStateObjectAsync(control.name, uuid, control.states, 'version', 'string', 'text');
+
         await this.createButtonCommandStateObjectAsync(control.name, uuid, 'answer');
-        this.addStateChangeListener(uuid + '.answer', () => {
-            this.sendCommand(control.uuidAction, 'answer');
-        }, { selfAck: true });
+        this.addStateChangeListener(
+            `${uuid}.answer`,
+            () => {
+                this.sendCommand(control.uuidAction, 'answer');
+            },
+            { selfAck: true },
+        );
+
         await this.loadSubControlsAsync(uuid, control);
     }
 }
-exports.Intercom = Intercom;
-//# sourceMappingURL=Intercom.js.map

package/src/controls/Jalousie.ts

@@ -0,0 +1,219 @@
+import type { CurrentStateValue, OldStateValue } from '../main';
+import type { Control } from '../structure-file';
+import type { ControlType } from './control-base';
+import { ControlBase } from './control-base';
+
+/**
+ * Handler for Jalousie controls.
+ */
+export class Jalousie extends ControlBase {
+    private positionTarget: number | undefined;
+
+    /**
+     * Loads the control and sets up state objects and event handlers.
+     *
+     * @param type The type of the control ('device' or 'channel').
+     * @param uuid The unique identifier of the control.
+     * @param control The control data from the structure file.
+     */
+    async loadAsync(type: ControlType, uuid: string, control: Control): Promise<void> {
+        await this.updateObjectAsync(uuid, {
+            type: type,
+            common: {
+                name: control.name,
+                role: 'blind',
+            },
+            native: { control },
+        });
+
+        await this.loadOtherControlStatesAsync(control.name, uuid, control.states, [
+            'up',
+            'down',
+            'position',
+            'shadePosition',
+            'safetyActive',
+            'autoAllowed',
+            'autoActive',
+            'locked',
+        ]);
+
+        await this.createBooleanControlStateObjectAsync(control.name, uuid, control.states, 'up', 'indicator', {
+            write: true,
+        });
+        this.addStateEventHandler(control.states.up, () => this.upDownChangeHandler(), 'up');
+
+        await this.createBooleanControlStateObjectAsync(control.name, uuid, control.states, 'down', 'indicator', {
+            write: true,
+        });
+        this.addStateEventHandler(control.states.down, () => this.upDownChangeHandler(), 'down');
+
+        await this.createPercentageControlStateObjectAsync(
+            control.name,
+            uuid,
+            control.states,
+            'position',
+            'level.blind',
+            {
+                write: true,
+                // TODO: re-add: smartIgnore: false
+            },
+        );
+
+        await this.createPercentageControlStateObjectAsync(
+            control.name,
+            uuid,
+            control.states,
+            'shadePosition',
+            'level',
+        );
+        await this.createBooleanControlStateObjectAsync(
+            control.name,
+            uuid,
+            control.states,
+            'safetyActive',
+            'indicator',
+        );
+        await this.createBooleanControlStateObjectAsync(control.name, uuid, control.states, 'autoAllowed', 'indicator');
+        await this.createBooleanControlStateObjectAsync(control.name, uuid, control.states, 'autoActive', 'indicator', {
+            write: true,
+        });
+        await this.createBooleanControlStateObjectAsync(control.name, uuid, control.states, 'locked', 'indicator');
+        await this.createSimpleControlStateObjectAsync(
+            control.name,
+            uuid,
+            control.states,
+            'infoText',
+            'string',
+            'text',
+        );
+
+        this.addStateChangeListener(`${uuid}.up`, (oldValue: OldStateValue, newValue: CurrentStateValue) => {
+            if (newValue) {
+                this.sendCommand(control.uuidAction, 'up');
+            } else {
+                this.sendCommand(control.uuidAction, 'UpOff');
+            }
+        });
+        this.addStateChangeListener(`${uuid}.down`, (oldValue: OldStateValue, newValue: CurrentStateValue) => {
+            if (newValue) {
+                this.sendCommand(control.uuidAction, 'down');
+            } else {
+                this.sendCommand(control.uuidAction, 'DownOff');
+            }
+        });
+        this.addStateChangeListener(
+            `${uuid}.autoActive`,
+            (oldValue: OldStateValue, newValue: CurrentStateValue) => {
+                if (newValue) {
+                    this.sendCommand(control.uuidAction, 'auto');
+                } else {
+                    this.sendCommand(control.uuidAction, 'NoAuto');
+                }
+            },
+            { notIfEqual: true },
+        );
+
+        // for Alexa support:
+        // ... but this is not really Alexa specific to be fair
+        if (control.states.position) {
+            this.addStateChangeListener(
+                `${uuid}.position`,
+                (oldValue: OldStateValue, newValue: CurrentStateValue) => {
+                    if (typeof oldValue !== 'number' || typeof newValue !== 'number') {
+                        // This should never happen due to convertToInt flag
+                        this.adapter.log.error(`Jalousie position is not a number`);
+                        return;
+                    }
+
+                    if (newValue === 100) {
+                        this.sendCommand(control.uuidAction, 'FullDown');
+                        return;
+                    }
+                    if (newValue === 0) {
+                        this.sendCommand(control.uuidAction, 'FullUp');
+                        return;
+                    }
+
+                    this.upDownAutoCommandHandled = false;
+                    if (oldValue < newValue) {
+                        this.positionTarget = (newValue - 5) / 100;
+                        this.sendCommand(control.uuidAction, 'down');
+                    } else {
+                        // Negative here because we use -ve numbers to indicate movement up
+                        this.positionTarget = -(newValue + 5) / 100;
+                        this.sendCommand(control.uuidAction, 'up');
+                    }
+                },
+                { notIfEqual: true, convertToInt: true, minInt: 0, maxInt: 100, ackTimeoutMs: 2500 },
+            );
+
+            this.addStateEventHandler(
+                control.states.position,
+                (value: any) => {
+                    if (typeof this.positionTarget === 'number') {
+                        // Below, the actual command ('up' or 'down') is irrelevant but we
+                        // need to know the direction for target test.
+                        if (this.positionTarget > 0) {
+                            // Going down
+                            if (value >= this.positionTarget) {
+                                this.positionTarget = undefined;
+                                this.sendCommand(control.uuidAction, 'down');
+                            }
+                        } else {
+                            // Going up - don't forget target is negative
+                            if (value <= -this.positionTarget) {
+                                this.positionTarget = undefined;
+                                this.sendCommand(control.uuidAction, 'up');
+                            }
+                        }
+                    }
+                },
+                'auto',
+            );
+        }
+
+        await this.createButtonCommandStateObjectAsync(control.name, uuid, 'fullUp');
+        this.addStateChangeListener(
+            `${uuid}.fullUp`,
+            () => {
+                this.sendCommand(control.uuidAction, 'FullUp');
+            },
+            { selfAck: true },
+        );
+
+        await this.createButtonCommandStateObjectAsync(control.name, uuid, 'fullDown');
+        this.addStateChangeListener(
+            `${uuid}.fullDown`,
+            () => {
+                this.sendCommand(control.uuidAction, 'FullDown');
+            },
+            { selfAck: true },
+        );
+
+        await this.createButtonCommandStateObjectAsync(control.name, uuid, 'shade');
+        this.addStateChangeListener(
+            `${uuid}.shade`,
+            () => {
+                this.sendCommand(control.uuidAction, 'shade');
+            },
+            { selfAck: true },
+        );
+    }
+
+    // The upDownChangeHandler callback will be triggered when any movement starts or stops.
+    // Normally we want upDownChangeHandler to clear any target as it signifies manual command
+    // has occurred. This can happen in normal use or before a target has been reached for
+    // example.
+    // But in the case of movement started as a result of an auto-position command, we don't
+    // want to clear that target.
+    // For this reason we have the below boolean that tells upDownChangeHandler to ignore the
+    // first change it sees after an auto-position command is started.
+    private upDownAutoCommandHandled = false;
+    private upDownChangeHandler(): void {
+        if (this.upDownAutoCommandHandled) {
+            this.positionTarget = undefined;
+        } else {
+            this.upDownAutoCommandHandled = true;
+        }
+    }
+}

package/src/controls/LightController.ts

@@ -0,0 +1,112 @@
+import type { CurrentStateValue, OldStateValue } from '../main';
+import type { Control } from '../structure-file';
+import type { ControlType } from './control-base';
+import { ControlBase } from './control-base';
+
+/**
+ * Handler for LightController controls.
+ */
+export class LightController extends ControlBase {
+    /**
+     * Loads the control and sets up state objects and event handlers.
+     *
+     * @param type The type of the control ('device' or 'channel').
+     * @param uuid The unique identifier of the control.
+     * @param control The control data from the structure file.
+     */
+    async loadAsync(type: ControlType, uuid: string, control: Control): Promise<void> {
+        await this.updateObjectAsync(uuid, {
+            type: type,
+            common: {
+                name: control.name,
+                role: 'light',
+            },
+            native: { control },
+        });
+
+        await this.loadOtherControlStatesAsync(control.name, uuid, control.states, ['activeScene', 'sceneList']);
+
+        await this.createSimpleControlStateObjectAsync(
+            control.name,
+            uuid,
+            control.states,
+            'activeScene',
+            'number',
+            'level',
+            { write: true },
+        );
+        this.addStateChangeListener(`${uuid}.activeScene`, (oldValue: OldStateValue, newValue: CurrentStateValue) => {
+            newValue = this.convertStateToInt(newValue);
+            if (newValue === 9) {
+                this.sendCommand(control.uuidAction, 'on');
+            } else {
+                this.sendCommand(control.uuidAction, newValue.toString());
+            }
+        });
+
+        if ('sceneList' in control.states) {
+            await this.updateStateObjectAsync(
+                `${uuid}.sceneList`,
+                {
+                    name: `${control.name}: sceneList`,
+                    read: true,
+                    write: false,
+                    type: 'array',
+                    role: 'list',
+                    // TODO: re-add: smartIgnore: true,
+                },
+                control.states.sceneList,
+                async (name: string, value: any) => {
+                    // weird documentation: they say it's 'text' within the struct, but I get the value directly; let's support both
+                    if ('text' in value) {
+                        await this.setStateAck(name, value.text.split(','));
+                    } else {
+                        await this.setStateAck(name, value.toString().split(','));
+                    }
+                },
+            );
+        }
+
+        await this.createButtonCommandStateObjectAsync(control.name, uuid, 'plus');
+        this.addStateChangeListener(
+            `${uuid}.plus`,
+            () => {
+                this.sendCommand(control.uuidAction, 'plus');
+            },
+            { selfAck: true },
+        );
+
+        await this.createButtonCommandStateObjectAsync(control.name, uuid, 'minus');
+        this.addStateChangeListener(
+            `${uuid}.minus`,
+            () => {
+                this.sendCommand(control.uuidAction, 'minus');
+            },
+            { selfAck: true },
+        );
+
+        // for Alexa support:
+        await this.createButtonCommandStateObjectAsync(
+            control.name,
+            uuid,
+            'control',
+            /* TODO: re-add: { smartIgnore: false }*/
+        );
+        this.addStateChangeListener(
+            `${uuid}.control`,
+            (oldValue: OldStateValue, newValue: CurrentStateValue) => {
+                if (newValue) {
+                    this.sendCommand(control.uuidAction, 'on');
+                } else {
+                    this.sendCommand(control.uuidAction, '0');
+                }
+            },
+            { selfAck: true },
+        );
+
+        // TODO: currently we don't support scene modifications ("learn" and "delete" commands),
+        // IMHO this should be done by the user through the Loxone Web interface
+
+        await this.loadSubControlsAsync(uuid, control);
+    }
+}