iobroker.squeezeboxrpc 2.0.2 → 3.0.0

package/lib/iosbserver.js

@@ -1,18 +1,22 @@
 'use strict';
 
-const dgram = require('node:dgram');
 const { ioUtil } = require('./ioUtil');
-const SqueezeServerNew = require(`${__dirname}/squeezenode/squeezeserver`);
+const { createLmsConnection } = require('./lms/connection');
+const { LmsDiscovery } = require('./lms/discovery');
 const ioSBPlayer = require(`${__dirname}/iosbplayer`);
 
+const SERVER_REFRESH_EVENTS = new Set(['client reconnect', 'client disconnect', 'client new', 'power 0', 'power 1']);
+const PLAYER_REFRESH_EVENTS = new Set(['playlist', 'newmetadata', 'mode', 'play', 'pause', 'stop', 'power', 'mixer']);
+const FULL_PLAYER_REFRESH_EVENTS = new Set(['playlist', 'newmetadata']);
+
 /**
  * Returns the names of all initialized players.
  *
  * @param players - Player collection indexed by player ID.
  * @returns The initialized player names in registration order.
  */
-function getPlayerNames(players) {
-    return Object.values(players || {})
+function getPlayerNames(players = {}) {
+    return Object.values(players)
         .map(player => player?.playername)
         .filter(playername => typeof playername === 'string' && playername.length > 0);
 }
@@ -241,20 +245,46 @@ function IoSbServer(adapter, i18n) {
 
     this.currentStates = {};
     this.players = [];
+    this.pendingFullPlayerRefresh = new Set();
     this.adapter = adapter;
 
     this.adapter.setState('info.connection', false, true);
     this.adapter.subscribeStates('*');
 
-    this.sbServer =
-        adapter.config.username != ''
-            ? new SqueezeServerNew(
-                  `http://${this.adapter.config.server}`,
-                  Number.parseInt(this.adapter.config.port),
-                  adapter.config.username,
-                  adapter.config.password,
-              )
-            : new SqueezeServerNew(`http://${this.adapter.config.server}`, Number.parseInt(this.adapter.config.port));
+    this.sbServer = createLmsConnection({
+        host: this.adapter.config.server,
+        port: Number.parseInt(this.adapter.config.port),
+        username: this.adapter.config.username,
+        password: this.adapter.config.password,
+        connectionType: this.adapter.config.connectionType || 'jsonrpc',
+        webSocketUrl: this.adapter.config.webSocketUrl,
+        useTelnet: this.adapter.config.usetelnet,
+        telnetPort: Number.parseInt(this.adapter.config.telnetport),
+        setTimeout: this.adapter.setTimeout.bind(this.adapter),
+        clearTimeout: this.adapter.clearTimeout.bind(this.adapter),
+        logDebug: message => this.ioUtil.logdebug(message),
+        logError: message => this.ioUtil.logerror(message),
+        onEvent: event => {
+            if (SERVER_REFRESH_EVENTS.has(event.command)) {
+                this.ioUtil.logdebug(`received LMS event ${event.command} for : ${event.playerId}`);
+                this.getServerstatus();
+            }
+            const commandName = event.command.split(' ')[0];
+            if (event.playerId && PLAYER_REFRESH_EVENTS.has(commandName)) {
+                if (FULL_PLAYER_REFRESH_EVENTS.has(commandName)) {
+                    this.pendingFullPlayerRefresh.add(event.playerId);
+                }
+                this.ioUtil.setMyTimeout(
+                    `player-event-${event.playerId}`,
+                    () => {
+                        const forceFull = this.pendingFullPlayerRefresh.delete(event.playerId);
+                        this.players[event.playerId]?.getPlayerUpdateStatus(forceFull);
+                    },
+                    100,
+                );
+            }
+        },
+    });
 
     this.log = {};
 
@@ -262,9 +292,7 @@ function IoSbServer(adapter, i18n) {
     this.errcnt = -1;
     this.connected = 0;
     this.firstStart = true;
-    this.server = null;
-    this.telnet = null;
-    this.otherserver = [];
+    this.discovery = null;
 
     /**
      * Initialization function of the Server object.
@@ -280,7 +308,7 @@ function IoSbServer(adapter, i18n) {
         this.setState('connection', true, 'info');
         this.doObserverServer();
         this.doObserverFavorites();
-        this.doTelnet();
+        this.sbServer.start();
     };
     /**
      * Observes the server status at regular intervals.
@@ -388,10 +416,10 @@ function IoSbServer(adapter, i18n) {
      */
     this.discoverLMS = function (command, message, from, callback) {
         this.ioUtil.logdebug(`discoverLMS ${JSON.stringify(message)}`);
-        const data = [];
-        for (const [, srv] of Object.entries(this.otherserver)) {
-            data.push({ label: `${srv.NAME}/${srv.ADDRESS}`, value: srv.ADDRESS });
-        }
+        const data = (this.discovery?.getServers() || []).map(srv => ({
+            label: `${srv.NAME}/${srv.ADDRESS}`,
+            value: srv.ADDRESS,
+        }));
         this.adapter.sendTo(from, command, [{ value: '', label: '---' }, ...data], callback);
     };
     /**
@@ -441,38 +469,21 @@ function IoSbServer(adapter, i18n) {
             });
             return;
         }
-        this.server = dgram.createSocket({ type: 'udp4', reuseAddr: true });
-        const broadcastPort = 3483;
-        this.server.bind(broadcastPort, '0.0.0.0', () => {
-            this.server && this.server.setBroadcast(true);
-        });
-        this.server.on('message', async (data, rinfo) => {
-            this.ioUtil.logsilly(`getDiscoverServers: Message resceived ${escape(data.toString())}`);
-            if (data.toString().charAt(0) == 'E') {
-                let msg = data.toString();
-                msg = msg.substr(1);
-                const srv = {};
-                let len = msg.length;
-                let tag, len2, val;
-                while (len > 0) {
-                    tag = msg.substr(0, 4);
-                    len2 = msg.charCodeAt(4);
-                    val = msg.substr(5, len2);
-                    msg = msg.substr(len2 + 5);
-                    len = len - len2 - 5;
-                    srv[tag] = val;
-                }
-                srv['ADDRESS'] = rinfo.address;
-                srv['TIMESTAMP'] = Date.now();
-                this.otherserver[srv['ADDRESS']] = srv;
+        this.discovery = new LmsDiscovery({
+            intervalMs: this.adapter.config.discoveryrefresh * 1000,
+            schedule: (callback, delay) => this.ioUtil.setMyTimeout('discover', callback, delay),
+            cancelSchedule: () => this.ioUtil.clearTimeout('discover'),
+            logDebug: message => this.ioUtil.logdebug(message),
+            onServer: async srv => {
+                const address = String(srv.ADDRESS);
                 const state = {};
                 Object.assign(state, this.sbServerStatus['otherServers']);
-                state.name = srv['ADDRESS'].replace(/\./g, '-');
+                state.name = address.replace(/\./g, '-');
                 state.def = JSON.stringify(srv);
                 await this.createFolder(this.sbServerStatus['otherServers'].name, this.ServerStatePath);
                 this.createObject(state, this.ServerStatePath, this.sbServerStatus['otherServers'].name, () => {
                     this.setState(
-                        srv['ADDRESS'].replace(/\./g, '-'),
+                        address.replace(/\./g, '-'),
                         JSON.stringify(srv),
                         this.ServerStatePath,
                         this.sbServerStatus['otherServers'].name,
@@ -484,143 +495,29 @@ function IoSbServer(adapter, i18n) {
                         srv['UUID']
                     }`,
                 );
-            }
-        });
-        this.server.on('error', err => {
-            this.ioUtil.logerror(`Error with Server discovery ${err.message}`);
-            if (err.message.includes('EADDRINUSE')) {
-                this.ioUtil.loginfo("use 'lsof -i -P' to check for ports used.");
-            }
-            try {
-                this.server &&
-                    this.server.close(() => {
-                        this.ioUtil.loginfo('Server discovery deactivated.');
-                        this.server = null;
-                    });
-            } catch (err) {
-                this.ioUtil.logerror(`server.close() ${err.message}`);
-            }
+            },
+            onExpired: srv => {
+                const address = String(srv.ADDRESS);
+                this.delObject(
+                    address.replace(/\./g, '-'),
+                    this.ServerStatePath,
+                    this.sbServerStatus.otherServers.name,
+                );
+                this.ioUtil.logdebug(`Autodiscover: Server removed ${srv.NAME} IP: ${address}`);
+            },
+            onError: err => this.ioUtil.logerror(`Error with Server discovery ${err.message}`),
         });
-        this.ioUtil.setMyTimeout('discover', this.doDiscoverServerSearch, 1000);
-    };
-    /**
-     * Called periodically to send a broadcast message to find other servers,
-     * and remove old entries from the list.
-     *
-     */
-    this.doDiscoverServerSearch = () => {
-        this.ioUtil.logdebug('doDiscoverServerSearch');
-        const msg = Buffer.from('eIPAD\0NAME\0JSON\0UUID\0VERS');
-        const broadcastAddress = '255.255.255.255';
-        const broadcastPort = 3483;
-        this.getStates('*', this.ServerStatePath, this.sbServerStatus['otherServers'].name, (err, states) => {
-            for (const id in states) {
-                const srv = JSON.parse(states[id]?.val || '{}');
-                if ((Date.now() - srv.TIMESTAMP) / 1000 > 60) {
-                    this.delObject(id);
-                    this.ioUtil.logdebug(
-                        `Autodiscover: Server removed ${srv['NAME']} IP: ${srv['ADDRESS']} Port ${
-                            srv['JSON']
-                        } UUID ${srv['UUID']}`,
-                    );
-                }
-            }
-        });
-        if (!this.server) {
-            return;
-        }
-        this.server.send(msg, 0, msg.length, broadcastPort, broadcastAddress, err => {
-            if (err) {
-                this.ioUtil.logerror(err);
-            }
-        });
-        this.ioUtil.setMyTimeout(
-            'discover',
-            this.doDiscoverServerSearch.bind(this),
-            this.adapter.config.discoveryrefresh * 1000,
-        );
+        this.discovery.start();
     };
     /**
      * Close the UDP server for discovery mode.
      *
      */
-    this.doDiscoverServerClose = function () {
+    this.doDiscoverServerClose = () => {
         this.ioUtil.logdebug('doDiscoverServerClose');
-        this.server && this.server.close();
-    };
-    /**
-     * Connect to the LMS server via Telnet, login and listen for player events.
-     *
-     */
-    this.doTelnet = () => {
-        this.ioUtil.logdebug('doTelnet');
-        if (!this.adapter.config.usetelnet) {
-            return;
-        }
-        const net = require('node:net');
-        this.telnet = net.createConnection(
-            { host: this.adapter.config.server, port: this.adapter.config.telnetport },
-            () => {
-                this.ioUtil.logdebug('doTelnet connected to server!');
-                this.telnet.write(`login ${this.adapter.config.username} ${this.adapter.config.password}\r\n`);
-                this.telnet.write('listen 1\r\n');
-            },
-        );
-        this.telnet.on('data', data => {
-            this.ioUtil.logdebug(`doTelnet received Data: ${data.toString()}`);
-            //console.log(decodeURIComponent(data.toString()));
-            const regex = /^((?:[0-9A-Fa-f]{2}[:-]){5}(?:[0-9A-Fa-f]{2}))\s*(.*)/gm;
-            let m;
-            const cmdQueue = decodeURIComponent(data.toString()).split('\r\n');
-            for (const cmd of cmdQueue) {
-                if ((m = regex.exec(cmd)) !== null) {
-                    const command = m[2].trim();
-                    if (command == 'client reconnect') {
-                        this.ioUtil.logdebug(`doTelnet received reconnect for : ${m[1]}`);
-                        this.getServerstatus();
-                    }
-                    if (command == 'client disconnect') {
-                        this.ioUtil.logdebug(`doTelnet received disconnect for : ${m[1]}`);
-                        this.getServerstatus();
-                    }
-                    if (command == 'client new') {
-                        this.ioUtil.logdebug(`doTelnet received client new for : ${m[1]}`);
-                        this.getServerstatus();
-                    }
-                    if (command == 'power 0') {
-                        this.ioUtil.logdebug(`doTelnet received power off : ${m[1]}`);
-                        this.getServerstatus();
-                    }
-                    if (command == 'power 1') {
-                        this.ioUtil.logdebug(`doTelnet received power on : ${m[1]}`);
-                        this.getServerstatus();
-                    }
-                }
-            }
-        });
-        this.telnet.on('end', () => {
-            this.ioUtil.logdebug('doTelnet disconnected from server');
-        });
-        this.telnet.on('timeout', () => {
-            this.ioUtil.logdebug('doTelnet Socket timeout, closing');
-            this.telnet.close();
-        });
-        this.telnet.on('error', err => {
-            this.ioUtil.logdebug(`doTelnet Socket error: ${err.message}`);
-        });
-        this.telnet.on('close', err => {
-            this.ioUtil.logdebug(`doTelnet Socket closed ${err.message}`);
-        });
+        this.discovery?.close();
+        this.discovery = null;
     };
-    /**
-     * Closes the Telnet connection by ending the socket connection with the server.
-     * Logs the action for debugging purposes.
-     */
-    this.doTelnetClose = function () {
-        this.ioUtil.logdebug('doTelnetClose');
-        this.telnet.end();
-    };
-
     /**
      * Closes all active connections by invoking the appropriate closing
      * methods for Telnet and Discovery servers based on the adapter configuration.
@@ -632,12 +529,10 @@ function IoSbServer(adapter, i18n) {
         for (const key in this.players) {
             this.players[key].ioUtil.closeConnections();
         }
-        if (this.adapter.config.usetelnet) {
-            this.doTelnetClose();
-        }
         if (this.adapter.config.usediscovery) {
             this.doDiscoverServerClose();
         }
+        this.sbServer.close();
     };
     /**
      * Retrieves the current server status and sync group information.
@@ -1298,7 +1193,7 @@ function IoSbServer(adapter, i18n) {
         this.adapter.log.info(s);
     }; */
     this.getDiscoverServers();
-    this.sbServer.on('register', this.init.bind(this));
+    this.init();
 }
 module.exports = IoSbServer;
 module.exports.getPlayerNames = getPlayerNames;

package/lib/lms/client.js

@@ -0,0 +1,22 @@
+'use strict';
+
+const { LmsJsonRpcClient } = require('./jsonRpcClient');
+const { LmsWebSocketClient } = require('./webSocketClient');
+
+/**
+ * Creates the configured LMS connection.
+ *
+ * Keeping transport selection in one place allows an experimental WebSocket
+ * connection to be added without changing server, player or announcement code.
+ *
+ * @param options LMS connection options.
+ * @returns The configured LMS client.
+ */
+function createLmsClient(options) {
+    if (options.connectionType === 'websocket') {
+        return new LmsWebSocketClient(options);
+    }
+    return new LmsJsonRpcClient(options);
+}
+
+module.exports = { createLmsClient };

package/lib/lms/connection.js

@@ -0,0 +1,104 @@
+'use strict';
+
+const { createLmsClient } = require('./client');
+const { LmsTelnetEventClient } = require('./telnetEventClient');
+
+/**
+ * Unified LMS connection facade.
+ *
+ * Commands currently use JSON-RPC. Optional notifications currently use the
+ * LMS CLI connection. Future WebSocket support can replace both behind this
+ * facade without changing adapter server or player code.
+ */
+class LmsConnection {
+    /**
+     * @param {object} options Connection options.
+     * @param {string} options.host LMS host.
+     * @param {number} options.port LMS JSON-RPC port.
+     * @param {string} [options.username] LMS username.
+     * @param {string} [options.password] LMS password.
+     * @param {'jsonrpc'|'websocket'} [options.connectionType] Command transport.
+     * @param {string} [options.webSocketUrl] Independent WebSocket web-server URL.
+     * @param {boolean} [options.useTelnet] Enables LMS CLI notifications.
+     * @param {number} [options.telnetPort] LMS CLI port.
+     * @param {typeof setTimeout} [options.setTimeout] Adapter-managed timer creator.
+     * @param {typeof clearTimeout} [options.clearTimeout] Adapter-managed timer cleanup.
+     * @param {(event: { playerId: string, command: string }) => void} [options.onEvent] Notification callback.
+     * @param {(message: string) => void} [options.logDebug] Debug logger.
+     * @param {(message: string) => void} [options.logError] Error logger.
+     * @param {(options: object) => {
+     * request: (playerId: string, command: unknown[], callback?: (result: object) => void) => Promise<object>,
+     * requestAsync: (playerId: string, command: unknown[]) => Promise<object>, start?: () => void,
+     * close: () => void}} [options.clientFactory]
+     * Command client factory used by tests.
+     * @param {new (options: object) => {start: () => void, close: () => void}} [options.telnetClientClass]
+     * Telnet client class used by tests.
+     */
+    constructor(options) {
+        const clientFactory = options.clientFactory || createLmsClient;
+        this.commandClient = clientFactory(options);
+        this.telnetClient = null;
+
+        if (options.connectionType !== 'websocket' && options.useTelnet) {
+            const TelnetClient = options.telnetClientClass || LmsTelnetEventClient;
+            this.telnetClient = new TelnetClient({
+                host: options.host,
+                port: options.telnetPort || 9090,
+                username: options.username,
+                password: options.password,
+                onEvent: options.onEvent || (() => undefined),
+                logDebug: options.logDebug,
+            });
+        }
+    }
+
+    /** Starts configured push-notification transports. */
+    start() {
+        if ('start' in this.commandClient && typeof this.commandClient.start === 'function') {
+            this.commandClient.start();
+        }
+        this.telnetClient?.start();
+    }
+
+    /**
+     * Delegates a command while retaining the adapter's callback contract.
+     *
+     * @param {string} playerId LMS player ID, or an empty string for server commands.
+     * @param {unknown[]} command LMS command tokens.
+     * @param {(result: object) => void} [callback] Compatibility callback.
+     * @returns {Promise<object>} Pending command result.
+     */
+    request(playerId, command, callback) {
+        return this.commandClient.request(playerId, command, callback);
+    }
+
+    /**
+     * Delegates a command using the promise API.
+     *
+     * @param {string} playerId LMS player ID, or an empty string for server commands.
+     * @param {unknown[]} command LMS command tokens.
+     * @returns {Promise<object>} Pending command result.
+     */
+    requestAsync(playerId, command) {
+        return this.commandClient.requestAsync(playerId, command);
+    }
+
+    /** Closes command and notification transports. */
+    close() {
+        this.telnetClient?.close();
+        this.telnetClient = null;
+        this.commandClient.close();
+    }
+}
+
+/**
+ * Creates the configured LMS connection facade.
+ *
+ * @param {ConstructorParameters<typeof LmsConnection>[0]} options Connection options.
+ * @returns {LmsConnection} Configured connection.
+ */
+function createLmsConnection(options) {
+    return new LmsConnection(options);
+}
+
+module.exports = { LmsConnection, createLmsConnection };

package/lib/lms/discovery.js

@@ -0,0 +1,145 @@
+'use strict';
+
+const dgram = require('node:dgram');
+
+const DISCOVERY_PORT = 3483;
+const BROADCAST_ADDRESS = '255.255.255.255';
+const SERVER_TTL_MS = 60_000;
+
+/**
+ * Parses an LMS UDP discovery response using byte lengths from the protocol.
+ *
+ * @param {Buffer} packet UDP response packet.
+ * @param {string} address Sender address.
+ * @param {number} [timestamp] Reception timestamp.
+ * @returns {Record<string, string | number> | null} Parsed LMS data.
+ */
+function parseDiscoveryResponse(packet, address, timestamp = Date.now()) {
+    if (!Buffer.isBuffer(packet) || packet.length === 0 || packet[0] !== 0x45) {
+        return null;
+    }
+
+    const server = Object.create(null);
+    let offset = 1;
+    while (offset < packet.length) {
+        if (offset + 5 > packet.length) {
+            return null;
+        }
+        const tag = packet.toString('ascii', offset, offset + 4);
+        const valueLength = packet[offset + 4];
+        offset += 5;
+        if (offset + valueLength > packet.length) {
+            return null;
+        }
+        server[tag] = packet.toString('utf8', offset, offset + valueLength);
+        offset += valueLength;
+    }
+    server.ADDRESS = address;
+    server.TIMESTAMP = timestamp;
+    return server;
+}
+
+/** Returns the unchanged LMS UDP discovery request. */
+function createDiscoveryRequest() {
+    return Buffer.from('eIPAD\0NAME\0JSON\0UUID\0VERS');
+}
+
+/** Owns LMS UDP discovery independently from ioBroker state handling. */
+class LmsDiscovery {
+    /**
+     * @param {object} options Discovery options.
+     * @param {number} options.intervalMs Broadcast interval.
+     * @param {(server: Record<string, string | number>) => void | Promise<void>} options.onServer Server callback.
+     * @param {(server: Record<string, string | number>) => void} options.onExpired Expiration callback.
+     * @param {(error: Error) => void} options.onError Error callback.
+     * @param {(message: string) => void} [options.logDebug] Debug logger.
+     * @param {(callback: () => void, delay: number) => void} options.schedule Timer scheduler.
+     * @param {() => void} options.cancelSchedule Timer cancellation.
+     * @param {typeof dgram.createSocket} [options.socketFactory] Socket factory used by tests.
+     */
+    constructor(options) {
+        this.intervalMs = options.intervalMs;
+        this.onServer = options.onServer;
+        this.onExpired = options.onExpired;
+        this.onError = options.onError;
+        this.logDebug = options.logDebug || (() => undefined);
+        this.schedule = options.schedule;
+        this.cancelSchedule = options.cancelSchedule;
+        this.socketFactory = options.socketFactory || dgram.createSocket;
+        this.socket = null;
+        this.servers = new Map();
+        this.closed = false;
+    }
+
+    /** Opens the UDP listener and schedules the first discovery broadcast. */
+    start() {
+        if (this.socket || this.closed) {
+            return;
+        }
+        const socket = this.socketFactory({ type: 'udp4', reuseAddr: true });
+        this.socket = socket;
+        socket.on('message', (packet, remote) => {
+            const server = parseDiscoveryResponse(packet, remote.address);
+            if (!server) {
+                return;
+            }
+            this.servers.set(remote.address, server);
+            Promise.resolve(this.onServer(server)).catch(error => this.onError(error));
+        });
+        socket.on('error', error => {
+            this.onError(error);
+            this.#closeSocket();
+        });
+        socket.bind(DISCOVERY_PORT, '0.0.0.0', () => socket.setBroadcast(true));
+        this.schedule(() => this.search(), 1_000);
+    }
+
+    /** Sends one broadcast, expires stale entries and schedules the next run. */
+    search() {
+        if (!this.socket || this.closed) {
+            return;
+        }
+        const now = Date.now();
+        for (const [address, server] of this.servers) {
+            if (now - Number(server.TIMESTAMP) > SERVER_TTL_MS) {
+                this.servers.delete(address);
+                this.onExpired(server);
+            }
+        }
+        this.socket.send(createDiscoveryRequest(), DISCOVERY_PORT, BROADCAST_ADDRESS, error => {
+            if (error) {
+                this.onError(error);
+            }
+        });
+        this.schedule(() => this.search(), this.intervalMs);
+    }
+
+    /** Returns currently known non-expired servers. */
+    getServers() {
+        const now = Date.now();
+        return [...this.servers.values()].filter(server => now - Number(server.TIMESTAMP) <= SERVER_TTL_MS);
+    }
+
+    /** Stops timers and closes the UDP socket. */
+    close() {
+        this.closed = true;
+        this.cancelSchedule();
+        this.#closeSocket();
+        this.servers.clear();
+    }
+
+    #closeSocket() {
+        const socket = this.socket;
+        this.socket = null;
+        if (!socket) {
+            return;
+        }
+        try {
+            socket.close();
+        } catch (error) {
+            this.logDebug(`LMS discovery socket close failed: ${error.message}`);
+        }
+    }
+}
+
+module.exports = { createDiscoveryRequest, LmsDiscovery, parseDiscoveryResponse };