app.js

"use strict";

var debug = require("debug")("roon-extension-denon"),
    debug_keepalive = require("debug")("roon-extension-denon:keepalive"),
    Denon = require("denon-client"),
    RoonApi = require("node-roon-api"),
    RoonApiSettings = require("node-roon-api-settings"),
    RoonApiStatus = require("node-roon-api-status"),
    RoonApiVolumeControl = require("node-roon-api-volume-control"),
    RoonApiSourceControl = require("node-roon-api-source-control"),
    fetch = require("node-fetch"),
    parse = require("fast-xml-parser");

var denon = {};
var roon = new RoonApi({
    extension_id: "org.pruessmann.roon.denon",
    display_name: "Denon/Marantz AVR",
    display_version: "2025.8.0",
    publisher: "Doc Bobo",
    email: "docbobo@pm.me",
    website: "https://github.com/docbobo/roon-extension-denon",
});

var mysettings = roon.load_config("settings") || {
    hostname: "",
    setsource: "",
    zone: "main",
    powerOffBothZones: true,
};

function make_layout(settings) {
    var l = {
        values: settings,
        layout: [],
        has_error: false,
    };

    l.layout.push({
        type: "string",
        title: "Host name or IP Address",
        subtitle: "The IP address or hostname of the Denon/Marantz receiver.",
        maxlength: 256,
        setting: "hostname",
    });
    
    l.layout.push({
        type: "dropdown",
        title: "Zone",
        subtitle: "Select which zone to control. Note: Zone 2 supports power control only, not volume control.",
        values: [
            { title: "Main Zone", value: "main" },
            { title: "Zone 2 (Power Only)", value: "zone2" }
        ],
        setting: "zone",
    });
    
    l.layout.push({
        type: "dropdown",
        title: "Power Off Behavior",
        subtitle: "When powering off, turn off both zones or just the selected zone",
        values: [
            { title: "Turn off both zones", value: true },
            { title: "Turn off selected zone only", value: false }
        ],
        setting: "powerOffBothZones",
    });
    
    if (settings.err) {
        l.has_error = true;
        l.layout.push({
            type: "status",
            title: settings.err,
        });
    } else {
        l.has_error = false;
        if (settings.hostname) {
            l.layout.push({
                type: "dropdown",
                title: "Input",
                values: settings.inputs,
                setting: "setsource",
            });
        }
    }
    return l;
}

var svc_settings = new RoonApiSettings(roon, {
    get_settings: function (cb) {
        probeInputs(mysettings).then((settings) => {
            cb(make_layout(settings));
        });
    },
    save_settings: function (req, isdryrun, settings) {
        probeInputs(settings.values).then((settings) => {
            let l = make_layout(settings);
            req.send_complete(l.has_error ? "NotValid" : "Success", {
                settings: l,
            });
            delete settings.inputs;

            if (!l.has_error && !isdryrun) {
                var old_hostname = mysettings.hostname;
                var old_setsource = mysettings.setsource;
                var old_zone = mysettings.zone;
                var old_powerOffBothZones = mysettings.powerOffBothZones;
                mysettings = l.values;
                svc_settings.update_settings(l);
                if (
                    old_hostname != mysettings.hostname ||
                    old_setsource != mysettings.setsource ||
                    old_zone != mysettings.zone ||
                    old_powerOffBothZones != mysettings.powerOffBothZones
                )
                    setup_denon_connection(mysettings.hostname);
                roon.save_config("settings", mysettings);
            }
        });
    },
});

var svc_status = new RoonApiStatus(roon);
var svc_volume_control = new RoonApiVolumeControl(roon);
var svc_source_control = new RoonApiSourceControl(roon);

roon.init_services({
    provided_services: [
        svc_status,
        svc_settings,
        svc_volume_control,
        svc_source_control,
    ],
});

function probeInputs(settings) {
    let inputs = (
        settings.hostname
            ? queryInputs(settings.hostname).then((inputs) => {
                  delete settings.err;
                  settings.inputs = inputs;
              })
            : Promise.resolve()
    )

        .catch((err) => {
            settings.err = err.message;
        })
        .then(() => {
            return settings;
        });
    return inputs;
}

function queryInputs(hostname) {
    return Promise.resolve(
        Object.keys(Denon.Options.InputOptions)
            .filter((title) => title != "Status")
            .sort()
            .map((title) => {
                return { title, value: Denon.Options.InputOptions[title] };
            }),
    );
}

