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.homematic.internal.handler;
  14
  15 import static org.openhab.binding.homematic.internal.HomematicBindingConstants.*;
  16 import static org.openhab.binding.homematic.internal.misc.HomematicConstants.*;
  17
  18 import java.io.IOException;
  19 import java.math.BigDecimal;
  20 import java.util.ArrayList;
  21 import java.util.HashMap;
  22 import java.util.Iterator;
  23 import java.util.List;
  24 import java.util.Map;
  25 import java.util.Map.Entry;
  26 import java.util.Objects;
  27 import java.util.concurrent.Future;
  28
  29 import org.openhab.binding.homematic.internal.HomematicBindingConstants;
  30 import org.openhab.binding.homematic.internal.common.HomematicConfig;
  31 import org.openhab.binding.homematic.internal.communicator.HomematicGateway;
  32 import org.openhab.binding.homematic.internal.converter.ConverterException;
  33 import org.openhab.binding.homematic.internal.converter.ConverterFactory;
  34 import org.openhab.binding.homematic.internal.converter.ConverterTypeException;
  35 import org.openhab.binding.homematic.internal.converter.TypeConverter;
  36 import org.openhab.binding.homematic.internal.misc.HomematicClientException;
  37 import org.openhab.binding.homematic.internal.misc.HomematicConstants;
  38 import org.openhab.binding.homematic.internal.model.HmChannel;
  39 import org.openhab.binding.homematic.internal.model.HmDatapoint;
  40 import org.openhab.binding.homematic.internal.model.HmDatapointConfig;
  41 import org.openhab.binding.homematic.internal.model.HmDatapointInfo;
  42 import org.openhab.binding.homematic.internal.model.HmDevice;
  43 import org.openhab.binding.homematic.internal.model.HmParamsetType;
  44 import org.openhab.binding.homematic.internal.type.HomematicChannelTypeProvider;
  45 import org.openhab.binding.homematic.internal.type.HomematicTypeGeneratorImpl;
  46 import org.openhab.binding.homematic.internal.type.MetadataUtils;
  47 import org.openhab.binding.homematic.internal.type.UidUtils;
  48 import org.openhab.core.config.core.Configuration;
  49 import org.openhab.core.config.core.validation.ConfigValidationException;
  50 import org.openhab.core.library.types.OnOffType;
  51 import org.openhab.core.library.types.StopMoveType;
  52 import org.openhab.core.thing.Bridge;
  53 import org.openhab.core.thing.Channel;
  54 import org.openhab.core.thing.ChannelUID;
  55 import org.openhab.core.thing.Thing;
  56 import org.openhab.core.thing.ThingStatus;
  57 import org.openhab.core.thing.ThingStatusDetail;
  58 import org.openhab.core.thing.binding.BaseThingHandler;
  59 import org.openhab.core.thing.binding.ThingHandler;
  60 import org.openhab.core.thing.binding.builder.ChannelBuilder;
  61 import org.openhab.core.thing.type.ChannelType;
  62 import org.openhab.core.thing.type.ChannelTypeUID;
  63 import org.openhab.core.types.Command;
  64 import org.openhab.core.types.RefreshType;
  65 import org.openhab.core.types.State;
  66 import org.slf4j.Logger;
  67 import org.slf4j.LoggerFactory;
  68
  69 /**
  70  * The {@link HomematicThingHandler} is responsible for handling commands, which are sent to one of the channels.
  71  *
  72  * @author Gerhard Riegler - Initial contribution
  73  */
  74 public class HomematicThingHandler extends BaseThingHandler {
  75     private final Logger logger = LoggerFactory.getLogger(HomematicThingHandler.class);
  76     private final HomematicChannelTypeProvider channelTypeProvider;
  77     private Future<?> initFuture;
  78     private final Object initLock = new Object();
  79     private volatile boolean deviceDeletionPending = false;
  80
  81     public HomematicThingHandler(Thing thing, HomematicChannelTypeProvider channelTypeProvider) {
  82         super(thing);
  83         this.channelTypeProvider = channelTypeProvider;
  84     }
  85
  86     @Override
  87     public void initialize() {
  88         if (initFuture != null) {
  89             return;
  90         }
  91
  92         initFuture = scheduler.submit(() -> {
  93             initFuture = null;
  94             try {
  95                 synchronized (initLock) {
  96                     doInitializeInBackground();
  97                 }
  98             } catch (HomematicClientException ex) {
  99                 updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.CONFIGURATION_ERROR, ex.getMessage());
 100             } catch (IOException ex) {
 101                 updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.COMMUNICATION_ERROR, ex.getMessage());
 102             } catch (GatewayNotAvailableException ex) {
 103                 updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.BRIDGE_OFFLINE, ex.getMessage());
 104             } catch (Exception ex) {
 105                 logger.error("{}", ex.getMessage(), ex);
 106                 updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.NONE, ex.getMessage());
 107             }
 108         });
 109     }
 110
 111     private void doInitializeInBackground() throws GatewayNotAvailableException, HomematicClientException, IOException {
 112         HomematicGateway gateway = getHomematicGateway();
 113         HmDevice device = gateway.getDevice(UidUtils.getHomematicAddress(getThing()));
 114         HmChannel channelZero = device.getChannel(0);
 115         loadHomematicChannelValues(channelZero);
 116         updateStatus(device);
 117         logger.debug("Initializing thing '{}' from gateway '{}'", getThing().getUID(), gateway.getId());
 118
 119         // update properties
 120         Map<String, String> properties = editProperties();
 121         setProperty(properties, channelZero, PROPERTY_BATTERY_TYPE, VIRTUAL_DATAPOINT_NAME_BATTERY_TYPE);
 122         setProperty(properties, channelZero, Thing.PROPERTY_FIRMWARE_VERSION, VIRTUAL_DATAPOINT_NAME_FIRMWARE);
 123         setProperty(properties, channelZero, Thing.PROPERTY_SERIAL_NUMBER, device.getAddress());
 124         setProperty(properties, channelZero, PROPERTY_AES_KEY, DATAPOINT_NAME_AES_KEY);
 125         updateProperties(properties);
 126
 127         // update data point list for reconfigurable channels
 128         for (HmChannel channel : device.getChannels()) {
 129             if (channel.isReconfigurable()) {
 130                 loadHomematicChannelValues(channel);
 131                 if (channel.checkForChannelFunctionChange()) {
 132                     gateway.updateChannelValueDatapoints(channel);
 133                 }
 134             }
 135         }
 136
 137         // update configurations
 138         Configuration config = editConfiguration();
 139         for (HmChannel channel : device.getChannels()) {
 140             loadHomematicChannelValues(channel);
 141             for (HmDatapoint dp : channel.getDatapoints()) {
 142                 if (dp.getParamsetType() == HmParamsetType.MASTER) {
 143                     config.put(MetadataUtils.getParameterName(dp),
 144                             dp.isEnumType() ? dp.getOptionValue() : dp.getValue());
 145                 }
 146             }
 147         }
 148         updateConfiguration(config);
 149
 150         boolean channelsChanged = false;
 151
 152         // update thing channel list for reconfigurable channels (relies on the new value of the
 153         // CHANNEL_FUNCTION datapoint fetched during configuration update)
 154         List<Channel> thingChannels = new ArrayList<>(getThing().getChannels());
 155
 156         if (thingChannels.isEmpty()) {
 157             for (HmChannel channel : device.getChannels()) {
 158                 for (HmDatapoint dp : channel.getDatapoints()) {
 159                     if (HomematicTypeGeneratorImpl.isIgnoredDatapoint(dp)
 160                             || dp.getParamsetType() != HmParamsetType.VALUES) {
 161                         continue;
 162                     }
 163                     ChannelUID channelUID = UidUtils.generateChannelUID(dp, getThing().getUID());
 164                     if (containsChannel(thingChannels, channelUID)) {
 165                         // Channel is already present
 166                         continue;
 167                     }
 168
 169                     ChannelTypeUID channelTypeUID = UidUtils.generateChannelTypeUID(dp);
 170                     ChannelType channelType = channelTypeProvider.getInternalChannelType(channelTypeUID);
 171                     if (channelType == null) {
 172                         channelType = HomematicTypeGeneratorImpl.createChannelType(dp, channelTypeUID);
 173                         channelTypeProvider.addChannelType(channelType);
 174                     }
 175
 176                     Channel thingChannel = ChannelBuilder.create(channelUID, MetadataUtils.getItemType(dp))
 177                             .withLabel(MetadataUtils.getLabel(dp))
 178                             .withDescription(MetadataUtils.getDatapointDescription(dp)).withType(channelType.getUID())
 179                             .build();
 180                     thingChannels.add(thingChannel);
 181
 182                     logger.debug(
 183                             "Updated value datapoints for channel {} of device '{}' (function {}), now has {} datapoints",
 184                             channel, channel.getDevice().getAddress(), channel.getCurrentFunction(),
 185                             channel.getDatapoints().size());
 186                 }
 187             }
 188             channelsChanged = true;
 189         }
 190
 191         if (updateDynamicChannelList(device, thingChannels)) {
 192             channelsChanged = true;
 193         }
 194
 195         if (channelsChanged) {
 196             updateThing(editThing().withChannels(thingChannels).build());
 197         }
 198
 199         thingChannels.forEach(channel -> {
 200             if (isLinked(channel.getUID())) {
 201                 channelLinked(channel.getUID());
 202             }
 203         });
 204     }
 205
 206     /**
 207      * Update the given thing channel list to reflect the device's current datapoint set
 208      *
 209      * @return true if the list was modified, false if it was not modified
 210      */
 211     private boolean updateDynamicChannelList(HmDevice device, List<Channel> thingChannels) {
 212         boolean changed = false;
 213         for (HmChannel channel : device.getChannels()) {
 214             if (!channel.isReconfigurable()) {
 215                 continue;
 216             }
 217             final String expectedFunction = channel
 218                     .getDatapoint(HmParamsetType.MASTER, HomematicConstants.DATAPOINT_NAME_CHANNEL_FUNCTION)
 219                     .getOptionValue();
 220             final String propertyName = String.format(PROPERTY_DYNAMIC_FUNCTION_FORMAT, channel.getNumber());
 221
 222             // remove thing channels that were configured for a different function
 223             Iterator<Channel> channelIter = thingChannels.iterator();
 224             while (channelIter.hasNext()) {
 225                 Map<String, String> properties = channelIter.next().getProperties();
 226                 String function = properties.get(propertyName);
 227                 if (function != null && !function.equals(expectedFunction)) {
 228                     channelIter.remove();
 229                     changed = true;
 230                 }
 231             }
 232             for (HmDatapoint dp : channel.getDatapoints()) {
 233                 if (HomematicTypeGeneratorImpl.isIgnoredDatapoint(dp)
 234                         || dp.getParamsetType() != HmParamsetType.VALUES) {
 235                     continue;
 236                 }
 237                 ChannelUID channelUID = UidUtils.generateChannelUID(dp, getThing().getUID());
 238                 if (containsChannel(thingChannels, channelUID)) {
 239                     // Channel is already present -> channel configuration likely hasn't changed
 240                     continue;
 241                 }
 242
 243                 Map<String, String> channelProps = new HashMap<>();
 244                 channelProps.put(propertyName, expectedFunction);
 245
 246                 ChannelTypeUID channelTypeUID = UidUtils.generateChannelTypeUID(dp);
 247                 ChannelType channelType = channelTypeProvider.getInternalChannelType(channelTypeUID);
 248                 if (channelType == null) {
 249                     channelType = HomematicTypeGeneratorImpl.createChannelType(dp, channelTypeUID);
 250                     channelTypeProvider.addChannelType(channelType);
 251                 }
 252
 253                 Channel thingChannel = ChannelBuilder.create(channelUID, MetadataUtils.getItemType(dp))
 254                         .withProperties(channelProps).withLabel(MetadataUtils.getLabel(dp))
 255                         .withDescription(MetadataUtils.getDatapointDescription(dp)).withType(channelType.getUID())
 256                         .build();
 257                 thingChannels.add(thingChannel);
 258                 changed = true;
 259             }
 260         }
 261
 262         return changed;
 263     }
 264
 265     /**
 266      * Checks whether the given list includes a channel with the given UID
 267      */
 268     private static boolean containsChannel(List<Channel> channels, ChannelUID channelUID) {
 269         for (Channel channel : channels) {
 270             ChannelUID uid = channel.getUID();
 271             if (Objects.equals(channelUID.getGroupId(), uid.getGroupId())
 272                     && Objects.equals(channelUID.getId(), uid.getId())) {
 273                 return true;
 274             }
 275         }
 276         return false;
 277     }
 278
 279     /**
 280      * Sets a thing property with a datapoint value.
 281      */
 282     private void setProperty(Map<String, String> properties, HmChannel channelZero, String propertyName,
 283             String datapointName) {
 284         HmDatapoint dp = channelZero
 285                 .getDatapoint(new HmDatapointInfo(HmParamsetType.VALUES, channelZero, datapointName));
 286         if (dp != null) {
 287             properties.put(propertyName, Objects.toString(dp.getValue(), ""));
 288         }
 289     }
 290
 291     @Override
 292     public void channelLinked(ChannelUID channelUID) {
 293         handleRefresh(channelUID);
 294     }
 295
 296     /**
 297      * Updates the state of the given channel.
 298      */
 299     protected void handleRefresh(ChannelUID channelUID) {
 300         try {
 301             if (thing.getStatus() == ThingStatus.ONLINE) {
 302                 logger.debug("Updating channel '{}' from thing id '{}'", channelUID, getThing().getUID().getId());
 303                 updateChannelState(channelUID);
 304             }
 305         } catch (Exception ex) {
 306             logger.warn("{}", ex.getMessage());
 307         }
 308     }
 309
 310     @Override
 311     public void handleCommand(ChannelUID channelUID, Command command) {
 312         logger.debug("Received command '{}' for channel '{}'", command, channelUID);
 313         HmDatapoint dp = null;
 314         try {
 315             HomematicGateway gateway = getHomematicGateway();
 316             HmDatapointInfo dpInfo = UidUtils.createHmDatapointInfo(channelUID);
 317             if (RefreshType.REFRESH == command) {
 318                 logger.debug("Refreshing {}", dpInfo);
 319                 dpInfo = new HmDatapointInfo(dpInfo.getAddress(), HmParamsetType.VALUES, 0,
 320                         VIRTUAL_DATAPOINT_NAME_RELOAD_FROM_GATEWAY);
 321                 dp = gateway.getDatapoint(dpInfo);
 322                 sendDatapoint(dp, new HmDatapointConfig(), Boolean.TRUE);
 323             } else {
 324                 Channel channel = getThing().getChannel(channelUID.getId());
 325                 if (channel == null) {
 326                     logger.warn("Channel '{}' not found in thing '{}' on gateway '{}'", channelUID, getThing().getUID(),
 327                             gateway.getId());
 328                 } else {
 329                     if (StopMoveType.STOP == command && DATAPOINT_NAME_LEVEL.equals(dpInfo.getName())) {
 330                         // special case with stop type (rollershutter)
 331                         dpInfo.setName(DATAPOINT_NAME_STOP);
 332                         HmDatapoint stopDp = gateway.getDatapoint(dpInfo);
 333                         ChannelUID stopChannelUID = UidUtils.generateChannelUID(stopDp, getThing().getUID());
 334                         handleCommand(stopChannelUID, OnOffType.ON);
 335                     } else {
 336                         dp = gateway.getDatapoint(dpInfo);
 337                         TypeConverter<?> converter = ConverterFactory.createConverter(channel.getAcceptedItemType());
 338                         Object newValue = converter.convertToBinding(command, dp);
 339                         HmDatapointConfig config = getChannelConfig(channel, dp);
 340                         sendDatapoint(dp, config, newValue);
 341                     }
 342                 }
 343             }
 344         } catch (HomematicClientException | GatewayNotAvailableException ex) {
 345             logger.warn("{}", ex.getMessage());
 346         } catch (IOException ex) {
 347             if (dp != null && dp.getChannel().getDevice().isOffline()) {
 348                 logger.warn("Device '{}' is OFFLINE, can't send command '{}' for channel '{}'",
 349                         dp.getChannel().getDevice().getAddress(), command, channelUID);
 350                 logger.trace("{}", ex.getMessage(), ex);
 351             } else {
 352                 logger.error("{}", ex.getMessage(), ex);
 353             }
 354         } catch (ConverterTypeException ex) {
 355             logger.warn("{}, please check the item type and the commands in your scripts", ex.getMessage());
 356         } catch (Exception ex) {
 357             logger.error("{}", ex.getMessage(), ex);
 358         }
 359     }
 360
 361     private void sendDatapoint(HmDatapoint dp, HmDatapointConfig config, Object newValue)
 362             throws IOException, HomematicClientException, GatewayNotAvailableException {
 363         String rxMode = getRxModeForDatapointTransmission(dp.getName(), dp.getValue(), newValue);
 364         getHomematicGateway().sendDatapoint(dp, config, newValue, rxMode);
 365     }
 366
 367     /**
 368      * Returns the rx mode that shall be used for transmitting a new value of a datapoint to the device. The
 369      * HomematicThingHandler always uses the default rx mode; custom thing handlers can override this method to
 370      * adjust the rx mode.
 371      *
 372      * @param datapointName The datapoint that will be updated on the device
 373      * @param currentValue The current value of the datapoint
 374      * @param newValue The value that will be sent to the device
 375      * @return The rxMode ({@link HomematicBindingConstants#RX_BURST_MODE "BURST"} for burst mode,
 376      *         {@link HomematicBindingConstants#RX_WAKEUP_MODE "WAKEUP"} for wakeup mode, or null for the default mode)
 377      */
 378     protected String getRxModeForDatapointTransmission(String datapointName, Object currentValue, Object newValue) {
 379         return null;
 380     }
 381
 382     /**
 383      * Evaluates the channel and datapoint for this channelUID and updates the state of the channel.
 384      */
 385     private void updateChannelState(ChannelUID channelUID)
 386             throws GatewayNotAvailableException, HomematicClientException, IOException, ConverterException {
 387         HomematicGateway gateway = getHomematicGateway();
 388         HmDatapointInfo dpInfo = UidUtils.createHmDatapointInfo(channelUID);
 389         HmDatapoint dp = gateway.getDatapoint(dpInfo);
 390         Channel channel = getThing().getChannel(channelUID.getId());
 391         updateChannelState(dp, channel);
 392     }
 393
 394     /**
 395      * Sets the configuration or evaluates the channel for this datapoint and updates the state of the channel.
 396      */
 397     protected void updateDatapointState(HmDatapoint dp) {
 398         try {
 399             updateStatus(dp.getChannel().getDevice());
 400
 401             if (dp.getParamsetType() == HmParamsetType.MASTER) {
 402                 // update configuration
 403                 Configuration config = editConfiguration();
 404                 config.put(MetadataUtils.getParameterName(dp), dp.isEnumType() ? dp.getOptionValue() : dp.getValue());
 405                 updateConfiguration(config);
 406             } else if (!HomematicTypeGeneratorImpl.isIgnoredDatapoint(dp)) {
 407                 // update channel
 408                 ChannelUID channelUID = UidUtils.generateChannelUID(dp, thing.getUID());
 409                 Channel channel = thing.getChannel(channelUID.getId());
 410                 if (channel != null) {
 411                     updateChannelState(dp, channel);
 412                 } else {
 413                     logger.warn("Channel not found for datapoint '{}'", new HmDatapointInfo(dp));
 414                 }
 415             }
 416         } catch (GatewayNotAvailableException ex) {
 417             // ignore
 418         } catch (Exception ex) {
 419             logger.error("{}", ex.getMessage(), ex);
 420         }
 421     }
 422
 423     /**
 424      * Converts the value of the datapoint to a State, updates the channel and also sets the thing status if necessary.
 425      */
 426     private void updateChannelState(final HmDatapoint dp, Channel channel)
 427             throws IOException, GatewayNotAvailableException, ConverterException {
 428         if (dp.isTrigger()) {
 429             final Object value = dp.getValue();
 430             if (value != null && !value.equals(dp.getPreviousValue())) {
 431                 triggerChannel(channel.getUID(), value.toString());
 432             }
 433         } else if (isLinked(channel)) {
 434             loadHomematicChannelValues(dp.getChannel());
 435
 436             TypeConverter<?> converter = ConverterFactory.createConverter(channel.getAcceptedItemType());
 437             State state = converter.convertFromBinding(dp);
 438             if (state != null) {
 439                 updateState(channel.getUID(), state);
 440             } else {
 441                 logger.debug("Failed to get converted state from datapoint '{}'", dp.getName());
 442             }
 443         }
 444     }
 445
 446     /**
 447      * Loads all values for the given Homematic channel if it is not initialized.
 448      */
 449     private void loadHomematicChannelValues(HmChannel hmChannel) throws GatewayNotAvailableException, IOException {
 450         if (!hmChannel.isInitialized()) {
 451             synchronized (this) {
 452                 if (!hmChannel.isInitialized()) {
 453                     try {
 454                         getHomematicGateway().loadChannelValues(hmChannel);
 455                     } catch (IOException ex) {
 456                         if (hmChannel.getDevice().isOffline()) {
 457                             logger.warn("Device '{}' is OFFLINE, can't update channel '{}'",
 458                                     hmChannel.getDevice().getAddress(), hmChannel.getNumber());
 459                         } else {
 460                             throw ex;
 461                         }
 462                     }
 463                 }
 464             }
 465         }
 466     }
 467
 468     /**
 469      * Updates the thing status based on device status.
 470      */
 471     private void updateStatus(HmDevice device) throws GatewayNotAvailableException, IOException {
 472         loadHomematicChannelValues(device.getChannel(0));
 473
 474         ThingStatus oldStatus = thing.getStatus();
 475         if (oldStatus == ThingStatus.UNINITIALIZED) {
 476             return;
 477         }
 478         ThingStatus newStatus = ThingStatus.ONLINE;
 479         ThingStatusDetail newDetail = ThingStatusDetail.NONE;
 480
 481         if ((getBridge() != null) && (getBridge().getStatus() == ThingStatus.OFFLINE)) {
 482             newStatus = ThingStatus.OFFLINE;
 483             newDetail = ThingStatusDetail.BRIDGE_OFFLINE;
 484         } else if (device.isFirmwareUpdating()) {
 485             newStatus = ThingStatus.OFFLINE;
 486             newDetail = ThingStatusDetail.FIRMWARE_UPDATING;
 487         } else if (device.isUnreach()) {
 488             newStatus = ThingStatus.OFFLINE;
 489             newDetail = ThingStatusDetail.COMMUNICATION_ERROR;
 490         } else if (device.isConfigPending() || device.isUpdatePending()) {
 491             newDetail = ThingStatusDetail.CONFIGURATION_PENDING;
 492         }
 493
 494         if (thing.getStatus() != newStatus || thing.getStatusInfo().getStatusDetail() != newDetail) {
 495             updateStatus(newStatus, newDetail);
 496         }
 497         if (oldStatus == ThingStatus.OFFLINE && newStatus == ThingStatus.ONLINE) {
 498             initialize();
 499         }
 500     }
 501
 502     /**
 503      * Returns true, if the channel is linked at least to one item.
 504      */
 505     private boolean isLinked(Channel channel) {
 506         return channel != null && super.isLinked(channel.getUID().getId());
 507     }
 508
 509     /**
 510      * Returns the channel config for the given datapoint.
 511      */
 512     protected HmDatapointConfig getChannelConfig(HmDatapoint dp) {
 513         ChannelUID channelUid = UidUtils.generateChannelUID(dp, getThing().getUID());
 514         Channel channel = getThing().getChannel(channelUid.getId());
 515         return channel != null ? getChannelConfig(channel, dp) : new HmDatapointConfig();
 516     }
 517
 518     /**
 519      * Returns the config for a channel.
 520      */
 521     private HmDatapointConfig getChannelConfig(Channel channel, HmDatapoint dp) {
 522         return channel.getConfiguration().as(HmDatapointConfig.class);
 523     }
 524
 525     /**
 526      * Returns the Homematic gateway if the bridge is available.
 527      */
 528     private HomematicGateway getHomematicGateway() throws GatewayNotAvailableException {
 529         final Bridge bridge = getBridge();
 530         if (bridge != null) {
 531             HomematicBridgeHandler bridgeHandler = (HomematicBridgeHandler) bridge.getHandler();
 532             if (bridgeHandler != null && bridgeHandler.getGateway() != null) {
 533                 return bridgeHandler.getGateway();
 534             }
 535         }
 536
 537         throw new GatewayNotAvailableException("HomematicGateway not yet available!");
 538     }
 539
 540     @Override
 541     public void handleConfigurationUpdate(Map<String, Object> configurationParameters)
 542             throws ConfigValidationException {
 543         super.handleConfigurationUpdate(configurationParameters);
 544
 545         try {
 546             HomematicGateway gateway = getHomematicGateway();
 547             HmDevice device = gateway.getDevice(UidUtils.getHomematicAddress(getThing()));
 548
 549             for (Entry<String, Object> configurationParameter : configurationParameters.entrySet()) {
 550                 String key = configurationParameter.getKey();
 551                 Object newValue = configurationParameter.getValue();
 552
 553                 if (key.startsWith("HMP_")) {
 554                     key = key.substring(4);
 555                     int sepPos = key.indexOf("_");
 556                     Integer channelNumber = Integer.valueOf(key.substring(0, sepPos));
 557                     String dpName = key.substring(sepPos + 1);
 558
 559                     HmDatapointInfo dpInfo = new HmDatapointInfo(device.getAddress(), HmParamsetType.MASTER,
 560                             channelNumber, dpName);
 561                     HmDatapoint dp = device.getChannel(channelNumber).getDatapoint(dpInfo);
 562
 563                     if (dp != null) {
 564                         try {
 565                             if (newValue != null) {
 566                                 if (newValue instanceof BigDecimal) {
 567                                     final BigDecimal decimal = (BigDecimal) newValue;
 568                                     if (dp.isIntegerType()) {
 569                                         newValue = decimal.intValue();
 570                                     } else if (dp.isFloatType()) {
 571                                         newValue = decimal.doubleValue();
 572                                     }
 573                                 }
 574                                 if (!Objects.equals(dp.isEnumType() ? dp.getOptionValue() : dp.getValue(), newValue)) {
 575                                     sendDatapoint(dp, new HmDatapointConfig(), newValue);
 576                                 }
 577                             }
 578                         } catch (IOException ex) {
 579                             logger.error("Error setting thing property {}: {}", dpInfo, ex.getMessage());
 580                         }
 581                     } else {
 582                         logger.error("Can't find datapoint for thing property {}", dpInfo);
 583                     }
 584                 }
 585             }
 586             gateway.triggerDeviceValuesReload(device);
 587         } catch (HomematicClientException | GatewayNotAvailableException ex) {
 588             logger.error("Error setting thing properties: {}", ex.getMessage(), ex);
 589         }
 590     }
 591
 592     @SuppressWarnings("null")
 593     @Override
 594     public synchronized void handleRemoval() {
 595         final Bridge bridge;
 596         final ThingHandler handler;
 597
 598         if ((bridge = getBridge()) == null || (handler = bridge.getHandler()) == null) {
 599             super.handleRemoval();
 600             return;
 601         }
 602
 603         final HomematicConfig config = bridge.getConfiguration().as(HomematicConfig.class);
 604         final boolean factoryResetOnDeletion = config.isFactoryResetOnDeletion();
 605         final boolean unpairOnDeletion = factoryResetOnDeletion || config.isUnpairOnDeletion();
 606
 607         if (unpairOnDeletion) {
 608             deviceDeletionPending = true;
 609             ((HomematicBridgeHandler) handler).deleteFromGateway(UidUtils.getHomematicAddress(thing),
 610                     factoryResetOnDeletion, false, true);
 611         } else {
 612             super.handleRemoval();
 613         }
 614     }
 615
 616     /**
 617      * Called by the bridgeHandler when this device has been removed from the gateway.
 618      */
 619     public synchronized void deviceRemoved() {
 620         deviceDeletionPending = false;
 621         if (getThing().getStatus() == ThingStatus.REMOVING) {
 622             // thing removal was initiated
 623             updateStatus(ThingStatus.REMOVED);
 624         } else {
 625             // device removal was initiated on homematic side, thing is not removed
 626             updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.GONE);
 627         }
 628     }
 629
 630     /**
 631      * Called by the bridgeHandler when the device for this thing has been added to the gateway.
 632      * This is used to reconnect a device that was previously unpaired.
 633      *
 634      * @param device The device that has been added to the gateway
 635      */
 636     public void deviceLoaded(HmDevice device) {
 637         try {
 638             updateStatus(device);
 639         } catch (GatewayNotAvailableException ex) {
 640             // ignore
 641         } catch (IOException ex) {
 642             logger.warn("Could not reinitialize the device '{}': {}", device.getAddress(), ex.getMessage(), ex);
 643         }
 644     }
 645
 646     /**
 647      * Returns whether the device deletion is pending.
 648      *
 649      * @return true, if the deletion of this device on its gateway has been triggered but has not yet completed
 650      */
 651     public synchronized boolean isDeletionPending() {
 652         return deviceDeletionPending;
 653     }
 654 }