iobroker.loxone 3.0.1 → 4.0.1

package/src/controls/AudioZone.ts

@@ -0,0 +1,227 @@
+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 AudioZone controls.
+ */
+export class AudioZone 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: 'media.music',
+            },
+            native: { control },
+        });
+
+        await this.loadOtherControlStatesAsync(control.name, uuid, control.states, [
+            'serverState',
+            'playState',
+            'clientState',
+            'power',
+            'volume',
+            'maxVolume',
+            'volumeStep',
+            'shuffle',
+            'sourceList',
+            'repeat',
+            'songName',
+            'duration',
+            'progress',
+            'album',
+            'artist',
+            'station',
+            'genre',
+            'cover',
+            'source',
+        ]);
+
+        const serverStates = {
+            '-3': 'invalid zone',
+            '-2': 'not reachable',
+            '-1': 'unknown',
+            0: 'offline',
+            1: 'initializing',
+            2: 'online',
+        };
+        const playStates = {
+            '-1': 'unknown',
+            0: 'stopped',
+            1: 'paused',
+            2: 'playing',
+        };
+        const clientStates = {
+            0: 'offline',
+            1: 'initializing',
+            2: 'online',
+        };
+        await this.createSimpleControlStateObjectAsync(
+            control.name,
+            uuid,
+            control.states,
+            'serverState',
+            'number',
+            'value',
+            { states: serverStates },
+        );
+        await this.createSimpleControlStateObjectAsync(
+            control.name,
+            uuid,
+            control.states,
+            'playState',
+            'number',
+            'value',
+            { write: true, states: playStates },
+        );
+        await this.createSimpleControlStateObjectAsync(
+            control.name,
+            uuid,
+            control.states,
+            'clientState',
+            'number',
+            'value',
+            { states: clientStates },
+        );
+        await this.createBooleanControlStateObjectAsync(control.name, uuid, control.states, 'power', 'switch', {
+            write: true,
+            // TODO: re-add: smartIgnore: false,
+        });
+        await this.createSimpleControlStateObjectAsync(
+            control.name,
+            uuid,
+            control.states,
+            'volume',
+            'number',
+            'level.volume',
+            { write: true },
+        );
+        await this.createSimpleControlStateObjectAsync(
+            control.name,
+            uuid,
+            control.states,
+            'maxVolume',
+            'number',
+            'value',
+        );
+        await this.createBooleanControlStateObjectAsync(control.name, uuid, control.states, 'shuffle', 'switch', {
+            write: true,
+        });
+        await this.createSimpleControlStateObjectAsync(
+            control.name,
+            uuid,
+            control.states,
+            'sourceList',
+            'string',
+            'json',
+        );
+        await this.createSimpleControlStateObjectAsync(
+            control.name,
+            uuid,
+            control.states,
+            'repeat',
+            'number',
+            'value',
+            { write: true },
+        );
+        await this.createSimpleControlStateObjectAsync(
+            control.name,
+            uuid,
+            control.states,
+            'songName',
+            'string',
+            'text',
+        );
+        await this.createSimpleControlStateObjectAsync(
+            control.name,
+            uuid,
+            control.states,
+            'duration',
+            'number',
+            'value.interval',
+        );
+        await this.createSimpleControlStateObjectAsync(
+            control.name,
+            uuid,
+            control.states,
+            'progress',
+            'number',
+            'value.interval',
+            { write: true },
+        );
+        await this.createSimpleControlStateObjectAsync(control.name, uuid, control.states, 'album', 'string', 'text');
+        await this.createSimpleControlStateObjectAsync(control.name, uuid, control.states, 'artist', 'string', 'text');
+        await this.createSimpleControlStateObjectAsync(control.name, uuid, control.states, 'station', 'string', 'text');
+        await this.createSimpleControlStateObjectAsync(control.name, uuid, control.states, 'genre', 'string', 'text');
+        await this.createSimpleControlStateObjectAsync(
+            control.name,
+            uuid,
+            control.states,
+            'cover',
+            'string',
+            'text.url',
+        );
+        await this.createSimpleControlStateObjectAsync(
+            control.name,
+            uuid,
+            control.states,
+            'source',
+            'number',
+            'value',
+            { write: true },
+        );
+
+        this.addStateChangeListener(`${uuid}.playState`, (oldValue: OldStateValue, newValue: CurrentStateValue) => {
+            newValue = this.convertStateToInt(newValue);
+            if (newValue === 0 || newValue === 1) {
+                this.sendCommand(control.uuidAction, 'pause');
+            } else if (newValue === 2) {
+                this.sendCommand(control.uuidAction, 'play');
+            }
+        });
+        this.addStateChangeListener(`${uuid}.power`, (oldValue: OldStateValue, newValue: CurrentStateValue) => {
+            this.sendCommand(control.uuidAction, newValue ? 'on' : 'off');
+        });
+        this.addStateChangeListener(`${uuid}.volume`, (oldValue: OldStateValue, newValue: CurrentStateValue) => {
+            this.sendCommand(control.uuidAction, `volume/${newValue}`);
+        });
+        this.addStateChangeListener(`${uuid}.shuffle`, (oldValue: OldStateValue, newValue: CurrentStateValue) => {
+            this.sendCommand(control.uuidAction, `shuffle/${newValue ? 1 : 0}`);
+        });
+        this.addStateChangeListener(`${uuid}.repeat`, (oldValue: OldStateValue, newValue: CurrentStateValue) => {
+            this.sendCommand(control.uuidAction, `repeat/${newValue}`);
+        });
+        this.addStateChangeListener(`${uuid}.progress`, (oldValue: OldStateValue, newValue: CurrentStateValue) => {
+            this.sendCommand(control.uuidAction, `progress/${newValue}`);
+        });
+        this.addStateChangeListener(`${uuid}.source`, (oldValue: OldStateValue, newValue: CurrentStateValue) => {
+            this.sendCommand(control.uuidAction, `source/${newValue}`);
+        });
+
+        await this.createButtonCommandStateObjectAsync(control.name, uuid, 'prev');
+        this.addStateChangeListener(
+            `${uuid}.prev`,
+            () => {
+                this.sendCommand(control.uuidAction, 'prev');
+            },
+            { selfAck: true },
+        );
+        await this.createButtonCommandStateObjectAsync(control.name, uuid, 'next');
+        this.addStateChangeListener(
+            `${uuid}.next`,
+            () => {
+                this.sendCommand(control.uuidAction, 'next');
+            },
+            { selfAck: true },
+        );
+    }
+}

