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

   1 /**
   2  * Copyright (c) 2010-2022 Contributors to the openHAB project
   3  *
   4  * See the NOTICE file(s) distributed with this work for additional
   5  * information.
   6  *
   7  * This program and the accompanying materials are made available under the
   8  * terms of the Eclipse Public License 2.0 which is available at
   9  * http://www.eclipse.org/legal/epl-2.0
  10  *
  11  * SPDX-License-Identifier: EPL-2.0
  12  */
  13 package org.openhab.binding.shelly.internal.handler;
  14
  15 import static org.openhab.binding.shelly.internal.ShellyBindingConstants.*;
  16 import static org.openhab.binding.shelly.internal.api.ShellyApiJsonDTO.*;
  17 import static org.openhab.binding.shelly.internal.handler.ShellyComponents.*;
  18 import static org.openhab.binding.shelly.internal.util.ShellyUtils.*;
  19 import static org.openhab.core.thing.Thing.*;
  20
  21 import java.net.InetAddress;
  22 import java.net.UnknownHostException;
  23 import java.util.List;
  24 import java.util.Map;
  25 import java.util.TreeMap;
  26 import java.util.concurrent.ScheduledFuture;
  27 import java.util.concurrent.TimeUnit;
  28
  29 import org.eclipse.jdt.annotation.NonNullByDefault;
  30 import org.eclipse.jdt.annotation.Nullable;
  31 import org.eclipse.jetty.client.HttpClient;
  32 import org.openhab.binding.shelly.internal.api.ShellyApiException;
  33 import org.openhab.binding.shelly.internal.api.ShellyApiJsonDTO;
  34 import org.openhab.binding.shelly.internal.api.ShellyApiJsonDTO.ShellyInputState;
  35 import org.openhab.binding.shelly.internal.api.ShellyApiJsonDTO.ShellyOtaCheckResult;
  36 import org.openhab.binding.shelly.internal.api.ShellyApiJsonDTO.ShellySettingsDevice;
  37 import org.openhab.binding.shelly.internal.api.ShellyApiJsonDTO.ShellySettingsStatus;
  38 import org.openhab.binding.shelly.internal.api.ShellyApiResult;
  39 import org.openhab.binding.shelly.internal.api.ShellyDeviceProfile;
  40 import org.openhab.binding.shelly.internal.api.ShellyHttpApi;
  41 import org.openhab.binding.shelly.internal.coap.ShellyCoapHandler;
  42 import org.openhab.binding.shelly.internal.coap.ShellyCoapJSonDTO;
  43 import org.openhab.binding.shelly.internal.coap.ShellyCoapServer;
  44 import org.openhab.binding.shelly.internal.config.ShellyBindingConfiguration;
  45 import org.openhab.binding.shelly.internal.config.ShellyThingConfiguration;
  46 import org.openhab.binding.shelly.internal.discovery.ShellyThingCreator;
  47 import org.openhab.binding.shelly.internal.provider.ShellyChannelDefinitions;
  48 import org.openhab.binding.shelly.internal.provider.ShellyTranslationProvider;
  49 import org.openhab.binding.shelly.internal.util.ShellyChannelCache;
  50 import org.openhab.binding.shelly.internal.util.ShellyVersionDTO;
  51 import org.openhab.core.library.types.DecimalType;
  52 import org.openhab.core.library.types.OnOffType;
  53 import org.openhab.core.library.types.OpenClosedType;
  54 import org.openhab.core.library.types.QuantityType;
  55 import org.openhab.core.thing.Channel;
  56 import org.openhab.core.thing.ChannelUID;
  57 import org.openhab.core.thing.Thing;
  58 import org.openhab.core.thing.ThingStatus;
  59 import org.openhab.core.thing.ThingStatusDetail;
  60 import org.openhab.core.thing.ThingTypeUID;
  61 import org.openhab.core.thing.binding.BaseThingHandler;
  62 import org.openhab.core.thing.binding.builder.ThingBuilder;
  63 import org.openhab.core.types.Command;
  64 import org.openhab.core.types.RefreshType;
  65 import org.openhab.core.types.State;
  66 import org.openhab.core.types.UnDefType;
  67 import org.slf4j.Logger;
  68 import org.slf4j.LoggerFactory;
  69
  70 /**
  71  * The {@link ShellyBaseHandler} is responsible for handling commands, which are
  72  * sent to one of the channels.
  73  *
  74  * @author Markus Michels - Initial contribution
  75  */
  76 @NonNullByDefault
  77 public class ShellyBaseHandler extends BaseThingHandler implements ShellyDeviceListener, ShellyManagerInterface {
  78     protected final Logger logger = LoggerFactory.getLogger(ShellyBaseHandler.class);
  79     protected final ShellyChannelDefinitions channelDefinitions;
  80
  81     public String thingName = "";
  82     public String thingType = "";
  83
  84     protected final ShellyHttpApi api;
  85     protected ShellyBindingConfiguration bindingConfig;
  86     protected ShellyThingConfiguration config = new ShellyThingConfiguration();
  87     protected ShellyDeviceProfile profile = new ShellyDeviceProfile(); // init empty profile to avoid NPE
  88     protected ShellyDeviceStats stats = new ShellyDeviceStats();
  89     private final ShellyCoapHandler coap;
  90     public boolean autoCoIoT = false;
  91
  92     public final ShellyTranslationProvider messages;
  93     protected boolean stopping = false;
  94     private boolean channelsCreated = false;
  95
  96     private long watchdog = now();
  97
  98     private @Nullable ScheduledFuture<?> statusJob;
  99     public int scheduledUpdates = 0;
 100     private int skipCount = UPDATE_SKIP_COUNT;
 101     private int skipUpdate = 0;
 102     private boolean refreshSettings = false;
 103
 104     // delay before enabling channel
 105     private final int cacheCount = UPDATE_SETTINGS_INTERVAL_SECONDS / UPDATE_STATUS_INTERVAL_SECONDS;
 106     protected final ShellyChannelCache cache;
 107
 108     private String localIP = "";
 109     private String localPort = "";
 110
 111     private String lastWakeupReason = "";
 112     private int vibrationFilter = 0;
 113
 114     /**
 115      * Constructor
 116      *
 117      * @param thing The Thing object
 118      * @param bindingConfig The binding configuration (beside thing
 119      *            configuration)
 120      * @param coapServer coap server instance
 121      * @param localIP local IP address from networkAddressService
 122      * @param httpPort from httpService
 123      */
 124     public ShellyBaseHandler(final Thing thing, final ShellyTranslationProvider translationProvider,
 125             final ShellyBindingConfiguration bindingConfig, final ShellyCoapServer coapServer, final String localIP,
 126             int httpPort, final HttpClient httpClient) {
 127         super(thing);
 128
 129         this.messages = translationProvider;
 130         this.cache = new ShellyChannelCache(this);
 131         this.channelDefinitions = new ShellyChannelDefinitions(messages);
 132         this.bindingConfig = bindingConfig;
 133
 134         this.localIP = localIP;
 135         this.localPort = String.valueOf(httpPort);
 136         this.api = new ShellyHttpApi(thingName, config, httpClient);
 137
 138         coap = new ShellyCoapHandler(this, coapServer);
 139     }
 140
 141     /**
 142      * Schedule asynchronous Thing initialization, register thing to event dispatcher
 143      */
 144     @Override
 145     public void initialize() {
 146         // start background initialization:
 147         scheduler.schedule(() -> {
 148             boolean start = true;
 149             try {
 150                 initializeThingConfig();
 151                 logger.debug("{}: Device config: IP address={}, HTTP user/password={}/{}, update interval={}",
 152                         thingName, config.deviceIp, config.userId.isEmpty() ? "<non>" : config.userId,
 153                         config.password.isEmpty() ? "<none>" : "***", config.updateInterval);
 154                 logger.debug(
 155                         "{}: Configured Events: Button: {}, Switch (on/off): {}, Push: {}, Roller: {}, Sensor: {}, CoIoT: {}, Enable AutoCoIoT: {}",
 156                         thingName, config.eventsButton, config.eventsSwitch, config.eventsPush, config.eventsRoller,
 157                         config.eventsSensorReport, config.eventsCoIoT, bindingConfig.autoCoIoT);
 158                 updateStatus(ThingStatus.UNKNOWN, ThingStatusDetail.CONFIGURATION_PENDING,
 159                         messages.get("status.unknown.initializing"));
 160                 start = initializeThing();
 161             } catch (ShellyApiException e) {
 162                 ShellyApiResult res = e.getApiResult();
 163                 if (isAuthorizationFailed(res)) {
 164                     start = false;
 165                 }
 166                 logger.debug("{}: Unable to initialize: {}, retrying later", thingName, e.toString());
 167             } catch (IllegalArgumentException e) {
 168                 logger.debug("{}: Unable to initialize, retrying later", thingName, e);
 169             } finally {
 170                 // even this initialization failed we start the status update
 171                 // the updateJob will then try to auto-initialize the thing
 172                 // in this case the thing stays in status INITIALIZING
 173                 if (start) {
 174                     startUpdateJob();
 175                 }
 176             }
 177         }, 2, TimeUnit.SECONDS);
 178     }
 179
 180     /**
 181      * This routine is called every time the Thing configuration has been changed
 182      */
 183     @Override
 184     public void handleConfigurationUpdate(Map<String, Object> configurationParameters) {
 185         super.handleConfigurationUpdate(configurationParameters);
 186         logger.debug("{}: Thing config updated, re-initialize", thingName);
 187         coap.stop();
 188         requestUpdates(1, true);// force re-initialization
 189     }
 190
 191     /**
 192      * Initialize Thing: Initialize API access, get settings and initialize Device Profile
 193      * If the device is password protected and the credentials are missing or don't match the API access will throw an
 194      * Exception. In this case the thing type will be changed to shelly-unknown. The user has the option to edit the
 195      * thing config and set the correct credentials. The thing type will be changed to the requested one if the
 196      * credentials are correct and the API access is initialized successful.
 197      *
 198      * @throws ShellyApiException e.g. http returned non-ok response, check e.getMessage() for details.
 199      */
 200     private boolean initializeThing() throws ShellyApiException {
 201         // Init from thing type to have a basic profile, gets updated when device info is received from API
 202         stopping = false;
 203         refreshSettings = false;
 204         lastWakeupReason = "";
 205         profile.initFromThingType(thingType);
 206         api.setConfig(thingName, config);
 207         cache.setThingName(thingName);
 208         cache.clear();
 209
 210         logger.debug("{}: Start initializing thing {}, type {}, ip address {}, CoIoT: {}", thingName,
 211                 getThing().getLabel(), thingType, config.deviceIp, config.eventsCoIoT);
 212         if (config.deviceIp.isEmpty()) {
 213             setThingOffline(ThingStatusDetail.CONFIGURATION_ERROR, "config-status.error.missing-device-ip");
 214             return false;
 215         }
 216
 217         // Setup CoAP listener to we get the CoAP message, which triggers initialization even the thing could not be
 218         // fully initialized here. In this case the CoAP messages triggers auto-initialization (like the Action URL does
 219         // when enabled)
 220         if (config.eventsCoIoT && !profile.alwaysOn) {
 221             coap.start(thingName, config);
 222         }
 223
 224         // Initialize API access, exceptions will be catched by initialize()
 225         ShellySettingsDevice devInfo = api.getDevInfo();
 226         if (devInfo.auth && config.userId.isEmpty()) {
 227             setThingOffline(ThingStatusDetail.CONFIGURATION_ERROR, "offline.conf-error-no-credentials");
 228             return false;
 229         }
 230
 231         ShellyDeviceProfile tmpPrf = api.getDeviceProfile(thingType);
 232         if (this.getThing().getThingTypeUID().equals(THING_TYPE_SHELLYPROTECTED)) {
 233             changeThingType(thingName, tmpPrf.mode);
 234             return false; // force re-initialization
 235         }
 236         // Validate device mode
 237         String reqMode = thingType.contains("-") ? substringAfter(thingType, "-") : "";
 238         if (!reqMode.isEmpty() && !tmpPrf.mode.equals(reqMode)) {
 239             setThingOffline(ThingStatusDetail.CONFIGURATION_ERROR, "offline.conf-error-wrong-mode");
 240             return false;
 241         }
 242         if (!getString(devInfo.coiot).isEmpty()) {
 243             // New Shelly devices might use a different endpoint for the CoAP listener
 244             tmpPrf.coiotEndpoint = devInfo.coiot;
 245         }
 246         tmpPrf.auth = devInfo.auth; // missing in /settings
 247
 248         logger.debug("{}: Initializing device {}, type {}, Hardware: Rev: {}, batch {}; Firmware: {} / {}", thingName,
 249                 tmpPrf.hostname, tmpPrf.deviceType, tmpPrf.hwRev, tmpPrf.hwBatchId, tmpPrf.fwVersion, tmpPrf.fwDate);
 250         logger.debug("{}: Shelly settings info for {}: {}", thingName, tmpPrf.hostname, tmpPrf.settingsJson);
 251         logger.debug("{}: Device "
 252                 + "hasRelays:{} (numRelays={}),isRoller:{} (numRoller={}),isDimmer:{},numMeter={},isEMeter:{})"
 253                 + ",isSensor:{},isDS:{},hasBattery:{}{},isSense:{},isMotion:{},isLight:{},isBulb:{},isDuo:{},isRGBW2:{},inColor:{}"
 254                 + ",alwaysOn:{}, ,updatePeriod:{}sec", thingName, tmpPrf.hasRelays, tmpPrf.numRelays, tmpPrf.isRoller,
 255                 tmpPrf.numRollers, tmpPrf.isDimmer, tmpPrf.numMeters, tmpPrf.isEMeter, tmpPrf.isSensor, tmpPrf.isDW,
 256                 tmpPrf.hasBattery, tmpPrf.hasBattery ? " (low battery threshold=" + config.lowBattery + "%)" : "",
 257                 tmpPrf.isSense, tmpPrf.isMotion, tmpPrf.isLight, profile.isBulb, tmpPrf.isDuo, tmpPrf.isRGBW2,
 258                 tmpPrf.inColor, tmpPrf.alwaysOn, tmpPrf.updatePeriod);
 259
 260         // update thing properties
 261         tmpPrf.status = api.getStatus();
 262         tmpPrf.updateFromStatus(tmpPrf.status);
 263         updateProperties(tmpPrf, tmpPrf.status);
 264         checkVersion(tmpPrf, tmpPrf.status);
 265         if (config.eventsCoIoT && (tmpPrf.settings.coiot != null) && (tmpPrf.settings.coiot.enabled != null)) {
 266             String devpeer = getString(tmpPrf.settings.coiot.peer);
 267             String ourpeer = config.localIp + ":" + ShellyCoapJSonDTO.COIOT_PORT;
 268             if (!tmpPrf.settings.coiot.enabled || (profile.isMotion && devpeer.isEmpty())) {
 269                 try {
 270                     api.setCoIoTPeer(ourpeer);
 271                     logger.info("{}: CoIoT peer updated to {}", thingName, ourpeer);
 272                 } catch (ShellyApiException e) {
 273                     logger.warn("{}: Unable to set CoIoT peer: {}", thingName, e.toString());
 274                 }
 275             } else if (!devpeer.isEmpty() && !devpeer.equals(ourpeer)) {
 276                 logger.warn("{}: CoIoT peer in device settings does not point this to this host", thingName);
 277             }
 278         }
 279         if (autoCoIoT) {
 280             logger.debug("{}: Auto-CoIoT is enabled, disabling action urls", thingName);
 281             config.eventsCoIoT = true;
 282             config.eventsSwitch = false;
 283             config.eventsButton = false;
 284             config.eventsPush = false;
 285             config.eventsRoller = false;
 286             config.eventsSensorReport = false;
 287             api.setConfig(thingName, config);
 288         }
 289
 290         // All initialization done, so keep the profile and set Thing to ONLINE
 291         fillDeviceStatus(tmpPrf.status, false);
 292         postEvent(ALARM_TYPE_NONE, false);
 293         api.setActionURLs(); // register event urls
 294         if (config.eventsCoIoT) {
 295             logger.debug("{}: Starting CoIoT (autoCoIoT={}/{})", thingName, bindingConfig.autoCoIoT, autoCoIoT);
 296             coap.start(thingName, config);
 297         }
 298
 299         logger.debug("{}: Thing successfully initialized.", thingName);
 300         profile = tmpPrf;
 301         setThingOnline(); // if API call was successful the thing must be online
 302
 303         return true; // success
 304     }
 305
 306     /**
 307      * Handle Channel Commands
 308      */
 309     @Override
 310     public void handleCommand(ChannelUID channelUID, Command command) {
 311         try {
 312             if (command instanceof RefreshType) {
 313                 String channelId = channelUID.getId();
 314                 State value = cache.getValue(channelId);
 315                 if (value != UnDefType.NULL) {
 316                     updateState(channelId, value);
 317                 }
 318                 return;
 319             }
 320
 321             if (!profile.isInitialized()) {
 322                 logger.debug("{}: {}", thingName, messages.get("command.init", command));
 323                 initializeThing();
 324             } else {
 325                 profile = getProfile(false);
 326             }
 327
 328             boolean update = false;
 329             switch (channelUID.getIdWithoutGroup()) {
 330                 case CHANNEL_SENSE_KEY: // Shelly Sense: Send Key
 331                     logger.debug("{}: Send key {}", thingName, command);
 332                     api.sendIRKey(command.toString());
 333                     update = true;
 334                     break;
 335
 336                 case CHANNEL_LED_STATUS_DISABLE:
 337                     logger.debug("{}: Set STATUS LED disabled to {}", thingName, command);
 338                     api.setLedStatus(SHELLY_LED_STATUS_DISABLE, command == OnOffType.ON);
 339                     break;
 340                 case CHANNEL_LED_POWER_DISABLE:
 341                     logger.debug("{}: Set POWER LED disabled to {}", thingName, command);
 342                     api.setLedStatus(SHELLY_LED_POWER_DISABLE, command == OnOffType.ON);
 343                     break;
 344
 345                 case CHANNEL_SENSOR_SLEEPTIME:
 346                     logger.debug("{}: Set sensor sleep time to {}", thingName, command);
 347                     int value = (int) getNumber(command);
 348                     value = value > 0 ? Math.max(SHELLY_MOTION_SLEEPTIME_OFFSET, value - SHELLY_MOTION_SLEEPTIME_OFFSET)
 349                             : 0;
 350                     api.setSleepTime(value);
 351                     break;
 352                 case CHANNEL_CONTROL_PROFILE:
 353                     logger.debug("{}: Select profile {}", thingName, command);
 354                     int profile = (int) getNumber(command);
 355                     if (profile < 0 || profile > 5) {
 356                         logger.warn("{}: Invalid profile Id {} requested", thingName, profile);
 357                         break;
 358                     }
 359                     api.setProfile(0, profile);
 360                     break;
 361                 case CHANNEL_CONTROL_MODE:
 362                     logger.debug("{}: Set mode to {}", thingName, command);
 363                     api.setValveMode(0, SHELLY_TRV_MODE_AUTO.equalsIgnoreCase(command.toString()));
 364                     break;
 365                 case CHANNEL_CONTROL_SETTEMP:
 366                     logger.debug("{}: Set temperature to {}", thingName, command);
 367                     api.setTemperature(0, (int) getNumber(command));
 368                     break;
 369                 case CHANNEL_CONTROL_POSITION:
 370                     logger.debug("{}: Set position to {}", thingName, command);
 371                     api.setValvePosition(0, getNumber(command));
 372                     break;
 373                 case CHANNEL_CONTROL_BCONTROL:
 374                     logger.debug("{}: Set boost mode to {}", thingName, command);
 375                     api.startBoost(0, command == OnOffType.ON ? -1 : 0);
 376                     break;
 377                 case CHANNEL_CONTROL_BTIMER:
 378                     logger.debug("{}: Set boost timer to {}", thingName, command);
 379                     api.setBoostTime(0, (int) getNumber(command));
 380                     break;
 381
 382                 default:
 383                     update = handleDeviceCommand(channelUID, command);
 384                     break;
 385             }
 386
 387             restartWatchdog();
 388             if (update && !autoCoIoT && !isUpdateScheduled()) {
 389                 logger.debug("{}: Command process, request status update", thingName);
 390                 requestUpdates(1, false);
 391             }
 392         } catch (ShellyApiException e) {
 393             ShellyApiResult res = e.getApiResult();
 394             if (isAuthorizationFailed(res)) {
 395                 return;
 396             }
 397             if (res.isNotCalibrtated()) {
 398                 logger.warn("{}: {}", thingName, messages.get("roller.calibrating"));
 399             } else {
 400                 logger.warn("{}: {} - {}", thingName, messages.get("command.failed", command, channelUID),
 401                         e.toString());
 402             }
 403         } catch (IllegalArgumentException e) {
 404             logger.debug("{}: {}", thingName, messages.get("command.failed", command, channelUID));
 405         }
 406     }
 407
 408     private double getNumber(Command command) {
 409         if (command instanceof QuantityType) {
 410             return ((QuantityType<?>) command).doubleValue();
 411         }
 412         if (command instanceof DecimalType) {
 413             return ((DecimalType) command).doubleValue();
 414         }
 415         if (command instanceof Number) {
 416             return ((Number) command).doubleValue();
 417         }
 418         throw new IllegalArgumentException("Invalid Number type for conversion: " + command);
 419     }
 420
 421     /**
 422      * Update device status and channels
 423      */
 424     protected void refreshStatus() {
 425         try {
 426             boolean updated = false;
 427
 428             if (vibrationFilter > 0) {
 429                 vibrationFilter--;
 430                 logger.debug("{}: Vibration events are absorbed for {} more seconds", thingName,
 431                         vibrationFilter * UPDATE_STATUS_INTERVAL_SECONDS);
 432             }
 433
 434             skipUpdate++;
 435             ThingStatus thingStatus = getThing().getStatus();
 436             if (refreshSettings || (scheduledUpdates > 0) || (skipUpdate % skipCount == 0)) {
 437                 if (!profile.isInitialized() || ((thingStatus == ThingStatus.OFFLINE))
 438                         || (thingStatus == ThingStatus.UNKNOWN)) {
 439                     logger.debug("{}: Status update triggered thing initialization", thingName);
 440                     initializeThing(); // may fire an exception if initialization failed
 441                 }
 442                 // Get profile, if refreshSettings == true reload settings from device
 443                 logger.trace("{}: Updating status (scheduledUpdates={}, refreshSettings={})", thingName,
 444                         scheduledUpdates, refreshSettings);
 445                 ShellySettingsStatus status = api.getStatus();
 446                 boolean restarted = checkRestarted(status);
 447                 profile = getProfile(refreshSettings || restarted);
 448                 profile.status = status;
 449                 profile.updateFromStatus(status);
 450                 if (restarted) {
 451                     logger.debug("{}: Device restart #{} detected", thingName, stats.restarts);
 452                     stats.restarts++;
 453                     postEvent(ALARM_TYPE_RESTARTED, true);
 454                 }
 455
 456                 // If status update was successful the thing must be online
 457                 setThingOnline();
 458
 459                 // map status to channels
 460                 updateChannel(CHANNEL_GROUP_DEV_STATUS, CHANNEL_DEVST_NAME, getStringType(profile.settings.name));
 461                 updated |= this.updateDeviceStatus(status);
 462                 updated |= ShellyComponents.updateDeviceStatus(this, status);
 463                 fillDeviceStatus(status, updated);
 464                 updated |= updateInputs(status);
 465                 updated |= updateMeters(this, status);
 466                 updated |= updateSensors(this, status);
 467
 468                 // All channels must be created after the first cycle
 469                 channelsCreated = true;
 470
 471                 // Restart watchdog when status update was successful (no exception)
 472                 restartWatchdog();
 473             }
 474         } catch (ShellyApiException e) {
 475             // http call failed: go offline except for battery devices, which might be in
 476             // sleep mode. Once the next update is successful the device goes back online
 477             String status = "";
 478             ShellyApiResult res = e.getApiResult();
 479             if (isWatchdogStarted()) {
 480                 if (!isWatchdogExpired()) {
 481                     logger.debug("{}: Ignore API Timeout, retry later", thingName);
 482                 } else {
 483                     if (isThingOnline()) {
 484                         status = "offline.status-error-watchdog";
 485                     }
 486                 }
 487             } else if (res.isHttpAccessUnauthorized()) {
 488                 status = "offline.conf-error-access-denied";
 489             } else if (e.isJSONException()) {
 490                 status = "offline.status-error-unexpected-api-result";
 491                 logger.debug("{}: Unable to parse API response: {}; json={}", thingName, res.getUrl(), res.response, e);
 492             } else if (res.isHttpTimeout()) {
 493                 // Watchdog not started, e.g. device in sleep mode
 494                 if (isThingOnline()) { // ignore when already offline
 495                     status = "offline.status-error-watchdog";
 496                 }
 497             } else {
 498                 status = "offline.status-error-unexpected-api-result";
 499                 logger.debug("{}: Unexpected API result: {}", thingName, res.response, e);
 500             }
 501
 502             if (!status.isEmpty()) {
 503                 setThingOffline(ThingStatusDetail.COMMUNICATION_ERROR, status);
 504             }
 505         } catch (NullPointerException | IllegalArgumentException e) {
 506             logger.debug("{}: Unable to refresh status: {}", thingName, messages.get("statusupdate.failed"), e);
 507         } finally {
 508             if (scheduledUpdates > 0) {
 509                 --scheduledUpdates;
 510                 logger.trace("{}: {} more updates requested", thingName, scheduledUpdates);
 511             } else if ((skipUpdate >= cacheCount) && !cache.isEnabled()) {
 512                 logger.debug("{}: Enabling channel cache ({} updates / {}s)", thingName, skipUpdate,
 513                         cacheCount * UPDATE_STATUS_INTERVAL_SECONDS);
 514                 cache.enable();
 515             }
 516         }
 517     }
 518
 519     public boolean isThingOnline() {
 520         return getThing().getStatus() == ThingStatus.ONLINE;
 521     }
 522
 523     public boolean isThingOffline() {
 524         return getThing().getStatus() == ThingStatus.OFFLINE;
 525     }
 526
 527     @Override
 528     public void setThingOnline() {
 529         if (!isThingOnline()) {
 530             updateStatus(ThingStatus.ONLINE);
 531
 532             // request 3 updates in a row (during the first 2+3*3 sec)
 533             logger.debug("{}: Thing went online, request status update", thingName);
 534             requestUpdates(profile.alwaysOn ? 3 : 1, !channelsCreated);
 535         }
 536         restartWatchdog();
 537     }
 538
 539     @Override
 540     public void setThingOffline(ThingStatusDetail detail, String messageKey) {
 541         if (!isThingOffline()) {
 542             logger.debug("{}: Thing goes OFFLINE: {}", thingName, messages.get(messageKey));
 543             updateStatus(ThingStatus.OFFLINE, detail, "@text/" + messageKey);
 544             watchdog = 0;
 545             channelsCreated = false; // check for new channels after devices gets re-initialized (e.g. new
 546         }
 547     }
 548
 549     public synchronized void restartWatchdog() {
 550         watchdog = now();
 551         updateChannel(CHANNEL_GROUP_DEV_STATUS, CHANNEL_DEVST_HEARTBEAT, getTimestamp());
 552         logger.trace("{}: Watchdog restarted (expires in {} sec)", thingName, profile.updatePeriod);
 553     }
 554
 555     private boolean isWatchdogExpired() {
 556         long delta = now() - watchdog;
 557         if ((watchdog > 0) && (delta > profile.updatePeriod)) {
 558             stats.remainingWatchdog = delta;
 559             return true;
 560         }
 561         return false;
 562     }
 563
 564     private boolean isWatchdogStarted() {
 565         return watchdog > 0;
 566     }
 567
 568     public void reinitializeThing() {
 569         logger.debug("{}: Re-Initialize Thing", thingName);
 570         updateStatus(ThingStatus.UNKNOWN);
 571         requestUpdates(0, true);
 572     }
 573
 574     private void fillDeviceStatus(ShellySettingsStatus status, boolean updated) {
 575         String alarm = "";
 576
 577         // Update uptime and WiFi, internal temp
 578         ShellyComponents.updateDeviceStatus(this, status);
 579         stats.wifiRssi = status.wifiSta.rssi;
 580
 581         if (api.isInitialized()) {
 582             stats.timeoutErrors = api.getTimeoutErrors();
 583             stats.timeoutsRecorvered = api.getTimeoutsRecovered();
 584         }
 585         stats.remainingWatchdog = watchdog > 0 ? now() - watchdog : 0;
 586
 587         // Check various device indicators like overheating
 588         if (checkRestarted(status)) {
 589             // Force re-initialization on next status update
 590             if (profile.alwaysOn) {
 591                 reinitializeThing();
 592             }
 593         } else if (getBool(status.overtemperature)) {
 594             alarm = ALARM_TYPE_OVERTEMP;
 595         } else if (getBool(status.overload)) {
 596             alarm = ALARM_TYPE_OVERLOAD;
 597         } else if (getBool(status.loaderror)) {
 598             alarm = ALARM_TYPE_LOADERR;
 599         }
 600         State internalTemp = getChannelValue(CHANNEL_GROUP_DEV_STATUS, CHANNEL_DEVST_ITEMP);
 601         if (internalTemp != UnDefType.NULL) {
 602             int temp = ((Number) internalTemp).intValue();
 603             if (temp > stats.maxInternalTemp) {
 604                 logger.debug("{}: Max Internal Temp for device changed to {}", thingName, temp);
 605                 stats.maxInternalTemp = temp;
 606             }
 607         }
 608
 609         stats.lastUptime = getLong(status.uptime);
 610         stats.coiotMessages = coap.getMessageCount();
 611         stats.coiotErrors = coap.getErrorCount();
 612
 613         if (!alarm.isEmpty()) {
 614             postEvent(alarm, false);
 615         }
 616     }
 617
 618     /**
 619      * Check if device has restarted and needs a new Thing initialization
 620      *
 621      * @return true: restart detected
 622      */
 623
 624     private boolean checkRestarted(ShellySettingsStatus status) {
 625         if (profile.isInitialized() && profile.alwaysOn /* exclude battery powered devices */
 626                 && (status.uptime < stats.lastUptime || !profile.status.update.oldVersion.isEmpty()
 627                         && !status.update.oldVersion.equals(profile.status.update.oldVersion))) {
 628             updateProperties(profile, status);
 629             return true;
 630         }
 631         return false;
 632     }
 633
 634     /**
 635      * Save alarm to the lastAlarm channel
 636      *
 637      * @param alarm Alarm Message
 638      */
 639     public void postEvent(String event, boolean force) {
 640         String channelId = mkChannelId(CHANNEL_GROUP_DEV_STATUS, CHANNEL_DEVST_ALARM);
 641         State value = cache.getValue(channelId);
 642         String lastAlarm = value != UnDefType.NULL ? value.toString() : "";
 643
 644         if (force || !lastAlarm.equals(event)
 645                 || (lastAlarm.equals(event) && now() > stats.lastAlarmTs + HEALTH_CHECK_INTERVAL_SEC)) {
 646             switch (event) {
 647                 case "0": // DW2 1.8
 648                 case SHELLY_WAKEUPT_SENSOR:
 649                 case SHELLY_WAKEUPT_PERIODIC:
 650                 case SHELLY_WAKEUPT_BUTTON:
 651                 case SHELLY_WAKEUPT_POWERON:
 652                 case SHELLY_WAKEUPT_UNKNOWN:
 653                     logger.debug("{}: {}", thingName, messages.get("event.filtered", event));
 654                 case "":
 655                 case ALARM_TYPE_NONE:
 656                     break;
 657                 default:
 658                     logger.debug("{}: {}", thingName, messages.get("event.triggered", event));
 659                     triggerChannel(channelId, event);
 660                     cache.updateChannel(channelId, getStringType(event));
 661                     stats.lastAlarm = event;
 662                     stats.lastAlarmTs = now();
 663                     stats.alarms++;
 664             }
 665         }
 666     }
 667
 668     /**
 669      * Callback for device events
 670      *
 671      * @param deviceName device receiving the event
 672      * @param parameters parameters from the event URL
 673      * @param data the HTML input data
 674      * @return true if event was processed
 675      */
 676     @Override
 677     public boolean onEvent(String ipAddress, String deviceName, String deviceIndex, String type,
 678             Map<String, String> parameters) {
 679         if (thingName.equalsIgnoreCase(deviceName) || config.deviceIp.equals(ipAddress)) {
 680             logger.debug("{}: Event received: class={}, index={}, parameters={}", deviceName, type, deviceIndex,
 681                     parameters);
 682             int idx = !deviceIndex.isEmpty() ? Integer.parseInt(deviceIndex) : 1;
 683             if (!profile.isInitialized()) {
 684                 logger.debug("{}: Device is not yet initialized, event triggers initialization", deviceName);
 685                 requestUpdates(1, true);
 686             } else {
 687                 String group = profile.getControlGroup(idx);
 688                 if (group.isEmpty()) {
 689                     logger.debug("{}: Unsupported event class: {}", thingName, type);
 690                     return false;
 691                 }
 692
 693                 // map some of the events to system defined button triggers
 694                 String channel = "";
 695                 String onoff = "";
 696                 String payload = "";
 697                 String parmType = getString(parameters.get("type"));
 698                 String event = !parmType.isEmpty() ? parmType : type;
 699                 boolean isButton = profile.inButtonMode(idx - 1);
 700                 switch (event) {
 701                     case SHELLY_EVENT_SHORTPUSH:
 702                     case SHELLY_EVENT_DOUBLE_SHORTPUSH:
 703                     case SHELLY_EVENT_TRIPLE_SHORTPUSH:
 704                     case SHELLY_EVENT_LONGPUSH:
 705                         if (isButton) {
 706                             triggerButton(group, idx, mapButtonEvent(event));
 707                             channel = CHANNEL_BUTTON_TRIGGER + profile.getInputSuffix(idx);
 708                             payload = ShellyApiJsonDTO.mapButtonEvent(event);
 709                         } else {
 710                             logger.debug("{}: Relay button is not in memontary or detached mode, ignore SHORT/LONGPUSH",
 711                                     thingName);
 712                         }
 713                         break;
 714                     case SHELLY_EVENT_BTN_ON:
 715                     case SHELLY_EVENT_BTN_OFF:
 716                         if (profile.isRGBW2) {
 717                             // RGBW2 has only one input, so not per channel
 718                             group = CHANNEL_GROUP_LIGHT_CONTROL;
 719                         }
 720                         onoff = CHANNEL_INPUT;
 721                         break;
 722                     case SHELLY_EVENT_BTN1_ON:
 723                     case SHELLY_EVENT_BTN1_OFF:
 724                         onoff = CHANNEL_INPUT1;
 725                         break;
 726                     case SHELLY_EVENT_BTN2_ON:
 727                     case SHELLY_EVENT_BTN2_OFF:
 728                         onoff = CHANNEL_INPUT2;
 729                         break;
 730                     case SHELLY_EVENT_OUT_ON:
 731                     case SHELLY_EVENT_OUT_OFF:
 732                         onoff = CHANNEL_OUTPUT;
 733                         break;
 734                     case SHELLY_EVENT_ROLLER_OPEN:
 735                     case SHELLY_EVENT_ROLLER_CLOSE:
 736                     case SHELLY_EVENT_ROLLER_STOP:
 737                         channel = CHANNEL_EVENT_TRIGGER;
 738                         payload = event;
 739                         break;
 740                     case SHELLY_EVENT_SENSORREPORT:
 741                         // process sensor with next refresh
 742                         break;
 743                     case SHELLY_EVENT_TEMP_OVER: // DW2
 744                     case SHELLY_EVENT_TEMP_UNDER:
 745                         channel = CHANNEL_EVENT_TRIGGER;
 746                         payload = event;
 747                         break;
 748                     case SHELLY_EVENT_FLOOD_DETECTED:
 749                     case SHELLY_EVENT_FLOOD_GONE:
 750                         updateChannel(group, CHANNEL_SENSOR_FLOOD,
 751                                 event.equalsIgnoreCase(SHELLY_EVENT_FLOOD_DETECTED) ? OnOffType.ON : OnOffType.OFF);
 752                         break;
 753
 754                     case SHELLY_EVENT_CLOSE: // DW 1.7
 755                     case SHELLY_EVENT_OPEN: // DW 1.7
 756                         updateChannel(group, CHANNEL_SENSOR_STATE,
 757                                 event.equalsIgnoreCase(SHELLY_API_DWSTATE_OPEN) ? OpenClosedType.OPEN
 758                                         : OpenClosedType.CLOSED);
 759                         break;
 760
 761                     case SHELLY_EVENT_DARK: // DW 1.7
 762                     case SHELLY_EVENT_TWILIGHT: // DW 1.7
 763                     case SHELLY_EVENT_BRIGHT: // DW 1.7
 764                         updateChannel(group, CHANNEL_SENSOR_ILLUM, getStringType(event));
 765                         break;
 766
 767                     case SHELLY_EVENT_ALARM_MILD: // Shelly Gas
 768                     case SHELLY_EVENT_ALARM_HEAVY:
 769                     case SHELLY_EVENT_ALARM_OFF:
 770                     case SHELLY_EVENT_VIBRATION: // DW2
 771                         channel = CHANNEL_SENSOR_ALARM_STATE;
 772                         payload = event.toUpperCase();
 773                         break;
 774
 775                     default:
 776                         // trigger will be provided by input/output channel or sensor channels
 777                 }
 778
 779                 if (!onoff.isEmpty()) {
 780                     updateChannel(group, onoff, event.toLowerCase().contains("_on") ? OnOffType.ON : OnOffType.OFF);
 781                 }
 782                 if (!payload.isEmpty()) {
 783                     // Pass event to trigger channel
 784                     payload = payload.toUpperCase();
 785                     logger.debug("{}: Post event {}", thingName, payload);
 786                     triggerChannel(mkChannelId(group, channel), payload);
 787                 }
 788             }
 789
 790             // request update on next interval (2x for non-battery devices)
 791             restartWatchdog();
 792             requestUpdates(scheduledUpdates >= 2 ? 0 : !profile.hasBattery ? 2 : 1, true);
 793             return true;
 794         }
 795         return false;
 796     }
 797
 798     /**
 799      * Initialize the binding's thing configuration, calc update counts
 800      */
 801     protected void initializeThingConfig() {
 802         thingType = getThing().getThingTypeUID().getId();
 803         final Map<String, String> properties = getThing().getProperties();
 804         thingName = getString(properties.get(PROPERTY_SERVICE_NAME));
 805         if (thingName.isEmpty()) {
 806             thingName = getString(thingType + "-" + getString(getThing().getUID().getId())).toLowerCase();
 807             logger.debug("{}: Thing name derived from UID {}", thingName, getString(getThing().getUID().toString()));
 808         }
 809
 810         config = getConfigAs(ShellyThingConfiguration.class);
 811         if (config.deviceIp.isEmpty()) {
 812             logger.warn("{}: IP address for the device must not be empty", thingName); // may not set in .things file
 813             return;
 814         }
 815         try {
 816             InetAddress addr = InetAddress.getByName(config.deviceIp);
 817             String saddr = addr.getHostAddress();
 818             if (!config.deviceIp.equals(saddr)) {
 819                 logger.debug("{}: hostname {} resolved to IP address {}", thingName, config.deviceIp, saddr);
 820                 config.deviceIp = saddr;
 821             }
 822         } catch (UnknownHostException e) {
 823             logger.debug("{}: Unable to resolve hostname {}", thingName, config.deviceIp);
 824         }
 825
 826         config.localIp = localIP;
 827         config.localPort = localPort;
 828         if (config.userId.isEmpty() && !bindingConfig.defaultUserId.isEmpty()) {
 829             config.userId = bindingConfig.defaultUserId;
 830             config.password = bindingConfig.defaultPassword;
 831             logger.debug("{}: Using userId {} from bindingConfig", thingName, config.userId);
 832         }
 833         if (config.updateInterval == 0) {
 834             config.updateInterval = UPDATE_STATUS_INTERVAL_SECONDS * UPDATE_SKIP_COUNT;
 835         }
 836         if (config.updateInterval < UPDATE_MIN_DELAY) {
 837             config.updateInterval = UPDATE_MIN_DELAY;
 838         }
 839
 840         // Try to get updatePeriod from properties
 841         // For battery devinities the REST call to get the settings will most likely fail, because the device is in
 842         // sleep mode. Therefore we use the last saved property value as default. Will be overwritten, when device is
 843         // initialized successfully by the REST call.
 844         String lastPeriod = getString(properties.get(PROPERTY_UPDATE_PERIOD));
 845         if (!lastPeriod.isEmpty()) {
 846             int period = Integer.parseInt(lastPeriod);
 847             if (period > 0) {
 848                 profile.updatePeriod = period;
 849             }
 850         }
 851
 852         skipCount = config.updateInterval / UPDATE_STATUS_INTERVAL_SECONDS;
 853         logger.trace("{}: updateInterval = {}s -> skipCount = {}", thingName, config.updateInterval, skipCount);
 854     }
 855
 856     private void checkVersion(ShellyDeviceProfile prf, ShellySettingsStatus status) {
 857         try {
 858             ShellyVersionDTO version = new ShellyVersionDTO();
 859             if (version.checkBeta(getString(prf.fwVersion))) {
 860                 logger.info("{}: {}", prf.hostname, messages.get("versioncheck.beta", prf.fwVersion, prf.fwDate));
 861             } else {
 862                 if ((version.compare(prf.fwVersion, SHELLY_API_MIN_FWVERSION) < 0) && !profile.isMotion) {
 863                     logger.warn("{}: {}", prf.hostname,
 864                             messages.get("versioncheck.tooold", prf.fwVersion, prf.fwDate, SHELLY_API_MIN_FWVERSION));
 865                 }
 866             }
 867             if (bindingConfig.autoCoIoT && ((version.compare(prf.fwVersion, SHELLY_API_MIN_FWCOIOT)) >= 0)
 868                     || (prf.fwVersion.equalsIgnoreCase("production_test"))) {
 869                 if (!config.eventsCoIoT) {
 870                     logger.debug("{}: {}", thingName, messages.get("versioncheck.autocoiot"));
 871                 }
 872                 autoCoIoT = true;
 873             }
 874             if (status.update.hasUpdate && !version.checkBeta(getString(prf.fwVersion))) {
 875                 logger.info("{}: {}", thingName,
 876                         messages.get("versioncheck.update", status.update.oldVersion, status.update.newVersion));
 877             }
 878         } catch (NullPointerException e) { // could be inconsistant format of beta version
 879             logger.debug("{}: {}", thingName, messages.get("versioncheck.failed", prf.fwVersion));
 880         }
 881     }
 882
 883     /**
 884      * Checks the http response for authorization error.
 885      * If the authorization failed the binding can't access the device settings and determine the thing type. In this
 886      * case the thing type shelly-unknown is set.
 887      *
 888      * @param response exception details including the http respone
 889      * @return true if the authorization failed
 890      */
 891     private boolean isAuthorizationFailed(ShellyApiResult result) {
 892         if (result.isHttpAccessUnauthorized()) {
 893             // If the device is password protected the API doesn't provide settings to the device settings
 894             logger.warn("{}: {}", thingName, messages.get("init.protected"));
 895             setThingOffline(ThingStatusDetail.CONFIGURATION_ERROR, "offline.conf-error-access-denied");
 896             changeThingType(THING_TYPE_SHELLYPROTECTED_STR, "");
 897             return true;
 898         }
 899         return false;
 900     }
 901
 902     /**
 903      * Change type of this thing.
 904      *
 905      * @param thingType thing type acc. to the xml definition
 906      * @param mode Device mode (e.g. relay, roller)
 907      */
 908     private void changeThingType(String thingType, String mode) {
 909         ThingTypeUID thingTypeUID = ShellyThingCreator.getThingTypeUID(thingType, "", mode);
 910         if (!thingTypeUID.equals(THING_TYPE_SHELLYUNKNOWN)) {
 911             logger.debug("{}: Changing thing type to {}", getThing().getLabel(), thingTypeUID);
 912             Map<String, String> properties = editProperties();
 913             properties.replace(PROPERTY_DEV_TYPE, thingType);
 914             properties.replace(PROPERTY_DEV_MODE, mode);
 915             updateProperties(properties);
 916             changeThingType(thingTypeUID, getConfig());
 917         }
 918     }
 919
 920     @Override
 921     public void thingUpdated(Thing thing) {
 922         logger.debug("{}: Channel definitions updated.", thingName);
 923         super.thingUpdated(thing);
 924     }
 925
 926     /**
 927      * Start the background updates
 928      */
 929     protected void startUpdateJob() {
 930         ScheduledFuture<?> statusJob = this.statusJob;
 931         if ((statusJob == null) || statusJob.isCancelled()) {
 932             this.statusJob = scheduler.scheduleWithFixedDelay(this::refreshStatus, 2, UPDATE_STATUS_INTERVAL_SECONDS,
 933                     TimeUnit.SECONDS);
 934             logger.debug("{}: Update status job started, interval={}*{}={}sec.", thingName, skipCount,
 935                     UPDATE_STATUS_INTERVAL_SECONDS, skipCount * UPDATE_STATUS_INTERVAL_SECONDS);
 936         }
 937     }
 938
 939     /**
 940      * Flag the status job to do an exceptional update (something happened) rather
 941      * than waiting until the next regular poll
 942      *
 943      * @param requestCount number of polls to execute
 944      * @param refreshSettings true=force a /settings query
 945      * @return true=Update schedule, false=skipped (too many updates already
 946      *         scheduled)
 947      */
 948     @Override
 949     public boolean requestUpdates(int requestCount, boolean refreshSettings) {
 950         this.refreshSettings |= refreshSettings;
 951         if (refreshSettings) {
 952             if (requestCount == 0) {
 953                 logger.debug("{}: Request settings refresh", thingName);
 954             }
 955             scheduledUpdates = 1;
 956             return true;
 957         }
 958         if (scheduledUpdates < 10) { // < 30s
 959             scheduledUpdates += requestCount;
 960             return true;
 961         }
 962         return false;
 963     }
 964
 965     public boolean isUpdateScheduled() {
 966         return scheduledUpdates > 0;
 967     }
 968
 969     /**
 970      * Map input states to channels
 971      *
 972      * @param groupName Channel Group (relay / relay1...)
 973      *
 974      * @param status Shelly device status
 975      * @return true: one or more inputs were updated
 976      */
 977     public boolean updateInputs(ShellySettingsStatus status) {
 978         boolean updated = false;
 979
 980         if (status.inputs != null) {
 981             int idx = 0;
 982             boolean multiInput = status.inputs.size() >= 2; // device has multiple SW (inputs)
 983             for (ShellyInputState input : status.inputs) {
 984                 String group = profile.getControlGroup(idx);
 985                 String suffix = multiInput ? profile.getInputSuffix(idx) : "";
 986
 987                 if (!areChannelsCreated()) {
 988                     updateChannelDefinitions(
 989                             ShellyChannelDefinitions.createInputChannels(thing, profile, status, group));
 990                 }
 991
 992                 updated |= updateChannel(group, CHANNEL_INPUT + suffix, getOnOff(input.input));
 993                 if (input.event != null) {
 994                     updated |= updateChannel(group, CHANNEL_STATUS_EVENTTYPE + suffix, getStringType(input.event));
 995                     updated |= updateChannel(group, CHANNEL_STATUS_EVENTCOUNT + suffix, getDecimal(input.eventCount));
 996                 }
 997                 idx++;
 998             }
 999         } else {
1000             if (status.input != null) {
1001                 // RGBW2: a single int rather than an array
1002                 return updateChannel(profile.getControlGroup(0), CHANNEL_INPUT,
1003                         getInteger(status.input) == 0 ? OnOffType.OFF : OnOffType.ON);
1004             }
1005         }
1006         return updated;
1007     }
1008
1009     public boolean updateWakeupReason(@Nullable List<Object> valueArray) {
1010         boolean changed = false;
1011         if (valueArray != null && !valueArray.isEmpty()) {
1012             String reason = getString((String) valueArray.get(0));
1013             String newVal = valueArray.toString();
1014             changed = updateChannel(CHANNEL_GROUP_DEV_STATUS, CHANNEL_DEVST_WAKEUP, getStringType(reason));
1015             changed |= !lastWakeupReason.isEmpty() && !lastWakeupReason.equals(newVal);
1016             if (changed) {
1017                 postEvent(reason.toUpperCase(), true);
1018             }
1019             lastWakeupReason = newVal;
1020         }
1021         return changed;
1022     }
1023
1024     public void triggerButton(String group, int idx, String value) {
1025         String trigger = mapButtonEvent(value);
1026         if (trigger.isEmpty()) {
1027             return;
1028         }
1029
1030         logger.debug("{}: Update button state with {}/{}", thingName, value, trigger);
1031         triggerChannel(group,
1032                 profile.isRoller ? CHANNEL_EVENT_TRIGGER : CHANNEL_BUTTON_TRIGGER + profile.getInputSuffix(idx),
1033                 trigger);
1034         updateChannel(group, CHANNEL_LAST_UPDATE, getTimestamp());
1035         if (profile.alwaysOn) {
1036             // refresh status of the input channel
1037             requestUpdates(1, false);
1038         }
1039     }
1040
1041     public void publishState(String channelId, State value) {
1042         String id = channelId.contains("$") ? substringBefore(channelId, "$") : channelId;
1043         if (!stopping && isLinked(id)) {
1044             updateState(id, value);
1045             logger.debug("{}: Channel {} updated with {} (type {}).", thingName, channelId, value, value.getClass());
1046         }
1047     }
1048
1049     public boolean updateChannel(String group, String channel, State value) {
1050         return updateChannel(mkChannelId(group, channel), value, false);
1051     }
1052
1053     public boolean updateChannel(String channelId, State value, boolean force) {
1054         return !stopping && cache.updateChannel(channelId, value, force);
1055     }
1056
1057     @Override
1058     public State getChannelValue(String group, String channel) {
1059         return cache.getValue(group, channel);
1060     }
1061
1062     public double getChannelDouble(String group, String channel) {
1063         State value = getChannelValue(group, channel);
1064         if (value != UnDefType.NULL) {
1065             if (value instanceof QuantityType) {
1066                 return ((QuantityType<?>) value).toBigDecimal().doubleValue();
1067             }
1068             if (value instanceof DecimalType) {
1069                 return ((DecimalType) value).doubleValue();
1070             }
1071         }
1072         return -1;
1073     }
1074
1075     /**
1076      * Update Thing's channels according to available status information from the API
1077      *
1078      * @param thingHandler
1079      */
1080     protected void updateChannelDefinitions(Map<String, Channel> dynChannels) {
1081         if (channelsCreated) {
1082             return; // already done
1083         }
1084
1085         try {
1086             // Get subset of those channels that currently do not exist
1087             List<Channel> existingChannels = getThing().getChannels();
1088             for (Channel channel : existingChannels) {
1089                 String id = channel.getUID().getId();
1090                 if (dynChannels.containsKey(id)) {
1091                     dynChannels.remove(id);
1092                 }
1093             }
1094
1095             if (!dynChannels.isEmpty()) {
1096                 logger.debug("{}: Updating channel definitions, {} channels", thingName, dynChannels.size());
1097                 ThingBuilder thingBuilder = editThing();
1098                 for (Map.Entry<String, Channel> channel : dynChannels.entrySet()) {
1099                     Channel c = channel.getValue();
1100                     logger.debug("{}: Adding channel {}", thingName, c.getUID().getId());
1101                     thingBuilder.withChannel(c);
1102                 }
1103                 updateThing(thingBuilder.build());
1104                 logger.debug("{}: Channel definitions updated", thingName);
1105             }
1106         } catch (IllegalArgumentException e) {
1107             logger.debug("{}: Unable to update channel definitions", thingName, e);
1108         }
1109     }
1110
1111     public boolean areChannelsCreated() {
1112         return channelsCreated;
1113     }
1114
1115     /**
1116      * Update thing properties with dynamic values
1117      *
1118      * @param profile The device profile
1119      * @param status the /status result
1120      */
1121     protected void updateProperties(ShellyDeviceProfile profile, ShellySettingsStatus status) {
1122         logger.debug("{}: Update properties", thingName);
1123         Map<String, Object> properties = fillDeviceProperties(profile);
1124         String serviceName = getString(getThing().getProperties().get(PROPERTY_SERVICE_NAME));
1125         String hostname = getString(profile.settings.device.hostname).toLowerCase();
1126         if (serviceName.isEmpty()) {
1127             properties.put(PROPERTY_SERVICE_NAME, hostname);
1128             logger.trace("{}: Updated serrviceName to {}", thingName, hostname);
1129         }
1130         String deviceName = getString(profile.settings.name);
1131         if (!deviceName.isEmpty()) {
1132             properties.put(PROPERTY_DEV_NAME, deviceName);
1133         }
1134
1135         // add status properties
1136         if (status.wifiSta != null) {
1137             properties.put(PROPERTY_WIFI_NETW, getString(status.wifiSta.ssid));
1138         }
1139         if (status.update != null) {
1140             properties.put(PROPERTY_UPDATE_STATUS, getString(status.update.status));
1141             properties.put(PROPERTY_UPDATE_AVAILABLE, getBool(status.update.hasUpdate) ? "yes" : "no");
1142             properties.put(PROPERTY_UPDATE_CURR_VERS, getString(status.update.oldVersion));
1143             properties.put(PROPERTY_UPDATE_NEW_VERS, getString(status.update.newVersion));
1144         }
1145         properties.put(PROPERTY_COIOTAUTO, String.valueOf(autoCoIoT));
1146
1147         Map<String, String> thingProperties = new TreeMap<>();
1148         for (Map.Entry<String, Object> property : properties.entrySet()) {
1149             thingProperties.put(property.getKey(), (String) property.getValue());
1150         }
1151         flushProperties(thingProperties);
1152     }
1153
1154     /**
1155      * Add one property to the Thing Properties
1156      *
1157      * @param key Name of the property
1158      * @param value Value of the property
1159      */
1160     public void updateProperties(String key, String value) {
1161         Map<String, String> thingProperties = editProperties();
1162         if (thingProperties.containsKey(key)) {
1163             thingProperties.replace(key, value);
1164         } else {
1165             thingProperties.put(key, value);
1166         }
1167         updateProperties(thingProperties);
1168         logger.trace("{}: Properties updated", thingName);
1169     }
1170
1171     public void flushProperties(Map<String, String> propertyUpdates) {
1172         Map<String, String> thingProperties = editProperties();
1173         for (Map.Entry<String, String> property : propertyUpdates.entrySet()) {
1174             if (thingProperties.containsKey(property.getKey())) {
1175                 thingProperties.replace(property.getKey(), property.getValue());
1176             } else {
1177                 thingProperties.put(property.getKey(), property.getValue());
1178             }
1179         }
1180         updateProperties(thingProperties);
1181     }
1182
1183     /**
1184      * Get one property from the Thing Properties
1185      *
1186      * @param key property name
1187      * @return property value or "" if property is not set
1188      */
1189     public String getProperty(String key) {
1190         Map<String, String> thingProperties = getThing().getProperties();
1191         return getString(thingProperties.get(key));
1192     }
1193
1194     /**
1195      * Fill Thing Properties with device attributes
1196      *
1197      * @param profile Property Map to full
1198      * @return a full property map
1199      */
1200     public static Map<String, Object> fillDeviceProperties(ShellyDeviceProfile profile) {
1201         Map<String, Object> properties = new TreeMap<>();
1202         properties.put(PROPERTY_VENDOR, VENDOR);
1203         if (profile.isInitialized()) {
1204             properties.put(PROPERTY_MODEL_ID, getString(profile.settings.device.type));
1205             properties.put(PROPERTY_MAC_ADDRESS, profile.mac);
1206             properties.put(PROPERTY_FIRMWARE_VERSION, profile.fwVersion + "/" + profile.fwDate);
1207             properties.put(PROPERTY_DEV_MODE, profile.mode);
1208             properties.put(PROPERTY_NUM_RELAYS, String.valueOf(profile.numRelays));
1209             properties.put(PROPERTY_NUM_ROLLERS, String.valueOf(profile.numRollers));
1210             properties.put(PROPERTY_NUM_METER, String.valueOf(profile.numMeters));
1211             properties.put(PROPERTY_UPDATE_PERIOD, String.valueOf(profile.updatePeriod));
1212             if (!profile.hwRev.isEmpty()) {
1213                 properties.put(PROPERTY_HWREV, profile.hwRev);
1214                 properties.put(PROPERTY_HWBATCH, profile.hwBatchId);
1215             }
1216         }
1217         return properties;
1218     }
1219
1220     /**
1221      * Return device profile.
1222      *
1223      * @param ForceRefresh true=force refresh before returning, false=return without
1224      *            refresh
1225      * @return ShellyDeviceProfile instance
1226      * @throws ShellyApiException
1227      */
1228     @Override
1229     public ShellyDeviceProfile getProfile(boolean forceRefresh) throws ShellyApiException {
1230         try {
1231             refreshSettings |= forceRefresh;
1232             if (refreshSettings) {
1233                 profile = api.getDeviceProfile(thingType);
1234                 if (!isThingOnline()) {
1235                     logger.debug("{}:Device profile re-initialized (thingType={})", thingName, thingType);
1236                 }
1237             }
1238         } finally {
1239             refreshSettings = false;
1240         }
1241         return profile;
1242     }
1243
1244     @Override
1245     public ShellyDeviceProfile getProfile() {
1246         return profile;
1247     }
1248
1249     protected ShellyHttpApi getShellyApi() {
1250         return api;
1251     }
1252
1253     protected ShellyDeviceProfile getDeviceProfile() {
1254         return profile;
1255     }
1256
1257     public void triggerChannel(String group, String channel, String payload) {
1258         String triggerCh = mkChannelId(group, channel);
1259         logger.debug("{}: Send event {} to channel {}", thingName, triggerCh, payload);
1260         if (EVENT_TYPE_VIBRATION.contentEquals(payload)) {
1261             if (vibrationFilter == 0) {
1262                 vibrationFilter = VIBRATION_FILTER_SEC / UPDATE_STATUS_INTERVAL_SECONDS + 1;
1263                 logger.debug("{}: Duplicate vibration events will be absorbed for the next {} sec", thingName,
1264                         vibrationFilter * UPDATE_STATUS_INTERVAL_SECONDS);
1265             } else {
1266                 logger.debug("{}: Vibration event absorbed, {} sec remaining", thingName,
1267                         vibrationFilter * UPDATE_STATUS_INTERVAL_SECONDS);
1268                 return;
1269             }
1270         }
1271
1272         triggerChannel(triggerCh, payload);
1273     }
1274
1275     public void stop() {
1276         logger.debug("{}: Shutting down", thingName);
1277         ScheduledFuture<?> job = this.statusJob;
1278         if (job != null) {
1279             job.cancel(true);
1280             statusJob = null;
1281             logger.debug("{}: Shelly statusJob stopped", thingName);
1282         }
1283
1284         coap.stop();
1285         profile.initialized = false;
1286     }
1287
1288     /**
1289      * Shutdown thing, make sure background jobs are canceled
1290      */
1291     @Override
1292     public void dispose() {
1293         stopping = true;
1294         stop();
1295         super.dispose();
1296     }
1297
1298     /**
1299      * Device specific command handlers are overriding this method to do additional stuff
1300      */
1301     public boolean handleDeviceCommand(ChannelUID channelUID, Command command) throws ShellyApiException {
1302         return false;
1303     }
1304
1305     /**
1306      * Device specific handlers are overriding this method to do additional stuff
1307      */
1308     public boolean updateDeviceStatus(ShellySettingsStatus status) throws ShellyApiException {
1309         return false;
1310     }
1311
1312     @Override
1313     public String getThingName() {
1314         return thingName;
1315     }
1316
1317     @Override
1318     public void resetStats() {
1319         // reset statistics
1320         stats = new ShellyDeviceStats();
1321     }
1322
1323     @Override
1324     public ShellyDeviceStats getStats() {
1325         return stats;
1326     }
1327
1328     @Override
1329     public ShellyHttpApi getApi() {
1330         return api;
1331     }
1332
1333     public Map<String, String> getStatsProp() {
1334         return stats.asProperties();
1335     }
1336
1337     public String checkForUpdate() {
1338         try {
1339             ShellyOtaCheckResult result = api.checkForUpdate();
1340             return result.status;
1341         } catch (ShellyApiException e) {
1342             return "";
1343         }
1344     }
1345 }