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

package/CHANGELOG.md

@@ -2,6 +2,41 @@
 
 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.1
+
+### Fixed
+
+- When switching on took a few seconds (e.g. while the power on favorite was being started), the tile briefly showed "off" before it switched to "on". The requested state is now reported from the moment of the tap, and intermediate states of the device are ignored until switching has finished.
+- The player list was requested twice per device at startup.
+
+## 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

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,9 +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), 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`.
+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
 
@@ -226,7 +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). Also used for automatically added devices. |
+| `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. |
@@ -297,6 +303,16 @@ Enable *Network Control* (sometimes called *IP Control*) in the receiver's netwo
 **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.
 

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": [
                 {

package/dist/denonClient.d.ts

@@ -59,7 +59,7 @@ export interface IDenonClient {
      * 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;
+    setPowerOnFavorite?(preset: number, infoLog?: (message: string) => void): void;
 }
 export declare abstract class DenonClient implements IDenonClient {
     readonly serialNumber: string;

package/dist/denonClientHeosCli.d.ts

@@ -198,9 +198,16 @@ export declare class DenonClientHeosCli extends DenonClient {
     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 playerIdLookup;
+    /** Looks up the player id; concurrent calls share one request. */
     private findPlayerId;
+    private findPlayerIdUncached;
     protected subscribeToChangeEvents(): Promise<void>;
     protected sendCommand(command: ProtocolCommand, commandMode: CommandMode, { value, passPayload }: {
         value?: string;
@@ -214,13 +221,17 @@ export declare class DenonClientHeosCli extends DenonClient {
     setPlayNext(): Promise<void>;
     setPlayPrevious(): Promise<void>;
     getPower(raceStatus?: RaceStatus): Promise<boolean>;
-    setPowerOnFavorite(preset: number): void;
+    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>;

package/dist/denonClientHeosCli.js

@@ -248,6 +248,10 @@ export class DenonClientHeosCli extends DenonClient {
     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, {
@@ -271,7 +275,15 @@ export class DenonClientHeosCli extends DenonClient {
             }
         });
     }
-    async findPlayerId() {
+    playerIdLookup;
+    /** Looks up the player id; concurrent calls share one request. */
+    findPlayerId() {
+        this.playerIdLookup ??= this.findPlayerIdUncached().finally(() => {
+            this.playerIdLookup = undefined;
+        });
+        return this.playerIdLookup;
+    }
+    async findPlayerIdUncached() {
         const payload_str = await super.sendCommand(DenonClientHeosCli.PROTOCOL.PLAYERS, CommandMode.GET, { passPayload: true });
         const payload = JSON.parse(payload_str);
         if (!Array.isArray(payload)) {
@@ -433,8 +445,11 @@ export class DenonClientHeosCli extends DenonClient {
         }
         return isPlaying[playing];
     }
-    setPowerOnFavorite(preset) {
+    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
@@ -452,20 +467,60 @@ export class DenonClientHeosCli extends DenonClient {
         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 === 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);
+        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 {
-            return isPlaying[await this.setPlaying(Playing.PLAY)];
+            await this.setPlaying(Playing.PLAY);
         }
         catch (error) {
-            if (!(error instanceof CommandFailedException) || this.powerOnFavorite <= 0) {
+            if (!(error instanceof CommandFailedException) || favorite <= 0) {
                 throw error;
             }
-            this.debugLog(`The device refused to resume playback, starting HEOS favorite ${this.powerOnFavorite}.`);
-            return this.playFavorite(this.powerOnFavorite);
+            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) {

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

@@ -38,6 +38,7 @@ export declare class DenonAudioAccessory {
     private targetMediaState;
     private volumeChangeOngoing;
     private pendingActive;
+    private powerChangeInProgress;
     private playingChangeOngoing;
     constructor(platform: DenonAudioPlatform, accessory: PlatformAccessory, config: DeviceConfig, log: Logger);
     /**

package/dist/platformAccessory.js

@@ -44,6 +44,7 @@ export class DenonAudioAccessory {
     targetMediaState;
     volumeChangeOngoing = false;
     pendingActive;
+    powerChangeInProgress = false;
     playingChangeOngoing = false;
     constructor(platform, accessory, config, log) {
         log.debug("Initializing DenonAudioAccessory...");
@@ -111,7 +112,7 @@ export class DenonAudioAccessory {
         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.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.");
@@ -312,6 +313,10 @@ export class DenonAudioAccessory {
     async setActive(newValue) {
         this.log.debug(`setActive for ${this.name} set to ${newValue}`);
         const active = newValue === this.platform.Characteristic.Active.ACTIVE;
+        // Report the requested state right away: switching on can take a few seconds (e.g. when the power on favorite is
+        // started), and the device reports intermediate states during that time.
+        this.pendingActive = { value: active, until: Number.POSITIVE_INFINITY };
+        this.powerChangeInProgress = true;
         try {
             await this.denonClient.setPower(active);
             this.pendingActive = { value: active, until: Date.now() + DenonAudioAccessory.POWER_STATE_SETTLE_TIME };
@@ -321,6 +326,9 @@ export class DenonAudioAccessory {
             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);
         }
+        finally {
+            this.powerChangeInProgress = false;
+        }
     }
     async setActiveIdentifier(newValue) {
         this.log.debug(`setActiveIdentifier for ${this.name} set to ${newValue}`);
@@ -542,6 +550,10 @@ export class DenonAudioAccessory {
      * Handles characteristic updates from the API
      */
     callbackActive(active) {
+        if (this.powerChangeInProgress && this.pendingActive && this.pendingActive.value !== active) {
+            this.log.debug(`Ignoring intermediate power state ${active} of ${this.name} while switching.`);
+            return;
+        }
         if (this.pendingActive && this.pendingActive.value !== active) {
             // changed on the device (e.g. in the HEOS app) - the device state wins
             this.pendingActive = undefined;

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