package/src/controls/AudioZoneV2.ts

@@ -0,0 +1,135 @@
+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 AudioZoneV2 controls.
+ */
+export class AudioZoneV2 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: 'media.music',
+            },
+            native: { control },
+        });
+
+        await this.loadOtherControlStatesAsync(control.name, uuid, control.states, [
+            'serverState',
+            'playState',
+            'clientState',
+            'power',
+            'volume',
+            'volumeStep',
+            'tts',
+        ]);
+
+        const serverStates = {
+            '-3': 'invalid zone',
+            '-2': 'not reachable',
+            '-1': 'unknown',
+            0: 'offline',
+            1: 'initializing',
+            2: 'online',
+        };
+        const playStates = {
+            '-1': 'unknown',
+            0: 'stopped',
+            1: 'paused',
+            2: 'playing',
+        };
+        const clientStates = {
+            0: 'offline',
+            1: 'initializing',
+            2: 'online',
+        };
+        await this.createSimpleControlStateObjectAsync(
+            control.name,
+            uuid,
+            control.states,
+            'serverState',
+            'number',
+            'value',
+            { states: serverStates },
+        );
+        await this.createSimpleControlStateObjectAsync(
+            control.name,
+            uuid,
+            control.states,
+            'playState',
+            'number',
+            'value',
+            { write: true, states: playStates },
+        );
+        await this.createSimpleControlStateObjectAsync(
+            control.name,
+            uuid,
+            control.states,
+            'clientState',
+            'number',
+            'value',
+            { states: clientStates },
+        );
+        await this.createBooleanControlStateObjectAsync(control.name, uuid, control.states, 'power', 'switch', {
+            write: true,
+            // TODO: re-add: smartIgnore: false,
+        });
+        this.addStateChangeListener(`${uuid}.playState`, (oldValue: OldStateValue, newValue: CurrentStateValue) => {
+            newValue = this.convertStateToInt(newValue);
+            if (newValue === 0 || newValue === 1) {
+                this.sendCommand(control.uuidAction, 'pause');
+            } else if (newValue === 2) {
+                this.sendCommand(control.uuidAction, 'play');
+            }
+        });
+        this.addStateChangeListener(`${uuid}.power`, (oldValue: OldStateValue, newValue: CurrentStateValue) => {
+            this.sendCommand(control.uuidAction, newValue ? 'on' : 'off');
+        });
+        await this.createSimpleControlStateObjectAsync(
+            control.name,
+            uuid,
+            control.states,
+            'volume',
+            'number',
+            'level.volume',
+            {
+                write: true,
+            },
+        );
+        this.addStateChangeListener(`${uuid}.volume`, (oldValue: OldStateValue, newValue: CurrentStateValue) => {
+            this.sendCommand(control.uuidAction, `volume/${newValue}`);
+        });
+        await this.createSimpleControlStateObjectAsync(control.name, uuid, control.states, 'tts', 'string', 'text', {
+            write: true,
+        });
+        this.addStateChangeListener(`${uuid}.tts`, (oldValue: OldStateValue, newValue: CurrentStateValue) => {
+            this.sendCommand(control.uuidAction, `tts/${newValue}`);
+        });
+        await this.createButtonCommandStateObjectAsync(control.name, uuid, 'prev');
+        this.addStateChangeListener(`${uuid}.prev`, () => {
+            this.sendCommand(control.uuidAction, 'prev');
+        });
+        await this.createButtonCommandStateObjectAsync(control.name, uuid, 'next');
+        this.addStateChangeListener(`${uuid}.next`, () => {
+            this.sendCommand(control.uuidAction, 'next');
+        });
+        await this.createButtonCommandStateObjectAsync(control.name, uuid, 'play');
+        this.addStateChangeListener(`${uuid}.pause`, () => {
+            this.sendCommand(control.uuidAction, 'pause');
+        });
+        await this.createButtonCommandStateObjectAsync(control.name, uuid, 'pause');
+        this.addStateChangeListener(`${uuid}.pause`, () => {
+            this.sendCommand(control.uuidAction, 'pause');
+        });
+    }
+}

