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.wemo.internal.handler;
  14
  15 import static org.openhab.binding.wemo.internal.WemoBindingConstants.*;
  16
  17 import java.io.StringReader;
  18 import java.math.BigDecimal;
  19 import java.net.URL;
  20 import java.time.Instant;
  21 import java.time.ZonedDateTime;
  22 import java.util.Collections;
  23 import java.util.HashMap;
  24 import java.util.Map;
  25 import java.util.Set;
  26 import java.util.TimeZone;
  27 import java.util.concurrent.ScheduledFuture;
  28 import java.util.concurrent.TimeUnit;
  29
  30 import javax.xml.parsers.DocumentBuilder;
  31 import javax.xml.parsers.DocumentBuilderFactory;
  32
  33 import org.apache.commons.lang.StringEscapeUtils;
  34 import org.apache.commons.lang.StringUtils;
  35 import org.openhab.binding.wemo.internal.http.WemoHttpCall;
  36 import org.openhab.core.config.core.Configuration;
  37 import org.openhab.core.io.transport.upnp.UpnpIOParticipant;
  38 import org.openhab.core.io.transport.upnp.UpnpIOService;
  39 import org.openhab.core.library.types.DateTimeType;
  40 import org.openhab.core.library.types.DecimalType;
  41 import org.openhab.core.library.types.OnOffType;
  42 import org.openhab.core.library.types.StringType;
  43 import org.openhab.core.thing.ChannelUID;
  44 import org.openhab.core.thing.Thing;
  45 import org.openhab.core.thing.ThingStatus;
  46 import org.openhab.core.thing.ThingStatusDetail;
  47 import org.openhab.core.thing.ThingTypeUID;
  48 import org.openhab.core.types.Command;
  49 import org.openhab.core.types.RefreshType;
  50 import org.openhab.core.types.State;
  51 import org.slf4j.Logger;
  52 import org.slf4j.LoggerFactory;
  53 import org.w3c.dom.CharacterData;
  54 import org.w3c.dom.Document;
  55 import org.w3c.dom.Element;
  56 import org.w3c.dom.Node;
  57 import org.w3c.dom.NodeList;
  58 import org.xml.sax.InputSource;
  59
  60 /**
  61  * The {@link WemoCoffeeHandler} is responsible for handling commands, which are
  62  * sent to one of the channels and to update their states.
  63  *
  64  * @author Hans-Jörg Merk - Initial contribution
  65  * @author Erdoan Hadzhiyusein - Adapted the class to work with the new DateTimeType
  66  */
  67
  68 public class WemoCoffeeHandler extends AbstractWemoHandler implements UpnpIOParticipant {
  69
  70     private final Logger logger = LoggerFactory.getLogger(WemoCoffeeHandler.class);
  71
  72     public static final Set<ThingTypeUID> SUPPORTED_THING_TYPES = Collections.singleton(THING_TYPE_COFFEE);
  73
  74     private Map<String, Boolean> subscriptionState = new HashMap<>();
  75
  76     protected static final int SUBSCRIPTION_DURATION = 600;
  77
  78     private UpnpIOService service;
  79
  80     /**
  81      * The default refresh interval in Seconds.
  82      */
  83     private final int REFRESH_INTERVAL = 60;
  84
  85     private ScheduledFuture<?> refreshJob;
  86
  87     private final Runnable refreshRunnable = new Runnable() {
  88
  89         @Override
  90         public void run() {
  91             try {
  92                 if (!isUpnpDeviceRegistered()) {
  93                     logger.debug("WeMo UPnP device {} not yet registered", getUDN());
  94                 }
  95
  96                 updateWemoState();
  97                 onSubscription();
  98             } catch (Exception e) {
  99                 logger.debug("Exception during poll", e);
 100                 updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.COMMUNICATION_ERROR, e.getMessage());
 101             }
 102         }
 103     };
 104
 105     public WemoCoffeeHandler(Thing thing, UpnpIOService upnpIOService, WemoHttpCall wemoHttpcaller) {
 106         super(thing);
 107
 108         this.wemoHttpCaller = wemoHttpcaller;
 109
 110         logger.debug("Creating a WemoCoffeeHandler V0.4 for thing '{}'", getThing().getUID());
 111
 112         if (upnpIOService != null) {
 113             this.service = upnpIOService;
 114         } else {
 115             logger.debug("upnpIOService not set.");
 116         }
 117     }
 118
 119     @Override
 120     public void initialize() {
 121         Configuration configuration = getConfig();
 122
 123         if (configuration.get("udn") != null) {
 124             logger.debug("Initializing WemoCoffeeHandler for UDN '{}'", configuration.get("udn"));
 125             onSubscription();
 126             onUpdate();
 127             updateStatus(ThingStatus.ONLINE);
 128         } else {
 129             logger.debug("Cannot initalize WemoCoffeeHandler. UDN not set.");
 130         }
 131     }
 132
 133     @Override
 134     public void dispose() {
 135         logger.debug("WeMoCoffeeHandler disposed.");
 136
 137         removeSubscription();
 138
 139         if (refreshJob != null && !refreshJob.isCancelled()) {
 140             refreshJob.cancel(true);
 141             refreshJob = null;
 142         }
 143     }
 144
 145     @Override
 146     public void handleCommand(ChannelUID channelUID, Command command) {
 147         logger.trace("Command '{}' received for channel '{}'", command, channelUID);
 148
 149         if (command instanceof RefreshType) {
 150             try {
 151                 updateWemoState();
 152             } catch (Exception e) {
 153                 logger.debug("Exception during poll", e);
 154             }
 155         } else if (channelUID.getId().equals(CHANNEL_STATE)) {
 156             if (command instanceof OnOffType) {
 157                 if (command.equals(OnOffType.ON)) {
 158                     try {
 159                         String soapHeader = "\"urn:Belkin:service:deviceevent:1#SetAttributes\"";
 160
 161                         String content = "<?xml version=\"1.0\"?>"
 162                                 + "<s:Envelope xmlns:s=\"http://schemas.xmlsoap.org/soap/envelope/\" s:encodingStyle=\"http://schemas.xmlsoap.org/soap/encoding/\">"
 163                                 + "<s:Body>" + "<u:SetAttributes xmlns:u=\"urn:Belkin:service:deviceevent:1\">"
 164                                 + "<attributeList>&lt;attribute&gt;&lt;name&gt;Brewed&lt;/name&gt;&lt;value&gt;NULL&lt;/value&gt;&lt;/attribute&gt;"
 165                                 + "&lt;attribute&gt;&lt;name&gt;LastCleaned&lt;/name&gt;&lt;value&gt;NULL&lt;/value&gt;&lt;/attribute&gt;&lt;attribute&gt;"
 166                                 + "&lt;name&gt;ModeTime&lt;/name&gt;&lt;value&gt;NULL&lt;/value&gt;&lt;/attribute&gt;&lt;attribute&gt;&lt;name&gt;Brewing&lt;/name&gt;"
 167                                 + "&lt;value&gt;NULL&lt;/value&gt;&lt;/attribute&gt;&lt;attribute&gt;&lt;name&gt;TimeRemaining&lt;/name&gt;&lt;value&gt;NULL&lt;/value&gt;"
 168                                 + "&lt;/attribute&gt;&lt;attribute&gt;&lt;name&gt;WaterLevelReached&lt;/name&gt;&lt;value&gt;NULL&lt;/value&gt;&lt;/attribute&gt;&lt;"
 169                                 + "attribute&gt;&lt;name&gt;Mode&lt;/name&gt;&lt;value&gt;4&lt;/value&gt;&lt;/attribute&gt;&lt;attribute&gt;&lt;name&gt;CleanAdvise&lt;/name&gt;"
 170                                 + "&lt;value&gt;NULL&lt;/value&gt;&lt;/attribute&gt;&lt;attribute&gt;&lt;name&gt;FilterAdvise&lt;/name&gt;&lt;value&gt;NULL&lt;/value&gt;&lt;/attribute&gt;"
 171                                 + "&lt;attribute&gt;&lt;name&gt;Cleaning&lt;/name&gt;&lt;value&gt;NULL&lt;/value&gt;&lt;/attribute&gt;</attributeList>"
 172                                 + "</u:SetAttributes>" + "</s:Body>" + "</s:Envelope>";
 173
 174                         String wemoURL = getWemoURL("deviceevent");
 175
 176                         if (wemoURL != null) {
 177                             String wemoCallResponse = wemoHttpCaller.executeCall(wemoURL, soapHeader, content);
 178                             if (wemoCallResponse != null) {
 179                                 updateState(CHANNEL_STATE, OnOffType.ON);
 180                                 State newMode = new StringType("Brewing");
 181                                 updateState(CHANNEL_COFFEEMODE, newMode);
 182                             }
 183                         }
 184                     } catch (Exception e) {
 185                         logger.error("Failed to send command '{}' for device '{}': {}", command, getThing().getUID(),
 186                                 e.getMessage());
 187                         updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.COMMUNICATION_ERROR);
 188                     }
 189                 }
 190                 // if command.equals(OnOffType.OFF) we do nothing because WeMo Coffee Maker cannot be switched off
 191                 // remotely
 192                 updateStatus(ThingStatus.ONLINE);
 193             }
 194         }
 195     }
 196
 197     @Override
 198     public void onServiceSubscribed(String service, boolean succeeded) {
 199         logger.debug("WeMo {}: Subscription to service {} {}", getUDN(), service, succeeded ? "succeeded" : "failed");
 200         subscriptionState.put(service, succeeded);
 201     }
 202
 203     @Override
 204     public void onValueReceived(String variable, String value, String service) {
 205         // We can subscribe to GENA events, but there is no usefull response right now.
 206     }
 207
 208     private synchronized void onSubscription() {
 209         if (service.isRegistered(this)) {
 210             logger.debug("Checking WeMo GENA subscription for '{}'", this);
 211
 212             String subscription = "deviceevent1";
 213             if ((subscriptionState.get(subscription) == null) || !subscriptionState.get(subscription).booleanValue()) {
 214                 logger.debug("Setting up GENA subscription {}: Subscribing to service {}...", getUDN(), subscription);
 215                 service.addSubscription(this, subscription, SUBSCRIPTION_DURATION);
 216                 subscriptionState.put(subscription, true);
 217             }
 218         } else {
 219             logger.debug("Setting up WeMo GENA subscription for '{}' FAILED - service.isRegistered(this) is FALSE",
 220                     this);
 221         }
 222     }
 223
 224     private synchronized void removeSubscription() {
 225         logger.debug("Removing WeMo GENA subscription for '{}'", this);
 226
 227         if (service.isRegistered(this)) {
 228             String subscription = "deviceevent1";
 229             if ((subscriptionState.get(subscription) != null) && subscriptionState.get(subscription).booleanValue()) {
 230                 logger.debug("WeMo {}: Unsubscribing from service {}...", getUDN(), subscription);
 231                 service.removeSubscription(this, subscription);
 232             }
 233
 234             subscriptionState = new HashMap<>();
 235             service.unregisterParticipant(this);
 236         }
 237     }
 238
 239     private synchronized void onUpdate() {
 240         if (refreshJob == null || refreshJob.isCancelled()) {
 241             Configuration config = getThing().getConfiguration();
 242             int refreshInterval = REFRESH_INTERVAL;
 243             Object refreshConfig = config.get("pollingInterval");
 244             if (refreshConfig != null) {
 245                 refreshInterval = ((BigDecimal) refreshConfig).intValue();
 246                 logger.debug("Setting WemoCoffeeHandler refreshInterval to '{}' seconds", refreshInterval);
 247             }
 248             refreshJob = scheduler.scheduleWithFixedDelay(refreshRunnable, 0, refreshInterval, TimeUnit.SECONDS);
 249         }
 250     }
 251
 252     private boolean isUpnpDeviceRegistered() {
 253         return service.isRegistered(this);
 254     }
 255
 256     @Override
 257     public String getUDN() {
 258         return (String) this.getThing().getConfiguration().get(UDN);
 259     }
 260
 261     /**
 262      * The {@link updateWemoState} polls the actual state of a WeMo CoffeeMaker.
 263      */
 264     protected void updateWemoState() {
 265         String action = "GetAttributes";
 266         String actionService = "deviceevent";
 267
 268         String soapHeader = "\"urn:Belkin:service:" + actionService + ":1#" + action + "\"";
 269         String content = "<?xml version=\"1.0\"?>"
 270                 + "<s:Envelope xmlns:s=\"http://schemas.xmlsoap.org/soap/envelope/\" s:encodingStyle=\"http://schemas.xmlsoap.org/soap/encoding/\">"
 271                 + "<s:Body>" + "<u:" + action + " xmlns:u=\"urn:Belkin:service:" + actionService + ":1\">" + "</u:"
 272                 + action + ">" + "</s:Body>" + "</s:Envelope>";
 273
 274         try {
 275             String wemoURL = getWemoURL(actionService);
 276             if (wemoURL != null) {
 277                 String wemoCallResponse = wemoHttpCaller.executeCall(wemoURL, soapHeader, content);
 278                 if (wemoCallResponse != null) {
 279                     try {
 280                         String stringParser = StringUtils.substringBetween(wemoCallResponse, "<attributeList>",
 281                                 "</attributeList>");
 282
 283                         // Due to Belkins bad response formatting, we need to run this twice.
 284                         stringParser = StringEscapeUtils.unescapeXml(stringParser);
 285                         stringParser = StringEscapeUtils.unescapeXml(stringParser);
 286
 287                         logger.trace("CoffeeMaker response '{}' for device '{}' received", stringParser,
 288                                 getThing().getUID());
 289
 290                         stringParser = "<data>" + stringParser + "</data>";
 291
 292                         DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
 293                         DocumentBuilder db = dbf.newDocumentBuilder();
 294                         InputSource is = new InputSource();
 295                         is.setCharacterStream(new StringReader(stringParser));
 296
 297                         Document doc = db.parse(is);
 298                         NodeList nodes = doc.getElementsByTagName("attribute");
 299
 300                         // iterate the attributes
 301                         for (int i = 0; i < nodes.getLength(); i++) {
 302                             Element element = (Element) nodes.item(i);
 303
 304                             NodeList deviceIndex = element.getElementsByTagName("name");
 305                             Element line = (Element) deviceIndex.item(0);
 306                             String attributeName = getCharacterDataFromElement(line);
 307                             logger.trace("attributeName: {}", attributeName);
 308
 309                             NodeList deviceID = element.getElementsByTagName("value");
 310                             line = (Element) deviceID.item(0);
 311                             String attributeValue = getCharacterDataFromElement(line);
 312                             logger.trace("attributeValue: {}", attributeValue);
 313
 314                             switch (attributeName) {
 315                                 case "Mode":
 316                                     State newMode = new StringType("Brewing");
 317                                     switch (attributeValue) {
 318                                         case "0":
 319                                             updateState(CHANNEL_STATE, OnOffType.ON);
 320                                             newMode = new StringType("Refill");
 321                                             updateState(CHANNEL_COFFEEMODE, newMode);
 322                                             break;
 323                                         case "1":
 324                                             updateState(CHANNEL_STATE, OnOffType.OFF);
 325                                             newMode = new StringType("PlaceCarafe");
 326                                             updateState(CHANNEL_COFFEEMODE, newMode);
 327                                             break;
 328                                         case "2":
 329                                             updateState(CHANNEL_STATE, OnOffType.OFF);
 330                                             newMode = new StringType("RefillWater");
 331                                             updateState(CHANNEL_COFFEEMODE, newMode);
 332                                             break;
 333                                         case "3":
 334                                             updateState(CHANNEL_STATE, OnOffType.OFF);
 335                                             newMode = new StringType("Ready");
 336                                             updateState(CHANNEL_COFFEEMODE, newMode);
 337                                             break;
 338                                         case "4":
 339                                             updateState(CHANNEL_STATE, OnOffType.ON);
 340                                             newMode = new StringType("Brewing");
 341                                             updateState(CHANNEL_COFFEEMODE, newMode);
 342                                             break;
 343                                         case "5":
 344                                             updateState(CHANNEL_STATE, OnOffType.OFF);
 345                                             newMode = new StringType("Brewed");
 346                                             updateState(CHANNEL_COFFEEMODE, newMode);
 347                                             break;
 348                                         case "6":
 349                                             updateState(CHANNEL_STATE, OnOffType.OFF);
 350                                             newMode = new StringType("CleaningBrewing");
 351                                             updateState(CHANNEL_COFFEEMODE, newMode);
 352                                             break;
 353                                         case "7":
 354                                             updateState(CHANNEL_STATE, OnOffType.OFF);
 355                                             newMode = new StringType("CleaningSoaking");
 356                                             updateState(CHANNEL_COFFEEMODE, newMode);
 357                                             break;
 358                                         case "8":
 359                                             updateState(CHANNEL_STATE, OnOffType.OFF);
 360                                             newMode = new StringType("BrewFailCarafeRemoved");
 361                                             updateState(CHANNEL_COFFEEMODE, newMode);
 362                                             break;
 363                                     }
 364                                     break;
 365                                 case "ModeTime":
 366                                     if (attributeValue != null) {
 367                                         State newAttributeValue = new DecimalType(attributeValue);
 368                                         updateState(CHANNEL_MODETIME, newAttributeValue);
 369                                     }
 370                                     break;
 371                                 case "TimeRemaining":
 372                                     if (attributeValue != null) {
 373                                         State newAttributeValue = new DecimalType(attributeValue);
 374                                         updateState(CHANNEL_TIMEREMAINING, newAttributeValue);
 375                                     }
 376                                     break;
 377                                 case "WaterLevelReached":
 378                                     if (attributeValue != null) {
 379                                         State newAttributeValue = new DecimalType(attributeValue);
 380                                         updateState(CHANNEL_WATERLEVELREACHED, newAttributeValue);
 381                                     }
 382                                     break;
 383                                 case "CleanAdvise":
 384                                     if (attributeValue != null) {
 385                                         State newAttributeValue = attributeValue.equals("0") ? OnOffType.OFF
 386                                                 : OnOffType.ON;
 387                                         updateState(CHANNEL_CLEANADVISE, newAttributeValue);
 388                                     }
 389                                     break;
 390                                 case "FilterAdvise":
 391                                     if (attributeValue != null) {
 392                                         State newAttributeValue = attributeValue.equals("0") ? OnOffType.OFF
 393                                                 : OnOffType.ON;
 394                                         updateState(CHANNEL_FILTERADVISE, newAttributeValue);
 395                                     }
 396                                     break;
 397                                 case "Brewed":
 398                                     if (attributeValue != null) {
 399                                         State newAttributeValue = getDateTimeState(attributeValue);
 400                                         if (newAttributeValue != null) {
 401                                             updateState(CHANNEL_BREWED, newAttributeValue);
 402                                         }
 403                                     }
 404                                     break;
 405                                 case "LastCleaned":
 406                                     if (attributeValue != null) {
 407                                         State newAttributeValue = getDateTimeState(attributeValue);
 408                                         if (newAttributeValue != null) {
 409                                             updateState(CHANNEL_LASTCLEANED, newAttributeValue);
 410                                         }
 411                                     }
 412                                     break;
 413                             }
 414                         }
 415                     } catch (Exception e) {
 416                         logger.error("Failed to parse attributeList for WeMo CoffeMaker '{}'", this.getThing().getUID(),
 417                                 e);
 418                     }
 419                 }
 420             }
 421         } catch (Exception e) {
 422             logger.error("Failed to get attributes for device '{}'", getThing().getUID(), e);
 423         }
 424     }
 425
 426     @SuppressWarnings("null")
 427     public State getDateTimeState(String attributeValue) {
 428         if (attributeValue != null) {
 429             long value = 0;
 430             try {
 431                 value = Long.parseLong(attributeValue) * 1000; // convert s to ms
 432             } catch (NumberFormatException e) {
 433                 logger.error("Unable to parse attributeValue '{}' for device '{}'; expected long", attributeValue,
 434                         getThing().getUID());
 435                 return null;
 436             }
 437             ZonedDateTime zoned = ZonedDateTime.ofInstant(Instant.ofEpochMilli(value),
 438                     TimeZone.getDefault().toZoneId());
 439             State dateTimeState = new DateTimeType(zoned);
 440             if (dateTimeState != null) {
 441                 logger.trace("New attribute brewed '{}' received", dateTimeState);
 442                 return dateTimeState;
 443             }
 444         }
 445         return null;
 446     }
 447
 448     public String getWemoURL(String actionService) {
 449         URL descriptorURL = service.getDescriptorURL(this);
 450         String wemoURL = null;
 451         if (descriptorURL != null) {
 452             String deviceURL = StringUtils.substringBefore(descriptorURL.toString(), "/setup.xml");
 453             wemoURL = deviceURL + "/upnp/control/" + actionService + "1";
 454             return wemoURL;
 455         }
 456         return null;
 457     }
 458
 459     public static String getCharacterDataFromElement(Element e) {
 460         Node child = e.getFirstChild();
 461         if (child instanceof CharacterData) {
 462             CharacterData cd = (CharacterData) child;
 463             return cd.getData();
 464         }
 465         return "?";
 466     }
 467
 468     @Override
 469     public void onStatusChanged(boolean status) {
 470     }
 471 }