iobroker.squeezeboxrpc 1.3.11 → 1.3.12

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2024 oweitman <oweitman@gmx.de>
+Copyright (c) 2019-2024 oweitman <oweitman@gmx.de>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -201,6 +201,12 @@ For more information visit the CLI-documentation:
   Placeholder for the next version (at the beginning of the line):
    ### **WORK IN PROGRESS**
 -->
+### 1.3.12 (2024-08-05)
+
+-   improve cmdGoto handling by kairauer, close PR #74
+-   fix issues from adapter checker
+-   integrate squeezenode lib
+
 ### 1.3.11 (2024-08-05)
 
 -   update adapter structure and switch to jsonconfig

package/io-package.json

@@ -1,8 +1,21 @@
 {
   "common": {
     "name": "squeezeboxrpc",
-    "version": "1.3.11",
+    "version": "1.3.12",
     "news": {
+      "1.3.12": {
+        "en": "improve cmdGoto handling by kairauer, close PR #74\nfix issues from adapter checker\nintegrate squeezenode lib",
+        "de": "verbessern cmd Goto Handling von kairauer, close PR #74\nprobleme von adapter checker beheben\npressnode lib integrieren",
+        "ru": "улучшить смс Goto handling by kairauer, close PR #74\nпроблемы с адаптером\nинтегрировать сжимнод lib",
+        "pt": "melhorar cm Goto manipulação por kairauer, close PR #74\ncorrigir problemas do verificador do adaptador\nintegrar o espremido lib",
+        "nl": "verbetering cmd Ga naar behandeling door Kairauer, sluit PR #74\nproblemen oplossen van adaptercontrole\nintegreer crownode lib",
+        "fr": "améliorer cmd Goto manipulation par kairauer, fermer PR #74\ncorrection des problèmes de l'adaptateur checker\nintégrer la lib de pressingnode",
+        "it": "migliorare cmd Goto handling by kairauer, close PR #74\nrisolvere problemi da adattatore checker\nintegrare compressione lib",
+        "es": "mejorar cmd Goto manejo por kairauer, cerrar PR #74\nsolucionar problemas desde el control de adaptador\nintegrar el exprimido lib",
+        "pl": "poprawić cmd Goto handling by kairauer, close PR # 74\nnaprawianie problemów z sprawdzaczem adaptera\nzintegrować lib wyciskacza",
+        "uk": "поліпшення cmd Goto обслуговування за допомогою kairauer, Закрити PR #74\nвиправити проблеми з перевіркою адаптера\nінтегрувати squeezenode lib",
+        "zh-cn": "改进 cmd 由Kairauer处理\n从适配器检查器中校正问题\n集成压缩节点 lib"
+      },
       "1.3.11": {
         "en": "update adapter structure and switch to jsonconfig",
         "de": "adapterstruktur aktualisieren und auf jsonconfig wechseln",
@@ -80,22 +93,8 @@
         "pl": "* naprawiono tworzenie obiektów w stanach",
         "uk": "* виправити створення об'єктів станів",
         "zh-cn": "* 修复状态的对象创建"
-      },
-      "1.3.5": {
-        "en": "* fix object creation for favorites",
-        "de": "* Objekterstellung für Favoriten korrigiert",
-        "ru": "* исправлено создание объектов для избранного",
-        "pt": "* corrigir a criação de objetos para favoritos",
-        "nl": "* probleem met het maken van objecten voor favorieten",
-        "fr": "* correction de la création d'objets pour les favoris",
-        "it": "* corretta la creazione di oggetti per i preferiti",
-        "es": "* arreglar la creación de objetos para favoritos",
-        "pl": "* naprawiono tworzenie obiektów dla ulubionych",
-        "uk": "* виправлено створення об'єктів для обраних",
-        "zh-cn": "* 修复收藏夹的对象创建"
       }
     },
-    "title": "SqueezeboxRPC: Controller for Logitech media Server over RPC-protokol",
     "titleLang": {
       "en": "SqueezeboxRPC: Controller for Logitech media Server over RPC-protokol",
       "de": "SqueezeboxRPC: Controller für Logitech Media Server über RPC-Protokoll",
@@ -126,17 +125,16 @@
       "oweitman <oweitman@gmx.de>"
     ],
     "keywords": [
-      "ioBroker",
-      "template",
-      "Smart Home",
-      "home automation"
+      "squeezebox",
+      "LMS",
+      "Logitech Media Server",
+      "music server"
     ],
     "licenseInformation": {
       "type": "free",
       "license": "MIT"
     },
     "platform": "Javascript/Node.js",
-    "main": "squeezeboxrpc.js",
     "icon": "squeezeboxrpc.png",
     "enabled": true,
     "extIcon": "https://raw.githubusercontent.com/oweitman/ioBroker.squeezeboxrpc/main/admin/squeezeboxrpc.png",
@@ -157,7 +155,7 @@
     },
     "dependencies": [
       {
-        "js-controller": ">=3.3.22"
+        "js-controller": ">=5.0.19"
       }
     ],
     "globalDependencies": [
@@ -166,6 +164,12 @@
       }
     ]
   },