package/src/controls/CentralAlarm.ts

@@ -0,0 +1,59 @@
+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 the CentralAlarm control.
+ */
+export class CentralAlarm 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: 'alarm',
+            },
+            native: { control },
+        });
+
+        await this.createButtonCommandStateObjectAsync(
+            control.name,
+            uuid,
+            'armed',
+            /* TODO: re-add: { smartIgnore: false }, */
+        );
+        this.addStateChangeListener(
+            `${uuid}.armed`,
+            (oldValue: OldStateValue, newValue: CurrentStateValue) => {
+                this.sendCommand(control.uuidAction, newValue ? 'on' : 'off');
+            },
+            { selfAck: true },
+        );
+
+        await this.createButtonCommandStateObjectAsync(control.name, uuid, 'delayedOn');
+        this.addStateChangeListener(
+            `${uuid}.delayedOn`,
+            () => {
+                this.sendCommand(control.uuidAction, 'delayedon');
+            },
+            { selfAck: true },
+        );
+
+        await this.createButtonCommandStateObjectAsync(control.name, uuid, 'quit');
+        this.addStateChangeListener(
+            `${uuid}.quit`,
+            () => {
+                this.sendCommand(control.uuidAction, 'quit');
+            },
+            { selfAck: true },
+        );
+    }
+}

