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.1.2",
    publisher: "Doc Bobo",
    email: "docbobo@pm.me",
    website: "https://github.com/docbobo/roon-extension-denon",
});

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

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",
    });
    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;
                mysettings = l.values;
                svc_settings.update_settings(l);
                if (
                    old_hostname != mysettings.hostname ||
                    old_setsource != mysettings.setsource
                )
                    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.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(() => create_volume_control(denon))
        .then(() =>
            mysettings.setsource
                ? create_source_control(denon)
                : Promise.resolve(),
        )
        .then(() => {
            svc_status.set_status("Connected to receiver", false);
        })
        .catch((error) => {
            debug("setup_denon_connection: Error during setup. Retrying...");

            // TODO: Fix error message
            console.log(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;
}

function create_volume_control(denon) {
    debug("create_volume_control: volume_control=%o", denon.volume_control);
    if (!denon.volume_control) {
        denon.volume_state = {
            display_name: "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.");

                        console.log(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.");

                        console.log(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: "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") {
                    denon.client.setPower("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) {
                denon.client.getPower().then((val) => {
                    denon.client
                        .setPower(val === "STANDBY" ? "ON" : "STANDBY")
                        .then(() => {
                            req.send_complete("Success");
                        })
                        .catch((error) => {
                            debug("set_standby: Failed with error.");

                            console.log(error);
                            req.send_complete("Failed");
                        });
                });
            },
        };
    }

    let result = denon.client
        .getPower()
        .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();