function setup_denon_connection(host) {
    debug("setup_denon_connection (" + host + ")");

    if (denon.keepalive) {
        clearInterval(denon.keepalive);
        denon.keepalive = null;
    }
    if (denon.client) {
        denon.client.removeAllListeners("close");
        denon.client.disconnect();
        delete denon.client;
    }

    if (!host) {
        svc_status.set_status("Not configured, please check settings.", true);
    } else {
        debug("Connecting to receiver...");
        svc_status.set_status("Connecting to " + host + "...", false);

        denon.client = new Denon.DenonClient(host);
        denon.client.socket.setTimeout(0);
        denon.client.socket.setKeepAlive(true, 10000);

        denon.client.socket.on("error", (error) => {
            // Handler for debugging purposes. No need to reconnect since the event will be followed by a close event,
            // according to documentation.
            debug("Received onError(%O)", error);
        });

        denon.client.on("data", (data) => {
            debug("%s", data);
        });

        denon.client.socket.on("timeout", () => {
            debug("Received onTimeout(): Closing connection...");
            denon.client.disconnect();
        });

        denon.client.on("close", (had_error) => {
            debug("Received onClose(%O): Reconnecting...", had_error);

            if (denon.client) {
                svc_status.set_status(
                    "Connection closed by receiver. Reconnecting...",
                    true,
                );
                setTimeout(() => {
                    connect();
                }, 1000);
            } else {
                svc_status.set_status(
                    "Not configured, please check settings.",
                    true,
                );
            }
        });

        denon.client.on("powerChanged", (val) => {
            debug("powerChanged: val=%s", val);

            let old_power_value = denon.source_state.Power;
            denon.source_state.Power = val;
            if (old_power_value != denon.source_state.Power) {
                let stat = check_status(
                    denon.source_state.Power,
                    denon.source_state.Input,
                );
                debug("Power differs - updating");
                if (denon.source_control) {
                    denon.source_control.update_state({ status: stat });
                }
            }
        });

        denon.client.on("inputChanged", (val) => {
            debug("inputChanged: val=%s", val);
            let old_Input = denon.source_state.Input;
            denon.source_state.Input = val;

            if (old_Input != denon.source_state.Input) {
                let stat = check_status(
                    denon.source_state.Power,
                    denon.source_state.Input,
                );
                debug("input differs - updating");
                if (denon.source_control) {
                    denon.source_control.update_state({ status: stat });
                }
            }
        });

        denon.client.on("muteChanged", (val) => {
            debug("muteChanged: val=%s", val);

            denon.volume_state.is_muted = val === Denon.Options.MuteOptions.On;
            if (denon.volume_control) {
                denon.volume_control.update_state({
                    is_muted: denon.volume_state.is_muted,
                });
            }
        });

        denon.client.on("masterVolumeChanged", (val) => {
            debug("masterVolumeChanged: val=%s", val - 80);

            denon.volume_state.volume_value = val - 80;
            if (denon.volume_control) {
                denon.volume_control.update_state({
                    volume_value: denon.volume_state.volume_value,
                });
            }
        });

        denon.client.on("masterVolumeMaxChanged", (val) => {
            debug("masterVolumeMaxChanged: val=%s", val - 80);

            denon.volume_state.volume_max = val - 80;
            if (denon.volume_control) {
                denon.volume_control.update_state({
                    volume_max: denon.volume_state.volume_max,
                });
            }
        });

        denon.client.on("zone2Changed", (val) => {
            debug("zone2Changed: val=%s", val);
            
            if (mysettings.zone === "zone2") {
                let old_power_value = denon.source_state.Power;
                denon.source_state.Power = (val === Denon.Options.Zone2Options.On) ? "ON" : "STANDBY";
                
                if (old_power_value != denon.source_state.Power) {
                    let stat = check_status(
                        denon.source_state.Power,
                        denon.source_state.Input,
                    );
                    debug("Zone2 power differs - updating");
                    if (denon.source_control) {
                        denon.source_control.update_state({ status: stat });
                    }
                }
            }
        });

        denon.keepalive = setInterval(() => {
            // Make regular calls to getBrightness for keep-alive.
            denon.client.getBrightness().then((val) => {
                debug_keepalive("Keep-Alive: getInput == %s", val);
            });
        }, 60000);

        connect();
    }
}

function connect() {
    denon.client
        .connect()
        .then(() => {
            // Only create volume control for Main Zone
            if (mysettings.zone === "main") {
                return create_volume_control(denon);
            } else {
                return Promise.resolve();
            }
        })
        .then(() =>
            mysettings.setsource
                ? create_source_control(denon)
                : Promise.resolve(),
        )
        .then(() => {
            const zoneInfo = mysettings.zone === "zone2" ? " (Zone 2 - Power Only)" : "";
            svc_status.set_status("Connected to receiver" + zoneInfo, false);
        })
        .catch((error) => {
            debug("setup_denon_connection: Error during setup. Retrying...");

            debug("Connection error during setup: %O", error);
            svc_status.set_status("Could not connect receiver: " + error, true);
        });
}

function check_status(power, input) {
    let stat = "";
    if (power == "ON") {
        if (input == mysettings.setsource) {
            stat = "selected";
        } else {
            stat = "deselected";
        }
    } else {
        stat = "standby";
    }
    debug("Receiver Status: %s", stat);
    return stat;
}

// Zone-specific helper functions
function getPowerForZone() {
    if (mysettings.zone === "zone2") {
        return denon.client.getZone2().then(status => {
            return (status === Denon.Options.Zone2Options.On) ? "ON" : "STANDBY";
        });
    } else {
        return denon.client.getPower();
    }
}