package/src/controls/CentralAudioZone.ts

@@ -0,0 +1,41 @@
+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 the CentralAudioZone control.
+ */
+export class CentralAudioZone 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: 'media.music',
+            },
+            native: { control },
+        });
+
+        await this.createButtonCommandStateObjectAsync(
+            control.name,
+            uuid,
+            'control',
+            /* TODO: re-add: { smartIgnore: false }, */
+        );
+        this.addStateChangeListener(
+            `${uuid}.control`,
+            (oldValue: OldStateValue, newValue: CurrentStateValue) => {
+                this.sendCommand(control.uuidAction, newValue ? 'play' : 'pause');
+            },
+            { selfAck: true },
+        );
+    }
+}

package/src/controls/CentralGate.ts

@@ -0,0 +1,53 @@
+import type { Control } from '../structure-file';
+import type { ControlType } from './control-base';
+import { ControlBase } from './control-base';
+
+/**
+ * Handler for the CentralGate control.
+ */
+export class CentralGate 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: 'blind',
+            },
+            native: { control },
+        });
+
+        await this.createButtonCommandStateObjectAsync(control.name, uuid, 'open');
+        this.addStateChangeListener(
+            `${uuid}.open`,
+            () => {
+                this.sendCommand(control.uuidAction, 'open');
+            },
+            { selfAck: true },
+        );
+
+        await this.createButtonCommandStateObjectAsync(control.name, uuid, 'close');
+        this.addStateChangeListener(
+            `${uuid}.close`,
+            () => {
+                this.sendCommand(control.uuidAction, 'close');
+            },
+            { selfAck: true },
+        );
+
+        await this.createButtonCommandStateObjectAsync(control.name, uuid, 'stop');
+        this.addStateChangeListener(
+            `${uuid}.stop`,
+            () => {
+                this.sendCommand(control.uuidAction, 'stop');
+            },
+            { selfAck: true },
+        );
+    }
+}

package/src/controls/CentralJalousie.ts

@@ -0,0 +1,67 @@
+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 the CentralJalousie control.
+ */
+export class CentralJalousie 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: 'blind',
+            },
+            native: { control },
+        });
+
+        await this.createButtonCommandStateObjectAsync(control.name, uuid, 'autoActive');
+        this.addStateChangeListener(
+            `${uuid}.autoActive`,
+            (oldValue: OldStateValue, newValue: CurrentStateValue) => {
+                if (newValue) {
+                    this.sendCommand(control.uuidAction, 'auto');
+                } else {
+                    this.sendCommand(control.uuidAction, 'NoAuto');
+                }
+            },
+            { selfAck: true },
+        );
+
+        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 },
+        );
+    }
+}

package/src/controls/CentralLightController.ts

@@ -0,0 +1,45 @@
+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 the CentralLightController control.
+ */
+export class CentralLightController 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.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, 'reset');
+                }
+            },
+            { selfAck: true },
+        );
+    }
+}

package/src/controls/ColorPickerV2.ts

@@ -0,0 +1,34 @@
+import type { Control } from '../structure-file';
+import { ColorpickerBase } from './ColorpickerBase';
+import type { ControlType } from './control-base';
+
+/**
+ * Handler for ColorPickerV2 controls.
+ */
+export class ColorPickerV2 extends ColorpickerBase {
+    /**
+     * 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.color.rgb',
+            },
+            native: { control },
+        });
+
+        await this.loadOtherControlStatesAsync(control.name, uuid, control.states, [
+            'color',
+            'sequence',
+            'sequenceColorIdx',
+        ]);
+
+        await this.loadColorPickerControlBaseAsync(uuid, control);
+    }
+}