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

   1 /**
   2  * Copyright (c) 2010-2022 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                 // Parameter Power
 684                 if ("power".equals(entry.key)) {
 685                     final boolean power = "1".equals(entry.value);
 686                     updatePlayer(listener -> listener.powerChangeEvent(mac, power));
 687                 }
 688                 // Parameter Volume
 689                 else if ("mixer volume".equals(entry.key)) {
 690                     final int volume = (int) Double.parseDouble(entry.value);
 691                     updatePlayer(listener -> listener.absoluteVolumeChangeEvent(mac, volume));
 692                 }
 693                 // Parameter Mode
 694                 else if ("mode".equals(entry.key)) {
 695                     updatePlayer(listener -> listener.modeChangeEvent(mac, entry.value));
 696                 }
 697                 // Parameter Playing Time
 698                 else if ("time".equals(entry.key)) {
 699                     final int time = (int) Double.parseDouble(entry.value);
 700                     updatePlayer(listener -> listener.currentPlayingTimeEvent(mac, time));
 701                 }
 702                 // Parameter duration
 703                 else if ("duration".equals(entry.key)) {
 704                     final int duration = (int) Double.parseDouble(entry.value);
 705                     updatePlayer(listener -> listener.durationEvent(mac, duration));
 706                 }
 707                 // Parameter Playing Playlist Index
 708                 else if ("playlist_cur_index".equals(entry.key)) {
 709                     final int index = (int) Double.parseDouble(entry.value);
 710                     updatePlayer(listener -> listener.currentPlaylistIndexEvent(mac, index));
 711                 }
 712                 // Parameter Playlist Number Tracks
 713                 else if ("playlist_tracks".equals(entry.key)) {
 714                     final int track = (int) Double.parseDouble(entry.value);
 715                     updatePlayer(listener -> listener.numberPlaylistTracksEvent(mac, track));
 716                 }
 717                 // Parameter Playlist Repeat Mode
 718                 else if ("playlist repeat".equals(entry.key)) {
 719                     final int repeat = (int) Double.parseDouble(entry.value);
 720                     updatePlayer(listener -> listener.currentPlaylistRepeatEvent(mac, repeat));
 721                 }
 722                 // Parameter Playlist Shuffle Mode
 723                 else if ("playlist shuffle".equals(entry.key)) {
 724                     final int shuffle = (int) Double.parseDouble(entry.value);
 725                     updatePlayer(listener -> listener.currentPlaylistShuffleEvent(mac, shuffle));
 726                 }
 727                 // Parameter Title
 728                 else if ("title".equals(entry.key)) {
 729                     updatePlayer(listener -> listener.titleChangeEvent(mac, entry.value));
 730                 }
 731                 // Parameter Remote Title (radio)
 732                 else if ("remote_title".equals(entry.key)) {
 733                     remoteTitle = entry.value;
 734                 }
 735                 // Parameter Artist
 736                 else if ("artist".equals(entry.key)) {
 737                     artist = entry.value;
 738                 }
 739                 // Parameter Album
 740                 else if ("album".equals(entry.key)) {
 741                     album = entry.value;
 742                 }
 743                 // Parameter Genre
 744                 else if ("genre".equals(entry.key)) {
 745                     genre = entry.value;
 746                 }
 747                 // Parameter Year
 748                 else if ("year".equals(entry.key)) {
 749                     year = entry.value;
 750                 }
 751                 // Parameter artwork_url contains url to cover art
 752                 else if ("artwork_url".equals(entry.key)) {
 753                     artworkUrl = entry.value;
 754                 }
 755                 // When coverart is "1" coverid will contain a unique coverart id
 756                 else if ("coverart".equals(entry.key)) {
 757                     coverart = "1".equals(entry.value);
 758                 }
 759                 // Id for covert art (only valid when coverart is "1")
 760                 else if ("coverid".equals(entry.key)) {
 761                     coverid = entry.value;
 762                 } else {
 763                     // Added to be able to see additional status message types
 764                     logger.trace("Unhandled status message type '{}' (value '{}')", entry.key, entry.value);
 765                 }
 766             }
 767
 768             final String finalUrl = constructCoverArtUrl(mac, coverart, coverid, artworkUrl);
 769             final String finalRemoteTitle = remoteTitle;
 770             final String finalArtist = artist;
 771             final String finalAlbum = album;
 772             final String finalGenre = genre;
 773             final String finalYear = year;
 774
 775             updatePlayer(listener -> {
 776                 listener.coverArtChangeEvent(mac, finalUrl);
 777                 listener.remoteTitleChangeEvent(mac, finalRemoteTitle);
 778                 listener.artistChangeEvent(mac, finalArtist);
 779                 listener.albumChangeEvent(mac, finalAlbum);
 780                 listener.genreChangeEvent(mac, finalGenre);
 781                 listener.yearChangeEvent(mac, finalYear);
 782             });
 783         }
 784
 785         private String constructCoverArtUrl(String mac, boolean coverart, String coverid, String artwork_url) {
 786             String hostAndPort;
 787             if (!userId.isEmpty()) {
 788                 hostAndPort = "http://" + encode(userId) + ":" + encode(password) + "@" + host + ":" + webport;
 789             } else {
 790                 hostAndPort = "http://" + host + ":" + webport;
 791             }
 792
 793             // Default to using the convenience artwork URL (should be rare)
 794             String url = hostAndPort + "/music/current/cover.jpg?player=" + encode(mac);
 795
 796             // If additional artwork info provided, use that instead
 797             if (coverart) {
 798                 if (coverid != null) {
 799                     // Typically is used to access cover art of local music files
 800                     url = hostAndPort + "/music/" + coverid + "/cover.jpg";
 801                 }
 802             } else if (artwork_url != null) {
 803                 if (artwork_url.startsWith("http")) {
 804                     // Typically indicates that cover art is not local to LMS
 805                     url = artwork_url;
 806                 } else if (artwork_url.startsWith("/")) {
 807                     // Typically used for default coverart for plugins (e.g. Pandora, etc.)
 808                     url = hostAndPort + artwork_url;
 809                 } else {
 810                     // Another variation of default coverart for plugins (e.g. Pandora, etc.)
 811                     url = hostAndPort + "/" + artwork_url;
 812                 }
 813             }
 814             return url;
 815         }
 816
 817         private void handlePlaylistMessage(final String mac, String[] messageParts) {
 818             if (messageParts.length < 3) {
 819                 return;
 820             }
 821             String action = messageParts[2];
 822             String mode;
 823             if (action.equals("newsong")) {
 824                 mode = "play";
 825                 // Execute in separate thread to avoid delaying listener
 826                 scheduler.execute(() -> updateCustomButtons(mac));
 827                 // Set the track duration to 0
 828                 updatePlayer(listener -> listener.durationEvent(mac, 0));
 829             } else if (action.equals("pause")) {
 830                 if (messageParts.length < 4) {
 831                     return;
 832                 }
 833                 mode = messageParts[3].equals("0") ? "play" : "pause";
 834             } else if (action.equals("stop")) {
 835                 mode = "stop";
 836             } else if ("play".equals(action) && "playlist".equals(messageParts[1])) {
 837                 if (messageParts.length >= 4) {
 838                     handleSourceChangeMessage(mac, messageParts[3]);
 839                 }
 840                 return;
 841             } else {
 842                 // Added so that actions (such as delete, index, jump, open) are not treated as "play"
 843                 logger.trace("Unhandled playlist message type '{}'", Arrays.toString(messageParts));
 844                 return;
 845             }
 846             final String value = mode;
 847             updatePlayer(listener -> listener.modeChangeEvent(mac, value));
 848         }
 849
 850         private void handleSourceChangeMessage(String mac, String rawSource) {
 851             String source = URLDecoder.decode(rawSource);
 852             updatePlayer(listener -> listener.sourceChangeEvent(mac, source));
 853         }
 854
 855         private void handlePrefsetMessage(final String mac, String[] messageParts) {
 856             if (messageParts.length < 5) {
 857                 return;
 858             }
 859             // server prefsets
 860             if (messageParts[2].equals("server")) {
 861                 String function = messageParts[3];
 862                 String value = messageParts[4];
 863                 if (function.equals("power")) {
 864                     final boolean power = value.equals("1");
 865                     updatePlayer(listener -> listener.powerChangeEvent(mac, power));
 866                 } else if (function.equals("volume")) {
 867                     final int volume = (int) Double.parseDouble(value);
 868                     updatePlayer(listener -> listener.absoluteVolumeChangeEvent(mac, volume));
 869                 }
 870             }
 871         }
 872
 873         private void handleFavorites(String message) {
 874             String[] messageParts = message.split("\\s");
 875             if (messageParts.length == 2 && "changed".equals(messageParts[1])) {
 876                 // LMS informing us that favorites have changed; request an update to the favorites list
 877                 requestFavorites();
 878                 return;
 879             }
 880             if (messageParts.length < 7) {
 881                 logger.trace("No favorites in message.");
 882                 return;
 883             }
 884
 885             List<Favorite> favorites = new ArrayList<>();
 886             Favorite f = null;
 887             boolean isTypePlaylist = false;
 888             for (KeyValue entry : decodeKeyValueResponse(messageParts)) {
 889                 // Favorite ID (in form xxxxxxxxx.n)
 890                 if ("id".equals(entry.key)) {
 891                     f = new Favorite(entry.value);
 892                     favorites.add(f);
 893                     isTypePlaylist = false;
 894                 }
 895                 // Favorite name
 896                 else if ("name".equals(entry.key)) {
 897                     f.name = entry.value;
 898                 } else if ("type".equals(entry.key) && "playlist".equals(entry.value)) {
 899                     isTypePlaylist = true;
 900                 }
 901                 // When "1", favorite is a submenu with additional favorites
 902                 else if ("hasitems".equals(entry.key)) {
 903                     boolean hasitems = "1".equals(entry.value);
 904                     if (f != null) {
 905                         // Except for some favorites (e.g. Spotify) use hasitems:1 and type:playlist
 906                         if (hasitems && isTypePlaylist == false) {
 907                             // Skip subfolders
 908                             favorites.remove(f);
 909                             f = null;
 910                         }
 911                     }
 912                 }
 913             }
 914             updatePlayer(listener -> listener.updateFavoritesListEvent(favorites));
 915             updateChannelFavoritesList(favorites);
 916         }
 917
 918         private void updateChannelFavoritesList(List<Favorite> favorites) {
 919             final Channel channel = getThing().getChannel(CHANNEL_FAVORITES_LIST);
 920             if (channel == null) {
 921                 logger.debug("Channel {} doesn't exist. Delete & add thing to get channel.", CHANNEL_FAVORITES_LIST);
 922                 return;
 923             }
 924
 925             // Get channel config parameter indicating whether name should be wrapped with double quotes
 926             Boolean includeQuotes = Boolean.FALSE;
 927             if (channel.getConfiguration().containsKey(CHANNEL_CONFIG_QUOTE_LIST)) {
 928                 includeQuotes = (Boolean) channel.getConfiguration().get(CHANNEL_CONFIG_QUOTE_LIST);
 929             }
 930
 931             String quote = includeQuotes.booleanValue() ? "\"" : "";
 932             StringBuilder sb = new StringBuilder();
 933             for (Favorite favorite : favorites) {
 934                 sb.append(favorite.shortId).append("=").append(quote).append(favorite.name.replaceAll(",", ""))
 935                         .append(quote).append(",");
 936             }
 937
 938             if (sb.length() == 0) {
 939                 updateState(CHANNEL_FAVORITES_LIST, UnDefType.NULL);
 940             } else {
 941                 // Drop the last comma
 942                 sb.setLength(sb.length() - 1);
 943                 String favoritesList = sb.toString();
 944                 logger.trace("Updating favorites channel for {} to state {}", getThing().getUID(), favoritesList);
 945                 updateState(CHANNEL_FAVORITES_LIST, new StringType(favoritesList));
 946             }
 947         }
 948
 949         private ScheduledFuture<?> scheduleRequestFavorites() {
 950             // Delay the execution to give the player thing handlers a chance to initialize
 951             return scheduler.schedule(SqueezeBoxServerHandler.this::requestFavorites, 3L, TimeUnit.SECONDS);
 952         }
 953
 954         private void updateCustomButtons(final String mac) {
 955             String response = executePost(jsonRpcUrl, JSONRPC_STATUS_REQUEST.replace("@@MAC@@", mac));
 956             if (response != null) {
 957                 logger.trace("Status response: {}", response);
 958                 String likeCommand = null;
 959                 String unlikeCommand = null;
 960                 try {
 961                     StatusResponseDTO status = gson.fromJson(response, StatusResponseDTO.class);
 962                     if (status != null && status.result != null && status.result.remoteMeta != null
 963                             && status.result.remoteMeta.buttons != null) {
 964                         ButtonsDTO buttons = status.result.remoteMeta.buttons;
 965                         if (buttons.repeat != null && buttons.repeat.isCustom()) {
 966                             likeCommand = buttons.repeat.command;
 967                         }
 968                         if (buttons.shuffle != null && buttons.shuffle.isCustom()) {
 969                             unlikeCommand = buttons.shuffle.command;
 970                         }
 971                     }
 972                 } catch (JsonSyntaxException e) {
 973                     logger.debug("JsonSyntaxException parsing status response: {}", response, e);
 974                 }
 975                 final String like = likeCommand;
 976                 final String unlike = unlikeCommand;
 977                 updatePlayer(listener -> listener.buttonsChangeEvent(mac, like, unlike));
 978             }
 979         }
 980
 981         private String executePost(String url, String content) {
 982             // @formatter:off
 983             HttpRequestBuilder builder = HttpRequestBuilder.postTo(url)
 984                 .withTimeout(Duration.ofSeconds(5))
 985                 .withContent(content)
 986                 .withHeader("charset", "utf-8")
 987                 .withHeader("Content-Type", "application/json");
 988             // @formatter:on
 989             if (basicAuthorization != null) {
 990                 builder = builder.withHeader("Authorization", "Basic " + basicAuthorization);
 991             }
 992             try {
 993                 return builder.getContentAsString();
 994             } catch (IOException e) {
 995                 logger.debug("Bridge: IOException on jsonrpc call: {}", e.getMessage(), e);
 996                 return null;
 997             }
 998         }
 999     }
1000
1001     /**
1002      * Interface to allow us to pass function call-backs to SqueezeBox Player
1003      * Event Listeners
1004      *
1005      * @author Dan Cunningham
1006      *
1007      */
1008     interface PlayerUpdateEvent {
1009         void updateListener(SqueezeBoxPlayerEventListener listener);
1010     }
1011
1012     /**
1013      * Update Listeners and child Squeeze Player Things
1014      *
1015      * @param event
1016      */
1017     private void updatePlayer(PlayerUpdateEvent event) {
1018         // update listeners like disco services
1019         synchronized (squeezeBoxPlayerListeners) {
1020             for (SqueezeBoxPlayerEventListener listener : squeezeBoxPlayerListeners) {
1021                 event.updateListener(listener);
1022             }
1023         }
1024         // update our children
1025         Bridge bridge = getThing();
1026
1027         List<Thing> things = bridge.getThings();
1028         for (Thing thing : things) {
1029             ThingHandler handler = thing.getHandler();
1030             if (handler instanceof SqueezeBoxPlayerEventListener && !squeezeBoxPlayerListeners.contains(handler)) {
1031                 event.updateListener((SqueezeBoxPlayerEventListener) handler);
1032             }
1033         }
1034     }
1035
1036     /**
1037      * Adds a listener for player events
1038      *
1039      * @param squeezeBoxPlayerListener
1040      * @return
1041      */
1042     public boolean registerSqueezeBoxPlayerListener(SqueezeBoxPlayerEventListener squeezeBoxPlayerListener) {
1043         logger.trace("Registering player listener");
1044         return squeezeBoxPlayerListeners.add(squeezeBoxPlayerListener);
1045     }
1046
1047     /**
1048      * Removes a listener from player events
1049      *
1050      * @param squeezeBoxPlayerListener
1051      * @return
1052      */
1053     public boolean unregisterSqueezeBoxPlayerListener(SqueezeBoxPlayerEventListener squeezeBoxPlayerListener) {
1054         logger.trace("Unregistering player listener");
1055         return squeezeBoxPlayerListeners.remove(squeezeBoxPlayerListener);
1056     }
1057
1058     /**
1059      * Removed a player from our known list of players, will populate again if
1060      * player is seen
1061      *
1062      * @param mac
1063      */
1064     public void removePlayerCache(String mac) {
1065         players.remove(mac);
1066     }
1067
1068     /**
1069      * Schedule the server to try and reconnect
1070      */
1071     private void scheduleReconnect() {
1072         logger.debug("scheduling squeeze server reconnect in {} seconds", RECONNECT_TIME);
1073         cancelReconnect();
1074         reconnectFuture = scheduler.schedule(this::connect, RECONNECT_TIME, TimeUnit.SECONDS);
1075     }
1076
1077     /**
1078      * Clears our reconnect job if exists
1079      */
1080     private void cancelReconnect() {
1081         if (reconnectFuture != null) {
1082             reconnectFuture.cancel(true);
1083         }
1084     }
1085 }