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

   1 /**
   2  * Copyright (c) 2010-2020 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.denonmarantz.internal.handler;
  14
  15 import static org.openhab.binding.denonmarantz.internal.DenonMarantzBindingConstants.*;
  16
  17 import java.io.IOException;
  18 import java.io.StringReader;
  19 import java.net.HttpURLConnection;
  20 import java.util.ArrayList;
  21 import java.util.HashSet;
  22 import java.util.List;
  23 import java.util.Map.Entry;
  24 import java.util.Set;
  25 import java.util.concurrent.ExecutionException;
  26 import java.util.concurrent.ScheduledFuture;
  27 import java.util.concurrent.TimeUnit;
  28 import java.util.concurrent.TimeoutException;
  29
  30 import javax.xml.parsers.DocumentBuilder;
  31 import javax.xml.parsers.DocumentBuilderFactory;
  32 import javax.xml.parsers.ParserConfigurationException;
  33 import javax.xml.xpath.XPath;
  34 import javax.xml.xpath.XPathConstants;
  35 import javax.xml.xpath.XPathExpressionException;
  36 import javax.xml.xpath.XPathFactory;
  37
  38 import org.eclipse.jetty.client.HttpClient;
  39 import org.eclipse.jetty.client.api.ContentResponse;
  40 import org.openhab.binding.denonmarantz.internal.DenonMarantzState;
  41 import org.openhab.binding.denonmarantz.internal.DenonMarantzStateChangedListener;
  42 import org.openhab.binding.denonmarantz.internal.UnsupportedCommandTypeException;
  43 import org.openhab.binding.denonmarantz.internal.config.DenonMarantzConfiguration;
  44 import org.openhab.binding.denonmarantz.internal.connector.DenonMarantzConnector;
  45 import org.openhab.binding.denonmarantz.internal.connector.DenonMarantzConnectorFactory;
  46 import org.openhab.binding.denonmarantz.internal.connector.http.DenonMarantzHttpConnector;
  47 import org.openhab.core.config.core.Configuration;
  48 import org.openhab.core.thing.Channel;
  49 import org.openhab.core.thing.ChannelUID;
  50 import org.openhab.core.thing.Thing;
  51 import org.openhab.core.thing.ThingStatus;
  52 import org.openhab.core.thing.ThingStatusDetail;
  53 import org.openhab.core.thing.binding.BaseThingHandler;
  54 import org.openhab.core.thing.binding.builder.ChannelBuilder;
  55 import org.openhab.core.thing.type.ChannelTypeUID;
  56 import org.openhab.core.types.Command;
  57 import org.openhab.core.types.RefreshType;
  58 import org.openhab.core.types.State;
  59 import org.slf4j.Logger;
  60 import org.slf4j.LoggerFactory;
  61 import org.w3c.dom.Document;
  62 import org.w3c.dom.Node;
  63 import org.xml.sax.InputSource;
  64 import org.xml.sax.SAXException;
  65
  66 /**
  67  * The {@link DenonMarantzHandler} is responsible for handling commands, which are
  68  * sent to one of the channels.
  69  *
  70  * @author Jan-Willem Veldhuis - Initial contribution
  71  */
  72 public class DenonMarantzHandler extends BaseThingHandler implements DenonMarantzStateChangedListener {
  73
  74     private final Logger logger = LoggerFactory.getLogger(DenonMarantzHandler.class);
  75     private static final int RETRY_TIME_SECONDS = 30;
  76     private HttpClient httpClient;
  77     private DenonMarantzConnector connector;
  78     private DenonMarantzConfiguration config;
  79     private DenonMarantzConnectorFactory connectorFactory = new DenonMarantzConnectorFactory();
  80     private DenonMarantzState denonMarantzState;
  81     private ScheduledFuture<?> retryJob;
  82
  83     public DenonMarantzHandler(Thing thing, HttpClient httpClient) {
  84         super(thing);
  85         this.httpClient = httpClient;
  86     }
  87
  88     @Override
  89     public void handleCommand(ChannelUID channelUID, Command command) {
  90         if (connector == null) {
  91             return;
  92         }
  93
  94         if (connector instanceof DenonMarantzHttpConnector && command instanceof RefreshType) {
  95             // Refreshing individual channels isn't supported by the Http connector.
  96             // The connector refreshes all channels together at the configured polling interval.
  97             return;
  98         }
  99
 100         try {
 101             switch (channelUID.getId()) {
 102                 case CHANNEL_POWER:
 103                     connector.sendPowerCommand(command, 0);
 104                     break;
 105                 case CHANNEL_MAIN_ZONE_POWER:
 106                     connector.sendPowerCommand(command, 1);
 107                     break;
 108                 case CHANNEL_MUTE:
 109                     connector.sendMuteCommand(command, 1);
 110                     break;
 111                 case CHANNEL_MAIN_VOLUME:
 112                     connector.sendVolumeCommand(command, 1);
 113                     break;
 114                 case CHANNEL_MAIN_VOLUME_DB:
 115                     connector.sendVolumeDbCommand(command, 1);
 116                     break;
 117                 case CHANNEL_INPUT:
 118                     connector.sendInputCommand(command, 1);
 119                     break;
 120                 case CHANNEL_SURROUND_PROGRAM:
 121                     connector.sendSurroundProgramCommand(command);
 122                     break;
 123                 case CHANNEL_COMMAND:
 124                     connector.sendCustomCommand(command);
 125                     break;
 126
 127                 case CHANNEL_ZONE2_POWER:
 128                     connector.sendPowerCommand(command, 2);
 129                     break;
 130                 case CHANNEL_ZONE2_MUTE:
 131                     connector.sendMuteCommand(command, 2);
 132                     break;
 133                 case CHANNEL_ZONE2_VOLUME:
 134                     connector.sendVolumeCommand(command, 2);
 135                     break;
 136                 case CHANNEL_ZONE2_VOLUME_DB:
 137                     connector.sendVolumeDbCommand(command, 2);
 138                     break;
 139                 case CHANNEL_ZONE2_INPUT:
 140                     connector.sendInputCommand(command, 2);
 141                     break;
 142
 143                 case CHANNEL_ZONE3_POWER:
 144                     connector.sendPowerCommand(command, 3);
 145                     break;
 146                 case CHANNEL_ZONE3_MUTE:
 147                     connector.sendMuteCommand(command, 3);
 148                     break;
 149                 case CHANNEL_ZONE3_VOLUME:
 150                     connector.sendVolumeCommand(command, 3);
 151                     break;
 152                 case CHANNEL_ZONE3_VOLUME_DB:
 153                     connector.sendVolumeDbCommand(command, 3);
 154                     break;
 155                 case CHANNEL_ZONE3_INPUT:
 156                     connector.sendInputCommand(command, 3);
 157                     break;
 158
 159                 case CHANNEL_ZONE4_POWER:
 160                     connector.sendPowerCommand(command, 4);
 161                     break;
 162                 case CHANNEL_ZONE4_MUTE:
 163                     connector.sendMuteCommand(command, 4);
 164                     break;
 165                 case CHANNEL_ZONE4_VOLUME:
 166                     connector.sendVolumeCommand(command, 4);
 167                     break;
 168                 case CHANNEL_ZONE4_VOLUME_DB:
 169                     connector.sendVolumeDbCommand(command, 4);
 170                     break;
 171                 case CHANNEL_ZONE4_INPUT:
 172                     connector.sendInputCommand(command, 4);
 173                     break;
 174
 175                 default:
 176                     throw new UnsupportedCommandTypeException();
 177             }
 178         } catch (UnsupportedCommandTypeException e) {
 179             logger.debug("Unsupported command {} for channel {}", command, channelUID.getId());
 180         }
 181     }
 182
 183     public boolean checkConfiguration() {
 184         // prevent too low values for polling interval
 185         if (config.httpPollingInterval < 5) {
 186             updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.CONFIGURATION_ERROR,
 187                     "The polling interval should be at least 5 seconds!");
 188             return false;
 189         }
 190         // Check zone count is within supported range
 191         if (config.getZoneCount() < 1 || config.getZoneCount() > 4) {
 192             updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.CONFIGURATION_ERROR,
 193                     "This binding supports 1 to 4 zones. Please update the zone count.");
 194             return false;
 195         }
 196         return true;
 197     }
 198
 199     /**
 200      * Try to auto configure the connection type (Telnet or HTTP)
 201      * for Things not added through Paper UI.
 202      */
 203     private void autoConfigure() {
 204         /*
 205          * The isTelnet parameter has no default.
 206          * When not set we will try to auto-detect the correct values
 207          * for isTelnet and zoneCount and update the Thing accordingly.
 208          */
 209         if (config.isTelnet() == null) {
 210             logger.debug("Trying to auto-detect the connection.");
 211             ContentResponse response;
 212             boolean telnetEnable = true;
 213             int httpPort = 80;
 214             boolean httpApiUsable = false;
 215
 216             // try to reach the HTTP API at port 80 (most models, except Denon ...H should respond.
 217             String host = config.getHost();
 218             try {
 219                 response = httpClient.newRequest("http://" + host + "/goform/Deviceinfo.xml")
 220                         .timeout(3, TimeUnit.SECONDS).send();
 221                 if (response.getStatus() == HttpURLConnection.HTTP_OK) {
 222                     logger.debug("We can access the HTTP API, disabling the Telnet mode by default.");
 223                     telnetEnable = false;
 224                     httpApiUsable = true;
 225                 }
 226             } catch (InterruptedException | TimeoutException | ExecutionException e) {
 227                 logger.debug("Error when trying to access AVR using HTTP on port 80, reverting to Telnet mode.", e);
 228             }
 229
 230             if (telnetEnable) {
 231                 // the above attempt failed. Let's try on port 8080, as for some models a subset of the HTTP API is
 232                 // available
 233                 try {
 234                     response = httpClient.newRequest("http://" + host + ":8080/goform/Deviceinfo.xml")
 235                             .timeout(3, TimeUnit.SECONDS).send();
 236                     if (response.getStatus() == HttpURLConnection.HTTP_OK) {
 237                         logger.debug(
 238                                 "This model responds to HTTP port 8080, we use this port to retrieve the number of zones.");
 239                         httpPort = 8080;
 240                         httpApiUsable = true;
 241                     }
 242                 } catch (InterruptedException | TimeoutException | ExecutionException e) {
 243                     logger.debug("Additionally tried to connect to port 8080, this also failed", e);
 244                 }
 245             }
 246
 247             // default zone count
 248             int zoneCount = 2;
 249
 250             // try to determine the zone count by checking the Deviceinfo.xml file
 251             if (httpApiUsable) {
 252                 int status = 0;
 253                 response = null;
 254                 try {
 255                     response = httpClient.newRequest("http://" + host + ":" + httpPort + "/goform/Deviceinfo.xml")
 256                             .timeout(3, TimeUnit.SECONDS).send();
 257                     status = response.getStatus();
 258                 } catch (InterruptedException | TimeoutException | ExecutionException e) {
 259                     logger.debug("Failed in fetching the Deviceinfo.xml to determine zone count", e);
 260                 }
 261
 262                 if (status == HttpURLConnection.HTTP_OK && response != null) {
 263                     DocumentBuilderFactory domFactory = DocumentBuilderFactory.newInstance();
 264                     DocumentBuilder builder;
 265                     try {
 266                         builder = domFactory.newDocumentBuilder();
 267                         Document dDoc = builder.parse(new InputSource(new StringReader(response.getContentAsString())));
 268                         XPath xPath = XPathFactory.newInstance().newXPath();
 269                         Node node = (Node) xPath.evaluate("/Device_Info/DeviceZones/text()", dDoc, XPathConstants.NODE);
 270                         if (node != null) {
 271                             String nodeValue = node.getNodeValue();
 272                             logger.trace("/Device_Info/DeviceZones/text() = {}", nodeValue);
 273                             zoneCount = Integer.parseInt(nodeValue);
 274                             logger.debug("Discovered number of zones: {}", zoneCount);
 275                         }
 276                     } catch (ParserConfigurationException | SAXException | IOException | XPathExpressionException
 277                             | NumberFormatException e) {
 278                         logger.debug("Something went wrong with looking up the zone count in Deviceinfo.xml: {}",
 279                                 e.getMessage());
 280                     }
 281                 }
 282             }
 283             config.setTelnet(telnetEnable);
 284             config.setZoneCount(zoneCount);
 285             Configuration configuration = editConfiguration();
 286             configuration.put(PARAMETER_TELNET_ENABLED, telnetEnable);
 287             configuration.put(PARAMETER_ZONE_COUNT, zoneCount);
 288             updateConfiguration(configuration);
 289         }
 290     }
 291
 292     @Override
 293     public void initialize() {
 294         cancelRetry();
 295         config = getConfigAs(DenonMarantzConfiguration.class);
 296
 297         // Configure Connection type (Telnet/HTTP) and number of zones
 298         // Note: this only happens for discovered Things
 299         autoConfigure();
 300
 301         if (!checkConfiguration()) {
 302             return;
 303         }
 304
 305         denonMarantzState = new DenonMarantzState(this);
 306         configureZoneChannels();
 307         updateStatus(ThingStatus.UNKNOWN);
 308         // create connection (either Telnet or HTTP)
 309         // ThingStatus ONLINE/OFFLINE is set when AVR status is known.
 310         createConnection();
 311     }
 312
 313     private void createConnection() {
 314         if (connector != null) {
 315             connector.dispose();
 316         }
 317         connector = connectorFactory.getConnector(config, denonMarantzState, scheduler, httpClient);
 318         connector.connect();
 319     }
 320
 321     private void cancelRetry() {
 322         ScheduledFuture<?> localRetryJob = retryJob;
 323         if (localRetryJob != null && !localRetryJob.isDone()) {
 324             localRetryJob.cancel(false);
 325         }
 326     }
 327
 328     private void configureZoneChannels() {
 329         logger.debug("Configuring zone channels");
 330         Integer zoneCount = config.getZoneCount();
 331         List<Channel> channels = new ArrayList<>(this.getThing().getChannels());
 332         boolean channelsUpdated = false;
 333
 334         // construct a set with the existing channel type UIDs, to quickly check
 335         Set<String> currentChannels = new HashSet<>();
 336         channels.forEach(channel -> currentChannels.add(channel.getUID().getId()));
 337
 338         Set<Entry<String, ChannelTypeUID>> channelsToRemove = new HashSet<>();
 339
 340         if (zoneCount > 1) {
 341             List<Entry<String, ChannelTypeUID>> channelsToAdd = new ArrayList<>(ZONE2_CHANNEL_TYPES.entrySet());
 342
 343             if (zoneCount > 2) {
 344                 // add channels for zone 3
 345                 channelsToAdd.addAll(ZONE3_CHANNEL_TYPES.entrySet());
 346                 if (zoneCount > 3) {
 347                     // add channels for zone 4 (more zones currently not supported)
 348                     channelsToAdd.addAll(ZONE4_CHANNEL_TYPES.entrySet());
 349                 } else {
 350                     channelsToRemove.addAll(ZONE4_CHANNEL_TYPES.entrySet());
 351                 }
 352             } else {
 353                 channelsToRemove.addAll(ZONE3_CHANNEL_TYPES.entrySet());
 354                 channelsToRemove.addAll(ZONE4_CHANNEL_TYPES.entrySet());
 355             }
 356
 357             // filter out the already existing channels
 358             channelsToAdd.removeIf(c -> currentChannels.contains(c.getKey()));
 359
 360             // add the channels that were not yet added
 361             if (!channelsToAdd.isEmpty()) {
 362                 for (Entry<String, ChannelTypeUID> entry : channelsToAdd) {
 363                     String itemType = CHANNEL_ITEM_TYPES.get(entry.getKey());
 364                     Channel channel = ChannelBuilder
 365                             .create(new ChannelUID(this.getThing().getUID(), entry.getKey()), itemType)
 366                             .withType(entry.getValue()).build();
 367                     channels.add(channel);
 368                 }
 369                 channelsUpdated = true;
 370             } else {
 371                 logger.debug("No zone channels have been added");
 372             }
 373         } else {
 374             channelsToRemove.addAll(ZONE2_CHANNEL_TYPES.entrySet());
 375             channelsToRemove.addAll(ZONE3_CHANNEL_TYPES.entrySet());
 376             channelsToRemove.addAll(ZONE4_CHANNEL_TYPES.entrySet());
 377         }
 378
 379         // filter out the non-existing channels
 380         channelsToRemove.removeIf(c -> !currentChannels.contains(c.getKey()));
 381
 382         // remove the channels that were not yet added
 383         if (!channelsToRemove.isEmpty()) {
 384             for (Entry<String, ChannelTypeUID> entry : channelsToRemove) {
 385                 if (channels.removeIf(c -> (entry.getKey()).equals(c.getUID().getId()))) {
 386                     logger.trace("Removed channel {}", entry.getKey());
 387                 } else {
 388                     logger.trace("Could NOT remove channel {}", entry.getKey());
 389                 }
 390             }
 391             channelsUpdated = true;
 392         } else {
 393             logger.debug("No zone channels have been removed");
 394         }
 395
 396         // update Thing if channels changed
 397         if (channelsUpdated) {
 398             updateThing(editThing().withChannels(channels).build());
 399         }
 400     }
 401
 402     @Override
 403     public void dispose() {
 404         if (connector != null) {
 405             connector.dispose();
 406             connector = null;
 407         }
 408         cancelRetry();
 409         super.dispose();
 410     }
 411
 412     @Override
 413     public void channelLinked(ChannelUID channelUID) {
 414         super.channelLinked(channelUID);
 415         String channelID = channelUID.getId();
 416         if (isLinked(channelID)) {
 417             State state = denonMarantzState.getStateForChannelID(channelID);
 418             if (state != null) {
 419                 updateState(channelID, state);
 420             }
 421         }
 422     }
 423
 424     @Override
 425     public void stateChanged(String channelID, State state) {
 426         logger.debug("Received state {} for channelID {}", state, channelID);
 427
 428         // Don't flood the log with thing 'updated: ONLINE' each time a single channel changed
 429         if (this.getThing().getStatus() != ThingStatus.ONLINE) {
 430             updateStatus(ThingStatus.ONLINE);
 431         }
 432         updateState(channelID, state);
 433     }
 434
 435     @Override
 436     public void connectionError(String errorMessage) {
 437         if (this.getThing().getStatus() != ThingStatus.OFFLINE) {
 438             // Don't flood the log with thing 'updated: OFFLINE' when already offline
 439             updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.COMMUNICATION_ERROR, errorMessage);
 440         }
 441         connector.dispose();
 442         retryJob = scheduler.schedule(this::createConnection, RETRY_TIME_SECONDS, TimeUnit.SECONDS);
 443     }
 444 }