git.basschouten.com Git - openhab-addons.git/blob

   1 /**
   2  * Copyright (c) 2010-2023 Contributors to the openHAB project
   3  *
   4  * See the NOTICE file(s) distributed with this work for additional
   5  * information.
   6  *
   7  * This program and the accompanying materials are made available under the
   8  * terms of the Eclipse Public License 2.0 which is available at
   9  * http://www.eclipse.org/legal/epl-2.0
  10  *
  11  * SPDX-License-Identifier: EPL-2.0
  12  */
  13 package org.openhab.binding.squeezebox.internal.handler;
  14
  15 import static org.openhab.binding.squeezebox.internal.SqueezeBoxBindingConstants.*;
  16
  17 import java.io.BufferedReader;
  18 import java.io.BufferedWriter;
  19 import java.io.IOException;
  20 import java.io.InputStreamReader;
  21 import java.io.OutputStreamWriter;
  22 import java.net.Socket;
  23 import java.net.URLDecoder;
  24 import java.net.URLEncoder;
  25 import java.nio.charset.StandardCharsets;
  26 import java.time.Duration;
  27 import java.util.ArrayList;
  28 import java.util.Arrays;
  29 import java.util.Base64;
  30 import java.util.Collections;
  31 import java.util.HashMap;
  32 import java.util.HashSet;
  33 import java.util.List;
  34 import java.util.Map;
  35 import java.util.Set;
  36 import java.util.concurrent.Future;
  37 import java.util.concurrent.ScheduledFuture;
  38 import java.util.concurrent.TimeUnit;
  39 import java.util.stream.Collectors;
  40
  41 import org.eclipse.jdt.annotation.NonNullByDefault;
  42 import org.openhab.binding.squeezebox.internal.config.SqueezeBoxServerConfig;
  43 import org.openhab.binding.squeezebox.internal.dto.ButtonDTO;
  44 import org.openhab.binding.squeezebox.internal.dto.ButtonDTODeserializer;
  45 import org.openhab.binding.squeezebox.internal.dto.ButtonsDTO;
  46 import org.openhab.binding.squeezebox.internal.dto.StatusResponseDTO;
  47 import org.openhab.binding.squeezebox.internal.model.Favorite;
  48 import org.openhab.core.io.net.http.HttpRequestBuilder;
  49 import org.openhab.core.library.types.StringType;
  50 import org.openhab.core.thing.Bridge;
  51 import org.openhab.core.thing.Channel;
  52 import org.openhab.core.thing.ChannelUID;
  53 import org.openhab.core.thing.Thing;
  54 import org.openhab.core.thing.ThingStatus;
  55 import org.openhab.core.thing.ThingStatusDetail;
  56 import org.openhab.core.thing.ThingTypeUID;
  57 import org.openhab.core.thing.binding.BaseBridgeHandler;
  58 import org.openhab.core.thing.binding.ThingHandler;
  59 import org.openhab.core.types.Command;
  60 import org.openhab.core.types.UnDefType;
  61 import org.slf4j.Logger;
  62 import org.slf4j.LoggerFactory;
  63
  64 import com.google.gson.Gson;
  65 import com.google.gson.GsonBuilder;
  66 import com.google.gson.JsonSyntaxException;
  67
  68 /**
  69  * Handles connection and event handling to a SqueezeBox Server.
  70  *
  71  * @author Markus Wolters - Initial contribution
  72  * @author Ben Jones - ?
  73  * @author Dan Cunningham - OH2 port
  74  * @author Daniel Walters - Fix player discovery when player name contains spaces
  75  * @author Mark Hilbush - Improve reconnect logic. Improve player status updates.
  76  * @author Mark Hilbush - Implement AudioSink and notifications
  77  * @author Mark Hilbush - Added duration channel
  78  * @author Mark Hilbush - Added login/password authentication for LMS
  79  * @author Philippe Siem - Improve refresh of cover art url,remote title, artist, album, genre, year.
  80  * @author Patrik Gfeller - Support for mixer volume message added
  81  * @author Mark Hilbush - Get favorites from LMS; update channel and send to players
  82  * @author Mark Hilbush - Add like/unlike functionality
  83  */
  84 public class SqueezeBoxServerHandler extends BaseBridgeHandler {
  85     private final Logger logger = LoggerFactory.getLogger(SqueezeBoxServerHandler.class);
  86
  87     public static final Set<ThingTypeUID> SUPPORTED_THING_TYPES_UIDS = Collections
  88             .singleton(SQUEEZEBOXSERVER_THING_TYPE);
  89
  90     // time in seconds to try to reconnect
  91     private static final int RECONNECT_TIME = 60;
  92
  93     // the value by which the volume is changed by each INCREASE or
  94     // DECREASE-Event
  95     private static final int VOLUME_CHANGE_SIZE = 5;
  96     private static final String NEW_LINE = System.getProperty("line.separator");
  97
  98     private static final String CHANNEL_CONFIG_QUOTE_LIST = "quoteList";
  99
 100     private static final String JSONRPC_STATUS_REQUEST = "{\"id\":1,\"method\":\"slim.request\",\"params\":[\"@@MAC@@\",[\"status\",\"-\",\"tags:yagJlNKjcB\"]]}";
 101
 102     private List<SqueezeBoxPlayerEventListener> squeezeBoxPlayerListeners = Collections
 103             .synchronizedList(new ArrayList<>());
 104
 105     private Map<String, SqueezeBoxPlayer> players = Collections.synchronizedMap(new HashMap<>());
 106
 107     // client socket and listener thread
 108     private Socket clientSocket;
 109     private SqueezeServerListener listener;
 110     private Future<?> reconnectFuture;
 111
 112     private String host;
 113
 114     private int cliport;
 115
 116     private int webport;
 117
 118     private String userId;
 119
 120     private String password;
 121
 122     private final Gson gson = new GsonBuilder().registerTypeAdapter(ButtonDTO.class, new ButtonDTODeserializer())
 123             .create();
 124     private String jsonRpcUrl;
 125     private String basicAuthorization;
 126
 127     public SqueezeBoxServerHandler(Bridge bridge) {
 128         super(bridge);
 129     }
 130
 131     @Override
 132     public void initialize() {
 133         logger.debug("initializing server handler for thing {}", getThing().getUID());
 134         scheduler.submit(this::connect);
 135     }
 136
 137     @Override
 138     public void dispose() {
 139         logger.debug("disposing server handler for thing {}", getThing().getUID());
 140         cancelReconnect();
 141         disconnect();
 142     }
 143
 144     @Override
 145     public void handleCommand(ChannelUID channelUID, Command command) {
 146     }
 147
 148     /**
 149      * Checks if we have a connection to the Server
 150      *
 151      * @return
 152      */
 153     public synchronized boolean isConnected() {
 154         if (clientSocket == null) {
 155             return false;
 156         }
 157
 158         // NOTE: isConnected() returns true once a connection is made and will
 159         // always return true even after the socket is closed
 160         // http://stackoverflow.com/questions/10163358/
 161         return clientSocket.isConnected() && !clientSocket.isClosed();
 162     }
 163
 164     public void mute(String mac) {
 165         sendCommand(mac + " mixer muting 1");
 166     }
 167
 168     public void unMute(String mac) {
 169         sendCommand(mac + " mixer muting 0");
 170     }
 171
 172     public void powerOn(String mac) {
 173         sendCommand(mac + " power 1");
 174     }
 175
 176     public void powerOff(String mac) {
 177         sendCommand(mac + " power 0");
 178     }
 179
 180     public void syncPlayer(String mac, String player2mac) {
 181         sendCommand(mac + " sync " + player2mac);
 182     }
 183
 184     public void unSyncPlayer(String mac) {
 185         sendCommand(mac + " sync -");
 186     }
 187
 188     public void play(String mac) {
 189         sendCommand(mac + " play");
 190     }
 191
 192     public void playUrl(String mac, String url) {
 193         sendCommand(mac + " playlist play " + url);
 194     }
 195
 196     public void pause(String mac) {
 197         sendCommand(mac + " pause 1");
 198     }
 199
 200     public void unPause(String mac) {
 201         sendCommand(mac + " pause 0");
 202     }
 203
 204     public void stop(String mac) {
 205         sendCommand(mac + " stop");
 206     }
 207
 208     public void prev(String mac) {
 209         sendCommand(mac + " playlist index -1");
 210     }
 211
 212     public void next(String mac) {
 213         sendCommand(mac + " playlist index +1");
 214     }
 215
 216     public void clearPlaylist(String mac) {
 217         sendCommand(mac + " playlist clear");
 218     }
 219
 220     public void deletePlaylistItem(String mac, int playlistIndex) {
 221         sendCommand(mac + " playlist delete " + playlistIndex);
 222     }
 223
 224     public void playPlaylistItem(String mac, int playlistIndex) {
 225         sendCommand(mac + " playlist index " + playlistIndex);
 226     }
 227
 228     public void addPlaylistItem(String mac, String url) {
 229         addPlaylistItem(mac, url, null);
 230     }
 231
 232     public void addPlaylistItem(String mac, String url, String title) {
 233         StringBuilder playlistCommand = new StringBuilder();
 234         playlistCommand.append(mac).append(" playlist add ").append(url);
 235         if (title != null) {
 236             playlistCommand.append(" ").append(title);
 237         }
 238         sendCommand(playlistCommand.toString());
 239     }
 240
 241     public void setPlayingTime(String mac, int time) {
 242         sendCommand(mac + " time " + time);
 243     }
 244
 245     public void setRepeatMode(String mac, int repeatMode) {
 246         sendCommand(mac + " playlist repeat " + repeatMode);
 247     }
 248
 249     public void setShuffleMode(String mac, int shuffleMode) {
 250         sendCommand(mac + " playlist shuffle " + shuffleMode);
 251     }
 252
 253     public void volumeUp(String mac, int currentVolume) {
 254         setVolume(mac, currentVolume + VOLUME_CHANGE_SIZE);
 255     }
 256
 257     public void volumeDown(String mac, int currentVolume) {
 258         setVolume(mac, currentVolume - VOLUME_CHANGE_SIZE);
 259     }
 260
 261     public void setVolume(String mac, int volume) {
 262         int newVolume = volume;
 263         newVolume = Math.min(100, newVolume);
 264         newVolume = Math.max(0, newVolume);
 265         sendCommand(mac + " mixer volume " + String.valueOf(newVolume));
 266     }
 267
 268     public void showString(String mac, String line) {
 269         showString(mac, line, 5);
 270     }
 271
 272     public void showString(String mac, String line, int duration) {
 273         sendCommand(mac + " show line1:" + line + " duration:" + String.valueOf(duration));
 274     }
 275
 276     public void showStringHuge(String mac, String line) {
 277         showStringHuge(mac, line, 5);
 278     }
 279
 280     public void showStringHuge(String mac, String line, int duration) {
 281         sendCommand(mac + " show line1:" + line + " font:huge duration:" + String.valueOf(duration));
 282     }
 283
 284     public void showStrings(String mac, String line1, String line2) {
 285         showStrings(mac, line1, line2, 5);
 286     }
 287
 288     public void showStrings(String mac, String line1, String line2, int duration) {
 289         sendCommand(mac + " show line1:" + line1 + " line2:" + line2 + " duration:" + String.valueOf(duration));
 290     }
 291
 292     public void playFavorite(String mac, String favorite) {
 293         sendCommand(mac + " favorites playlist play item_id:" + favorite);
 294     }
 295
 296     public void rate(String mac, String rateCommand) {
 297         if (rateCommand != null) {
 298             sendCommand(mac + " " + rateCommand);
 299         }
 300     }
 301
 302     public void sleep(String mac, Duration sleepDuration) {
 303         sendCommand(mac + " sleep " + String.valueOf(sleepDuration.toSeconds()));
 304     }
 305
 306     /**
 307      * Send a generic command to a given player
 308      *
 309      * @param playerId
 310      * @param command
 311      */
 312     public void playerCommand(String mac, String command) {
 313         sendCommand(mac + " " + command);
 314     }
 315
 316     /**
 317      * Ask for player list
 318      */
 319     public void requestPlayers() {
 320         sendCommand("players 0");
 321     }
 322
 323     /**
 324      * Ask for favorites list
 325      */
 326     public void requestFavorites() {
 327         sendCommand("favorites items 0 100");
 328     }
 329
 330     /**
 331      * Login to server
 332      */
 333     public void login() {
 334         if (userId.isEmpty()) {
 335             return;
 336         }
 337         // Create basic auth string for jsonrpc interface
 338         basicAuthorization = new String(
 339                 Base64.getEncoder().encode((userId + ":" + password).getBytes(StandardCharsets.UTF_8)));
 340         logger.debug("Logging into Squeeze Server using userId={}", userId);
 341         sendCommand("login " + userId + " " + password);
 342     }
 343
 344     /**
 345      * Send a command to the Squeeze Server.
 346      */
 347     private synchronized void sendCommand(String command) {
 348         if (getThing().getStatus() != ThingStatus.ONLINE) {
 349             return;
 350         }
 351
 352         if (!isConnected()) {
 353             logger.debug("no connection to squeeze server when trying to send command, returning...");
 354             return;
 355         }
 356
 357         logger.debug("Sending command: {}", sanitizeCommand(command));
 358         try {
 359             BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(clientSocket.getOutputStream()));
 360             writer.write(command + NEW_LINE);
 361             writer.flush();
 362         } catch (IOException e) {
 363             logger.error("Error while sending command to Squeeze Server ({}) ", sanitizeCommand(command), e);
 364         }
 365     }
 366
 367     /*
 368      * Remove password from login command to prevent it from being logged
 369      */
 370     String sanitizeCommand(String command) {
 371         String sanitizedCommand = command;
 372         if (command.startsWith("login")) {
 373             sanitizedCommand = command.replace(password, "**********");
 374         }
 375         return sanitizedCommand;
 376     }
 377
 378     /**
 379      * Connects to a SqueezeBox Server
 380      */
 381     private void connect() {
 382         logger.trace("attempting to get a connection to the server");
 383         disconnect();
 384         SqueezeBoxServerConfig config = getConfigAs(SqueezeBoxServerConfig.class);
 385         this.host = config.ipAddress;
 386         this.cliport = config.cliport;
 387         this.webport = config.webport;
 388         this.userId = config.userId;
 389         this.password = config.password;
 390
 391         if (host.isEmpty()) {
 392             updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.OFFLINE.CONFIGURATION_ERROR, "host is not set");
 393             return;
 394         }
 395         // Create URL for jsonrpc interface
 396         jsonRpcUrl = String.format("http://%s:%d/jsonrpc.js", host, webport);
 397
 398         try {
 399             clientSocket = new Socket(host, cliport);
 400         } catch (IOException e) {
 401             logger.debug("unable to open socket to server: {}", e.getMessage());
 402             updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.OFFLINE.COMMUNICATION_ERROR, e.getMessage());
 403             scheduleReconnect();
 404             return;
 405         }
 406
 407         try {
 408             listener = new SqueezeServerListener();
 409             listener.start();
 410             logger.debug("listener connection started to server {}:{}", host, cliport);
 411         } catch (IllegalThreadStateException e) {
 412             updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.COMMUNICATION_ERROR, e.getMessage());
 413         }
 414         // Mark the server ONLINE. bridgeStatusChanged will cause the players to come ONLINE
 415         updateStatus(ThingStatus.ONLINE);
 416     }
 417
 418     /**
 419      * Disconnects from a SqueezeBox Server
 420      */
 421     private void disconnect() {
 422         try {
 423             if (listener != null) {
 424                 listener.terminate();
 425             }
 426             if (clientSocket != null) {
 427                 clientSocket.close();
 428             }
 429         } catch (Exception e) {
 430             logger.trace("Error attempting to disconnect from Squeeze Server", e);
 431             return;
 432         } finally {
 433             clientSocket = null;
 434             listener = null;
 435         }
 436         players.clear();
 437         logger.trace("Squeeze Server connection stopped.");
 438     }
 439
 440     private class SqueezeServerListener extends Thread {
 441         private boolean terminate = false;
 442
 443         public SqueezeServerListener() {
 444             super("Squeeze Server Listener");
 445         }
 446
 447         public void terminate() {
 448             logger.debug("setting squeeze server listener terminate flag");
 449             this.terminate = true;
 450         }
 451
 452         @Override
 453         public void run() {
 454             BufferedReader reader = null;
 455             boolean endOfStream = false;
 456             ScheduledFuture<?> requestFavoritesJob = null;
 457
 458             try {
 459                 reader = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
 460                 login();
 461                 updateStatus(ThingStatus.ONLINE);
 462                 requestPlayers();
 463                 requestFavoritesJob = scheduleRequestFavorites();
 464                 sendCommand("listen 1");
 465
 466                 String message = null;
 467                 while (!terminate && (message = reader.readLine()) != null) {
 468                     // Message is very long and frequent; only show when running at trace level logging
 469                     logger.trace("Message received: {}", message);
 470
 471                     // Fix for some third-party apps that are sending "subscribe playlist"
 472                     if (message.startsWith("listen 1") || message.startsWith("subscribe playlist")) {
 473                         continue;
 474                     }
 475
 476                     if (message.startsWith("players 0")) {
 477                         handlePlayersList(message);
 478                     } else if (message.startsWith("favorites")) {
 479                         handleFavorites(message);
 480                     } else {
 481                         handlePlayerUpdate(message);
 482                     }
 483                 }
 484                 if (message == null) {
 485                     endOfStream = true;
 486                 }
 487             } catch (IOException e) {
 488                 if (!terminate) {
 489                     logger.warn("failed to read line from squeeze server socket: {}", e.getMessage());
 490                     updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.COMMUNICATION_ERROR, e.getMessage());
 491                     scheduleReconnect();
 492                 }
 493             } finally {
 494                 if (reader != null) {
 495                     try {
 496                         reader.close();
 497                     } catch (IOException e) {
 498                         // ignore
 499                     }
 500                     reader = null;
 501                 }
 502             }
 503
 504             // check for end of stream from readLine
 505             if (endOfStream && !terminate) {
 506                 logger.info("end of stream received from socket during readLine");
 507                 updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.COMMUNICATION_ERROR,
 508                         "end of stream on socket read");
 509                 scheduleReconnect();
 510             }
 511             if (requestFavoritesJob != null && !requestFavoritesJob.isDone()) {
 512                 requestFavoritesJob.cancel(true);
 513                 logger.debug("Canceled request favorites job");
 514             }
 515             logger.debug("Squeeze Server listener exiting.");
 516         }
 517
 518         private String decode(String raw) {
 519             return URLDecoder.decode(raw, StandardCharsets.UTF_8);
 520         }
 521
 522         private String encode(String raw) {
 523             return URLEncoder.encode(raw, StandardCharsets.UTF_8);
 524         }
 525
 526         @NonNullByDefault
 527         private class KeyValue {
 528             final String key;
 529             final String value;
 530
 531             public KeyValue(String key, String value) {
 532                 this.key = key;
 533                 this.value = value;
 534             }
 535         };
 536
 537         private List<KeyValue> decodeKeyValueResponse(String[] response) {
 538             final List<KeyValue> keysAndValues = new ArrayList<>();
 539             if (response != null) {
 540                 for (String line : response) {
 541                     final String decoded = decode(line);
 542                     int colonPos = decoded.indexOf(":");
 543                     if (colonPos < 0) {
 544                         continue;
 545                     }
 546                     keysAndValues.add(new KeyValue(decoded.substring(0, colonPos), decoded.substring(colonPos + 1)));
 547                 }
 548             }
 549             return keysAndValues;
 550         }
 551
 552         private void handlePlayersList(String message) {
 553             final Set<String> connectedPlayers = new HashSet<>();
 554
 555             // Split out players
 556             String[] playersList = message.split("playerindex\\S*\\s");
 557             for (String playerParams : playersList) {
 558                 // For each player, split out parameters and decode parameter
 559                 final Map<String, String> keysAndValues = decodeKeyValueResponse(playerParams.split("\\s")).stream()
 560                         .collect(Collectors.toMap(kv -> kv.key, kv -> kv.value));
 561                 final String macAddress = keysAndValues.get("playerid");
 562
 563                 // if none found then ignore this set of params
 564                 if (macAddress == null) {
 565                     continue;
 566                 }
 567
 568                 final SqueezeBoxPlayer player = new SqueezeBoxPlayer(macAddress, keysAndValues.get("name"),
 569                         keysAndValues.get("ip"), keysAndValues.get("model"), keysAndValues.get("uuid"));
 570                 if ("1".equals(keysAndValues.get("connected"))) {
 571                     connectedPlayers.add(macAddress);
 572                 }
 573
 574                 // Save player if we haven't seen it yet
 575                 if (!players.containsKey(macAddress)) {
 576                     players.put(macAddress, player);
 577                     updatePlayer(listener -> listener.playerAdded(player));
 578                     // tell the server we want to subscribe to player updates
 579                     sendCommand(player.macAddress + " status - 1 subscribe:10 tags:yagJlNKjc");
 580                 }
 581             }
 582             for (final SqueezeBoxPlayer player : players.values()) {
 583                 final boolean connected = connectedPlayers.contains(player.macAddress);
 584                 updatePlayer(listener -> listener.connectedStateChangeEvent(player.macAddress, connected));
 585             }
 586         }
 587
 588         private void handlePlayerUpdate(String message) {
 589             String[] messageParts = message.split("\\s");
 590             if (messageParts.length < 2) {
 591                 logger.warn("Invalid message - expecting at least 2 parts. Ignoring.");
 592                 return;
 593             }
 594
 595             final String mac = decode(messageParts[0]);
 596
 597             // get the message type
 598             String messageType = messageParts[1];
 599             switch (messageType) {
 600                 case "client":
 601                     handleClientMessage(mac, messageParts);
 602                     break;
 603                 case "status":
 604                     handleStatusMessage(mac, messageParts);
 605                     break;
 606                 case "playlist":
 607                     handlePlaylistMessage(mac, messageParts);
 608                     break;
 609                 case "prefset":
 610                     handlePrefsetMessage(mac, messageParts);
 611                     break;
 612                 case "mixer":
 613                     handleMixerMessage(mac, messageParts);
 614                     break;
 615                 case "ir":
 616                     final String ircode = messageParts[2];
 617                     updatePlayer(listener -> listener.irCodeChangeEvent(mac, ircode));
 618                     break;
 619                 default:
 620                     logger.trace("Unhandled player update message type '{}'.", messageType);
 621             }
 622         }
 623
 624         private void handleMixerMessage(String mac, String[] messageParts) {
 625             if (messageParts.length < 4) {
 626                 return;
 627             }
 628             String action = messageParts[2];
 629
 630             switch (action) {
 631                 case "volume":
 632                     String volumeStringValue = decode(messageParts[3]);
 633                     updatePlayer(listener -> {
 634                         try {
 635                             int volume = Math.round(Float.parseFloat(volumeStringValue));
 636
 637                             // Check if we received a relative volume change, or an absolute
 638                             // volume value.
 639                             if (volumeStringValue.contains("+") || (volumeStringValue.contains("-"))) {
 640                                 listener.relativeVolumeChangeEvent(mac, volume);
 641                             } else {
 642                                 listener.absoluteVolumeChangeEvent(mac, volume);
 643                             }
 644                         } catch (NumberFormatException e) {
 645                             logger.warn("Unable to parse volume [{}] received from mixer message.", volumeStringValue,
 646                                     e);
 647                         }
 648                     });
 649                     break;
 650                 default:
 651                     logger.trace("Unhandled mixer message type '{}'", Arrays.toString(messageParts));
 652
 653             }
 654         }
 655
 656         private void handleClientMessage(final String mac, String[] messageParts) {
 657             if (messageParts.length < 3) {
 658                 return;
 659             }
 660
 661             String action = messageParts[2];
 662             final boolean connected;
 663
 664             if ("new".equals(action) || "reconnect".equals(action)) {
 665                 connected = true;
 666             } else if ("disconnect".equals(action) || "forget".equals(action)) {
 667                 connected = false;
 668             } else {
 669                 logger.trace("Unhandled client message type '{}'", Arrays.toString(messageParts));
 670                 return;
 671             }
 672
 673             updatePlayer(listener -> listener.connectedStateChangeEvent(mac, connected));
 674         }
 675
 676         private void handleStatusMessage(final String mac, String[] messageParts) {
 677             String remoteTitle = "", artist = "", album = "", genre = "", year = "";
 678             boolean coverart = false;
 679             String coverid = null;
 680             String artworkUrl = null;
 681
 682             for (KeyValue entry : decodeKeyValueResponse(messageParts)) {
 683                 try {
 684                     // Parameter Power
 685                     if ("power".equals(entry.key)) {
 686                         final boolean power = "1".equals(entry.value);
 687                         updatePlayer(listener -> listener.powerChangeEvent(mac, power));
 688                     }
 689                     // Parameter Volume
 690                     else if ("mixer volume".equals(entry.key)) {
 691                         final int volume = (int) Double.parseDouble(entry.value);
 692                         updatePlayer(listener -> listener.absoluteVolumeChangeEvent(mac, volume));
 693                     }
 694                     // Parameter Mode
 695                     else if ("mode".equals(entry.key)) {
 696                         updatePlayer(listener -> listener.modeChangeEvent(mac, entry.value));
 697                     }
 698                     // Parameter Playing Time
 699                     else if ("time".equals(entry.key) && !"N/A".equals(entry.value)) {
 700                         final int time = (int) Double.parseDouble(entry.value);
 701                         updatePlayer(listener -> listener.currentPlayingTimeEvent(mac, time));
 702                     }
 703                     // Parameter duration
 704                     else if ("duration".equals(entry.key)) {
 705                         final int duration = (int) Double.parseDouble(entry.value);
 706                         updatePlayer(listener -> listener.durationEvent(mac, duration));
 707                     }
 708                     // Parameter Playing Playlist Index
 709                     else if ("playlist_cur_index".equals(entry.key)) {
 710                         final int index = (int) Double.parseDouble(entry.value);
 711                         updatePlayer(listener -> listener.currentPlaylistIndexEvent(mac, index));
 712                     }
 713                     // Parameter Playlist Number Tracks
 714                     else if ("playlist_tracks".equals(entry.key)) {
 715                         final int track = (int) Double.parseDouble(entry.value);
 716                         updatePlayer(listener -> listener.numberPlaylistTracksEvent(mac, track));
 717                     }
 718                     // Parameter Playlist Repeat Mode
 719                     else if ("playlist repeat".equals(entry.key)) {
 720                         final int repeat = (int) Double.parseDouble(entry.value);
 721                         updatePlayer(listener -> listener.currentPlaylistRepeatEvent(mac, repeat));
 722                     }
 723                     // Parameter Playlist Shuffle Mode
 724                     else if ("playlist shuffle".equals(entry.key)) {
 725                         final int shuffle = (int) Double.parseDouble(entry.value);
 726                         updatePlayer(listener -> listener.currentPlaylistShuffleEvent(mac, shuffle));
 727                     }
 728                     // Parameter Title
 729                     else if ("title".equals(entry.key)) {
 730                         updatePlayer(listener -> listener.titleChangeEvent(mac, entry.value));
 731                     }
 732                     // Parameter Remote Title (radio)
 733                     else if ("remote_title".equals(entry.key)) {
 734                         remoteTitle = entry.value;
 735                     }
 736                     // Parameter Artist
 737                     else if ("artist".equals(entry.key)) {
 738                         artist = entry.value;
 739                     }
 740                     // Parameter Album
 741                     else if ("album".equals(entry.key)) {
 742                         album = entry.value;
 743                     }
 744                     // Parameter Genre
 745                     else if ("genre".equals(entry.key)) {
 746                         genre = entry.value;
 747                     }
 748                     // Parameter Year
 749                     else if ("year".equals(entry.key)) {
 750                         year = entry.value;
 751                     }
 752                     // Parameter artwork_url contains url to cover art
 753                     else if ("artwork_url".equals(entry.key)) {
 754                         artworkUrl = entry.value;
 755                     }
 756                     // When coverart is "1" coverid will contain a unique coverart id
 757                     else if ("coverart".equals(entry.key)) {
 758                         coverart = "1".equals(entry.value);
 759                     }
 760                     // Id for covert art (only valid when coverart is "1")
 761                     else if ("coverid".equals(entry.key)) {
 762                         coverid = entry.value;
 763                     } else {
 764                         // Added to be able to see additional status message types
 765                         logger.trace("Unhandled status message type '{}' (value '{}')", entry.key, entry.value);
 766                     }
 767                 } catch (NumberFormatException e) {
 768                     // Skip this key/value
 769                     logger.debug("Cannot parse number in status message: key '{}', value '{}'", entry.key, entry.value);
 770                 }
 771             }
 772
 773             final String finalUrl = constructCoverArtUrl(mac, coverart, coverid, artworkUrl);
 774             final String finalRemoteTitle = remoteTitle;
 775             final String finalArtist = artist;
 776             final String finalAlbum = album;
 777             final String finalGenre = genre;
 778             final String finalYear = year;
 779
 780             updatePlayer(listener -> {
 781                 listener.coverArtChangeEvent(mac, finalUrl);
 782                 listener.remoteTitleChangeEvent(mac, finalRemoteTitle);
 783                 listener.artistChangeEvent(mac, finalArtist);
 784                 listener.albumChangeEvent(mac, finalAlbum);
 785                 listener.genreChangeEvent(mac, finalGenre);
 786                 listener.yearChangeEvent(mac, finalYear);
 787             });
 788         }
 789
 790         private String constructCoverArtUrl(String mac, boolean coverart, String coverid, String artwork_url) {
 791             String hostAndPort;
 792             if (!userId.isEmpty()) {
 793                 hostAndPort = "http://" + encode(userId) + ":" + encode(password) + "@" + host + ":" + webport;
 794             } else {
 795                 hostAndPort = "http://" + host + ":" + webport;
 796             }
 797
 798             // Default to using the convenience artwork URL (should be rare)
 799             String url = hostAndPort + "/music/current/cover.jpg?player=" + encode(mac);
 800
 801             // If additional artwork info provided, use that instead
 802             if (coverart) {
 803                 if (coverid != null) {
 804                     // Typically is used to access cover art of local music files
 805                     url = hostAndPort + "/music/" + coverid + "/cover.jpg";
 806                 }
 807             } else if (artwork_url != null) {
 808                 if (artwork_url.startsWith("http")) {
 809                     // Typically indicates that cover art is not local to LMS
 810                     url = artwork_url;
 811                 } else if (artwork_url.startsWith("/")) {
 812                     // Typically used for default coverart for plugins (e.g. Pandora, etc.)
 813                     url = hostAndPort + artwork_url;
 814                 } else {
 815                     // Another variation of default coverart for plugins (e.g. Pandora, etc.)
 816                     url = hostAndPort + "/" + artwork_url;
 817                 }
 818             }
 819             return url;
 820         }
 821
 822         private void handlePlaylistMessage(final String mac, String[] messageParts) {
 823             if (messageParts.length < 3) {
 824                 return;
 825             }
 826             String action = messageParts[2];
 827             String mode;
 828             if (action.equals("newsong")) {
 829                 mode = "play";
 830                 // Execute in separate thread to avoid delaying listener
 831                 scheduler.execute(() -> updateCustomButtons(mac));
 832                 // Set the track duration to 0
 833                 updatePlayer(listener -> listener.durationEvent(mac, 0));
 834             } else if (action.equals("pause")) {
 835                 if (messageParts.length < 4) {
 836                     return;
 837                 }
 838                 mode = messageParts[3].equals("0") ? "play" : "pause";
 839             } else if (action.equals("stop")) {
 840                 mode = "stop";
 841             } else if ("play".equals(action) && "playlist".equals(messageParts[1])) {
 842                 if (messageParts.length >= 4) {
 843                     handleSourceChangeMessage(mac, messageParts[3]);
 844                 }
 845                 return;
 846             } else {
 847                 // Added so that actions (such as delete, index, jump, open) are not treated as "play"
 848                 logger.trace("Unhandled playlist message type '{}'", Arrays.toString(messageParts));
 849                 return;
 850             }
 851             final String value = mode;
 852             updatePlayer(listener -> listener.modeChangeEvent(mac, value));
 853         }
 854
 855         private void handleSourceChangeMessage(String mac, String rawSource) {
 856             String source = URLDecoder.decode(rawSource);
 857             updatePlayer(listener -> listener.sourceChangeEvent(mac, source));
 858         }
 859
 860         private void handlePrefsetMessage(final String mac, String[] messageParts) {
 861             if (messageParts.length < 5) {
 862                 return;
 863             }
 864             // server prefsets
 865             if (messageParts[2].equals("server")) {
 866                 String function = messageParts[3];
 867                 String value = messageParts[4];
 868                 if (function.equals("power")) {
 869                     final boolean power = value.equals("1");
 870                     updatePlayer(listener -> listener.powerChangeEvent(mac, power));
 871                 } else if (function.equals("volume")) {
 872                     final int volume = (int) Double.parseDouble(value);
 873                     updatePlayer(listener -> listener.absoluteVolumeChangeEvent(mac, volume));
 874                 }
 875             }
 876         }
 877
 878         private void handleFavorites(String message) {
 879             String[] messageParts = message.split("\\s");
 880             if (messageParts.length == 2 && "changed".equals(messageParts[1])) {
 881                 // LMS informing us that favorites have changed; request an update to the favorites list
 882                 requestFavorites();
 883                 return;
 884             }
 885             if (messageParts.length < 7) {
 886                 logger.trace("No favorites in message.");
 887                 return;
 888             }
 889
 890             List<Favorite> favorites = new ArrayList<>();
 891             Favorite f = null;
 892             boolean isTypePlaylist = false;
 893             for (KeyValue entry : decodeKeyValueResponse(messageParts)) {
 894                 // Favorite ID (in form xxxxxxxxx.n)
 895                 if ("id".equals(entry.key)) {
 896                     f = new Favorite(entry.value);
 897                     favorites.add(f);
 898                     isTypePlaylist = false;
 899                 }
 900                 // Favorite name
 901                 else if ("name".equals(entry.key)) {
 902                     f.name = entry.value;
 903                 } else if ("type".equals(entry.key) && "playlist".equals(entry.value)) {
 904                     isTypePlaylist = true;
 905                 }
 906                 // When "1", favorite is a submenu with additional favorites
 907                 else if ("hasitems".equals(entry.key)) {
 908                     boolean hasitems = "1".equals(entry.value);
 909                     if (f != null) {
 910                         // Except for some favorites (e.g. Spotify) use hasitems:1 and type:playlist
 911                         if (hasitems && isTypePlaylist == false) {
 912                             // Skip subfolders
 913                             favorites.remove(f);
 914                             f = null;
 915                         }
 916                     }
 917                 }
 918             }
 919             updatePlayer(listener -> listener.updateFavoritesListEvent(favorites));
 920             updateChannelFavoritesList(favorites);
 921         }
 922
 923         private void updateChannelFavoritesList(List<Favorite> favorites) {
 924             final Channel channel = getThing().getChannel(CHANNEL_FAVORITES_LIST);
 925             if (channel == null) {
 926                 logger.debug("Channel {} doesn't exist. Delete & add thing to get channel.", CHANNEL_FAVORITES_LIST);
 927                 return;
 928             }
 929
 930             // Get channel config parameter indicating whether name should be wrapped with double quotes
 931             Boolean includeQuotes = Boolean.FALSE;
 932             if (channel.getConfiguration().containsKey(CHANNEL_CONFIG_QUOTE_LIST)) {
 933                 includeQuotes = (Boolean) channel.getConfiguration().get(CHANNEL_CONFIG_QUOTE_LIST);
 934             }
 935
 936             String quote = includeQuotes.booleanValue() ? "\"" : "";
 937             StringBuilder sb = new StringBuilder();
 938             for (Favorite favorite : favorites) {
 939                 sb.append(favorite.shortId).append("=").append(quote).append(favorite.name.replaceAll(",", ""))
 940                         .append(quote).append(",");
 941             }
 942
 943             if (sb.length() == 0) {
 944                 updateState(CHANNEL_FAVORITES_LIST, UnDefType.NULL);
 945             } else {
 946                 // Drop the last comma
 947                 sb.setLength(sb.length() - 1);
 948                 String favoritesList = sb.toString();
 949                 logger.trace("Updating favorites channel for {} to state {}", getThing().getUID(), favoritesList);
 950                 updateState(CHANNEL_FAVORITES_LIST, new StringType(favoritesList));
 951             }
 952         }
 953
 954         private ScheduledFuture<?> scheduleRequestFavorites() {
 955             // Delay the execution to give the player thing handlers a chance to initialize
 956             return scheduler.schedule(SqueezeBoxServerHandler.this::requestFavorites, 3L, TimeUnit.SECONDS);
 957         }
 958
 959         private void updateCustomButtons(final String mac) {
 960             String response = executePost(jsonRpcUrl, JSONRPC_STATUS_REQUEST.replace("@@MAC@@", mac));
 961             if (response != null) {
 962                 logger.trace("Status response: {}", response);
 963                 String likeCommand = null;
 964                 String unlikeCommand = null;
 965                 try {
 966                     StatusResponseDTO status = gson.fromJson(response, StatusResponseDTO.class);
 967                     if (status != null && status.result != null && status.result.remoteMeta != null
 968                             && status.result.remoteMeta.buttons != null) {
 969                         ButtonsDTO buttons = status.result.remoteMeta.buttons;
 970                         if (buttons.repeat != null && buttons.repeat.isCustom()) {
 971                             likeCommand = buttons.repeat.command;
 972                         }
 973                         if (buttons.shuffle != null && buttons.shuffle.isCustom()) {
 974                             unlikeCommand = buttons.shuffle.command;
 975                         }
 976                     }
 977                 } catch (JsonSyntaxException e) {
 978                     logger.debug("JsonSyntaxException parsing status response: {}", response, e);
 979                 }
 980                 final String like = likeCommand;
 981                 final String unlike = unlikeCommand;
 982                 updatePlayer(listener -> listener.buttonsChangeEvent(mac, like, unlike));
 983             }
 984         }
 985
 986         private String executePost(String url, String content) {
 987             // @formatter:off
 988             HttpRequestBuilder builder = HttpRequestBuilder.postTo(url)
 989                 .withTimeout(Duration.ofSeconds(5))
 990                 .withContent(content)
 991                 .withHeader("charset", "utf-8")
 992                 .withHeader("Content-Type", "application/json");
 993             // @formatter:on
 994             if (basicAuthorization != null) {
 995                 builder = builder.withHeader("Authorization", "Basic " + basicAuthorization);
 996             }
 997             try {
 998                 return builder.getContentAsString();
 999             } catch (IOException e) {
1000                 logger.debug("Bridge: IOException on jsonrpc call: {}", e.getMessage(), e);
1001                 return null;
1002             }
1003         }
1004     }
1005
1006     /**
1007      * Interface to allow us to pass function call-backs to SqueezeBox Player
1008      * Event Listeners
1009      *
1010      * @author Dan Cunningham
1011      *
1012      */
1013     interface PlayerUpdateEvent {
1014         void updateListener(SqueezeBoxPlayerEventListener listener);
1015     }
1016
1017     /**
1018      * Update Listeners and child Squeeze Player Things
1019      *
1020      * @param event
1021      */
1022     private void updatePlayer(PlayerUpdateEvent event) {
1023         // update listeners like disco services
1024         synchronized (squeezeBoxPlayerListeners) {
1025             for (SqueezeBoxPlayerEventListener listener : squeezeBoxPlayerListeners) {
1026                 event.updateListener(listener);
1027             }
1028         }
1029         // update our children
1030         Bridge bridge = getThing();
1031
1032         List<Thing> things = bridge.getThings();
1033         for (Thing thing : things) {
1034             ThingHandler handler = thing.getHandler();
1035             if (handler instanceof SqueezeBoxPlayerEventListener && !squeezeBoxPlayerListeners.contains(handler)) {
1036                 event.updateListener((SqueezeBoxPlayerEventListener) handler);
1037             }
1038         }
1039     }
1040
1041     /**
1042      * Adds a listener for player events
1043      *
1044      * @param squeezeBoxPlayerListener
1045      * @return
1046      */
1047     public boolean registerSqueezeBoxPlayerListener(SqueezeBoxPlayerEventListener squeezeBoxPlayerListener) {
1048         logger.trace("Registering player listener");
1049         return squeezeBoxPlayerListeners.add(squeezeBoxPlayerListener);
1050     }
1051
1052     /**
1053      * Removes a listener from player events
1054      *
1055      * @param squeezeBoxPlayerListener
1056      * @return
1057      */
1058     public boolean unregisterSqueezeBoxPlayerListener(SqueezeBoxPlayerEventListener squeezeBoxPlayerListener) {
1059         logger.trace("Unregistering player listener");
1060         return squeezeBoxPlayerListeners.remove(squeezeBoxPlayerListener);
1061     }
1062
1063     /**
1064      * Removed a player from our known list of players, will populate again if
1065      * player is seen
1066      *
1067      * @param mac
1068      */
1069     public void removePlayerCache(String mac) {
1070         players.remove(mac);
1071     }
1072
1073     /**
1074      * Schedule the server to try and reconnect
1075      */
1076     private void scheduleReconnect() {
1077         logger.debug("scheduling squeeze server reconnect in {} seconds", RECONNECT_TIME);
1078         cancelReconnect();
1079         reconnectFuture = scheduler.schedule(this::connect, RECONNECT_TIME, TimeUnit.SECONDS);
1080     }
1081
1082     /**
1083      * Clears our reconnect job if exists
1084      */
1085     private void cancelReconnect() {
1086         if (reconnectFuture != null) {
1087             reconnectFuture.cancel(true);
1088         }
1089     }
1090 }