+  "encryptedNative": [
+    "password"
+  ],
+  "protectedNative": [
+    "password"
+  ],
   "native": {
     "server": "0.0.0.0",
     "port": 9000,

package/lib/iosbplayer.js

@@ -752,6 +752,12 @@ function ioSBPlayer(server, playerdata) {
             }
         }
         if (idParts[0] == "cmdGoTime") {
+            // state.val needs to be a string, although the time is set in seconds
+            // when settings cmdGoTime via ioBroker.simple-api its not possible to submit a number as string
+            // if we receive a number, we need to cast this to a string
+            if (typeof state.val === "number") {
+                state.val = state.val.toString();
+            }
             if (state.val.trim() !== "" && !isNaN(state.val.trim())) {
                 this.request(this.playerid, ["time", state.val.trim()]);
                 this.setState(idParts[0], " ", this.statePath, this.playername, false);

package/lib/iosbserver.js

@@ -3,7 +3,7 @@
 
 //const utils = require('@iobroker/adapter-core');
 const dgram = require('dgram');
-const SqueezeServer = require('squeezenode-oweitman');
+const SqueezeServerNew = require(__dirname + '/squeezenode/squeezeserver');
 const ioSBPlayer = require(__dirname + '/iosbplayer');
 
 function IoSbServer(adapter) {
@@ -212,7 +212,7 @@ function IoSbServer(adapter) {
     this.adapter.setState('info.connection', false, true);
     this.adapter.subscribeStates('*');
 
-    this.sbServer = (adapter.config.username != "") ? new SqueezeServer('http://' + this.adapter.config.server, Number.parseInt(this.adapter.config.port), adapter.config.username, adapter.config.password) : new SqueezeServer('http://' + this.adapter.config.server, Number.parseInt(this.adapter.config.port));
+    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.log = {};
     this.islogsilly = this.adapter.config.outputserversilly;

package/lib/squeezenode/squeezeplayer.js

@@ -0,0 +1,483 @@
+/*
+ The MIT License (MIT)
+ Copyright (c) 2013-2015 Piotr Raczynski, pio[dot]raczynski[at]gmail[dot]com
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+ The above copyright notice and this permission notice shall be included in all
+ copies or substantial portions of the Software.
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ SOFTWARE.
+ */
+
+var _ = require('lodash');
+var inherits = require('super');
+var SqueezeRequest = require('./squeezerequest');
+
+/**
+ * Create a SqueezePlayer object
+ *
+ * @param playerId The ID of the player
+ * @param name The name of the player
+ * @param address The URL of the server
+ * @param port The port that the server listens on
+ * @param username The username for authentication
+ * @param password The password for authentication
+ */
+
+function SqueezePlayer(playerId, name, address, port, username, password) {
+
+    this.playerId = playerId;
+    this.name = name;
+
+    SqueezePlayer.super_.apply(this, [address, port, username, password]);
+
+    /**
+     * @method callMethod
+     *
+     * You can use this function to call any available method in the Logitech
+     * Media Server API. The documentation for the API can be found here -
+     * `http://<your-server-ip>:9000/html/docs/help.html`
+     *
+     * ...then click on "Technical Information"
+     * ...then click on "The Logitech Media Server Command Line Interface"
+     *
+     * (God, they don't make it easy...)
+     *
+     * You can then use `callMethod` for anything, like so,
+     * @example
+     * squeezePlayer.callMethod({
+     *     playerId: myPlayerId,
+     *     method: 'mixer',
+     *     params: ['volume', '?'],
+     *     callback: myCallbackFunction
+     * });
+     *
+     * While `callMethod` can be used to execute any of the LMS API methods, the additional
+     * functions below (e.g `play`, `clearPlayList`, etc) may be more convenient and easier
+     * to remember. Use whichever you prefer. `callMethod` is designed to provide flexibility
+     * for calling methods that have not been explicitly defined on the SqueezePlayer
+     * object. Plus, it supports promises! 🙀
+     *
+     * @param Object opts - The options object for the request.
+     * @param string opts.method - The method name. Required.
+     * @param array opts.params - The additional parameters for the request. Required.
+     * @param function [opts.callback] - The callback function. Optional. If you don't
+     *                                   provide a callback, a promise will be returned.
+     * @throws Throws an error is opts.method is empty.
+     * @returns Promise|Undefined
+     *
+     */
+
+    this.callMethod = function (opts) {
+
+        if (_.isUndefined(opts.method)) {
+            throw Error('Method name missing.');
+        }
+
+        var params = _.flatten([
+            _.get(opts, 'method'),
+            _.get(opts, 'params'),
+        ]);
+
+        var cb = _.get(opts, 'callback');
+
+        if (cb) {
+            this.request(this.playerId, params, cb);
+        } else {
+            return new Promise(_.bind(function (resolve, reject) {
+                this.request(
+                    this.playerId,
+                    params,
+                    function (result) {
+                        if (!result.ok) {
+                            reject(result);
+                        } else {
+                            resolve(result);
+                        }
+                    }
+                );
+            }, this));
+        }
+    };
+
+    /**
+     * Clear the playlist for this player.
+     *
+     * @param callback The function to call with the result
+     */
+
+    this.clearPlayList = function (callback) {
+        this.request(playerId, ["playlist", "clear"], callback);
+    };
+
+    /**
+     * Get the current state of the player. i.e. playing, paused or stopped.
+     *
+     * @param callback The function to call with the result
+     */
+
+    this.getMode = function (callback) {
+        this.request(playerId, ["mode", "?"], callback);
+    };
+
+    /**
+     * Set the name of the player.
+     *
+     * @param name The new name for the player
+     * @param callback The function to call with the result
+     */
+
+    this.setName = function (name, callback) {
+        this.request(playerId, ["name", name], callback);
+    };
+
+    /**
+     * Get the name of the player.
+     *
+     * @param callback The function to call with the result
+     */
+
+    this.getName = function (callback) {
+        this.request(playerId, ["name", "?"], callback);
+    };
+
+    /**
+     * Get the title of the current song playing.
+     *
+     * @param callback The function to call with the result
+     */
+
+    this.getCurrentTitle = function (callback) {
+        this.request(playerId, ["current_title", "?"], function (reply) {
+            if (reply.ok)
+                reply.result = reply.result._current_title;
+            callback(reply);
+        });
+    };
+
+    /**
+     * Get the artist of the current song playing.
+     *
+     * @param callback The function to call with the result
+     */
+
+    this.getArtist = function (callback) {
+        this.request(playerId, ["artist", "?"], function (reply) {
+            if (reply.ok)
+                reply.result = reply.result._artist;
+            callback(reply);
+        });
+    };
+
+    /**
+     * Get the album of the current song playing.
+     *
+     * @param callback The function to call with the result
+     */
+
+    this.getAlbum = function (callback) {
+        this.request(playerId, ["album", "?"], function (reply) {
+            if (reply.ok)
+                reply.result = reply.result._album;
+            callback(reply);
+        });
+    };
+
+    /**
+     * Get the remoteMeta part of the status of the player.
+     *
+     * @param callback The function to call with the result
+     */
+
+    this.getCurrentRemoteMeta = function (callback) {
+        this.request(playerId, ["status"], function (reply) {
+            if (reply.ok)
+                reply.result = reply.result.remoteMeta;
+            callback(reply);
+        });
+    };
+
+    /**
+     * Get the complete status of the player.
+     *
+     * @param callback The function to call with the result
+     */
+
+    this.getStatus = function (callback) {
+        this.request(playerId, ["status"], callback);
+    };
+
+    /**
+     * Get the status with part of the current playlist.
+     *
+     * @param from The place in the playlist to start getting information
+     * @param to The place in the playlist to get information up to
+     * @param callback The function to call with the result
+     */
+
+    this.getStatusWithPlaylist = function (from, to, callback) {
+        this.request(playerId, ["status", from, to], function (reply) {
+            if (reply.ok)
+                reply.result = reply.result;
+            callback(reply);
+        });
+    };
+
+    /**
+     * Get a portion of the playlist.
+     *
+     * @param from The place in the playlist to start getting information
+     * @param to The place in the playlist to get information up to
+     * @param callback The function to call with the result
+     */
+
+    this.getPlaylist = function (from, to, callback) {
+        this.request(playerId, ["status", from, to], function (reply) {
+            if (reply.ok)
+                reply.result = reply.result.playlist_loop;
+            callback(reply);
+        });
+    };
+
+    /**
+     * Start the player playing.
+     *
+     * @param callback The function to call with the result
+     */
+
+    this.play = function (callback) {
+        this.request(playerId, ["play"], callback);
+    };
+
+    /**
+     * Play a specific song in the playlist.
+     *
+     * @param index The index of the song to play.
+     * @param callback The function to call with the result
+     */
+
+    this.playIndex = function (index, callback) {
+        this.request(playerId, ["playlist", "index", index], callback);
+    };
+
+    /**
+     * Pause or unpause the player.
+     *
+     * @param state 1 to pause, 0 to unpause
+     * @param callback The function to call with the result
+     */
+
+    this.pause = function (state, callback) {
+        this.request(playerId, ["pause", state ? "1" : "0"], callback);
+    };
+
+    /**
+     * Toggle the pause state of the player.
+     *
+     * @param callback The function to call with the result
+     */
+
+    this.togglepause = function (callback) {
+        this.request(playerId, ["pause"], callback);
+    };
+
+    /**
+     * Move the player to the previous song in the playlist.
+     *
+     * @param callback The function to call with the result
+     */
+
+    this.previous = function (callback) {
+        this.request(playerId, ["button", "jump_rew"], callback);
+    };
+
+    /**
+     * Move the player to the next song in the playlist.
+     *
+     * @param callback The function to call with the result
+     */
+
+    this.next = function (callback) {
+        this.request(playerId, ["button", "jump_fwd"], callback);
+    };
+
+    /**
+     * Delete a song from the playlist.
+     *
+     * @param index The index of the song to delete
+     * @param callback The function to call with the result
+     */
+
+    this.playlistDelete = function (index, callback) {
+        this.request(playerId, ["playlist", "delete", index], callback);
+    };
+
+    /**
+     * Move a song in the playlist.
+     *
+     * @param fromIndex The index to move the song from
+     * @param toIndex The index to move the song to
+     * @param callback The function to call with the result
+     */
+
+    this.playlistMove = function (fromIndex, toIndex, callback) {
+        this.request(playerId, ["playlist", "move", fromIndex, toIndex], callback);
+    };
+
+    /**
+     * Save the current playlist.
+     *
+     * @param playlistName The name to save the playlist as.
+     * @param callback The function to call with the result
+     */
+
+    this.playlistSave = function (playlistName, callback) {
+        this.request(playerId, ["playlist", "save", playlistName], callback);
+    };
+
+    /**
+     * Sync the current player to another.
+     *
+     * @param syncTo The index or playerId to sync to
+     * @param callback The function to call with the result
+     */
+
+    this.sync = function (syncTo, callback) {
+        this.request(playerId, ["sync", syncTo], callback);
+    };
+
+    /**
+     * Unsync the current player.
+     *
+     * @param callback The function to call with the result
+     */
+
+    this.unSync = function (callback) {
+        this.request(playerId, ["sync", "-"], callback);
+    };
+
+    /**
+     * Move the playback of the current song to a specific point.
+     *
+     * @param seconds The time in the song to move to
+     * @param callback The function to call with the result
+     */
+
+    this.seek = function (seconds, callback) {
+        this.request(playerId, ["time", seconds], callback);
+    };
+
+    /**
+     * Set the volume of the player.
+     *
+     * @param volume The volume to set to between 0 and 100
+     * @param callback The function to call with the result
+     */
+
+    this.setVolume = function (volume, callback) {
+        this.request(playerId, ["mixer", "volume", volume], callback);
+    };
+
+    /**
+     * Get the current volume of the player.
+     *
+     * @param callback The function to call with the result
+     */
+
+    this.getVolume = function (callback) {
+        this.request(playerId, ["mixer", "volume", "?"], function (reply) {
+            if (reply.ok)
+                reply.result = reply.result._volume;
+            callback(reply);
+        });
+    };
+
+    /**
+     * Create and play a random list.
+     *
+     * @param target The type of list to generate, e.g. tracks, albums, contributors, year
+     * @param callback The function to call with the result
+     */
+
+    this.randomPlay = function (target, callback) {
+        this.request(playerId, ["randomplay", target], callback);
+    };
+
+    /**
+     * Turn on or off the player.
+     *
+     * @param state 0 to turn the player off, 0 to turn it on
+     * @param callback The function to call with the result
+     */
+
+    this.power = function (state, callback) {
+        this.request(playerId, ["power", state ? "1" : "0"], callback);
+    };
+
+    /**
+     * Play a favourite
+     *
+     * @param favorite The ID of the item to play
+     * @param callback The function to call with the result
+     */
+
+    this.playFavorite = function (favorite, callback) {
+        this.request(playerId, ["favorites", "playlist", "play", "item_id:" + favorite], callback);
+    };
+
+    /**
+     * Add an item to the playlist.
+     *
+     * @param item The item to add to the playlist
+     * @param callback The function to call with the result
+     */
+
+    this.addToPlaylist = function (item, callback) {
+        this.request(playerId, ["playlist", "add", item], callback);
+    };
+
+    /**
+     * Insert an item into the playlist to be played immediately.
+     *
+     * @param item The item to insert
+     * @param callback The function to call with the result
+     */
+
+    this.insertToPlaylist = function (item, callback) {
+        this.request(playerId, ["playlist", "insert", item], callback);
+    };
+
+    /**
+     * Set the shuffle state of the current playlist.
+     *
+     * @param state The state to set the list to, 0 no shuffle, 1 to shuffle
+     * @param callback The function to call with the result
+     */
+
+    this.shuffle = function (state, callback) {
+        this.request(playerId, ["playlist", "shuffle", state ? "1" : "0"], callback);
+    };
+
+    /**
+     * Function to set Linein mode on Squeezebox Boom
+     *
+     * @param callback The function to call with the result
+     */
+
+    this.setLinein = function (callback) {
+        this.request(playerId, ["setlinein", "linein"], callback);
+    };
+}
+
+inherits(SqueezePlayer, SqueezeRequest);
+
+module.exports = SqueezePlayer;

package/lib/squeezenode/squeezerequest.js

@@ -0,0 +1,265 @@
+/*
+ The MIT License (MIT)
+
+ Copyright (c) 2013-2015 Piotr Raczynski, pio[dot]raczynski[at]gmail[dot]com
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all
+ copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ SOFTWARE.
+ */
+
+const jayson = require("jayson");
+const inherits = require("super");
+let AWS;
+
+
+// address "<http|https>://|hostbame[:port]"
+// transport "<[0-9]*|sqs[://region]|ssh://password:username@hostname:port"
+// sqs password = {send: "Queue URL, recv "Queue URL" }
+
+function SqueezeRequest(address, port, username, password) {
+    // FIXME URI
+    this.address = (typeof address !== "string") ? "localhost" : address;
+    this.port = (port !== undefined) ? port : 9000;
+    this.username = username;
+    this.password = password;
+    this.id = "squeezenode." + process.pid;// FIXME lamba seems to be 1 always add instance?
+    this.queue = [];
+    const that = this;
+
+    /**
+     * Function to handle responses
+     *
+     * @param err An error message
+     * @param reply The reply
+     * @param callback The function to call with the result
+     */
+    function handle(err, reply, callback) {
+        let result = {};
+        if (err) {
+            result = err;
+            result.ok = false;
+        } else {
+            result = reply;
+            result.ok = true;
+        }
+
+        if (callback)
+            callback(result);
+    }
+
+    // Set up to use an AWS SQS queue URL to communicate
+    if (typeof port === "string" && port.substr(0, 3) === "ssh") {
+        const { URL } = require("url");
+        const turl = new URL(this.port);
+        const surl = new URL(this.address);
+        const fp = 9192;
+        const Tunnel = require("tunnel-ssh");
+        const tunnel_config = {
+            // transport url
+            host: turl.hostname,
+            port: (turl.port) ? turl.port : 22,
+            username: turl.username,
+            // server url
+            dstPort: (surl.port) ? surl.port : 9000,
+            dstHost: surl.hostname,
+            // forward url?
+            localPort: fp,
+            //localHost: ,
+            keepAlive: true,
+        };
+        const tp = decodeURIComponent(turl.password);
+        console.log(tp);
+        if (tp.substr(0, 7) === "file://") {
+            tunnel_config["privateKey"] = require("fs").readFileSync(tp.substr(7));
+        } else {
+            tunnel_config["password"] = turl.password;
+        }
+        console.log(tunnel_config);
+        this.ssh_tunnel = Tunnel(tunnel_config, function (error, server) {
+            if (error) {
+                console.log(error);
+            }
+        });
+
+        // Use a listener to handle errors outside the callback
+        this.ssh_tunnel.on("error", function (err) {
+            console.error("SSH Tunnel:", err);
+            console.log("Tunnel error");
+        });
+        this.address = surl.protocol + "//localhost";
+        this.port = fp;
+        console.log(surl);
+    }
+
+    if (typeof this.port === "string" && this.port.substr(0, 6) === "awssqs") {
+        AWS = require("aws-sdk");
+        this.request = request_sqs;
+        // FIXME decode region from url
+        this.sqs = new AWS.SQS({ region: "us-west-2" });
+        this.sendq = { QueueUrl: password.send, MessageGroupId: this.id };
+        this.recvq = { QueueUrl: password.recv, WaitTimeSeconds: 0, MaxNumberOfMessages: 10 };
+        this.reciving = true;
+        this.sqs.receiveMessage(that.recvq, function (err, reply) {
+            that.recvq.MaxNumberOfMessages = 1;
+            that.recvq.WaitTimeSeconds = 20;
+            if (reply.Messages) {
+                let msg = reply.Messages.pop();
+                while (msg) {
+                    const deleteParams = {
+                        QueueUrl: that.recvq.QueueUrl,
+                        ReceiptHandle: msg.ReceiptHandle
+                    };
+                    that.sqs.deleteMessage(deleteParams, function (err, data) {
+                        //
+                    });
+                    msg = reply.Messages.pop();
+                }
+            }
+            request_sqs_dispatch_queue();
+        }); //Drain Q.
+
+    } else {
+        // Use JSON RPC to communicate
+        this.request = request_rpc;
+
+        const jsonrpc = (typeof this.port === "number") ? this.address + ":" + this.port + "/jsonrpc.js" : this.address + "/jsonrpc.js";
+        client = (this.address.substr(0, 5) === "https") ? jayson.client.https(jsonrpc) : client = jayson.client.http(jsonrpc);
+        client.options.version = 1;
+
+        // FIXME URL
+        // Add a header for basic authentication if a username and password are given
+        if (username && password) {
+            if (!client.options.headers)
+                client.options.headers = {};
+            client.options.headers["Authorization"] = formatBasicHeader(username, password);
+        }
+    }
+
+    /**
+     * Request function for JSON RPC
+     *
+     * @param player The target player
+     * @param params Request parameters
+     * @param callback The function to call with the result
+     */
+
+    function request_rpc(player, params, callback) {
+
+        client.request("slim.request", [player, params], that.id, function (err, reply) {
+            handle(err, reply, callback);
+        });
+    }
+
+    /**
+     * Request function to use AWS SQS
+     *
+     * @param player The target player
+     * @param params Request parameters
+     * @param callback The function to call with the result
+     */
+
+    function request_sqs_dispatch(player, params, callback) {
+
+        that.sendq["MessageBody"] = JSON.stringify({
+            "params": [player, params],
+            "id": that.id + process.hrtime(),
+            "version": "1.0",
+            "method": "slim.request"
+        }); // FIXME id not on pid but an uuid? for instrance from env?
+        that.sendq["MessageDeduplicationId"] = that.sendq.MessageGroupId + process.hrtime();
+        //console.log("send ",that.sendq['MessageBody']);
+        that.sqs.sendMessage(that.sendq, function (err, data) {
+            if (err) {
+                handle(err, data, callback);
+                console.error("Send Error ", err);
+            } else {
+                // successful response - callback for reply
+                that.reciving = true;
+                that.sqs.receiveMessage(that.recvq, function (err, reply) {
+                    //console.log("reply data ",reply);
+                    let message_data = {};
+                    if (reply.Messages) {
+
+                        //id check?
+
+                        message_data = reply.Messages.pop();
+
+                        //delete and drain?
+
+                        let msg = message_data;
+                        message_data = JSON.parse(message_data.Body);
+                        //console.log("reply ",message_data);
+                        while (msg) {
+                            const deleteParams = {
+                                QueueUrl: that.recvq.QueueUrl,
+                                ReceiptHandle: msg.ReceiptHandle
+                            };
+                            // FIXME delete error
+                            that.sqs.deleteMessage(deleteParams, function (err, data) {
+                                if (err) {
+                                    console.error("Delete Error", err);
+                                } else {
+                                    //console.log("Message Deleted", data);
+                                }
+                            });
+                            msg = reply.Messages.pop();
+                        }
+
+                    } else {
+                        console.warn("no msgs ", err);
+                        err = "No reply message recvied";
+                    }
+
+                    handle(err, message_data, callback);
+                    request_sqs_dispatch_queue();
+                });
+            }
+        });
+    }
+
+    // We need to serialise requests and responces for queue use
+
+    function request_sqs(player, params, callback) {
+        if (that.reciving) {
+            that.queue.push([player, params, callback]);
+        } else {
+            request_sqs_dispatch(player, params, callback);
+        }
+    }
+
+    function request_sqs_dispatch_queue() {
+        const args = that.queue.pop();
+        if (args) {
+            request_sqs_dispatch.apply(null, args);
+        } else {
+            that.reciving = false;
+        }
+    }
+}
+
+/**
+ * Function to format the header for basic authentication.
+ */
+
+function formatBasicHeader(username, password) {
+    const tok = username + ":" + password;
+    const hash = new Buffer.from(tok).toString("base64");
+    return "Basic " + hash;
+}
+
+module.exports = SqueezeRequest;

package/lib/squeezenode/squeezeserver.js

@@ -0,0 +1,346 @@
+/*
+ The MIT License (MIT)
+
+ Copyright (c) 2013 Piotr Raczynski, pio[dot]raczynski[at]gmail[dot]com
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all
+ copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ SOFTWARE.
+ */
+
+const inherits = require("super");
+const fs = require("fs");
+const SqueezeRequest = require(__dirname + "/squeezerequest");
+const SqueezePlayer = require(__dirname + "/squeezeplayer");
+
+/**
+ * Create a SqueezeServer object
+ *
+ * @param address The URL of the server
+ * @param port The port that the server listens on
+ * @param username The username for authentication
+ * @param password The password for authentication
+ * @param sa A flag to skip apps
+ */
+
+function SqueezeServer(address, port, username, password, sa, sp) {
+
+    SqueezeServer.super_.apply(this, arguments);
+    const defaultPlayer = "00:00:00:00:00:00";
+    const self = this;
+    this.players = [];
+    this.apps = [];
+    const subs = {};
+
+    /**
+     * Subscribe to an event on a channel
+     *
+     * @param channel The channel that received the event
+     * @param sub The callback for the event
+     */
+
+    this.on = function (channel, sub) {
+
+        subs[channel] = subs[channel] || [];
+        subs[channel].push(sub);
+    };
+
+    /**
+     * Send an event.
+     *
+     * @param channel The even channel
+     */
+
+    this.emit = function (channel) {
+
+        const args = [].slice.call(arguments, 1);
+        for (const sub in subs[channel]) {
+            subs[channel][sub].apply(void 0, args);
+        }
+    };
+
+    /**
+     * Method to the the number of players.
+     *
+     * @param callback The function to call with the result.
+     */
+
+    this.getPlayerCount = function (callback) {
+        this.request(defaultPlayer, ["player", "count", "?"], callback);
+    };
+
+    /**
+     * Method to get the ID of a player given it's index
+     *
+     * @param index The index of the player to get the ID for
+     * @param callback The function to call with the result.
+     */
+
+    this.getPlayerId = function (index, callback) {
+        this.request(defaultPlayer, ["player", "id", index, "?"], callback);
+    };
+
+    /**
+     * Method to get the IP address of a player
+     *
+     * @param playerId The ID or index of the player
+     * @param callback The function to call with the result.
+     */
+
+    this.getPlayerIp = function (playerId, callback) {
+        this.request(defaultPlayer, ["player", "ip", playerId, "?"], callback);
+    };
+
+    /**
+     * Method to get the name of a player.
+     *
+     * @param playerId The ID or index of the player
+     * @param callback The function to call with the result.
+     */
+
+    this.getPlayerName = function (playerId, callback) {
+        this.request(defaultPlayer, ["player", "name", playerId, "?"], callback);
+    };
+
+    /**
+     * Get a list of the synchronization group members
+     *
+     * @param callback The function to call with the result.
+     */
+
+    this.getSyncGroups = function (callback) {
+        this.request(defaultPlayer, ["syncgroups", "?"], callback);
+    };
+
+    /**
+     * Get a list of the apps installed in the server
+     *
+     * @param callback The function to call with the result.
+     */
+
+    this.getApps = function (callback) {
+        this.request(defaultPlayer, ["apps", 0, 100], callback);
+    };
+
+    //
+
+    /**
+     * Get the content of a music folder.
+     *
+     * @param folderId The ID of the folder to get. Pass 0 or empty string "" to display root of music folder
+     * @param callback The function to call with the result.
+     */
+
+    this.musicfolder = function (folderId, callback) {
+        this.request(defaultPlayer, ["musicfolder", 0, 100, "folder_id:" + folderId], callback);
+    };
+
+    /**
+     * Get a information about the players.
+     *
+     * @param callback The function to call with the result.
+     */
+
+    this.getPlayers = function (callback) {
+
+        self.request(defaultPlayer, ["players", 0, 100], function (reply) {
+            if (reply.ok)
+                reply.result = reply.result.players_loop;
+            callback(reply);
+        });
+    };
+
+    /**
+     * Get a list of the artists from the server
+     *
+     * @param callback The callback to call with the result
+     * @param limit The maximum number of results
+     */
+
+    this.getArtists = function (callback, limit) {
+
+        self.request(defaultPlayer, ["artists", 0, limit], function (reply) {
+            if (reply.ok)
+                reply.result = reply.result.artists_loop;
+            callback(reply);
+        });
+    };
+
+    /**
+     * Get a list of the albums from the server
+     *
+     * @param callback The callback to call with the result
+     * @param limit The maximum number of results
+     */
+
+    this.getAlbums = function (callback, limit) {
+
+        self.request(defaultPlayer, ["albums", 0, limit], function (reply) {
+            if (reply.ok)
+                reply.result = reply.result.albums_loop;
+            callback(reply);
+        });
+    };
+
+    /**
+     * Get a list of the genre's from the server
+     *
+     * @param callback The callback to call with the result
+     * @param limit The maximum number of results
+     */
+
+    this.getGenres = function (callback, limit) {
+
+        self.request(defaultPlayer, ["genres", 0, limit], function (reply) {
+            if (reply.ok)
+                reply.result = reply.result.genres_loop;
+            callback(reply);
+        });
+    };
+
+    /**
+     * Get a 'info' list from the server
+     *
+     * @param callback The callback to call with the result
+     * @param limit The maximum number of results
+     * @param slot The query to make to the server [genres, albums, artists, playlists ]
+     */
+
+    this.getInfo = function (callback, limit, slot) {
+
+        self.request(defaultPlayer, [slot, 0, limit], function (reply) {
+            if (reply.ok)
+                reply.result = reply.result[slot + "_loop"];
+            callback(reply);
+        });
+    };
+
+    this.registerPlayers = function (players) {
+        for (const pl in players) {
+            if (!self.players[players[pl].playerid]) { // player not on the list
+                self.players[players[pl].playerid] = new SqueezePlayer(players[pl].playerid, players[pl].name, self.address, self.port, self.username, self.password);
+            }
+        }
+    };
+
+    /**
+     * Get Player oject for name, needs the players registred and normisles names with a lc search removeving puntuation
+     *
+     * @param name string
+     * @param only reten the one player if only one
+     */
+    this.findPlayerObjectByName = function (name, only) {
+        name = this.normalizePlayer(name);
+
+        // Look for the player in the players list that matches the given name. Then return the corresponding player object
+        // from the squeezeserver stored by the player's id
+
+        for (const id in this.players) {
+            if (
+                this.normalizePlayer(this.players[id].name) === name || // name matches the requested player
+                (name === "" && (only && this.players.length === 1))      // name is undefined and there's only one player,
+                // so assume that's the one we want.
+            ) {
+                return this.players[id];
+            }
+        }
+        return undefined;
+    };
+
+    /**
+     *  Do any necessary clean up of player names
+     *
+     * @param playerName The name of the player to clean up
+     * @param filter optional fn(str) returns str
+     * @returns The normalized player name
+     */
+
+    this.normalizePlayer = function (playerName) {
+
+        playerName || (playerName = ""); // protect against `playerName` being undefined
+        playerName = playerName.replace("-", " ");
+        playerName = playerName.replace("   ", "  ");
+        playerName = playerName.replace("  ", "  ");
+        playerName = playerName.toLowerCase(playerName);
+
+        return playerName;
+    };
+
+    /**
+     * Find out if we can contact the server and get some basic information
+     *
+     * @param skipApps A flag to skip getting information about the apps
+     */
+
+    function register(skipApps, skipPlayers) {
+
+        if (!skipPlayers) {
+            // Get the list of players from the server
+            self.getPlayers(function (reply) {
+                // Process the player information and create Player objects for each one
+                if (reply.ok)
+                    self.registerPlayers(reply.result);
+
+                // Send a signal that we are done
+                if (skipApps) {
+                    self.emit("register", reply, undefined);
+                } else {
+                    self.emit("registerPlayers", reply);
+                }
+            });
+        }
+
+        if (!skipApps) {
+            // Once the players have been obtained, request a list of the apps
+            self.on("registerPlayers", function (reply) {
+
+                self.getApps(function (areply) {
+
+                    if (areply.ok) {
+
+                        const apps = areply.result.appss_loop;
+                        const dir = __dirname + "/";
+                        fs.readdir(dir, function (err, files) {
+                            files.forEach(function (file) {
+
+                                const fil = file.substr(0, file.lastIndexOf("."));
+                                for (const pl in apps) {
+                                    if (fil === apps[pl].cmd) {
+                                        const app = require(dir + file);
+                                        self.apps[apps[pl].cmd] = new app(defaultPlayer, apps[pl].name, apps[pl].cmd, self.address, self.port, self.username, self.password);
+                                        /* workaround, app needs existing player id so first is used here */
+                                    }
+                                }
+                            });
+
+                            self.emit("register", reply, areply);
+                        });
+
+                    } else {
+                        self.emit("register", reply, areply);
+                    }
+                });
+            });
+        }
+    }
+
+    register(sa, sp);
+}
+
+inherits(SqueezeServer, SqueezeRequest);
+
+module.exports = SqueezeServer;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "iobroker.squeezeboxrpc",
-  "version": "1.3.11",
+  "version": "1.3.12",
   "description": "ioBroker Logitech Squeezebox Adapter over JSON/RPC-Protocol",
   "author": {
     "name": "oweitman",
@@ -10,8 +10,10 @@
   "license": "MIT",
   "keywords": [
     "ioBroker",
-    "Smart Home",
-    "home automation"
+    "squeezebox",
+    "LMS",
+    "Logitech Media Server",
+    "music server"
   ],
   "repository": {
     "type": "git",
@@ -22,7 +24,10 @@
   },
   "dependencies": {
     "@iobroker/adapter-core": "^3.1.6",
-    "squeezenode-oweitman": "https://github.com/oweitman/squeezenode/tarball/master"
+    "jayson": "^3.2.0",
+    "lodash": "^4.17.4",
+    "request": "^2.88.0",
+    "super": "^0.2.3"
   },
   "devDependencies": {
     "@alcalzone/release-script": "^3.8.0",
@@ -40,8 +45,8 @@
     "@types/proxyquire": "^1.3.31",
     "@types/sinon": "^17.0.3",
     "@types/sinon-chai": "^3.2.12",
+    "axios": "^0.28.0",
     "chai": "^4.4.1",
-    "axios": "^0.21.1",
     "chai-as-promised": "^7.1.2",
     "eslint": "^8.57.0",
     "eslint-config-prettier": "^9.1.0",