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

   1 /**
   2  * Copyright (c) 2010-2021 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.iaqualink.internal.handler;
  14
  15 import static org.openhab.core.library.unit.ImperialUnits.FAHRENHEIT;
  16 import static org.openhab.core.library.unit.SIUnits.CELSIUS;
  17
  18 import java.io.IOException;
  19 import java.math.BigDecimal;
  20 import java.math.RoundingMode;
  21 import java.util.ArrayList;
  22 import java.util.Arrays;
  23 import java.util.Collections;
  24 import java.util.HashMap;
  25 import java.util.List;
  26 import java.util.Map;
  27 import java.util.Objects;
  28 import java.util.Optional;
  29 import java.util.concurrent.ScheduledFuture;
  30 import java.util.concurrent.TimeUnit;
  31
  32 import javax.measure.Unit;
  33 import javax.measure.quantity.Temperature;
  34
  35 import org.eclipse.jdt.annotation.NonNullByDefault;
  36 import org.eclipse.jdt.annotation.Nullable;
  37 import org.eclipse.jetty.client.HttpClient;
  38 import org.openhab.binding.iaqualink.internal.IAqualinkBindingConstants;
  39 import org.openhab.binding.iaqualink.internal.api.IAqualinkClient;
  40 import org.openhab.binding.iaqualink.internal.api.IAqualinkClient.NotAuthorizedException;
  41 import org.openhab.binding.iaqualink.internal.api.model.AccountInfo;
  42 import org.openhab.binding.iaqualink.internal.api.model.Auxiliary;
  43 import org.openhab.binding.iaqualink.internal.api.model.Device;
  44 import org.openhab.binding.iaqualink.internal.api.model.Home;
  45 import org.openhab.binding.iaqualink.internal.api.model.OneTouch;
  46 import org.openhab.binding.iaqualink.internal.config.IAqualinkConfiguration;
  47 import org.openhab.core.library.types.DecimalType;
  48 import org.openhab.core.library.types.OnOffType;
  49 import org.openhab.core.library.types.PercentType;
  50 import org.openhab.core.library.types.QuantityType;
  51 import org.openhab.core.library.types.StringType;
  52 import org.openhab.core.thing.Channel;
  53 import org.openhab.core.thing.ChannelUID;
  54 import org.openhab.core.thing.Thing;
  55 import org.openhab.core.thing.ThingStatus;
  56 import org.openhab.core.thing.ThingStatusDetail;
  57 import org.openhab.core.thing.binding.BaseThingHandler;
  58 import org.openhab.core.thing.binding.builder.ChannelBuilder;
  59 import org.openhab.core.thing.binding.builder.ThingBuilder;
  60 import org.openhab.core.thing.type.ChannelTypeUID;
  61 import org.openhab.core.types.Command;
  62 import org.openhab.core.types.RefreshType;
  63 import org.openhab.core.types.State;
  64 import org.openhab.core.types.UnDefType;
  65 import org.slf4j.Logger;
  66 import org.slf4j.LoggerFactory;
  67
  68 /**
  69  *
  70  * iAquaLink Control Binding
  71  *
  72  * iAquaLink controllers allow remote access to Jandy/Zodiac pool systems. This
  73  * binding allows openHAB to both monitor and control a pool system through
  74  * these controllers.
  75  *
  76  * The {@link IAqualinkHandler} is responsible for handling commands, which
  77  * are sent to one of the channels.
  78  *
  79  * @author Dan Cunningham - Initial contribution
  80  */
  81 @NonNullByDefault
  82 public class IAqualinkHandler extends BaseThingHandler {
  83
  84     private final Logger logger = LoggerFactory.getLogger(IAqualinkHandler.class);
  85
  86     /**
  87      * Minimum amount of time we can poll for updates
  88      */
  89     private static final int MIN_REFRESH_SECONDS = 5;
  90
  91     /**
  92      * Minimum amount of time we can poll after a command
  93      */
  94     private static final int COMMAND_REFRESH_SECONDS = 5;
  95
  96     /**
  97      * Default iAqulink key used by existing clients in the marketplace
  98      */
  99     private static final String DEFAULT_API_KEY = "EOOEMOW4YR6QNB07";
 100
 101     /**
 102      * Local cache of iAqualink states
 103      */
 104     private Map<String, State> stateMap = Collections.synchronizedMap(new HashMap<>());
 105
 106     /**
 107      * Our poll rate
 108      */
 109     private int refresh;
 110
 111     /**
 112      * fixed API key provided by iAqualink clients (Android, IOS), unknown if this will change in the future.
 113      */
 114
 115     private @Nullable String apiKey;
 116
 117     /**
 118      * Optional serial number of the pool controller to connect to, only useful if you have more then one controller
 119      */
 120     private @Nullable String serialNumber;
 121
 122     /**
 123      * Server issued sessionId
 124      */
 125     private @Nullable String sessionId;
 126
 127     /**
 128      * When we first connect we will dynamically create channels based on what the controller is configured for
 129      */
 130     private boolean firstRun;
 131
 132     /**
 133      * Future to poll for updated
 134      */
 135     private @Nullable ScheduledFuture<?> pollFuture;
 136
 137     /**
 138      * The client interface to the iAqualink Service
 139      */
 140     private IAqualinkClient client;
 141
 142     /**
 143      * Temperature unit, will be set based on user setting
 144      */
 145     private Unit<Temperature> temperatureUnit = CELSIUS;
 146
 147     /**
 148      * Constructs a new {@link IAqualinkHandler}
 149      *
 150      * @param thing
 151      * @param httpClient
 152      */
 153     public IAqualinkHandler(Thing thing, HttpClient httpClient) {
 154         super(thing);
 155         client = new IAqualinkClient(httpClient);
 156     }
 157
 158     @Override
 159     public void initialize() {
 160         // don't hold up initialize
 161         scheduler.schedule(this::configure, 0, TimeUnit.SECONDS);
 162     }
 163
 164     @Override
 165     public void dispose() {
 166         logger.debug("Handler disposed.");
 167         clearPolling();
 168     }
 169
 170     @Override
 171     public void channelLinked(ChannelUID channelUID) {
 172         // clear our cached value so the new channel gets updated on the next poll
 173         stateMap.remove(channelUID.getAsString());
 174     }
 175
 176     @Override
 177     public void handleCommand(ChannelUID channelUID, Command command) {
 178         logger.debug("handleCommand channel: {} command: {}", channelUID, command);
 179
 180         if (getThing().getStatus() != ThingStatus.ONLINE) {
 181             logger.warn("Controller is not ONLINE and is not responding to commands");
 182             return;
 183         }
 184
 185         clearPolling();
 186
 187         String channelName = channelUID.getIdWithoutGroup();
 188         // remove the current state to ensure we send an update
 189         stateMap.remove(channelUID.getAsString());
 190         try {
 191             if (command instanceof RefreshType) {
 192                 logger.debug("Channel {} state has been cleared", channelName);
 193             } else if (channelName.startsWith("aux_")) {
 194                 // Auxiliary Commands
 195                 String auxId = channelName.replaceFirst("aux_", "");
 196                 if (command instanceof PercentType) {
 197                     client.dimmerCommand(serialNumber, sessionId, auxId, command.toString());
 198                 } else if (command instanceof StringType) {
 199                     String cmd = "off".equals(command.toString()) ? "0"
 200                             : "on".equals(command.toString()) ? "1" : command.toString();
 201                     client.lightCommand(serialNumber, sessionId, auxId, cmd,
 202                             AuxiliaryType.fromChannelTypeUID(getChannelTypeUID(channelUID)).getSubType());
 203                 } else if (command instanceof OnOffType) {
 204                     // these are toggle commands and require we have the current state to turn on/off
 205                     Auxiliary[] auxs = client.getAux(serialNumber, sessionId);
 206                     Optional<Auxiliary> optional = Arrays.stream(auxs).filter(o -> o.getName().equals(channelName))
 207                             .findFirst();
 208                     if (optional.isPresent()) {
 209                         if (toState(channelName, "Switch", optional.get().getState()) != command) {
 210                             client.auxSetCommand(serialNumber, sessionId, channelName);
 211                         }
 212                     }
 213                 }
 214             } else if (channelName.endsWith("_set_point")) {
 215                 // Set Point Commands
 216                 if ("spa_set_point".equals(channelName)) {
 217                     BigDecimal value = commandToRoundedTemperature(command, temperatureUnit);
 218                     if (value != null) {
 219                         client.setSpaTemp(serialNumber, sessionId, value.floatValue());
 220                     }
 221                 } else if ("pool_set_point".equals(channelName)) {
 222                     BigDecimal value = commandToRoundedTemperature(command, temperatureUnit);
 223                     if (value != null) {
 224                         client.setPoolTemp(serialNumber, sessionId, value.floatValue());
 225                     }
 226                 }
 227             } else if (command instanceof OnOffType) {
 228                 // these are toggle commands and require we have the current state to turn on/off
 229                 if (channelName.startsWith("onetouch_")) {
 230                     OneTouch[] ota = client.getOneTouch(serialNumber, sessionId);
 231                     Optional<OneTouch> optional = Arrays.stream(ota).filter(o -> o.getName().equals(channelName))
 232                             .findFirst();
 233                     if (optional.isPresent()) {
 234                         if (toState(channelName, "Switch", optional.get().getState()) != command) {
 235                             logger.debug("Sending command {} to {}", command, channelName);
 236                             client.oneTouchSetCommand(serialNumber, sessionId, channelName);
 237                         }
 238                     }
 239                 } else if (channelName.endsWith("heater") || channelName.endsWith("pump")) {
 240                     String value = client.getHome(serialNumber, sessionId).getSerializedMap().get(channelName);
 241                     if (toState(channelName, "Switch", value) != command) {
 242                         logger.debug("Sending command {} to {}", command, channelName);
 243                         client.homeScreenSetCommand(serialNumber, sessionId, channelName);
 244                     }
 245                 }
 246             }
 247             initPolling(COMMAND_REFRESH_SECONDS);
 248         } catch (IOException e) {
 249             logger.debug("Exception executing command", e);
 250             initPolling(COMMAND_REFRESH_SECONDS);
 251         } catch (NotAuthorizedException e) {
 252             logger.debug("Authorization Exception sending command", e);
 253             configure();
 254         }
 255     }
 256
 257     /**
 258      * Configures this thing
 259      */
 260     private void configure() {
 261         clearPolling();
 262         firstRun = true;
 263
 264         IAqualinkConfiguration configuration = getConfig().as(IAqualinkConfiguration.class);
 265         String username = configuration.userName;
 266         String password = configuration.password;
 267         String confSerialId = configuration.serialId;
 268         String confApiKey = configuration.apiKey;
 269
 270         if (confApiKey != null && !confApiKey.isBlank()) {
 271             this.apiKey = confApiKey;
 272         } else {
 273             this.apiKey = DEFAULT_API_KEY;
 274         }
 275
 276         this.refresh = Math.max(configuration.refresh, MIN_REFRESH_SECONDS);
 277
 278         try {
 279             AccountInfo accountInfo = client.login(username, password, apiKey);
 280             sessionId = accountInfo.getSessionId();
 281             if (sessionId == null) {
 282                 throw new IOException("Response from controller not valid");
 283             }
 284             logger.debug("SessionID {}", sessionId);
 285
 286             Device[] devices = client.getDevices(apiKey, accountInfo.getAuthenticationToken(), accountInfo.getId());
 287
 288             if (devices.length == 0) {
 289                 updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.CONFIGURATION_ERROR, "No registered devices found");
 290                 return;
 291             }
 292
 293             if (confSerialId != null && !confSerialId.isBlank()) {
 294                 serialNumber = confSerialId.replaceAll("[^a-zA-Z0-9]", "").toLowerCase();
 295                 if (!Arrays.stream(devices).anyMatch(device -> device.getSerialNumber().equals(serialNumber))) {
 296                     updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.CONFIGURATION_ERROR,
 297                             "No Device for given serialId found");
 298                     return;
 299                 }
 300             } else {
 301                 serialNumber = devices[0].getSerialNumber();
 302             }
 303
 304             initPolling(COMMAND_REFRESH_SECONDS);
 305         } catch (IOException e) {
 306             logger.debug("Could not connect to service {}", e.getMessage());
 307             updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.COMMUNICATION_ERROR, e.getMessage());
 308         } catch (NotAuthorizedException e) {
 309             logger.debug("Credentials not valid");
 310             updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.CONFIGURATION_ERROR, "Credentials not valid");
 311         }
 312     }
 313
 314     /**
 315      * Starts/Restarts polling with an initial delay. This allows changes in the poll cycle for when commands are sent
 316      * and we need to poll sooner then the next refresh cycle.
 317      */
 318     private synchronized void initPolling(int initialDelay) {
 319         clearPolling();
 320         pollFuture = scheduler.scheduleWithFixedDelay(this::pollController, initialDelay, refresh, TimeUnit.SECONDS);
 321     }
 322
 323     /**
 324      * Stops/clears this thing's polling future
 325      */
 326     private void clearPolling() {
 327         ScheduledFuture<?> localFuture = pollFuture;
 328         if (isFutureValid(localFuture)) {
 329             if (localFuture != null) {
 330                 localFuture.cancel(true);
 331             }
 332         }
 333     }
 334
 335     private boolean isFutureValid(@Nullable ScheduledFuture<?> future) {
 336         return future != null && !future.isCancelled();
 337     }
 338
 339     /**
 340      * Poll the controller for updates.
 341      */
 342     private void pollController() {
 343         ScheduledFuture<?> localFuture = pollFuture;
 344         try {
 345             Home home = client.getHome(serialNumber, sessionId);
 346
 347             if ("Error".equals(home.getResponse())) {
 348                 updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.COMMUNICATION_ERROR,
 349                         "Service reports controller status as: " + home.getStatus());
 350                 return;
 351             }
 352
 353             Map<String, String> map = home.getSerializedMap();
 354             if (map != null) {
 355                 temperatureUnit = "F".equalsIgnoreCase(map.get("temp_scale")) ? FAHRENHEIT : CELSIUS;
 356                 map.forEach((k, v) -> {
 357                     updatedState(k, v);
 358                     if (k.endsWith("_heater")) {
 359                         HeaterState hs = HeaterState.fromValue(v);
 360                         updatedState(k + "_status", hs == null ? null : hs.getLabel());
 361                     }
 362                 });
 363             }
 364
 365             OneTouch[] oneTouches = client.getOneTouch(serialNumber, sessionId);
 366             Auxiliary[] auxes = client.getAux(serialNumber, sessionId);
 367
 368             if (firstRun) {
 369                 firstRun = false;
 370                 updateChannels(auxes, oneTouches);
 371             }
 372
 373             for (OneTouch ot : oneTouches) {
 374                 updatedState(ot.getName(), ot.getState());
 375             }
 376
 377             for (Auxiliary aux : auxes) {
 378                 switch (aux.getType()) {
 379                     // dimmer uses subType for value
 380                     case "1":
 381                         updatedState(aux.getName(), aux.getSubtype());
 382                         break;
 383                     // Color lights do not report the color value, only on/off
 384                     case "2":
 385                         updatedState(aux.getName(), "0".equals(aux.getState()) ? "off" : "on");
 386                         break;
 387                     // all else are switches
 388                     default:
 389                         updatedState(aux.getName(), aux.getState());
 390                 }
 391             }
 392
 393             if (getThing().getStatus() != ThingStatus.ONLINE) {
 394                 updateStatus(ThingStatus.ONLINE);
 395             }
 396         } catch (IOException e) {
 397             // poller will continue to run, set offline until next run
 398             logger.debug("Exception polling", e);
 399             if (isFutureValid(localFuture)) {
 400                 // only valid futures should set state, otherwise this exception was do to being canceled.
 401                 updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.COMMUNICATION_ERROR, e.getMessage());
 402             }
 403         } catch (NotAuthorizedException e) {
 404             // if are creds are not valid, we need to try re authorizing again
 405             logger.debug("Authorization Exception during polling", e);
 406             clearPolling();
 407             configure();
 408         }
 409     }
 410
 411     /**
 412      * Update an channels state only if the value of the channel has changed since our last poll.
 413      *
 414      * @param name
 415      * @param value
 416      */
 417     private void updatedState(String name, @Nullable String value) {
 418         logger.trace("updatedState {} : {}", name, value);
 419         Channel channel = getThing().getChannel(name);
 420         if (channel != null) {
 421             State state = toState(name, channel.getAcceptedItemType(), value);
 422             State oldState = stateMap.put(channel.getUID().getAsString(), state);
 423             if (!state.equals(oldState)) {
 424                 logger.trace("updating channel {} with state {} (old state {})", channel.getUID(), state, oldState);
 425                 updateState(channel.getUID(), state);
 426             }
 427         }
 428     }
 429
 430     /**
 431      * Converts a {@link String} value to a {@link State} for a given
 432      * {@link String} accepted type
 433      *
 434      * @param itemType
 435      * @param value
 436      * @return {@link State}
 437      */
 438     private State toState(String name, @Nullable String type, @Nullable String value) {
 439         try {
 440             if (value == null || value.isBlank()) {
 441                 return UnDefType.UNDEF;
 442             }
 443
 444             if (type == null) {
 445                 return StringType.valueOf(value);
 446             }
 447
 448             switch (type) {
 449                 case "Number:Temperature":
 450                     return new QuantityType<>(Float.parseFloat(value), temperatureUnit);
 451                 case "Number":
 452                     return new DecimalType(value);
 453                 case "Dimmer":
 454                     return new PercentType(value);
 455                 case "Switch":
 456                     return Integer.parseInt(value) > 0 ? OnOffType.ON : OnOffType.OFF;
 457                 default:
 458                     return StringType.valueOf(value);
 459             }
 460         } catch (NumberFormatException e) {
 461             return UnDefType.UNDEF;
 462         }
 463     }
 464
 465     /**
 466      * Creates channels based on what is supported by the controller.
 467      */
 468     private void updateChannels(Auxiliary[] auxes, OneTouch[] oneTouches) {
 469         List<Channel> channels = new ArrayList<>(getThing().getChannels());
 470         for (Auxiliary aux : auxes) {
 471             ChannelUID channelUID = new ChannelUID(getThing().getUID(), aux.getName());
 472             logger.debug("Add channel Aux Name: {} Label: {} Type: {} Subtype: {}", aux.getName(), aux.getLabel(),
 473                     aux.getType(), aux.getSubtype());
 474             switch (aux.getType()) {
 475                 case "1":
 476                     addNewChannelToList(channels, channelUID, "Dimmer",
 477                             IAqualinkBindingConstants.CHANNEL_TYPE_UID_AUX_DIMMER, aux.getLabel());
 478                     break;
 479                 case "2": {
 480                     addNewChannelToList(channels, channelUID, "String",
 481                             AuxiliaryType.fromSubType(aux.getSubtype()).getChannelTypeUID(), aux.getLabel());
 482                 }
 483                     break;
 484                 default:
 485                     addNewChannelToList(channels, channelUID, "Switch",
 486                             IAqualinkBindingConstants.CHANNEL_TYPE_UID_AUX_SWITCH, aux.getLabel());
 487             }
 488         }
 489
 490         for (OneTouch oneTouch : oneTouches) {
 491             if ("0".equals(oneTouch.getStatus())) {
 492                 // OneTouch is not enabled
 493                 continue;
 494             }
 495
 496             ChannelUID channelUID = new ChannelUID(getThing().getUID(), oneTouch.getName());
 497             addNewChannelToList(channels, channelUID, "Switch", IAqualinkBindingConstants.CHANNEL_TYPE_UID_ONETOUCH,
 498                     oneTouch.getLabel());
 499         }
 500
 501         ThingBuilder thingBuilder = editThing();
 502         thingBuilder.withChannels(channels);
 503         updateThing(thingBuilder.build());
 504     }
 505
 506     /**
 507      * Adds a channel to the list of channels if the channel does not exist or is of a different type
 508      *
 509      */
 510     private void addNewChannelToList(List<Channel> list, ChannelUID channelUID, String itemType,
 511             ChannelTypeUID channelType, String label) {
 512         // if there is no entry, add it
 513         if (!list.stream().anyMatch(c -> c.getUID().equals(channelUID))) {
 514             list.add(ChannelBuilder.create(channelUID, itemType).withType(channelType).withLabel(label).build());
 515         } else if (list.removeIf(c -> c.getUID().equals(channelUID) && !channelType.equals(c.getChannelTypeUID()))) {
 516             // this channel uid exists, but has a different type so remove and add our new one
 517             list.add(ChannelBuilder.create(channelUID, itemType).withType(channelType).withLabel(label).build());
 518         }
 519     }
 520
 521     /**
 522      * inspired by the openHAB Nest thermostat binding
 523      */
 524     @SuppressWarnings("unchecked")
 525     private @Nullable BigDecimal commandToRoundedTemperature(Command command, Unit<Temperature> unit)
 526             throws IllegalArgumentException {
 527         QuantityType<Temperature> quantity;
 528         if (command instanceof QuantityType) {
 529             quantity = (QuantityType<Temperature>) command;
 530         } else {
 531             quantity = new QuantityType<>(new BigDecimal(command.toString()), unit);
 532         }
 533
 534         QuantityType<Temperature> temparatureQuantity = quantity.toUnit(unit);
 535         if (temparatureQuantity == null) {
 536             return null;
 537         }
 538
 539         BigDecimal value = temparatureQuantity.toBigDecimal();
 540         BigDecimal increment = CELSIUS == unit ? new BigDecimal("0.5") : new BigDecimal("1");
 541         BigDecimal divisor = value.divide(increment, 0, RoundingMode.HALF_UP);
 542         return divisor.multiply(increment);
 543     }
 544
 545     private ChannelTypeUID getChannelTypeUID(ChannelUID channelUID) {
 546         Channel channel = getThing().getChannel(channelUID.getId());
 547         Objects.requireNonNull(channel);
 548         ChannelTypeUID channelTypeUID = channel.getChannelTypeUID();
 549         Objects.requireNonNull(channelTypeUID);
 550         return channelTypeUID;
 551     }
 552 }