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

package/CHANGELOG.md

@@ -2,6 +2,44 @@
 
 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.2.0
+
+### New
+
+- **Control protocol check at startup:** the plugin checks which protocols a device supports. If the configured protocol isn't supported (e.g. *Hybrid* or *AVR Control* on a Denon Home speaker), it uses a supported one and logs a warning with what to change, instead of the device showing "No Response". A device configured with *HEOS CLI* that also supports AVR Control gets a hint that *Hybrid* is possible. Devices that are switched off at startup keep their configuration.
+- The plugin settings explain which devices support which protocol.
+
+### Changed
+
+- The protocol support of a device is checked on both ports in parallel (faster startup if a device is offline).
+
+## 1.1.2
+
+### Fixed
+
+- Switching on (HEOS CLI) also starts the HEOS favorite when the speaker reports "paused" but has nothing to play: if the current media is empty, or if the speaker accepts the play command but playback doesn't start within 3 seconds. Seen on a Denon Home Amp after a streaming session.
+
+## 1.1.1
+
+### Changed
+
+- Switching on a speaker that is already playing no longer sends an unnecessary play command.
+- Starting the power on favorite is shown in the normal log (not only in the debug log), e.g. `Nothing to resume, starting HEOS favorite 1.`
+
+### Documentation
+
+- README: a HEOS favorite is required for switching on without a source; fixed ports and the *Ciao* mDNS advertiser help if devices appear offline in the Homebridge UI after restarts.
+
+## 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

