@tplnet/homebridge-denon-heos-audio 1.0.1 → 1.1.0

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 All notable changes of this fork. The fork is based on [hov3rcraft/homebridge-denon-heos-audio](https://github.com/hov3rcraft/homebridge-denon-heos-audio) 1.0.0-beta.1.
 
+## 1.1.0
+
+### New
+
+- **Switching on always plays something (HEOS CLI):** if a speaker has nothing to resume (no active source, e.g. after a restart) or refuses to resume, the first HEOS favorite is started. This makes switching on via scenes and automations reliable. Configurable per device with `powerOnFavorite` (number of the favorite, 0 = disabled).
+
+### Fixed
+
+- After switching on or off, the tile could briefly jump back to the old state, because devices report the old state for a moment. The new state is now kept for a few seconds, unless the device reports a different change (e.g. from the HEOS app).
+
 ## 1.0.1
 
 ### Changed

package/README.md

@@ -56,6 +56,7 @@ Not sure what your device supports? Turn on [device discovery](#1-find-your-devi
 | **Hybrid** | AV receivers and amplifiers with HEOS (e.g. Marantz Cinema series, Denon AVR-X, Denon Home Amp) | Real power on / standby | ✅ | ✅ |
 
 **Why does "power" mean "playback" with HEOS CLI?** HEOS speakers have no real standby command. The plugin therefore treats "playing" as on and "stopped/paused" as off.
+Switching on resumes the last source. If there is nothing to resume (e.g. after the speaker was restarted), the first HEOS favorite is started, so switching on also works in scenes and automations. You can choose another favorite or turn this off with `powerOnFavorite`.
 
 **Hybrid** uses AVR Control for power and HEOS CLI for everything else. Pick it whenever discovery reports both protocols.
 
@@ -126,7 +127,7 @@ Enable **Add Discovered Devices Automatically** in the plugin settings (or set `
 - the **name** from the HEOS app (e.g. *Patio Music*),
 - the **control protocol** `HYBRID` if the device supports both protocols, otherwise `HEOSCLI`,
 - the inputs reported by the device,
-- default settings (volume step 2, no volume limit).
+- default settings (volume step 2, no volume limit, first HEOS favorite when switching on without a source).
 
 The log confirms every device: `Automatically adding discovered device 'Patio Music' (HYBRID, 192.168.1.149).`
 
@@ -225,6 +226,7 @@ Repeat these steps for every device. You only have to do it once per device. Upd
 | `devices[].volumeLimitEnabled` | no | `false` | Enables the volume limit. |
 | `devices[].volumeLimit` | no | `99` | 0–99. With a limit, 100 % in the Home app equals this value on the device. |
 | `devices[].volumeStepSize` | no | `2` | 1–10. Volume change per press of the volume buttons in the Remote. |
+| `devices[].powerOnFavorite` | no | `1` | HEOS CLI only: HEOS favorite that is started when the speaker is switched on but has nothing to resume (1 = first favorite in the HEOS app, 0 = disabled). Also used for automatically added devices. |
 | `devices[].inputs` | no | `[]` | Inputs to show in the Home app, see [Inputs](#inputs). |
 | `devices[].inputs[].inputID` | yes | | Input ID (depends on the protocol, see below). |
 | `devices[].inputs[].name` | yes | | Name shown in the Home app. |
@@ -268,7 +270,7 @@ Streaming sources (Spotify, TuneIn, AirPlay, …) are recognised and shown as th
 
 | Action | What happens |
 | --- | --- |
-| Power button | Power on / standby (AVR Control, Hybrid) or play / stop (HEOS CLI) |
+| Power button | Power on / standby (AVR Control, Hybrid) or play / stop (HEOS CLI). With HEOS CLI, switching on resumes the last source; if there is none, the first HEOS favorite is started (see `powerOnFavorite`). |
 | Input picker | Switches the input |
 | Control Center → Remote → volume buttons on your iPhone | Volume up / down by `volumeStepSize` |
 | Remote → centre button / play-pause | Play / pause (HEOS CLI, Hybrid) |
@@ -286,6 +288,9 @@ The serial number doesn't match. Use the value from device discovery exactly as
 **Discovery finds nothing.**
 SSDP doesn't cross VLANs or guest networks. Docker installations need `network_mode: host`.
 
+**A speaker doesn't switch on (HEOS CLI).**
+Switching on starts playback. If the speaker has nothing to resume, the plugin starts the HEOS favorite set in `powerOnFavorite` (default: the first one). Make sure at least one favorite exists in the HEOS app (*Music → Favorites*). The debug log shows `starting HEOS favorite …` when this happens.
+
 **The Marantz receiver doesn't react to AVR Control commands.**
 Enable *Network Control* (sometimes called *IP Control*) in the receiver's network settings so it stays reachable in standby.
 
@@ -304,7 +309,7 @@ Every change is checked against the current Homebridge release and for known vul
 | Checked | Versions |
 | --- | --- |
 | Homebridge | 1.11.4 and 2.5.0 (HAP-NodeJS 0.14.3 / 2.3.0) |
-| Node.js | 22, 24 (Homebridge 2.5 supports 22.12+, 24 and 26) |
+| Node.js | 22, 24 and 26 (Homebridge 1.x: up to 24) |
 | Known vulnerabilities | `npm audit`: 0 findings (runtime and development dependencies) |
 
 *Last checked: November 2026.* The GitHub workflow repeats these checks on every push and **weekly**, so new Homebridge releases and newly published CVEs are noticed even without code changes.

package/config.schema.json

@@ -102,6 +102,15 @@
               "maximum": 10,
               "default": 2
             },
+            "powerOnFavorite": {
+              "title": "Power On Favorite",
+              "description": "HEOS CLI only: if a speaker has nothing to resume when it is switched on, this HEOS favorite is started (1 = first favorite in the HEOS app). 0 = disabled.",
+              "type": "integer",
+              "required": false,
+              "minimum": 0,
+              "maximum": 50,
+              "default": 1
+            },
             "inputs": {
               "title": "Inputs",
               "description": "The list of inputs to your device. If you configure inputs here, those inputs will become selectable in the Home app.",

package/dist/config.d.ts

@@ -14,5 +14,6 @@ export interface DeviceConfig {
     volumeLimitEnabled?: boolean;
     volumeLimit?: number;
     volumeStepSize?: number;
+    powerOnFavorite?: number;
     inputs?: InputConfig[];
 }

package/dist/denonClient.d.ts

@@ -55,6 +55,11 @@ export interface IDenonClient {
      * Inputs that are only used to show the current source (e.g. streaming services), if the inputs could be read from the device.
      */
     readonly displayOnlyInputs: DefaultInput[];
+    /**
+     * HEOS favorite that is started when switching on a HEOS CLI device that has nothing to resume (0 = disabled).
+     * Not used by protocols with a real power state.
+     */
+    setPowerOnFavorite?(preset: number): void;
 }
 export declare abstract class DenonClient implements IDenonClient {
     readonly serialNumber: string;

package/dist/denonClientHeosCli.d.ts

@@ -63,6 +63,14 @@ export declare class DenonClientHeosCli extends DenonClient {
                 };
             };
         };
+        PLAY_PRESET: {
+            SET: {
+                COMMAND: string;
+                PARAMS: string;
+                EXP_RES: RegExp;
+                TIMEOUT: number;
+            };
+        };
         PLAY_NEXT: {
             SET: {
                 COMMAND: string;
@@ -188,6 +196,8 @@ export declare class DenonClientHeosCli extends DenonClient {
     static readonly DEFAULT_INPUT_SOURCES: DefaultInput[];
     readonly displayOnlyInputs: DefaultInput[];
     private player_id;
+    /** HEOS favorite (1, 2, …) that is started when switching on without something to resume; 0 = disabled. */
+    private powerOnFavorite;
     private player_name;
     constructor(serialNumber: string, name: string, host: string, connect_timeout: number, response_timeout: number, debugLogCallback?: (message: string, ...parameters: any[]) => void, powerUpdateCallback?: (power: boolean) => void, muteUpdateCallback?: (mute: boolean) => void, volumeUpdateCallback?: (volume: number) => void, inputUpdateCallback?: (input: string) => void);
     private findPlayerId;
@@ -204,7 +214,14 @@ export declare class DenonClientHeosCli extends DenonClient {
     setPlayNext(): Promise<void>;
     setPlayPrevious(): Promise<void>;
     getPower(raceStatus?: RaceStatus): Promise<boolean>;
+    setPowerOnFavorite(preset: number): void;
+    /**
+     * Switching on means starting playback. If there is nothing to resume (play state "unknown", e.g. no source
+     * since the speaker was started) or the device refuses to play, the configured HEOS favorite is started instead.
+     */
     setPower(power: boolean): Promise<boolean>;
+    private powerOn;
+    private playFavorite;
     getMute(raceStatus?: RaceStatus): Promise<boolean>;
     setMute(mute: boolean): Promise<boolean>;
     getVolume(raceStatus?: RaceStatus): Promise<number>;

package/dist/denonClientHeosCli.js

@@ -66,6 +66,15 @@ export class DenonClientHeosCli extends DenonClient {
                 },
             },
         },
+        PLAY_PRESET: {
+            // plays a HEOS favorite (preset position starting at 1)
+            SET: {
+                COMMAND: "browse/play_preset",
+                PARAMS: "?pid=[PID]&preset=[VALUE]",
+                EXP_RES: /preset=(\d+)/,
+                TIMEOUT: 6000,
+            },
+        },
         PLAY_NEXT: {
             SET: {
                 COMMAND: "player/play_next",
@@ -237,6 +246,8 @@ export class DenonClientHeosCli extends DenonClient {
     static DEFAULT_INPUT_SOURCES = [...DenonClientHeosCli.DISPLAY_ONLY_INPUT_SOURCES, ...DenonClientHeosCli.INPUT_SOURCES];
     displayOnlyInputs = DenonClientHeosCli.DISPLAY_ONLY_INPUT_SOURCES;
     player_id;
+    /** HEOS favorite (1, 2, …) that is started when switching on without something to resume; 0 = disabled. */
+    powerOnFavorite = 1;
     player_name;
     constructor(serialNumber, name, host, connect_timeout, response_timeout, debugLogCallback, powerUpdateCallback, muteUpdateCallback, volumeUpdateCallback, inputUpdateCallback) {
         super(serialNumber, name, {
@@ -422,12 +433,44 @@ export class DenonClientHeosCli extends DenonClient {
         }
         return isPlaying[playing];
     }
+    setPowerOnFavorite(preset) {
+        this.powerOnFavorite = preset;
+    }
+    /**
+     * Switching on means starting playback. If there is nothing to resume (play state "unknown", e.g. no source
+     * since the speaker was started) or the device refuses to play, the configured HEOS favorite is started instead.
+     */
     async setPower(power) {
-        const newPlaying = await this.setPlaying(power ? Playing.PLAY : Playing.STOP);
-        if (this.powerUpdateCallback) {
-            this.powerUpdateCallback(isPlaying[newPlaying]);
+        let playing;
+        if (!power) {
+            playing = isPlaying[await this.setPlaying(Playing.STOP)];
+        }
+        else {
+            playing = await this.powerOn();
         }
-        return isPlaying[newPlaying];
+        this.powerUpdateCallback?.(playing);
+        return playing;
+    }
+    async powerOn() {
+        const rawState = await this.sendCommand(DenonClientHeosCli.PROTOCOL.PLAY_STATE, CommandMode.GET, {});
+        if (rawState === DenonClientHeosCli.PROTOCOL.PLAY_STATE.VALUES.UNKNOWN.VALUE && this.powerOnFavorite > 0) {
+            this.debugLog(`Nothing to resume (play state "${rawState}"), starting HEOS favorite ${this.powerOnFavorite}.`);
+            return this.playFavorite(this.powerOnFavorite);
+        }
+        try {
+            return isPlaying[await this.setPlaying(Playing.PLAY)];
+        }
+        catch (error) {
+            if (!(error instanceof CommandFailedException) || this.powerOnFavorite <= 0) {
+                throw error;
+            }
+            this.debugLog(`The device refused to resume playback, starting HEOS favorite ${this.powerOnFavorite}.`);
+            return this.playFavorite(this.powerOnFavorite);
+        }
+    }
+    async playFavorite(preset) {
+        await this.sendCommand(DenonClientHeosCli.PROTOCOL.PLAY_PRESET, CommandMode.SET, { value: preset.toString() });
+        return true;
     }
     async getMute(raceStatus) {
         const response = await this.sendCommand(DenonClientHeosCli.PROTOCOL.MUTE, CommandMode.GET, {});

package/dist/platformAccessory.d.ts

@@ -11,6 +11,8 @@ export declare class DenonAudioAccessory {
     private static readonly API_CONNECT_TIMEOUT;
     private static readonly API_RESPONSE_TIMEOUT;
     private static readonly DEFAULT_VOLUME_STEP_SIZE;
+    private static readonly DEFAULT_POWER_ON_FAVORITE;
+    private static readonly POWER_STATE_SETTLE_TIME;
     private static readonly INPUT_QUERY_TIMEOUT;
     private static readonly DEFAULT_VOLUME_LIMIT;
     private readonly platform;
@@ -35,6 +37,7 @@ export declare class DenonAudioAccessory {
     private lastSetVolume;
     private targetMediaState;
     private volumeChangeOngoing;
+    private pendingActive;
     private playingChangeOngoing;
     constructor(platform: DenonAudioPlatform, accessory: PlatformAccessory, config: DeviceConfig, log: Logger);
     /**

package/dist/platformAccessory.js

@@ -15,6 +15,9 @@ export class DenonAudioAccessory {
     static API_CONNECT_TIMEOUT = 5 * 1000;
     static API_RESPONSE_TIMEOUT = 1 * 1000;
     static DEFAULT_VOLUME_STEP_SIZE = 2;
+    static DEFAULT_POWER_ON_FAVORITE = 1;
+    // after switching, devices report the old state for a moment; HomeKit gets the new state during this time
+    static POWER_STATE_SETTLE_TIME = 5 * 1000;
     // includes the time to connect to the device and to look up the player id
     static INPUT_QUERY_TIMEOUT = 15 * 1000;
     static DEFAULT_VOLUME_LIMIT = 99;
@@ -40,6 +43,7 @@ export class DenonAudioAccessory {
     lastSetVolume;
     targetMediaState;
     volumeChangeOngoing = false;
+    pendingActive;
     playingChangeOngoing = false;
     constructor(platform, accessory, config, log) {
         log.debug("Initializing DenonAudioAccessory...");
@@ -103,6 +107,11 @@ export class DenonAudioAccessory {
         this.speakerService.setCharacteristic(this.platform.Characteristic.VolumeControlType, this.platform.Characteristic.VolumeControlType.ABSOLUTE);
         // choose appropriate client
         this.denonClient = new DenonProtocol.CLIENT_MAP[this.controlMode](this.serialNumber, this.name, this.ip, DenonAudioAccessory.API_CONNECT_TIMEOUT, DenonAudioAccessory.API_RESPONSE_TIMEOUT, this.log.debug.bind(this.log), this.callbackActive.bind(this), this.callbackMute.bind(this), this.callbackVolume.bind(this), this.callbackInput.bind(this));
+        const powerOnFavorite = config.powerOnFavorite ?? DenonAudioAccessory.DEFAULT_POWER_ON_FAVORITE;
+        if (!Number.isInteger(powerOnFavorite) || powerOnFavorite < 0) {
+            throw new Error("Power on favorite must be 0 (disabled) or the number of a HEOS favorite (1, 2, …)");
+        }
+        this.denonClient.setPowerOnFavorite?.(powerOnFavorite);
         this.configuredInputs = config.inputs ?? [];
         this.unknownInput = new ConfiguredInput("unknown", "Unknown Input", false, 0, false);
         this.log.info("Finished initializing accessory.");
@@ -206,6 +215,11 @@ export class DenonAudioAccessory {
      * These are sent when HomeKit wants to know the current state of the accessory, for example, checking if a Light bulb is on.
      */
     async getActive() {
+        if (this.pendingActive && Date.now() < this.pendingActive.until) {
+            this.log.debug(`getActive for ${this.name}. [recently set to ${this.pendingActive.value}]`);
+            return this.pendingActive.value;
+        }
+        this.pendingActive = undefined;
         return this.queryDevice("getActive", "power status", (raceStatus) => this.denonClient.getPower(raceStatus));
     }
     async getActiveIdentifier() {
@@ -297,10 +311,13 @@ export class DenonAudioAccessory {
     }
     async setActive(newValue) {
         this.log.debug(`setActive for ${this.name} set to ${newValue}`);
+        const active = newValue === this.platform.Characteristic.Active.ACTIVE;
         try {
-            await this.denonClient.setPower(newValue === this.platform.Characteristic.Active.ACTIVE);
+            await this.denonClient.setPower(active);
+            this.pendingActive = { value: active, until: Date.now() + DenonAudioAccessory.POWER_STATE_SETTLE_TIME };
         }
         catch (error) {
+            this.pendingActive = undefined;
             this.log.error(`An error occured while setting power status for ${this.name}.`, error);
             throw new this.platform.api.hap.HapStatusError(this.platform.api.hap.HAPStatus.SERVICE_COMMUNICATION_FAILURE);
         }
@@ -525,6 +542,10 @@ export class DenonAudioAccessory {
      * Handles characteristic updates from the API
      */
     callbackActive(active) {
+        if (this.pendingActive && this.pendingActive.value !== active) {
+            // changed on the device (e.g. in the HEOS app) - the device state wins
+            this.pendingActive = undefined;
+        }
         this.tvService.updateCharacteristic(this.platform.Characteristic.Active, active);
     }
     callbackMute(mute) {

package/package.json

@@ -2,7 +2,7 @@
   "name": "@tplnet/homebridge-denon-heos-audio",
   "displayName": "Homebridge Denon Heos Audio (tplnet)",
   "type": "module",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "description": "Control your Denon and Marantz HEOS speakers, amplifiers and AVRs via AVR Control and/or HEOS CLI",
   "author": "tplnet",
   "contributors": [