function setPowerForZone(powerState) {
    if (mysettings.zone === "zone2") {
        const zone2State = (powerState === "ON") ? 
            Denon.Options.Zone2Options.On : 
            Denon.Options.Zone2Options.Off;
        return denon.client.setZone2(zone2State);
    } else {
        return denon.client.setPower(powerState);
    }
}

function setPowerBothZones(powerState) {
    debug("setPowerBothZones: powerState=%s", powerState);
    
    if (mysettings.powerOffBothZones && powerState === "STANDBY") {
        // Turn off both zones when powering off
        const mainZonePromise = denon.client.setPower("STANDBY");
        const zone2Promise = denon.client.setZone2(Denon.Options.Zone2Options.Off);
        
        return Promise.all([mainZonePromise, zone2Promise]).then(() => {
            debug("Both zones powered off successfully");
        }).catch(error => {
            debug("Error powering off both zones: %O", error);
            throw error;
        });
    } else {
        // Use zone-specific power control
        return setPowerForZone(powerState);
    }
}

function create_volume_control(denon) {
    debug("create_volume_control: volume_control=%o", denon.volume_control);
    if (!denon.volume_control) {
        denon.volume_state = {
            display_name: mysettings.zone === "zone2" ? "Zone 2" : "Main Zone",
            volume_type: "db",
            volume_min: -79.5,
            volume_step: 0.5,
        };

        var device = {
            state: denon.volume_state,
            control_key: 1,

            set_volume: function (req, mode, value) {
                debug("set_volume: mode=%s value=%d", mode, value);

                let newvol =
                    mode == "absolute" ? value : state.volume_value + value;
                if (newvol < this.state.volume_min)
                    newvol = this.state.volume_min;
                else if (newvol > this.state.volume_max)
                    newvol = this.state.volume_max;

                denon.client
                    .setVolume(newvol + 80)
                    .then(() => {
                        debug("set_volume: Succeeded.");
                        req.send_complete("Success");
                    })
                    .catch((error) => {
                        debug("set_volume: Failed with error: %O", error);
                        req.send_complete("Failed");
                    });
            },
            set_mute: function (req, inAction) {
                debug("set_mute: action=%s", inAction);

                const action = !this.state.is_muted ? "on" : "off";
                denon.client
                    .setMute(
                        action === "on"
                            ? Denon.Options.MuteOptions.On
                            : Denon.Options.MuteOptions.Off,
                    )
                    .then(() => {
                        debug("set_mute: Succeeded.");

                        req.send_complete("Success");
                    })
                    .catch((error) => {
                        debug("set_mute: Failed with error: %O", error);
                        req.send_complete("Failed");
                    });
            },
        };
    }
    let result = denon.client
        .getVolume()
        .then((val) => {
            denon.volume_state.volume_value = val - 80;
            return denon.client.getMaxVolume();
        })
        .then((val) => {
            denon.volume_state.volume_max = val - 80;
            return denon.client.getMute();
        })
        .then((val) => {
            denon.volume_state.is_muted = val === Denon.Options.MuteOptions.On;
            if (denon.volume_control) {
                denon.volume_control.update_state(denon.volume_state);
            } else {
                debug("Registering volume control extension");
                denon.volume_control = svc_volume_control.new_device(device);
            }
        });
    return result;
}

function create_source_control(denon) {
    debug("create_source_control: source_control=%o", denon.source_control);
    if (!denon.source_control) {
        denon.source_state = {
            display_name: mysettings.zone === "zone2" ? "Zone 2" : "Main Zone",
            supports_standby: true,
            status: "",
            Power: "",
            Input: "",
        };

        var device = {
            state: denon.source_state,
            control_key: 2,

            convenience_switch: function (req) {
                if (denon.source_state.Power === "STANDBY") {
                    setPowerForZone("ON");
                }

                if (denon.source_state.Input == mysettings.setsource) {
                    req.send_complete("Success");
                } else {
                    denon.client
                        .setInput(mysettings.setsource)
                        .then(() => {
                            req.send_complete("Success");
                        })
                        .catch((error) => {
                            debug("set_source: Failed with error.");
                            req.send_complete("Failed");
                        });
                }
            },
            standby: function (req) {
                getPowerForZone().then((val) => {
                    const newPowerState = val === "STANDBY" ? "ON" : "STANDBY";
                    setPowerBothZones(newPowerState)
                        .then(() => {
                            req.send_complete("Success");
                        })
                        .catch((error) => {
                            debug("set_standby: Failed with error: %O", error);
                            req.send_complete("Failed");
                        });
                });
            },
        };
    }

    let result = getPowerForZone()
        .then((val) => {
            denon.source_state.Power = val;
            return denon.client.getInput();
        })
        .then((val) => {
            denon.source_state.Input = val;
            denon.source_state.status = check_status(
                denon.source_state.Power,
                denon.source_state.Input,
            );
            if (denon.source_control) {
                denon.source_control.update_state(denon.source_state);
            } else {
                debug("Registering source control extension");
                denon.source_control = svc_source_control.new_device(device);
            }
        });
    return result;
}

setup_denon_connection(mysettings.hostname);

roon.start_discovery();