@@ -10,7 +10,7 @@ Each device appears in the Home app as a TV accessory, so you can:
 - play, pause and skip tracks with the Remote in Control Center
 
 [![npm](https://img.shields.io/npm/v/@tplnet/homebridge-denon-heos-audio)](https://www.npmjs.com/package/@tplnet/homebridge-denon-heos-audio)
-[![CI](https://github.com/tplnet/homebridge-denon-heos-audio/actions/workflows/ci.yml/badge.svg)](https://github.com/tplnet/homebridge-denon-heos-audio/actions/workflows/ci.yml)
+[![CI](https://github.com/tplnet/homebridge-denon-heos-audio/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/tplnet/homebridge-denon-heos-audio/actions/workflows/ci.yml)
 
 > This is a fork of [hov3rcraft/homebridge-denon-heos-audio](https://github.com/hov3rcraft/homebridge-denon-heos-audio) with stability fixes
 > (no more Homebridge crashes on unexpected device messages), automatic setup of discovered devices, inputs read from the device,
@@ -56,8 +56,15 @@ 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 or a streaming session ended), or playback doesn't start within 3 seconds, 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.
+> **Requirement:** at least one favorite in the HEOS app (*Music → Favorites*, e.g. a radio station). Without a favorite, a speaker that has nothing to resume can't be switched on from HomeKit.
+
+**Hybrid** uses AVR Control for power and HEOS CLI for everything else. Pick it whenever discovery reports both protocols and you want real standby.
+
+**Wrong protocol?** At startup the plugin checks which protocols the device supports. If the configured one isn't supported (e.g. *Hybrid* on a Denon Home 150), it uses a supported one instead and logs a warning:
+`"Office Speaker" doesn't support AVR Control (port 23 closed), so "Hybrid" can't be used. Using "HEOS CLI" instead – please change "Control Protocol" in the plugin settings.`
+If a device configured with *HEOS CLI* also supports AVR Control, the log mentions that *Hybrid* is possible. If the device is switched off at startup, the configuration is used unchanged.
 
 ## Installation
 
@@ -126,7 +133,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 +232,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). The favorite must exist in the HEOS app. 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 +276,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,12 +294,25 @@ 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.
 
 **The device can't be added in the Home app.**
 See [The device does not appear in step 4?](#adding-a-device-to-apple-home-step-by-step)
 
+**Devices appear offline in the Homebridge UI after a restart ("fetch failed"), or commands from the UI don't arrive.**
+Every device runs on its own port. Without a port range, the ports change at every restart and the Homebridge UI may still use the old ones, especially if mDNS doesn't work reliably (e.g. on a Synology NAS: `Failed to create listener for avahi-daemon`). In the Homebridge UI under **Settings → Network**:
+1. set a **port range** for accessories, e.g. `52100`–`52150` (or `"ports": { "start": 52100, "end": 52150 }` in `config.json`), outside of the ports of your bridges,
+2. set the **mDNS Advertiser** to **Ciao**,
+
+then restart Homebridge **once** and reload the page.
+
+**Homebridge doesn't start: `EADDRINUSE: address already in use`.**
+Usually an old Homebridge process is still running (e.g. after several restarts in a row): `ps aux | grep -i [h]omebridge` shows two main `homebridge` processes. Stop Homebridge, end the old process (`kill <pid>`) and start Homebridge again.
+
 **A device is added automatically although I don't want it in HomeKit.**
 Add its serial number to `excludedSerialNumbers` and restart Homebridge. Then remove it from the Home app.
 
@@ -304,7 +325,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

@@ -61,6 +61,7 @@
             },
             "controlProtocol": {
               "title": "Control Protocol",
+              "description": "HEOS CLI: speakers like the Denon Home series (on/off = play/stop). Hybrid: devices that also support AVR Control, e.g. AV receivers and the Denon Home Amp (real standby). AVR Control: receivers without HEOS. Device discovery lists the supported protocols in the log; an unsupported protocol is replaced automatically at startup (with a warning).",
               "type": "string",
               "oneOf": [
                 {
@@ -102,6 +103,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, infoLog?: (message: string) => void): 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,12 @@ 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 static readonly PLAY_VERIFY_CHECKS;
+    private playVerifyIntervalMs;
+    /** Log for actions the user should see without debug logging (e.g. starting the power on favorite). */
+    private infoLog;
     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 +218,18 @@ export declare class DenonClientHeosCli extends DenonClient {
     setPlayNext(): Promise<void>;
     setPlayPrevious(): Promise<void>;
     getPower(raceStatus?: RaceStatus): Promise<boolean>;
+    setPowerOnFavorite(preset: number, infoLog?: (message: string) => void): 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;
+    /**
+     * True if the player has no current media to resume (e.g. an empty entry after a streaming session ended).
+     */
+    private hasNoMedia;
+    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,12 @@ 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;
+    static PLAY_VERIFY_CHECKS = 3;
+    playVerifyIntervalMs = 1000;
+    /** Log for actions the user should see without debug logging (e.g. starting the power on favorite). */
+    infoLog = (message) => this.debugLog(message);
     player_name;
     constructor(serialNumber, name, host, connect_timeout, response_timeout, debugLogCallback, powerUpdateCallback, muteUpdateCallback, volumeUpdateCallback, inputUpdateCallback) {
         super(serialNumber, name, {
@@ -422,12 +437,87 @@ export class DenonClientHeosCli extends DenonClient {
         }
         return isPlaying[playing];
     }
+    setPowerOnFavorite(preset, infoLog) {
+        this.powerOnFavorite = preset;
+        if (infoLog) {
+            this.infoLog = infoLog;
+        }
+    }
+    /**
+     * 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)];
         }
-        return isPlaying[newPlaying];
+        else {
+            playing = await this.powerOn();
+        }
+        this.powerUpdateCallback?.(playing);
+        return playing;
+    }
+    async powerOn() {
+        const PLAY = DenonClientHeosCli.PROTOCOL.PLAY_STATE.VALUES.PLAY.VALUE;
+        const rawState = await this.sendCommand(DenonClientHeosCli.PROTOCOL.PLAY_STATE, CommandMode.GET, {});
+        if (rawState === PLAY) {
+            this.debugLog("Already playing, nothing to do.");
+            return true;
+        }
+        const favorite = this.powerOnFavorite;
+        if (favorite > 0) {
+            if (rawState === DenonClientHeosCli.PROTOCOL.PLAY_STATE.VALUES.UNKNOWN.VALUE) {
+                this.infoLog(`Nothing to resume, starting HEOS favorite ${favorite}.`);
+                return this.playFavorite(favorite);
+            }
+            if (await this.hasNoMedia()) {
+                this.infoLog(`Nothing to resume (no current media), starting HEOS favorite ${favorite}.`);
+                return this.playFavorite(favorite);
+            }
+        }
+        try {
+            await this.setPlaying(Playing.PLAY);
+        }
+        catch (error) {
+            if (!(error instanceof CommandFailedException) || favorite <= 0) {
+                throw error;
+            }
+            this.infoLog(`The speaker refused to resume playback, starting HEOS favorite ${favorite}.`);
+            return this.playFavorite(favorite);
+        }
+        if (favorite <= 0) {
+            return true;
+        }
+        // Some devices accept "play" without having anything to play (they stay paused), so check that playback started.
+        for (let check = 0; check < DenonClientHeosCli.PLAY_VERIFY_CHECKS; check++) {
+            await new Promise((resolve) => setTimeout(resolve, this.playVerifyIntervalMs));
+            if ((await this.sendCommand(DenonClientHeosCli.PROTOCOL.PLAY_STATE, CommandMode.GET, {})) === PLAY) {
+                return true;
+            }
+        }
+        this.infoLog(`Playback did not start, starting HEOS favorite ${favorite}.`);
+        return this.playFavorite(favorite);
+    }
+    /**
+     * True if the player has no current media to resume (e.g. an empty entry after a streaming session ended).
+     */
+    async hasNoMedia() {
+        try {
+            const payload = JSON.parse(await this.sendCommand(DenonClientHeosCli.PROTOCOL.INPUT, CommandMode.GET, { passPayload: true }));
+            if (typeof payload?.mid === "string" && payload.mid.startsWith("inputs/")) {
+                return false; // a physical input can always be resumed
+            }
+            return ["song", "station", "artist", "album"].every((field) => !payload?.[field]);
+        }
+        catch (error) {
+            this.debugLog("Could not read the current media:", error instanceof Error ? error.message : error);
+            return false;
+        }
+    }
+    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/denonProtocol.js

@@ -30,15 +30,9 @@ function checkProtocolSupportAtPort(host, port, debugLogCallback) {
     });
 }
 export async function checkProtocolSupport(host, debugLogCallback) {
-    const supportedProtocols = [];
-    for (const controlMode of Object.values(ControlMode).filter((value) => typeof value === "number")) {
-        if (controlMode >= 0) {
-            const supported = await checkProtocolSupportAtPort(host, controlMode, debugLogCallback);
-            if (supported) {
-                supportedProtocols.push(controlMode);
-            }
-        }
-    }
-    return supportedProtocols;
+    const modes = Object.values(ControlMode).filter((value) => typeof value === "number" && value >= 0);
+    // check all ports in parallel, so an unreachable device delays the startup only once
+    const results = await Promise.all(modes.map((mode) => checkProtocolSupportAtPort(host, mode, debugLogCallback)));
+    return modes.filter((_mode, index) => results[index]);
 }
 //# sourceMappingURL=denonProtocol.js.map

package/dist/platform.d.ts

@@ -30,6 +30,11 @@ export declare class DenonAudioPlatform implements DynamicPlatformPlugin {
      * (HomeKit only allows one television accessory per bridge).
      */
     private publishNewAccessory;
+    /**
+     * Checks the configured control protocol against the protocols the device supports and falls back to a supported
+     * one if necessary (with a warning). If the device can't be reached, the configuration is used unchanged.
+     */
+    private withCheckedProtocol;
     /**
      * Adds a discovered device as new accessory, unless it is configured manually, excluded or already set up.
      */

package/dist/platform.js

@@ -3,6 +3,7 @@ import * as CustomLogging from "./customLogging.js";
 import { PLATFORM_NAME, PLUGIN_NAME } from "./settings.js";
 import * as DenonProtocol from "./denonProtocol.js";
 import { buildDiscoveredDeviceConfig } from "./discovery.js";
+import { checkControlProtocol } from "./protocolCheck.js";
 import { HeosDiscovery } from "./heosDiscovery.js";
 const MINUTE = 60 * 1000;
 export class DenonAudioPlatform {
@@ -77,9 +78,9 @@ export class DenonAudioPlatform {
                     // the accessory already exists
                     this.log.info("Restoring existing accessory from cache:", existingAccessory.displayName);
                     // create the accessory handler for the restored accessory
-                    this.createAccessoryHandler(existingAccessory, deviceConfig)
-                        ?.setupInputs()
-                        .catch((error) => this.log.error(`Could not set up the inputs of '${deviceConfig.name}':`, error));
+                    this.withCheckedProtocol(deviceConfig)
+                        .then((checkedConfig) => this.createAccessoryHandler(existingAccessory, checkedConfig)?.setupInputs())
+                        .catch((error) => this.log.error(`Could not set up '${deviceConfig.name}':`, error));
                     // after it has been restored, the existing accessory should be removed form the uuid list
                     existingAccessoriesUuids = existingAccessoriesUuids.filter((uuid) => uuid !== existingAccessory.UUID);
                 }
@@ -116,18 +117,38 @@ export class DenonAudioPlatform {
      * Sets up a new accessory and publishes it as external accessory
      * (HomeKit only allows one television accessory per bridge).
      */
-    publishNewAccessory(deviceConfig, accessory) {
+    publishNewAccessory(deviceConfig, accessory, supportedModes) {
         // store a copy of the device object in the `accessory.context`
         accessory.context.device = deviceConfig;
-        const handler = this.createAccessoryHandler(accessory, deviceConfig);
-        if (!handler) {
-            return;
+        this.withCheckedProtocol(deviceConfig, supportedModes)
+            .then(async (checkedConfig) => {
+            const handler = this.createAccessoryHandler(accessory, checkedConfig);
+            if (!handler) {
+                return;
+            }
+            // the inputs are read from the device first, as the services of a published accessory should not change anymore
+            await handler.setupInputs().catch((error) => this.log.error(`Could not set up the inputs of '${deviceConfig.name}':`, error));
+            this.api.publishExternalAccessories(PLUGIN_NAME, [accessory]);
+        })
+            .catch((error) => this.log.error(`Could not set up '${deviceConfig.name}':`, error));
+    }
+    /**
+     * Checks the configured control protocol against the protocols the device supports and falls back to a supported
+     * one if necessary (with a warning). If the device can't be reached, the configuration is used unchanged.
+     */
+    async withCheckedProtocol(deviceConfig, knownSupportedModes) {
+        const supportedModes = knownSupportedModes ?? (await DenonProtocol.checkProtocolSupport(deviceConfig.ip, this.log.debug.bind(this.log)));
+        const result = checkControlProtocol(deviceConfig.name, deviceConfig.controlProtocol, supportedModes);
+        if (result.warning) {
+            this.log.warn(result.warning);
+        }
+        if (result.hint) {
+            this.log.info(result.hint);
+        }
+        if (supportedModes.length === 0) {
+            this.log.debug(`Could not check the protocols of '${deviceConfig.name}' (${deviceConfig.ip} not reachable). Using the configuration.`);
         }
-        // the inputs are read from the device first, as the services of a published accessory should not change anymore
-        handler
-            .setupInputs()
-            .catch((error) => this.log.error(`Could not set up the inputs of '${deviceConfig.name}':`, error))
-            .finally(() => this.api.publishExternalAccessories(PLUGIN_NAME, [accessory]));
+        return result.protocol === deviceConfig.controlProtocol ? deviceConfig : { ...deviceConfig, controlProtocol: result.protocol };
     }
     /**
      * Adds a discovered device as new accessory, unless it is configured manually, excluded or already set up.
@@ -147,7 +168,7 @@ export class DenonAudioPlatform {
         }
         this.activeSerialNumbers.add(serialNumber);
         this.log.info(`Automatically adding discovered device '${deviceConfig.name}' (${deviceConfig.controlProtocol}, ${ip}).`);
-        this.publishNewAccessory(deviceConfig, new this.api.platformAccessory(deviceConfig.name, this.api.hap.uuid.generate(serialNumber)));
+        this.publishNewAccessory(deviceConfig, new this.api.platformAccessory(deviceConfig.name, this.api.hap.uuid.generate(serialNumber)), supportedModes);
     }
     /**
      * Creates the accessory handler. Configuration errors are logged instead of being thrown,

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, (message) => this.log.info(message));
         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/dist/protocolCheck.d.ts

@@ -0,0 +1,20 @@
+import { ControlMode } from "./controlMode.js";
+import type { DeviceConfig } from "./config.js";
+type ProtocolName = DeviceConfig["controlProtocol"];
+export interface ProtocolCheckResult {
+    /** The protocol to use. */
+    protocol: ProtocolName;
+    /** Warning for the log if the configured protocol can't be used. */
+    warning?: string;
+    /** Hint for the log (e.g. a better protocol is available). */
+    hint?: string;
+}
+/**
+ * Checks the configured control protocol against the protocols the device supports.
+ *
+ * - The device supports everything the protocol needs: keep it (with a hint if Hybrid would be possible instead of HEOS CLI).
+ * - The device doesn't support it, but another one: use the best supported protocol and return a warning.
+ * - The device can't be reached (nothing supported): keep the configuration, the device may just be switched off.
+ */
+export declare function checkControlProtocol(deviceName: string, configured: ProtocolName, supportedModes: ControlMode[]): ProtocolCheckResult;
+export {};

package/dist/protocolCheck.js

@@ -0,0 +1,46 @@
+import { ControlMode, CONTROL_MODE_BY_NAME } from "./controlMode.js";
+import { chooseControlProtocol } from "./discovery.js";
+/** Ports (= control modes) a protocol needs. */
+const REQUIRED_MODES = {
+    AVRCONTROL: [ControlMode.AVRCONTROL],
+    HEOSCLI: [ControlMode.HEOSCLI],
+    HYBRID: [ControlMode.AVRCONTROL, ControlMode.HEOSCLI],
+};
+const PROTOCOL_LABEL = {
+    AVRCONTROL: "AVR Control",
+    HEOSCLI: "HEOS CLI",
+    HYBRID: "Hybrid",
+};
+/**
+ * Checks the configured control protocol against the protocols the device supports.
+ *
+ * - The device supports everything the protocol needs: keep it (with a hint if Hybrid would be possible instead of HEOS CLI).
+ * - The device doesn't support it, but another one: use the best supported protocol and return a warning.
+ * - The device can't be reached (nothing supported): keep the configuration, the device may just be switched off.
+ */
+export function checkControlProtocol(deviceName, configured, supportedModes) {
+    if (!(configured in CONTROL_MODE_BY_NAME) || supportedModes.length === 0) {
+        return { protocol: configured };
+    }
+    const missing = REQUIRED_MODES[configured].filter((mode) => !supportedModes.includes(mode));
+    if (missing.length === 0) {
+        if (configured === "HEOSCLI" && supportedModes.includes(ControlMode.AVRCONTROL)) {
+            return {
+                protocol: configured,
+                hint: `"${deviceName}" also supports AVR Control. "Hybrid" would switch it to real standby instead of only stopping the playback.`,
+            };
+        }
+        return { protocol: configured };
+    }
+    const fallback = chooseControlProtocol(supportedModes);
+    if (!fallback) {
+        return { protocol: configured };
+    }
+    const missingText = missing.map((mode) => `${ControlMode[mode] === "AVRCONTROL" ? "AVR Control" : "HEOS CLI"} (port ${mode} closed)`).join(", ");
+    return {
+        protocol: fallback,
+        warning: `"${deviceName}" doesn't support ${missingText}, so "${PROTOCOL_LABEL[configured]}" can't be used. ` +
+            `Using "${PROTOCOL_LABEL[fallback]}" instead – please change "Control Protocol" in the plugin settings.`,
+    };
+}
+//# sourceMappingURL=protocolCheck.js.map

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.2.0",
   "description": "Control your Denon and Marantz HEOS speakers, amplifiers and AVRs via AVR Control and/or HEOS CLI",
   "author": "tplnet",
   "contributors": [