public/openhab-addons
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

[squeezebox] Cleanup / code simplification (#10941)

Browse Source 
* [squeezebox] Reduce boilerplate by using lambda expressions.
* [squeezebox] Make code dealing with key/value responses more readable.
* Fix off-by-one mistake.
* [squeezebox] Simplify CLI response parsing code.
* [squeezebox] Optimize some redundant code.

Signed-off-by: Danny Baumann <dannybaumann@web.de>
This commit is contained in:
maniac103 2021-07-18 19:16:48 +02:00 committed by GitHub
parent 8c6c97e237
commit 5d7993843a
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
5 changed files with 174 additions and 398 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
bundles/org.openhab.binding.squeezebox/src/main/java/org/openhab/binding/squeezebox/internal/discovery/SqueezeBoxPlayerDiscoveryParticipant.java
View File

@ -85,32 +85,31 @@ public class SqueezeBoxPlayerDiscoveryParticipant extends AbstractDiscoveryServi
public void playerAdded(SqueezeBoxPlayer player) { public void playerAdded(SqueezeBoxPlayer player) {
ThingUID bridgeUID = squeezeBoxServerHandler.getThing().getUID(); ThingUID bridgeUID = squeezeBoxServerHandler.getThing().getUID();
ThingUID thingUID = new ThingUID(SQUEEZEBOXPLAYER_THING_TYPE, bridgeUID, ThingUID thingUID = new ThingUID(SQUEEZEBOXPLAYER_THING_TYPE, bridgeUID, player.macAddress.replace(":", ""));
player.getMacAddress().replace(":", ""));
if (!playerThingExists(thingUID)) { if (!playerThingExists(thingUID)) {
logger.debug("player added {} : {} ", player.getMacAddress(), player.getName()); logger.debug("player added {} : {} ", player.macAddress, player.name);
Map<String, Object> properties = new HashMap<>(1); Map<String, Object> properties = new HashMap<>(1);
String representationPropertyName = "mac"; String representationPropertyName = "mac";
properties.put(representationPropertyName, player.getMacAddress()); properties.put(representationPropertyName, player.macAddress);
// Added other properties // Added other properties
properties.put("modelId", player.getModel()); properties.put("modelId", player.model);
properties.put("name", player.getName()); properties.put("name", player.name);
properties.put("uid", player.getUuid()); properties.put("uid", player.uuid);
properties.put("ip", player.getIpAddr()); properties.put("ip", player.ipAddr);
DiscoveryResult discoveryResult = DiscoveryResultBuilder.create(thingUID).withProperties(properties) DiscoveryResult discoveryResult = DiscoveryResultBuilder.create(thingUID).withProperties(properties)
.withRepresentationProperty(representationPropertyName).withBridge(bridgeUID) .withRepresentationProperty(representationPropertyName).withBridge(bridgeUID).withLabel(player.name)
.withLabel(player.getName()).build(); .build();
thingDiscovered(discoveryResult); thingDiscovered(discoveryResult);
} }
} }
private boolean playerThingExists(ThingUID newThingUID) { private boolean playerThingExists(ThingUID newThingUID) {
return squeezeBoxServerHandler.getThing().getThing(newThingUID) != null ? true : false; return squeezeBoxServerHandler.getThing().getThing(newThingUID) != null;
} }
/** /**

115
bundles/org.openhab.binding.squeezebox/src/main/java/org/openhab/binding/squeezebox/internal/handler/SqueezeBoxPlayer.java
View File

@ -12,110 +12,33 @@
*/ */
package org.openhab.binding.squeezebox.internal.handler; package org.openhab.binding.squeezebox.internal.handler;
import org.eclipse.jdt.annotation.NonNullByDefault;
import org.eclipse.jdt.annotation.Nullable;
/** /**
* Represents a Squeeze Player * Represents a Squeeze Player
* *
* @author Dan Cunningham - Initial contribution * @author Dan Cunningham - Initial contribution
* *
*/ */
@NonNullByDefault
public class SqueezeBoxPlayer { public class SqueezeBoxPlayer {
public String macAddress; public final String macAddress;
public String name; @Nullable
public String ipAddr; public final String name;
public String model; @Nullable
public String uuid; public final String ipAddr;
@Nullable
public final String model;
@Nullable
public final String uuid;
public SqueezeBoxPlayer() { public SqueezeBoxPlayer(String mac, @Nullable String name, @Nullable String ip, @Nullable String model,
super(); @Nullable String uuid) {
} this.macAddress = mac;
this.name = name;
/** this.ipAddr = ip;
* UID of player this.model = model;
*
* @return
*/
public String getUuid() {
return uuid;
}
/**
* UID of player
*
* @param uuid
*/
public void setUuid(String uuid) {
this.uuid = uuid; this.uuid = uuid;
} }
/**
* Mac Address of player
*
* @param macAddress
*/
public String getMacAddress() {
return macAddress;
}
/**
* Mac Address of player
*
* @param macAddress
*/
public void setMacAddress(String macAddress) {
this.macAddress = macAddress;
}
/**
* The name (label) of a player
*
* @return
*/
public String getName() {
return name;
}
/**
* The name (label) of a player
*
* @param name
*/
public void setName(String name) {
this.name = name;
}
/**
* The ip address of a player
*
* @return
*/
public String getIpAddr() {
return ipAddr;
}
/**
* The ip address of a player
*
* @param ipAddr
*/
public void setIpAddr(String ipAddr) {
this.ipAddr = ipAddr;
}
/**
* The type of player
*
* @return
*/
public String getModel() {
return model;
}
/**
* The type of player
*
* @param model
*/
public void setModel(String model) {
this.model = model;
}
} }

69
bundles/org.openhab.binding.squeezebox/src/main/java/org/openhab/binding/squeezebox/internal/handler/SqueezeBoxPlayerHandler.java
View File

@ -577,83 +577,52 @@ public class SqueezeBoxPlayerHandler extends BaseThingHandler implements Squeeze
* @return * @return
*/ */
int currentVolume() { int currentVolume() {
if (stateMap.containsKey(CHANNEL_VOLUME)) { return cachedStateAsInt(CHANNEL_VOLUME);
return ((DecimalType) stateMap.get(CHANNEL_VOLUME)).intValue();
} else {
return 0;
}
} }
int currentPlayingTime() { int currentPlayingTime() {
if (stateMap.containsKey(CHANNEL_CURRENT_PLAYING_TIME)) { return cachedStateAsInt(CHANNEL_CURRENT_PLAYING_TIME);
return ((DecimalType) stateMap.get(CHANNEL_CURRENT_PLAYING_TIME)).intValue();
} else {
return 0;
}
} }
int currentNumberPlaylistTracks() { int currentNumberPlaylistTracks() {
if (stateMap.containsKey(CHANNEL_NUMBER_PLAYLIST_TRACKS)) { return cachedStateAsInt(CHANNEL_NUMBER_PLAYLIST_TRACKS);
return ((DecimalType) stateMap.get(CHANNEL_NUMBER_PLAYLIST_TRACKS)).intValue();
} else {
return 0;
}
} }
int currentPlaylistIndex() { int currentPlaylistIndex() {
if (stateMap.containsKey(CHANNEL_PLAYLIST_INDEX)) { return cachedStateAsInt(CHANNEL_PLAYLIST_INDEX);
return ((DecimalType) stateMap.get(CHANNEL_PLAYLIST_INDEX)).intValue();
} else {
return 0;
}
} }
boolean currentPower() { boolean currentPower() {
if (stateMap.containsKey(CHANNEL_POWER)) { return cachedStateAsBoolean(CHANNEL_POWER, OnOffType.ON);
return (stateMap.get(CHANNEL_POWER).equals(OnOffType.ON) ? true : false);
} else {
return false;
}
} }
boolean currentStop() { boolean currentStop() {
if (stateMap.containsKey(CHANNEL_STOP)) { return cachedStateAsBoolean(CHANNEL_STOP, OnOffType.ON);
return (stateMap.get(CHANNEL_STOP).equals(OnOffType.ON) ? true : false);
} else {
return false;
}
} }
boolean currentControl() { boolean currentControl() {
if (stateMap.containsKey(CHANNEL_CONTROL)) { return cachedStateAsBoolean(CHANNEL_CONTROL, PlayPauseType.PLAY);
return (stateMap.get(CHANNEL_CONTROL).equals(PlayPauseType.PLAY) ? true : false);
} else {
return false;
}
} }
boolean currentMute() { boolean currentMute() {
if (stateMap.containsKey(CHANNEL_MUTE)) { return cachedStateAsBoolean(CHANNEL_MUTE, OnOffType.ON);
return (stateMap.get(CHANNEL_MUTE).equals(OnOffType.ON) ? true : false);
} else {
return false;
}
} }
int currentShuffle() { int currentShuffle() {
if (stateMap.containsKey(CHANNEL_CURRENT_PLAYLIST_SHUFFLE)) { return cachedStateAsInt(CHANNEL_CURRENT_PLAYLIST_SHUFFLE);
return ((DecimalType) stateMap.get(CHANNEL_CURRENT_PLAYLIST_SHUFFLE)).intValue();
} else {
return 0;
}
} }
int currentRepeat() { int currentRepeat() {
if (stateMap.containsKey(CHANNEL_CURRENT_PLAYLIST_REPEAT)) { return cachedStateAsInt(CHANNEL_CURRENT_PLAYLIST_REPEAT);
return ((DecimalType) stateMap.get(CHANNEL_CURRENT_PLAYLIST_REPEAT)).intValue(); }
} else {
return 0; private boolean cachedStateAsBoolean(String key, @NonNull State activeState) {
} return activeState.equals(stateMap.get(key));
}
private int cachedStateAsInt(String key) {
State state = stateMap.get(key);
return state instanceof DecimalType ? ((DecimalType) state).intValue() : 0;
} }
/** /**

4
bundles/org.openhab.binding.squeezebox/src/main/java/org/openhab/binding/squeezebox/internal/handler/SqueezeBoxPlayerState.java
View File

@ -60,7 +60,7 @@ class SqueezeBoxPlayerState {
} }
boolean isShuffling() { boolean isShuffling() {
return savedShuffle == 0 ? false : true; return savedShuffle != 0;
} }
int getShuffle() { int getShuffle() {
@ -68,7 +68,7 @@ class SqueezeBoxPlayerState {
} }
boolean isRepeating() { boolean isRepeating() {
return savedRepeat == 0 ? false : true; return savedRepeat != 0;
} }
int getRepeat() { int getRepeat() {

363
bundles/org.openhab.binding.squeezebox/src/main/java/org/openhab/binding/squeezebox/internal/handler/SqueezeBoxServerHandler.java
View File

@ -37,7 +37,9 @@ import java.util.Set;
import java.util.concurrent.Future; import java.util.concurrent.Future;
import java.util.concurrent.ScheduledFuture; import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit; import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
import org.eclipse.jdt.annotation.NonNullByDefault;
import org.openhab.binding.squeezebox.internal.config.SqueezeBoxServerConfig; import org.openhab.binding.squeezebox.internal.config.SqueezeBoxServerConfig;
import org.openhab.binding.squeezebox.internal.dto.ButtonDTO; import org.openhab.binding.squeezebox.internal.dto.ButtonDTO;
import org.openhab.binding.squeezebox.internal.dto.ButtonDTODeserializer; import org.openhab.binding.squeezebox.internal.dto.ButtonDTODeserializer;
@ -535,69 +537,65 @@ public class SqueezeBoxServerHandler extends BaseBridgeHandler {
} }
} }
@NonNullByDefault
private class KeyValue {
final String key;
final String value;
public KeyValue(String key, String value) {
this.key = key;
this.value = value;
}
};
private List<KeyValue> decodeKeyValueResponse(String[] response) {
final List<KeyValue> keysAndValues = new ArrayList<>();
if (response != null) {
for (String line : response) {
final String decoded = decode(line);
int colonPos = decoded.indexOf(":");
if (colonPos < 0) {
continue;
}
keysAndValues.add(new KeyValue(decoded.substring(0, colonPos), decoded.substring(colonPos + 1)));
}
}
return keysAndValues;
}
private void handlePlayersList(String message) { private void handlePlayersList(String message) {
final Set<String> connectedPlayers = new HashSet<>(); final Set<String> connectedPlayers = new HashSet<>();
// Split out players // Split out players
String[] playersList = message.split("playerindex\\S*\\s"); String[] playersList = message.split("playerindex\\S*\\s");
for (String playerParams : playersList) { for (String playerParams : playersList) {
// For each player, split out parameters and decode parameter // For each player, split out parameters and decode parameter
String[] parameterList = playerParams.split("\\s"); final Map<String, String> keysAndValues = decodeKeyValueResponse(playerParams.split("\\s")).stream()
for (int i = 0; i < parameterList.length; i++) { .collect(Collectors.toMap(kv -> kv.key, kv -> kv.value));
parameterList[i] = decode(parameterList[i]); final String macAddress = keysAndValues.get("playerid");
}
// parse out the MAC address first
String macAddress = null;
for (String parameter : parameterList) {
if (parameter.contains("playerid")) {
macAddress = parameter.substring(parameter.indexOf(":") + 1);
break;
}
}
// if none found then ignore this set of params // if none found then ignore this set of params
if (macAddress == null) { if (macAddress == null) {
continue; continue;
} }
final SqueezeBoxPlayer player = new SqueezeBoxPlayer(); final SqueezeBoxPlayer player = new SqueezeBoxPlayer(macAddress, keysAndValues.get("name"),
player.setMacAddress(macAddress); keysAndValues.get("ip"), keysAndValues.get("model"), keysAndValues.get("uuid"));
// populate the player state if ("1".equals(keysAndValues.get("connected"))) {
for (String parameter : parameterList) { connectedPlayers.add(macAddress);
if (parameter.startsWith("ip:")) {
player.setIpAddr(parameter.substring(parameter.indexOf(":") + 1));
} else if (parameter.startsWith("uuid:")) {
player.setUuid(parameter.substring(parameter.indexOf(":") + 1));
} else if (parameter.startsWith("name:")) {
player.setName(parameter.substring(parameter.indexOf(":") + 1));
} else if (parameter.startsWith("model:")) {
player.setModel(parameter.substring(parameter.indexOf(":") + 1));
} else if (parameter.startsWith("connected:")) {
if ("1".equals(parameter.substring(parameter.indexOf(":") + 1))) {
connectedPlayers.add(macAddress);
}
}
} }
// Save player if we haven't seen it yet // Save player if we haven't seen it yet
if (!players.containsKey(macAddress)) { if (!players.containsKey(macAddress)) {
players.put(macAddress, player); players.put(macAddress, player);
updatePlayer(new PlayerUpdateEvent() { updatePlayer(listener -> listener.playerAdded(player));
@Override
public void updateListener(SqueezeBoxPlayerEventListener listener) {
listener.playerAdded(player);
}
});
// tell the server we want to subscribe to player updates // tell the server we want to subscribe to player updates
sendCommand(player.getMacAddress() + " status - 1 subscribe:10 tags:yagJlNKjc"); sendCommand(player.macAddress + " status - 1 subscribe:10 tags:yagJlNKjc");
} }
} }
for (final SqueezeBoxPlayer player : players.values()) { for (final SqueezeBoxPlayer player : players.values()) {
final String mac = player.getMacAddress(); final boolean connected = connectedPlayers.contains(player.macAddress);
final boolean connected = connectedPlayers.contains(mac); updatePlayer(listener -> listener.connectedStateChangeEvent(player.macAddress, connected));
updatePlayer(listener -> listener.connectedStateChangeEvent(mac, connected));
} }
} }
@ -630,12 +628,7 @@ public class SqueezeBoxServerHandler extends BaseBridgeHandler {
break; break;
case "ir": case "ir":
final String ircode = messageParts[2]; final String ircode = messageParts[2];
updatePlayer(new PlayerUpdateEvent() { updatePlayer(listener -> listener.irCodeChangeEvent(mac, ircode));
@Override
public void updateListener(SqueezeBoxPlayerEventListener listener) {
listener.irCodeChangeEvent(mac, ircode);
}
});
break; break;
default: default:
logger.trace("Unhandled player update message type '{}'.", messageType); logger.trace("Unhandled player update message type '{}'.", messageType);
@ -651,23 +644,20 @@ public class SqueezeBoxServerHandler extends BaseBridgeHandler {
switch (action) { switch (action) {
case "volume": case "volume":
String volumeStringValue = decode(messageParts[3]); String volumeStringValue = decode(messageParts[3]);
updatePlayer(new PlayerUpdateEvent() { updatePlayer(listener -> {
@Override try {
public void updateListener(SqueezeBoxPlayerEventListener listener) { int volume = Integer.parseInt(volumeStringValue);
try {
int volume = Integer.parseInt(volumeStringValue);
// Check if we received a relative volume change, or an absolute // Check if we received a relative volume change, or an absolute
// volume value. // volume value.
if (volumeStringValue.contains("+") || (volumeStringValue.contains("-"))) { if (volumeStringValue.contains("+") || (volumeStringValue.contains("-"))) {
listener.relativeVolumeChangeEvent(mac, volume); listener.relativeVolumeChangeEvent(mac, volume);
} else { } else {
listener.absoluteVolumeChangeEvent(mac, volume); listener.absoluteVolumeChangeEvent(mac, volume);
}
} catch (NumberFormatException e) {
logger.warn("Unable to parse volume [{}] received from mixer message.",
volumeStringValue, e);
} }
} catch (NumberFormatException e) {
logger.warn("Unable to parse volume [{}] received from mixer message.", volumeStringValue,
e);
} }
}); });
break; break;
@ -703,148 +693,89 @@ public class SqueezeBoxServerHandler extends BaseBridgeHandler {
String coverid = null; String coverid = null;
String artworkUrl = null; String artworkUrl = null;
for (String messagePart : messageParts) { for (KeyValue entry : decodeKeyValueResponse(messageParts)) {
// Parameter Power // Parameter Power
if (messagePart.startsWith("power%3A")) { if ("power".equals(entry.key)) {
final boolean power = "1".matches(messagePart.substring("power%3A".length())); final boolean power = "1".equals(entry.value);
updatePlayer(new PlayerUpdateEvent() { updatePlayer(listener -> listener.powerChangeEvent(mac, power));
@Override
public void updateListener(SqueezeBoxPlayerEventListener listener) {
listener.powerChangeEvent(mac, power);
}
});
} }
// Parameter Volume // Parameter Volume
else if (messagePart.startsWith("mixer%20volume%3A")) { else if ("mixer volume".equals(entry.key)) {
String value = messagePart.substring("mixer%20volume%3A".length()); final int volume = (int) Double.parseDouble(entry.value);
final int volume = (int) Double.parseDouble(value); updatePlayer(listener -> listener.absoluteVolumeChangeEvent(mac, volume));
updatePlayer(new PlayerUpdateEvent() {
@Override
public void updateListener(SqueezeBoxPlayerEventListener listener) {
listener.absoluteVolumeChangeEvent(mac, volume);
}
});
} }
// Parameter Mode // Parameter Mode
else if (messagePart.startsWith("mode%3A")) { else if ("mode".equals(entry.key)) {
final String mode = messagePart.substring("mode%3A".length()); updatePlayer(listener -> listener.modeChangeEvent(mac, entry.value));
updatePlayer(new PlayerUpdateEvent() {
@Override
public void updateListener(SqueezeBoxPlayerEventListener listener) {
listener.modeChangeEvent(mac, mode);
}
});
} }
// Parameter Playing Time // Parameter Playing Time
else if (messagePart.startsWith("time%3A")) { else if ("time".equals(entry.key)) {
String value = messagePart.substring("time%3A".length()); final int time = (int) Double.parseDouble(entry.value);
final int time = (int) Double.parseDouble(value); updatePlayer(listener -> listener.currentPlayingTimeEvent(mac, time));
updatePlayer(new PlayerUpdateEvent() {
@Override
public void updateListener(SqueezeBoxPlayerEventListener listener) {
listener.currentPlayingTimeEvent(mac, time);
}
});
} }
// Parameter duration // Parameter duration
else if (messagePart.startsWith("duration%3A")) { else if ("duration".equals(entry.key)) {
String value = messagePart.substring("duration%3A".length()); final int duration = (int) Double.parseDouble(entry.value);
final int duration = (int) Double.parseDouble(value); updatePlayer(listener -> listener.durationEvent(mac, duration));
updatePlayer(new PlayerUpdateEvent() {
@Override
public void updateListener(SqueezeBoxPlayerEventListener listener) {
listener.durationEvent(mac, duration);
}
});
} }
// Parameter Playing Playlist Index // Parameter Playing Playlist Index
else if (messagePart.startsWith("playlist_cur_index%3A")) { else if ("playlist_cur_index".equals(entry.key)) {
String value = messagePart.substring("playlist_cur_index%3A".length()); final int index = (int) Double.parseDouble(entry.value);
final int index = (int) Double.parseDouble(value); updatePlayer(listener -> listener.currentPlaylistIndexEvent(mac, index));
updatePlayer(new PlayerUpdateEvent() {
@Override
public void updateListener(SqueezeBoxPlayerEventListener listener) {
listener.currentPlaylistIndexEvent(mac, index);
}
});
} }
// Parameter Playlist Number Tracks // Parameter Playlist Number Tracks
else if (messagePart.startsWith("playlist_tracks%3A")) { else if ("playlist_tracks".equals(entry.key)) {
String value = messagePart.substring("playlist_tracks%3A".length()); final int track = (int) Double.parseDouble(entry.value);
final int track = (int) Double.parseDouble(value); updatePlayer(listener -> listener.numberPlaylistTracksEvent(mac, track));
updatePlayer(new PlayerUpdateEvent() {
@Override
public void updateListener(SqueezeBoxPlayerEventListener listener) {
listener.numberPlaylistTracksEvent(mac, track);
}
});
} }
// Parameter Playlist Repeat Mode // Parameter Playlist Repeat Mode
else if (messagePart.startsWith("playlist%20repeat%3A")) { else if ("playlist repeat".equals(entry.key)) {
String value = messagePart.substring("playlist%20repeat%3A".length()); final int repeat = (int) Double.parseDouble(entry.value);
final int repeat = (int) Double.parseDouble(value); updatePlayer(listener -> listener.currentPlaylistRepeatEvent(mac, repeat));
updatePlayer(new PlayerUpdateEvent() {
@Override
public void updateListener(SqueezeBoxPlayerEventListener listener) {
listener.currentPlaylistRepeatEvent(mac, repeat);
}
});
} }
// Parameter Playlist Shuffle Mode // Parameter Playlist Shuffle Mode
else if (messagePart.startsWith("playlist%20shuffle%3A")) { else if ("playlist shuffle".equals(entry.key)) {
String value = messagePart.substring("playlist%20shuffle%3A".length()); final int shuffle = (int) Double.parseDouble(entry.value);
final int shuffle = (int) Double.parseDouble(value); updatePlayer(listener -> listener.currentPlaylistShuffleEvent(mac, shuffle));
updatePlayer(new PlayerUpdateEvent() {
@Override
public void updateListener(SqueezeBoxPlayerEventListener listener) {
listener.currentPlaylistShuffleEvent(mac, shuffle);
}
});
} }
// Parameter Title // Parameter Title
else if (messagePart.startsWith("title%3A")) { else if ("title".equals(entry.key)) {
final String value = messagePart.substring("title%3A".length()); updatePlayer(listener -> listener.titleChangeEvent(mac, entry.value));
updatePlayer(new PlayerUpdateEvent() {
@Override
public void updateListener(SqueezeBoxPlayerEventListener listener) {
listener.titleChangeEvent(mac, decode(value));
}
});
} }
// Parameter Remote Title (radio) // Parameter Remote Title (radio)
else if (messagePart.startsWith("remote_title%3A")) { else if ("remote_title".equals(entry.key)) {
remoteTitle = messagePart.substring("remote_title%3A".length()); remoteTitle = entry.value;
} }
// Parameter Artist // Parameter Artist
else if (messagePart.startsWith("artist%3A")) { else if ("artist".equals(entry.key)) {
artist = messagePart.substring("artist%3A".length()); artist = entry.value;
} }
// Parameter Album // Parameter Album
else if (messagePart.startsWith("album%3A")) { else if ("album".equals(entry.key)) {
album = messagePart.substring("album%3A".length()); album = entry.value;
} }
// Parameter Genre // Parameter Genre
else if (messagePart.startsWith("genre%3A")) { else if ("genre".equals(entry.key)) {
genre = messagePart.substring("genre%3A".length()); genre = entry.value;
} }
// Parameter Year // Parameter Year
else if (messagePart.startsWith("year%3A")) { else if ("year".equals(entry.key)) {
year = messagePart.substring("year%3A".length()); year = entry.value;
} }
// Parameter artwork_url contains url to cover art // Parameter artwork_url contains url to cover art
else if (messagePart.startsWith("artwork_url%3A")) { else if ("artwork_url".equals(entry.key)) {
artworkUrl = messagePart.substring("artwork_url%3A".length()); artworkUrl = entry.value;
} }
// When coverart is "1" coverid will contain a unique coverart id // When coverart is "1" coverid will contain a unique coverart id
else if (messagePart.startsWith("coverart%3A")) { else if ("coverart".equals(entry.key)) {
coverart = "1".matches(messagePart.substring("coverart%3A".length())); coverart = "1".equals(entry.value);
} }
// Id for covert art (only valid when coverart is "1") // Id for covert art (only valid when coverart is "1")
else if (messagePart.startsWith("coverid%3A")) { else if ("coverid".equals(entry.key)) {
coverid = messagePart.substring("coverid%3A".length()); coverid = entry.value;
} else { } else {
// Added to be able to see additional status message types // Added to be able to see additional status message types
logger.trace("Unhandled status message type '{}'", messagePart); logger.trace("Unhandled status message type '{}' (value '{}')", entry.key, entry.value);
} }
} }
@ -855,16 +786,13 @@ public class SqueezeBoxServerHandler extends BaseBridgeHandler {
final String finalGenre = genre; final String finalGenre = genre;
final String finalYear = year; final String finalYear = year;
updatePlayer(new PlayerUpdateEvent() { updatePlayer(listener -> {
@Override listener.coverArtChangeEvent(mac, finalUrl);
public void updateListener(SqueezeBoxPlayerEventListener listener) { listener.remoteTitleChangeEvent(mac, finalRemoteTitle);
listener.coverArtChangeEvent(mac, finalUrl); listener.artistChangeEvent(mac, finalArtist);
listener.remoteTitleChangeEvent(mac, decode(finalRemoteTitle)); listener.albumChangeEvent(mac, finalAlbum);
listener.artistChangeEvent(mac, decode(finalArtist)); listener.genreChangeEvent(mac, finalGenre);
listener.albumChangeEvent(mac, decode(finalAlbum)); listener.yearChangeEvent(mac, finalYear);
listener.genreChangeEvent(mac, decode(finalGenre));
listener.yearChangeEvent(mac, decode(finalYear));
}
}); });
} }
@ -888,13 +816,13 @@ public class SqueezeBoxServerHandler extends BaseBridgeHandler {
} else if (artwork_url != null) { } else if (artwork_url != null) {
if (artwork_url.startsWith("http")) { if (artwork_url.startsWith("http")) {
// Typically indicates that cover art is not local to LMS // Typically indicates that cover art is not local to LMS
url = decode(artwork_url); url = artwork_url;
} else if (artwork_url.startsWith("%2F")) { } else if (artwork_url.startsWith("/")) {
// Typically used for default coverart for plugins (e.g. Pandora, etc.) // Typically used for default coverart for plugins (e.g. Pandora, etc.)
url = hostAndPort + decode(artwork_url); url = hostAndPort + artwork_url;
} else { } else {
// Another variation of default coverart for plugins (e.g. Pandora, etc.) // Another variation of default coverart for plugins (e.g. Pandora, etc.)
url = hostAndPort + "/" + decode(artwork_url); url = hostAndPort + "/" + artwork_url;
} }
} }
return url; return url;
@ -911,12 +839,7 @@ public class SqueezeBoxServerHandler extends BaseBridgeHandler {
// Execute in separate thread to avoid delaying listener // Execute in separate thread to avoid delaying listener
scheduler.execute(() -> updateCustomButtons(mac)); scheduler.execute(() -> updateCustomButtons(mac));
// Set the track duration to 0 // Set the track duration to 0
updatePlayer(new PlayerUpdateEvent() { updatePlayer(listener -> listener.durationEvent(mac, 0));
@Override
public void updateListener(SqueezeBoxPlayerEventListener listener) {
listener.durationEvent(mac, 0);
}
});
} else if (action.equals("pause")) { } else if (action.equals("pause")) {
if (messageParts.length < 4) { if (messageParts.length < 4) {
return; return;
@ -935,22 +858,12 @@ public class SqueezeBoxServerHandler extends BaseBridgeHandler {
return; return;
} }
final String value = mode; final String value = mode;
updatePlayer(new PlayerUpdateEvent() { updatePlayer(listener -> listener.modeChangeEvent(mac, value));
@Override
public void updateListener(SqueezeBoxPlayerEventListener listener) {
listener.modeChangeEvent(mac, value);
}
});
} }
private void handleSourceChangeMessage(String mac, String rawSource) { private void handleSourceChangeMessage(String mac, String rawSource) {
String source = URLDecoder.decode(rawSource); String source = URLDecoder.decode(rawSource);
updatePlayer(new PlayerUpdateEvent() { updatePlayer(listener -> listener.sourceChangeEvent(mac, source));
@Override
public void updateListener(SqueezeBoxPlayerEventListener listener) {
listener.sourceChangeEvent(mac, source);
}
});
} }
private void handlePrefsetMessage(final String mac, String[] messageParts) { private void handlePrefsetMessage(final String mac, String[] messageParts) {
@ -963,20 +876,10 @@ public class SqueezeBoxServerHandler extends BaseBridgeHandler {
String value = messageParts[4]; String value = messageParts[4];
if (function.equals("power")) { if (function.equals("power")) {
final boolean power = value.equals("1"); final boolean power = value.equals("1");
updatePlayer(new PlayerUpdateEvent() { updatePlayer(listener -> listener.powerChangeEvent(mac, power));
@Override
public void updateListener(SqueezeBoxPlayerEventListener listener) {
listener.powerChangeEvent(mac, power);
}
});
} else if (function.equals("volume")) { } else if (function.equals("volume")) {
final int volume = (int) Double.parseDouble(value); final int volume = (int) Double.parseDouble(value);
updatePlayer(new PlayerUpdateEvent() { updatePlayer(listener -> listener.absoluteVolumeChangeEvent(mac, volume));
@Override
public void updateListener(SqueezeBoxPlayerEventListener listener) {
listener.absoluteVolumeChangeEvent(mac, volume);
}
});
} }
} }
} }
@ -996,26 +899,22 @@ public class SqueezeBoxServerHandler extends BaseBridgeHandler {
List<Favorite> favorites = new ArrayList<>(); List<Favorite> favorites = new ArrayList<>();
Favorite f = null; Favorite f = null;
boolean isTypePlaylist = false; boolean isTypePlaylist = false;
for (String part : messageParts) { for (KeyValue entry : decodeKeyValueResponse(messageParts)) {
// Favorite ID (in form xxxxxxxxx.n) // Favorite ID (in form xxxxxxxxx.n)
if (part.startsWith("id%3A")) { if ("id".equals(entry.key)) {
String id = part.substring("id%3A".length()); f = new Favorite(entry.value);
f = new Favorite(id);
favorites.add(f); favorites.add(f);
isTypePlaylist = false; isTypePlaylist = false;
} }
// Favorite name // Favorite name
else if (part.startsWith("name%3A")) { else if ("name".equals(entry.key)) {
String name = decode(part.substring("name%3A".length())); f.name = entry.value;
if (f != null) { } else if ("type".equals(entry.key) && "playlist".equals(entry.value)) {
f.name = name;
}
} else if (part.equals("type%3Aplaylist")) {
isTypePlaylist = true; isTypePlaylist = true;
} }
// When "1", favorite is a submenu with additional favorites // When "1", favorite is a submenu with additional favorites
else if (part.startsWith("hasitems%3A")) { else if ("hasitems".equals(entry.key)) {
boolean hasitems = "1".matches(part.substring("hasitems%3A".length())); boolean hasitems = "1".equals(entry.value);
if (f != null) { if (f != null) {
// Except for some favorites (e.g. Spotify) use hasitems:1 and type:playlist // Except for some favorites (e.g. Spotify) use hasitems:1 and type:playlist
if (hasitems && isTypePlaylist == false) { if (hasitems && isTypePlaylist == false) {
@ -1026,19 +925,10 @@ public class SqueezeBoxServerHandler extends BaseBridgeHandler {
} }
} }
} }
updatePlayersFavoritesList(favorites); updatePlayer(listener -> listener.updateFavoritesListEvent(favorites));
updateChannelFavoritesList(favorites); updateChannelFavoritesList(favorites);
} }
private void updatePlayersFavoritesList(List<Favorite> favorites) {
updatePlayer(new PlayerUpdateEvent() {
@Override
public void updateListener(SqueezeBoxPlayerEventListener listener) {
listener.updateFavoritesListEvent(favorites);
}
});
}
private void updateChannelFavoritesList(List<Favorite> favorites) { private void updateChannelFavoritesList(List<Favorite> favorites) {
final Channel channel = getThing().getChannel(CHANNEL_FAVORITES_LIST); final Channel channel = getThing().getChannel(CHANNEL_FAVORITES_LIST);
if (channel == null) { if (channel == null) {
@ -1098,12 +988,7 @@ public class SqueezeBoxServerHandler extends BaseBridgeHandler {
} }
final String like = likeCommand; final String like = likeCommand;
final String unlike = unlikeCommand; final String unlike = unlikeCommand;
updatePlayer(new PlayerUpdateEvent() { updatePlayer(listener -> listener.buttonsChangeEvent(mac, like, unlike));
@Override
public void updateListener(SqueezeBoxPlayerEventListener listener) {
listener.buttonsChangeEvent(mac, like, unlike);
}
});
} }
} }