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.io.homekit.internal.accessories;
  14
  15 import static org.openhab.io.homekit.internal.HomekitCharacteristicType.*;
  16
  17 import java.math.BigDecimal;
  18 import java.math.RoundingMode;
  19 import java.util.HashMap;
  20 import java.util.Map;
  21 import java.util.concurrent.CompletableFuture;
  22 import java.util.function.BiFunction;
  23 import java.util.function.Consumer;
  24 import java.util.function.Supplier;
  25
  26 import javax.measure.Quantity;
  27 import javax.measure.Unit;
  28
  29 import org.eclipse.jdt.annotation.NonNullByDefault;
  30 import org.eclipse.jdt.annotation.Nullable;
  31 import org.openhab.core.items.GenericItem;
  32 import org.openhab.core.library.items.ColorItem;
  33 import org.openhab.core.library.items.DimmerItem;
  34 import org.openhab.core.library.items.NumberItem;
  35 import org.openhab.core.library.items.StringItem;
  36 import org.openhab.core.library.items.SwitchItem;
  37 import org.openhab.core.library.types.DecimalType;
  38 import org.openhab.core.library.types.HSBType;
  39 import org.openhab.core.library.types.OnOffType;
  40 import org.openhab.core.library.types.OpenClosedType;
  41 import org.openhab.core.library.types.PercentType;
  42 import org.openhab.core.library.types.QuantityType;
  43 import org.openhab.core.library.types.StringType;
  44 import org.openhab.core.library.unit.ImperialUnits;
  45 import org.openhab.core.library.unit.SIUnits;
  46 import org.openhab.core.types.State;
  47 import org.openhab.core.types.UnDefType;
  48 import org.openhab.io.homekit.Homekit;
  49 import org.openhab.io.homekit.internal.HomekitAccessoryUpdater;
  50 import org.openhab.io.homekit.internal.HomekitCharacteristicType;
  51 import org.openhab.io.homekit.internal.HomekitCommandType;
  52 import org.openhab.io.homekit.internal.HomekitException;
  53 import org.openhab.io.homekit.internal.HomekitImpl;
  54 import org.openhab.io.homekit.internal.HomekitTaggedItem;
  55 import org.osgi.framework.FrameworkUtil;
  56 import org.slf4j.Logger;
  57 import org.slf4j.LoggerFactory;
  58
  59 import io.github.hapjava.characteristics.Characteristic;
  60 import io.github.hapjava.characteristics.CharacteristicEnum;
  61 import io.github.hapjava.characteristics.ExceptionalConsumer;
  62 import io.github.hapjava.characteristics.HomekitCharacteristicChangeCallback;
  63 import io.github.hapjava.characteristics.impl.airquality.NitrogenDioxideDensityCharacteristic;
  64 import io.github.hapjava.characteristics.impl.airquality.OzoneDensityCharacteristic;
  65 import io.github.hapjava.characteristics.impl.airquality.PM10DensityCharacteristic;
  66 import io.github.hapjava.characteristics.impl.airquality.PM25DensityCharacteristic;
  67 import io.github.hapjava.characteristics.impl.airquality.SulphurDioxideDensityCharacteristic;
  68 import io.github.hapjava.characteristics.impl.airquality.VOCDensityCharacteristic;
  69 import io.github.hapjava.characteristics.impl.audio.VolumeCharacteristic;
  70 import io.github.hapjava.characteristics.impl.battery.StatusLowBatteryCharacteristic;
  71 import io.github.hapjava.characteristics.impl.battery.StatusLowBatteryEnum;
  72 import io.github.hapjava.characteristics.impl.carbondioxidesensor.CarbonDioxideLevelCharacteristic;
  73 import io.github.hapjava.characteristics.impl.carbondioxidesensor.CarbonDioxidePeakLevelCharacteristic;
  74 import io.github.hapjava.characteristics.impl.carbonmonoxidesensor.CarbonMonoxideLevelCharacteristic;
  75 import io.github.hapjava.characteristics.impl.carbonmonoxidesensor.CarbonMonoxidePeakLevelCharacteristic;
  76 import io.github.hapjava.characteristics.impl.common.ActiveCharacteristic;
  77 import io.github.hapjava.characteristics.impl.common.ActiveEnum;
  78 import io.github.hapjava.characteristics.impl.common.ConfiguredNameCharacteristic;
  79 import io.github.hapjava.characteristics.impl.common.NameCharacteristic;
  80 import io.github.hapjava.characteristics.impl.common.ObstructionDetectedCharacteristic;
  81 import io.github.hapjava.characteristics.impl.common.StatusActiveCharacteristic;
  82 import io.github.hapjava.characteristics.impl.common.StatusFaultCharacteristic;
  83 import io.github.hapjava.characteristics.impl.common.StatusFaultEnum;
  84 import io.github.hapjava.characteristics.impl.common.StatusTamperedCharacteristic;
  85 import io.github.hapjava.characteristics.impl.common.StatusTamperedEnum;
  86 import io.github.hapjava.characteristics.impl.fan.CurrentFanStateCharacteristic;
  87 import io.github.hapjava.characteristics.impl.fan.CurrentFanStateEnum;
  88 import io.github.hapjava.characteristics.impl.fan.LockPhysicalControlsCharacteristic;
  89 import io.github.hapjava.characteristics.impl.fan.LockPhysicalControlsEnum;
  90 import io.github.hapjava.characteristics.impl.fan.RotationDirectionCharacteristic;
  91 import io.github.hapjava.characteristics.impl.fan.RotationDirectionEnum;
  92 import io.github.hapjava.characteristics.impl.fan.RotationSpeedCharacteristic;
  93 import io.github.hapjava.characteristics.impl.fan.SwingModeCharacteristic;
  94 import io.github.hapjava.characteristics.impl.fan.SwingModeEnum;
  95 import io.github.hapjava.characteristics.impl.fan.TargetFanStateCharacteristic;
  96 import io.github.hapjava.characteristics.impl.fan.TargetFanStateEnum;
  97 import io.github.hapjava.characteristics.impl.filtermaintenance.FilterLifeLevelCharacteristic;
  98 import io.github.hapjava.characteristics.impl.filtermaintenance.ResetFilterIndicationCharacteristic;
  99 import io.github.hapjava.characteristics.impl.humiditysensor.CurrentRelativeHumidityCharacteristic;
 100 import io.github.hapjava.characteristics.impl.lightbulb.BrightnessCharacteristic;
 101 import io.github.hapjava.characteristics.impl.lightbulb.ColorTemperatureCharacteristic;
 102 import io.github.hapjava.characteristics.impl.lightbulb.HueCharacteristic;
 103 import io.github.hapjava.characteristics.impl.lightbulb.SaturationCharacteristic;
 104 import io.github.hapjava.characteristics.impl.slat.CurrentTiltAngleCharacteristic;
 105 import io.github.hapjava.characteristics.impl.slat.TargetTiltAngleCharacteristic;
 106 import io.github.hapjava.characteristics.impl.thermostat.CoolingThresholdTemperatureCharacteristic;
 107 import io.github.hapjava.characteristics.impl.thermostat.HeatingThresholdTemperatureCharacteristic;
 108 import io.github.hapjava.characteristics.impl.valve.RemainingDurationCharacteristic;
 109 import io.github.hapjava.characteristics.impl.valve.SetDurationCharacteristic;
 110 import io.github.hapjava.characteristics.impl.windowcovering.CurrentHorizontalTiltAngleCharacteristic;
 111 import io.github.hapjava.characteristics.impl.windowcovering.CurrentVerticalTiltAngleCharacteristic;
 112 import io.github.hapjava.characteristics.impl.windowcovering.HoldPositionCharacteristic;
 113 import io.github.hapjava.characteristics.impl.windowcovering.TargetHorizontalTiltAngleCharacteristic;
 114 import io.github.hapjava.characteristics.impl.windowcovering.TargetVerticalTiltAngleCharacteristic;
 115 import tech.units.indriya.unit.UnitDimension;
 116
 117 /**
 118  * Creates a optional characteristics .
 119  *
 120  * @author Eugen Freiter - Initial contribution
 121  */
 122 @NonNullByDefault
 123 public class HomekitCharacteristicFactory {
 124     private static final Logger logger = LoggerFactory.getLogger(HomekitCharacteristicFactory.class);
 125
 126     // List of optional characteristics and corresponding method to create them.
 127     private final static Map<HomekitCharacteristicType, BiFunction<HomekitTaggedItem, HomekitAccessoryUpdater, Characteristic>> optional = new HashMap<HomekitCharacteristicType, BiFunction<HomekitTaggedItem, HomekitAccessoryUpdater, Characteristic>>() {
 128         {
 129             put(NAME, HomekitCharacteristicFactory::createNameCharacteristic);
 130             put(BATTERY_LOW_STATUS, HomekitCharacteristicFactory::createStatusLowBatteryCharacteristic);
 131             put(FAULT_STATUS, HomekitCharacteristicFactory::createStatusFaultCharacteristic);
 132             put(TAMPERED_STATUS, HomekitCharacteristicFactory::createStatusTamperedCharacteristic);
 133             put(ACTIVE_STATUS, HomekitCharacteristicFactory::createStatusActiveCharacteristic);
 134             put(CARBON_MONOXIDE_LEVEL, HomekitCharacteristicFactory::createCarbonMonoxideLevelCharacteristic);
 135             put(CARBON_MONOXIDE_PEAK_LEVEL, HomekitCharacteristicFactory::createCarbonMonoxidePeakLevelCharacteristic);
 136             put(CARBON_DIOXIDE_LEVEL, HomekitCharacteristicFactory::createCarbonDioxideLevelCharacteristic);
 137             put(CARBON_DIOXIDE_PEAK_LEVEL, HomekitCharacteristicFactory::createCarbonDioxidePeakLevelCharacteristic);
 138             put(HOLD_POSITION, HomekitCharacteristicFactory::createHoldPositionCharacteristic);
 139             put(OBSTRUCTION_STATUS, HomekitCharacteristicFactory::createObstructionDetectedCharacteristic);
 140             put(CURRENT_HORIZONTAL_TILT_ANGLE,
 141                     HomekitCharacteristicFactory::createCurrentHorizontalTiltAngleCharacteristic);
 142             put(CURRENT_VERTICAL_TILT_ANGLE,
 143                     HomekitCharacteristicFactory::createCurrentVerticalTiltAngleCharacteristic);
 144             put(TARGET_HORIZONTAL_TILT_ANGLE,
 145                     HomekitCharacteristicFactory::createTargetHorizontalTiltAngleCharacteristic);
 146             put(TARGET_VERTICAL_TILT_ANGLE, HomekitCharacteristicFactory::createTargetVerticalTiltAngleCharacteristic);
 147             put(CURRENT_TILT_ANGLE, HomekitCharacteristicFactory::createCurrentTiltAngleCharacteristic);
 148             put(TARGET_TILT_ANGLE, HomekitCharacteristicFactory::createTargetTiltAngleCharacteristic);
 149             put(HUE, HomekitCharacteristicFactory::createHueCharacteristic);
 150             put(BRIGHTNESS, HomekitCharacteristicFactory::createBrightnessCharacteristic);
 151             put(SATURATION, HomekitCharacteristicFactory::createSaturationCharacteristic);
 152             put(COLOR_TEMPERATURE, HomekitCharacteristicFactory::createColorTemperatureCharacteristic);
 153             put(CURRENT_FAN_STATE, HomekitCharacteristicFactory::createCurrentFanStateCharacteristic);
 154             put(TARGET_FAN_STATE, HomekitCharacteristicFactory::createTargetFanStateCharacteristic);
 155             put(ROTATION_DIRECTION, HomekitCharacteristicFactory::createRotationDirectionCharacteristic);
 156             put(ROTATION_SPEED, HomekitCharacteristicFactory::createRotationSpeedCharacteristic);
 157             put(SWING_MODE, HomekitCharacteristicFactory::createSwingModeCharacteristic);
 158             put(LOCK_CONTROL, HomekitCharacteristicFactory::createLockPhysicalControlsCharacteristic);
 159             put(DURATION, HomekitCharacteristicFactory::createDurationCharacteristic);
 160             put(VOLUME, HomekitCharacteristicFactory::createVolumeCharacteristic);
 161             put(COOLING_THRESHOLD_TEMPERATURE, HomekitCharacteristicFactory::createCoolingThresholdCharacteristic);
 162             put(HEATING_THRESHOLD_TEMPERATURE, HomekitCharacteristicFactory::createHeatingThresholdCharacteristic);
 163             put(RELATIVE_HUMIDITY, HomekitCharacteristicFactory::createRelativeHumidityCharacteristic);
 164             put(REMAINING_DURATION, HomekitCharacteristicFactory::createRemainingDurationCharacteristic);
 165             put(OZONE_DENSITY, HomekitCharacteristicFactory::createOzoneDensityCharacteristic);
 166             put(NITROGEN_DIOXIDE_DENSITY, HomekitCharacteristicFactory::createNitrogenDioxideDensityCharacteristic);
 167             put(SULPHUR_DIOXIDE_DENSITY, HomekitCharacteristicFactory::createSulphurDioxideDensityCharacteristic);
 168             put(PM25_DENSITY, HomekitCharacteristicFactory::createPM25DensityCharacteristic);
 169             put(PM10_DENSITY, HomekitCharacteristicFactory::createPM10DensityCharacteristic);
 170             put(VOC_DENSITY, HomekitCharacteristicFactory::createVOCDensityCharacteristic);
 171             put(FILTER_LIFE_LEVEL, HomekitCharacteristicFactory::createFilterLifeLevelCharacteristic);
 172             put(FILTER_RESET_INDICATION, HomekitCharacteristicFactory::createFilterResetCharacteristic);
 173             put(ACTIVE, HomekitCharacteristicFactory::createActiveCharacteristic);
 174             put(CONFIGURED_NAME, HomekitCharacteristicFactory::createConfiguredNameCharacteristic);
 175         }
 176     };
 177
 178     /**
 179      * create optional HomeKit characteristic
 180      *
 181      * @param item corresponding OH item
 182      * @param updater update to keep OH item and HomeKit characteristic in sync
 183      * @return HomeKit characteristic
 184      */
 185     public static Characteristic createCharacteristic(HomekitTaggedItem item, HomekitAccessoryUpdater updater)
 186             throws HomekitException {
 187         final @Nullable HomekitCharacteristicType type = item.getCharacteristicType();
 188         logger.trace("Create characteristic {}", item);
 189         if (optional.containsKey(type)) {
 190             return optional.get(type).apply(item, updater);
 191         }
 192         logger.warn("Unsupported optional characteristic from item {}. Accessory type {}, characteristic type {}",
 193                 item.getName(), item.getAccessoryType(), type.getTag());
 194         throw new HomekitException(
 195                 "Unsupported optional characteristic. Characteristic type \"" + type.getTag() + "\"");
 196     }
 197
 198     // METHODS TO CREATE SINGLE CHARACTERISTIC FROM OH ITEM
 199
 200     // supporting methods
 201
 202     public static boolean useFahrenheit() {
 203         return FrameworkUtil.getBundle(HomekitImpl.class).getBundleContext()
 204                 .getServiceReference(Homekit.class.getName()).getProperty("useFahrenheitTemperature") == Boolean.TRUE;
 205     }
 206
 207     private static <T extends CharacteristicEnum> CompletableFuture<T> getEnumFromItem(HomekitTaggedItem item,
 208             T offEnum, T onEnum, T defaultEnum) {
 209         final State state = item.getItem().getState();
 210         if (state instanceof OnOffType) {
 211             return CompletableFuture
 212                     .completedFuture(state.equals(item.isInverted() ? OnOffType.ON : OnOffType.OFF) ? offEnum : onEnum);
 213         } else if (state instanceof OpenClosedType) {
 214             return CompletableFuture.completedFuture(
 215                     state.equals(item.isInverted() ? OpenClosedType.OPEN : OpenClosedType.CLOSED) ? offEnum : onEnum);
 216         } else if (state instanceof DecimalType) {
 217             return CompletableFuture.completedFuture(((DecimalType) state).intValue() == 0 ? offEnum : onEnum);
 218         } else if (state instanceof UnDefType) {
 219             return CompletableFuture.completedFuture(defaultEnum);
 220         }
 221         logger.warn(
 222                 "Item state {} is not supported. Only OnOffType,OpenClosedType and Decimal (0/1) are supported. Ignore item {}",
 223                 state, item.getName());
 224         return CompletableFuture.completedFuture(defaultEnum);
 225     }
 226
 227     private static void setValueFromEnum(HomekitTaggedItem taggedItem, CharacteristicEnum value,
 228             CharacteristicEnum offEnum, CharacteristicEnum onEnum) {
 229         if (taggedItem.getBaseItem() instanceof SwitchItem) {
 230             if (value.equals(offEnum)) {
 231                 taggedItem.send(taggedItem.isInverted() ? OnOffType.ON : OnOffType.OFF);
 232             } else if (value.equals(onEnum)) {
 233                 taggedItem.send(taggedItem.isInverted() ? OnOffType.OFF : OnOffType.ON);
 234             } else {
 235                 logger.warn("Enum value {} is not supported for {}. Only following values are supported: {},{}", value,
 236                         taggedItem.getName(), offEnum, onEnum);
 237             }
 238         } else if (taggedItem.getBaseItem() instanceof NumberItem) {
 239             taggedItem.send(new DecimalType(value.getCode()));
 240         } else {
 241             logger.warn("Item {} of type {} is not supported. Only Switch and Number item types are supported.",
 242                     taggedItem.getName(), taggedItem.getBaseItem().getType());
 243         }
 244     }
 245
 246     private static int getIntFromItem(HomekitTaggedItem taggedItem, int defaultValue) {
 247         int value = defaultValue;
 248         final State state = taggedItem.getItem().getState();
 249         if (state instanceof PercentType) {
 250             value = ((PercentType) state).intValue();
 251         } else if (state instanceof DecimalType) {
 252             value = ((DecimalType) state).intValue();
 253         } else if (state instanceof UnDefType) {
 254             logger.debug("Item state {} is UNDEF {}. Returning default value {}", state, taggedItem.getName(),
 255                     defaultValue);
 256         } else {
 257             logger.warn(
 258                     "Item state {} is not supported for {}. Only PercentType and DecimalType (0/100) are supported.",
 259                     state, taggedItem.getName());
 260         }
 261         return value;
 262     }
 263
 264     /** special method for tilts. it converts percentage to angle */
 265     private static int getAngleFromItem(HomekitTaggedItem taggedItem, int defaultValue) {
 266         int value = defaultValue;
 267         final State state = taggedItem.getItem().getState();
 268         if (state instanceof PercentType) {
 269             value = (int) ((((PercentType) state).intValue() * 90.0) / 50.0 - 90.0);
 270         } else {
 271             value = getIntFromItem(taggedItem, defaultValue);
 272         }
 273         return value;
 274     }
 275
 276     private static <T extends Quantity<T>> double convertAndRound(double value, Unit<T> from, Unit<T> to) {
 277         double rawValue = from.equals(to) ? value : from.getConverterTo(to).convert(value);
 278         return new BigDecimal(rawValue).setScale(1, RoundingMode.HALF_UP).doubleValue();
 279     }
 280
 281     public static @Nullable Double stateAsTemperature(@Nullable State state) {
 282         if (state == null || state instanceof UnDefType) {
 283             return null;
 284         }
 285
 286         if (state instanceof QuantityType<?>) {
 287             final QuantityType<?> qt = (QuantityType<?>) state;
 288             if (qt.getDimension().equals(UnitDimension.TEMPERATURE)) {
 289                 return qt.toUnit(SIUnits.CELSIUS).doubleValue();
 290             }
 291         }
 292
 293         return convertToCelsius(state.as(DecimalType.class).doubleValue());
 294     }
 295
 296     public static double convertToCelsius(double degrees) {
 297         return convertAndRound(degrees, useFahrenheit() ? ImperialUnits.FAHRENHEIT : SIUnits.CELSIUS, SIUnits.CELSIUS);
 298     }
 299
 300     public static double convertFromCelsius(double degrees) {
 301         return convertAndRound(degrees, SIUnits.CELSIUS, useFahrenheit() ? ImperialUnits.FAHRENHEIT : SIUnits.CELSIUS);
 302     }
 303
 304     private static Supplier<CompletableFuture<Integer>> getAngleSupplier(HomekitTaggedItem taggedItem,
 305             int defaultValue) {
 306         return () -> CompletableFuture.completedFuture(getAngleFromItem(taggedItem, defaultValue));
 307     }
 308
 309     private static Supplier<CompletableFuture<Integer>> getIntSupplier(HomekitTaggedItem taggedItem, int defaultValue) {
 310         return () -> CompletableFuture.completedFuture(getIntFromItem(taggedItem, defaultValue));
 311     }
 312
 313     private static ExceptionalConsumer<Integer> setIntConsumer(HomekitTaggedItem taggedItem) {
 314         return (value) -> {
 315             if (taggedItem.getBaseItem() instanceof NumberItem) {
 316                 taggedItem.send(new DecimalType(value));
 317             } else {
 318                 logger.warn("Item type {} is not supported for {}. Only NumberItem is supported.",
 319                         taggedItem.getBaseItem().getType(), taggedItem.getName());
 320             }
 321         };
 322     }
 323
 324     private static ExceptionalConsumer<Integer> setPercentConsumer(HomekitTaggedItem taggedItem) {
 325         return (value) -> {
 326             if (taggedItem.getBaseItem() instanceof NumberItem) {
 327                 taggedItem.send(new DecimalType(value));
 328             } else if (taggedItem.getBaseItem() instanceof DimmerItem) {
 329                 taggedItem.send(new PercentType(value));
 330             } else {
 331                 logger.warn("Item type {} is not supported for {}. Only DimmerItem and NumberItem are supported.",
 332                         taggedItem.getBaseItem().getType(), taggedItem.getName());
 333             }
 334         };
 335     }
 336
 337     private static ExceptionalConsumer<Integer> setAngleConsumer(HomekitTaggedItem taggedItem) {
 338         return (value) -> {
 339             if (taggedItem.getBaseItem() instanceof NumberItem) {
 340                 taggedItem.send(new DecimalType(value));
 341             } else if (taggedItem.getBaseItem() instanceof DimmerItem) {
 342                 value = (int) (value * 50.0 / 90.0 + 50.0);
 343                 taggedItem.send(new PercentType(value));
 344             } else {
 345                 logger.warn("Item type {} is not supported for {}. Only DimmerItem and NumberItem are supported.",
 346                         taggedItem.getBaseItem().getType(), taggedItem.getName());
 347             }
 348         };
 349     }
 350
 351     private static Supplier<CompletableFuture<Double>> getDoubleSupplier(HomekitTaggedItem taggedItem,
 352             double defaultValue) {
 353         return () -> {
 354             final State state = taggedItem.getItem().getState();
 355             double value = defaultValue;
 356             if (state instanceof PercentType) {
 357                 value = ((PercentType) state).doubleValue();
 358             } else if (state instanceof DecimalType) {
 359                 value = ((DecimalType) state).doubleValue();
 360             } else if (state instanceof QuantityType) {
 361                 value = ((QuantityType) state).doubleValue();
 362             }
 363             return CompletableFuture.completedFuture(value);
 364         };
 365     }
 366
 367     private static ExceptionalConsumer<Double> setDoubleConsumer(HomekitTaggedItem taggedItem) {
 368         return (value) -> {
 369             if (taggedItem.getBaseItem() instanceof NumberItem) {
 370                 taggedItem.send(new DecimalType(value.doubleValue()));
 371             } else if (taggedItem.getBaseItem() instanceof DimmerItem) {
 372                 taggedItem.send(new PercentType(value.intValue()));
 373             } else {
 374                 logger.warn("Item type {} is not supported for {}. Only Number and Dimmer type are supported.",
 375                         taggedItem.getBaseItem().getType(), taggedItem.getName());
 376             }
 377         };
 378     }
 379
 380     private static Supplier<CompletableFuture<Double>> getTemperatureSupplier(HomekitTaggedItem taggedItem,
 381             double defaultValue) {
 382         return () -> {
 383             final @Nullable Double value = stateAsTemperature(taggedItem.getItem().getState());
 384             return CompletableFuture.completedFuture(value != null ? value : defaultValue);
 385         };
 386     }
 387
 388     private static ExceptionalConsumer<Double> setTemperatureConsumer(HomekitTaggedItem taggedItem) {
 389         return (value) -> {
 390             if (taggedItem.getBaseItem() instanceof NumberItem) {
 391                 taggedItem.send(new DecimalType(convertFromCelsius(value)));
 392             } else {
 393                 logger.warn("Item type {} is not supported for {}. Only Number type is supported.",
 394                         taggedItem.getBaseItem().getType(), taggedItem.getName());
 395             }
 396         };
 397     }
 398
 399     protected static Consumer<HomekitCharacteristicChangeCallback> getSubscriber(HomekitTaggedItem taggedItem,
 400             HomekitCharacteristicType key, HomekitAccessoryUpdater updater) {
 401         return (callback) -> updater.subscribe((GenericItem) taggedItem.getItem(), key.getTag(), callback);
 402     }
 403
 404     protected static Runnable getUnsubscriber(HomekitTaggedItem taggedItem, HomekitCharacteristicType key,
 405             HomekitAccessoryUpdater updater) {
 406         return () -> updater.unsubscribe((GenericItem) taggedItem.getItem(), key.getTag());
 407     }
 408
 409     // create method for characteristic
 410     private static StatusLowBatteryCharacteristic createStatusLowBatteryCharacteristic(HomekitTaggedItem taggedItem,
 411             HomekitAccessoryUpdater updater) {
 412         BigDecimal lowThreshold = taggedItem.getConfiguration(HomekitTaggedItem.BATTERY_LOW_THRESHOLD,
 413                 BigDecimal.valueOf(20));
 414         BooleanItemReader lowBatteryReader = new BooleanItemReader(taggedItem.getItem(),
 415                 taggedItem.isInverted() ? OnOffType.OFF : OnOffType.ON,
 416                 taggedItem.isInverted() ? OpenClosedType.CLOSED : OpenClosedType.OPEN, lowThreshold, true);
 417         return new StatusLowBatteryCharacteristic(
 418                 () -> CompletableFuture.completedFuture(
 419                         lowBatteryReader.getValue() ? StatusLowBatteryEnum.LOW : StatusLowBatteryEnum.NORMAL),
 420                 getSubscriber(taggedItem, BATTERY_LOW_STATUS, updater),
 421                 getUnsubscriber(taggedItem, BATTERY_LOW_STATUS, updater));
 422     }
 423
 424     private static StatusFaultCharacteristic createStatusFaultCharacteristic(HomekitTaggedItem taggedItem,
 425             HomekitAccessoryUpdater updater) {
 426         return new StatusFaultCharacteristic(
 427                 () -> getEnumFromItem(taggedItem, StatusFaultEnum.NO_FAULT, StatusFaultEnum.GENERAL_FAULT,
 428                         StatusFaultEnum.NO_FAULT),
 429                 getSubscriber(taggedItem, FAULT_STATUS, updater), getUnsubscriber(taggedItem, FAULT_STATUS, updater));
 430     }
 431
 432     private static StatusTamperedCharacteristic createStatusTamperedCharacteristic(HomekitTaggedItem taggedItem,
 433             HomekitAccessoryUpdater updater) {
 434         return new StatusTamperedCharacteristic(
 435                 () -> getEnumFromItem(taggedItem, StatusTamperedEnum.NOT_TAMPERED, StatusTamperedEnum.TAMPERED,
 436                         StatusTamperedEnum.NOT_TAMPERED),
 437                 getSubscriber(taggedItem, TAMPERED_STATUS, updater),
 438                 getUnsubscriber(taggedItem, TAMPERED_STATUS, updater));
 439     }
 440
 441     private static ObstructionDetectedCharacteristic createObstructionDetectedCharacteristic(
 442             HomekitTaggedItem taggedItem, HomekitAccessoryUpdater updater) {
 443         return new ObstructionDetectedCharacteristic(
 444                 () -> CompletableFuture.completedFuture(taggedItem.getItem().getState() == OnOffType.ON
 445                         || taggedItem.getItem().getState() == OpenClosedType.OPEN),
 446                 getSubscriber(taggedItem, OBSTRUCTION_STATUS, updater),
 447                 getUnsubscriber(taggedItem, OBSTRUCTION_STATUS, updater));
 448     }
 449
 450     private static StatusActiveCharacteristic createStatusActiveCharacteristic(HomekitTaggedItem taggedItem,
 451             HomekitAccessoryUpdater updater) {
 452         return new StatusActiveCharacteristic(
 453                 () -> CompletableFuture.completedFuture(taggedItem.getItem().getState() == OnOffType.ON
 454                         || taggedItem.getItem().getState() == OpenClosedType.OPEN),
 455                 getSubscriber(taggedItem, ACTIVE_STATUS, updater), getUnsubscriber(taggedItem, ACTIVE_STATUS, updater));
 456     }
 457
 458     private static NameCharacteristic createNameCharacteristic(HomekitTaggedItem taggedItem,
 459             HomekitAccessoryUpdater updater) {
 460         return new NameCharacteristic(() -> {
 461             final State state = taggedItem.getItem().getState();
 462             return CompletableFuture.completedFuture(state instanceof UnDefType ? "" : state.toString());
 463         });
 464     }
 465
 466     private static HoldPositionCharacteristic createHoldPositionCharacteristic(HomekitTaggedItem taggedItem,
 467             HomekitAccessoryUpdater updater) {
 468         return new HoldPositionCharacteristic(value -> ((SwitchItem) taggedItem.getItem()).send(OnOffType.from(value)));
 469     }
 470
 471     private static CarbonMonoxideLevelCharacteristic createCarbonMonoxideLevelCharacteristic(
 472             HomekitTaggedItem taggedItem, HomekitAccessoryUpdater updater) {
 473         return new CarbonMonoxideLevelCharacteristic(
 474                 getDoubleSupplier(taggedItem,
 475                         taggedItem.getConfigurationAsDouble(HomekitTaggedItem.MIN_VALUE,
 476                                 CarbonMonoxideLevelCharacteristic.DEFAULT_MIN_VALUE)),
 477                 getSubscriber(taggedItem, CARBON_DIOXIDE_LEVEL, updater),
 478                 getUnsubscriber(taggedItem, CARBON_DIOXIDE_LEVEL, updater));
 479     }
 480
 481     private static CarbonMonoxidePeakLevelCharacteristic createCarbonMonoxidePeakLevelCharacteristic(
 482             HomekitTaggedItem taggedItem, HomekitAccessoryUpdater updater) {
 483         return new CarbonMonoxidePeakLevelCharacteristic(
 484                 getDoubleSupplier(taggedItem,
 485                         taggedItem.getConfigurationAsDouble(HomekitTaggedItem.MIN_VALUE,
 486                                 CarbonMonoxidePeakLevelCharacteristic.DEFAULT_MIN_VALUE)),
 487                 getSubscriber(taggedItem, CARBON_DIOXIDE_PEAK_LEVEL, updater),
 488                 getUnsubscriber(taggedItem, CARBON_DIOXIDE_PEAK_LEVEL, updater));
 489     }
 490
 491     private static CarbonDioxideLevelCharacteristic createCarbonDioxideLevelCharacteristic(HomekitTaggedItem taggedItem,
 492             HomekitAccessoryUpdater updater) {
 493         return new CarbonDioxideLevelCharacteristic(
 494                 getDoubleSupplier(taggedItem,
 495                         taggedItem.getConfigurationAsDouble(HomekitTaggedItem.MIN_VALUE,
 496                                 CarbonDioxideLevelCharacteristic.DEFAULT_MIN_VALUE)),
 497                 getSubscriber(taggedItem, CARBON_MONOXIDE_LEVEL, updater),
 498                 getUnsubscriber(taggedItem, CARBON_MONOXIDE_LEVEL, updater));
 499     }
 500
 501     private static CarbonDioxidePeakLevelCharacteristic createCarbonDioxidePeakLevelCharacteristic(
 502             HomekitTaggedItem taggedItem, HomekitAccessoryUpdater updater) {
 503         return new CarbonDioxidePeakLevelCharacteristic(
 504                 getDoubleSupplier(taggedItem,
 505                         taggedItem.getConfigurationAsDouble(HomekitTaggedItem.MIN_VALUE,
 506                                 CarbonDioxidePeakLevelCharacteristic.DEFAULT_MIN_VALUE)),
 507                 getSubscriber(taggedItem, CARBON_MONOXIDE_PEAK_LEVEL, updater),
 508                 getUnsubscriber(taggedItem, CARBON_MONOXIDE_PEAK_LEVEL, updater));
 509     }
 510
 511     private static CurrentHorizontalTiltAngleCharacteristic createCurrentHorizontalTiltAngleCharacteristic(
 512             HomekitTaggedItem taggedItem, HomekitAccessoryUpdater updater) {
 513         return new CurrentHorizontalTiltAngleCharacteristic(getAngleSupplier(taggedItem, 0),
 514                 getSubscriber(taggedItem, CURRENT_HORIZONTAL_TILT_ANGLE, updater),
 515                 getUnsubscriber(taggedItem, CURRENT_HORIZONTAL_TILT_ANGLE, updater));
 516     }
 517
 518     private static CurrentVerticalTiltAngleCharacteristic createCurrentVerticalTiltAngleCharacteristic(
 519             HomekitTaggedItem taggedItem, HomekitAccessoryUpdater updater) {
 520         return new CurrentVerticalTiltAngleCharacteristic(getAngleSupplier(taggedItem, 0),
 521                 getSubscriber(taggedItem, CURRENT_VERTICAL_TILT_ANGLE, updater),
 522                 getUnsubscriber(taggedItem, CURRENT_VERTICAL_TILT_ANGLE, updater));
 523     }
 524
 525     private static TargetHorizontalTiltAngleCharacteristic createTargetHorizontalTiltAngleCharacteristic(
 526             HomekitTaggedItem taggedItem, HomekitAccessoryUpdater updater) {
 527         return new TargetHorizontalTiltAngleCharacteristic(getAngleSupplier(taggedItem, 0),
 528                 setAngleConsumer(taggedItem), getSubscriber(taggedItem, TARGET_HORIZONTAL_TILT_ANGLE, updater),
 529                 getUnsubscriber(taggedItem, TARGET_HORIZONTAL_TILT_ANGLE, updater));
 530     }
 531
 532     private static TargetVerticalTiltAngleCharacteristic createTargetVerticalTiltAngleCharacteristic(
 533             HomekitTaggedItem taggedItem, HomekitAccessoryUpdater updater) {
 534         return new TargetVerticalTiltAngleCharacteristic(getAngleSupplier(taggedItem, 0), setAngleConsumer(taggedItem),
 535                 getSubscriber(taggedItem, TARGET_HORIZONTAL_TILT_ANGLE, updater),
 536                 getUnsubscriber(taggedItem, TARGET_HORIZONTAL_TILT_ANGLE, updater));
 537     }
 538
 539     private static CurrentTiltAngleCharacteristic createCurrentTiltAngleCharacteristic(HomekitTaggedItem taggedItem,
 540             HomekitAccessoryUpdater updater) {
 541         return new CurrentTiltAngleCharacteristic(getAngleSupplier(taggedItem, 0),
 542                 getSubscriber(taggedItem, CURRENT_TILT_ANGLE, updater),
 543                 getUnsubscriber(taggedItem, CURRENT_TILT_ANGLE, updater));
 544     }
 545
 546     private static TargetTiltAngleCharacteristic createTargetTiltAngleCharacteristic(HomekitTaggedItem taggedItem,
 547             HomekitAccessoryUpdater updater) {
 548         return new TargetTiltAngleCharacteristic(getAngleSupplier(taggedItem, 0), setAngleConsumer(taggedItem),
 549                 getSubscriber(taggedItem, TARGET_TILT_ANGLE, updater),
 550                 getUnsubscriber(taggedItem, TARGET_TILT_ANGLE, updater));
 551     }
 552
 553     private static HueCharacteristic createHueCharacteristic(HomekitTaggedItem taggedItem,
 554             HomekitAccessoryUpdater updater) {
 555         return new HueCharacteristic(() -> {
 556             double value = 0.0;
 557             State state = taggedItem.getItem().getState();
 558             if (state instanceof HSBType) {
 559                 value = ((HSBType) state).getHue().doubleValue();
 560             }
 561             return CompletableFuture.completedFuture(value);
 562         }, (hue) -> {
 563             if (taggedItem.getBaseItem() instanceof ColorItem) {
 564                 taggedItem.sendCommandProxy(HomekitCommandType.HUE_COMMAND, new DecimalType(hue));
 565             } else {
 566                 logger.warn("Item type {} is not supported for {}. Only Color type is supported.",
 567                         taggedItem.getBaseItem().getType(), taggedItem.getName());
 568             }
 569         }, getSubscriber(taggedItem, HUE, updater), getUnsubscriber(taggedItem, HUE, updater));
 570     }
 571
 572     private static BrightnessCharacteristic createBrightnessCharacteristic(HomekitTaggedItem taggedItem,
 573             HomekitAccessoryUpdater updater) {
 574         return new BrightnessCharacteristic(() -> {
 575             int value = 0;
 576             final State state = taggedItem.getItem().getState();
 577             if (state instanceof HSBType) {
 578                 value = ((HSBType) state).getBrightness().intValue();
 579             } else if (state instanceof PercentType) {
 580                 value = ((PercentType) state).intValue();
 581             }
 582             return CompletableFuture.completedFuture(value);
 583         }, (brightness) -> {
 584             if (taggedItem.getBaseItem() instanceof DimmerItem) {
 585                 taggedItem.sendCommandProxy(HomekitCommandType.BRIGHTNESS_COMMAND, new PercentType(brightness));
 586             } else {
 587                 logger.warn("Item type {} is not supported for {}. Only ColorItem and DimmerItem are supported.",
 588                         taggedItem.getBaseItem().getType(), taggedItem.getName());
 589             }
 590         }, getSubscriber(taggedItem, BRIGHTNESS, updater), getUnsubscriber(taggedItem, BRIGHTNESS, updater));
 591     }
 592
 593     private static SaturationCharacteristic createSaturationCharacteristic(HomekitTaggedItem taggedItem,
 594             HomekitAccessoryUpdater updater) {
 595         return new SaturationCharacteristic(() -> {
 596             double value = 0.0;
 597             State state = taggedItem.getItem().getState();
 598             if (state instanceof HSBType) {
 599                 value = ((HSBType) state).getSaturation().doubleValue();
 600             } else if (state instanceof PercentType) {
 601                 value = ((PercentType) state).doubleValue();
 602             }
 603             return CompletableFuture.completedFuture(value);
 604         }, (saturation) -> {
 605             if (taggedItem.getBaseItem() instanceof ColorItem) {
 606                 taggedItem.sendCommandProxy(HomekitCommandType.SATURATION_COMMAND,
 607                         new PercentType(saturation.intValue()));
 608             } else {
 609                 logger.warn("Item type {} is not supported for {}. Only Color type is supported.",
 610                         taggedItem.getBaseItem().getType(), taggedItem.getName());
 611             }
 612         }, getSubscriber(taggedItem, SATURATION, updater), getUnsubscriber(taggedItem, SATURATION, updater));
 613     }
 614
 615     private static ColorTemperatureCharacteristic createColorTemperatureCharacteristic(HomekitTaggedItem taggedItem,
 616             HomekitAccessoryUpdater updater) {
 617         int minValue = taggedItem.getConfigurationAsInt(HomekitTaggedItem.MIN_VALUE,
 618                 ColorTemperatureCharacteristic.DEFAULT_MIN_VALUE);
 619         return new ColorTemperatureCharacteristic(minValue,
 620                 taggedItem.getConfigurationAsInt(HomekitTaggedItem.MAX_VALUE,
 621                         ColorTemperatureCharacteristic.DEFAULT_MAX_VALUE),
 622                 getIntSupplier(taggedItem, minValue), setIntConsumer(taggedItem),
 623                 getSubscriber(taggedItem, COLOR_TEMPERATURE, updater),
 624                 getUnsubscriber(taggedItem, COLOR_TEMPERATURE, updater));
 625     }
 626
 627     private static CurrentFanStateCharacteristic createCurrentFanStateCharacteristic(HomekitTaggedItem taggedItem,
 628             HomekitAccessoryUpdater updater) {
 629         return new CurrentFanStateCharacteristic(() -> {
 630             final @Nullable DecimalType value = taggedItem.getItem().getStateAs(DecimalType.class);
 631             @Nullable
 632             CurrentFanStateEnum currentFanStateEnum = value != null ? CurrentFanStateEnum.fromCode(value.intValue())
 633                     : null;
 634             if (currentFanStateEnum == null) {
 635                 currentFanStateEnum = CurrentFanStateEnum.INACTIVE;
 636             }
 637             return CompletableFuture.completedFuture(currentFanStateEnum);
 638         }, getSubscriber(taggedItem, CURRENT_FAN_STATE, updater),
 639                 getUnsubscriber(taggedItem, CURRENT_FAN_STATE, updater));
 640     }
 641
 642     private static TargetFanStateCharacteristic createTargetFanStateCharacteristic(HomekitTaggedItem taggedItem,
 643             HomekitAccessoryUpdater updater) {
 644         return new TargetFanStateCharacteristic(
 645                 () -> getEnumFromItem(taggedItem, TargetFanStateEnum.MANUAL, TargetFanStateEnum.AUTO,
 646                         TargetFanStateEnum.AUTO),
 647                 (targetState) -> setValueFromEnum(taggedItem, targetState, TargetFanStateEnum.MANUAL,
 648                         TargetFanStateEnum.AUTO),
 649                 getSubscriber(taggedItem, TARGET_FAN_STATE, updater),
 650                 getUnsubscriber(taggedItem, TARGET_FAN_STATE, updater));
 651     }
 652
 653     private static RotationDirectionCharacteristic createRotationDirectionCharacteristic(HomekitTaggedItem taggedItem,
 654             HomekitAccessoryUpdater updater) {
 655         return new RotationDirectionCharacteristic(
 656                 () -> getEnumFromItem(taggedItem, RotationDirectionEnum.CLOCKWISE,
 657                         RotationDirectionEnum.COUNTER_CLOCKWISE, RotationDirectionEnum.CLOCKWISE),
 658                 (value) -> setValueFromEnum(taggedItem, value, RotationDirectionEnum.CLOCKWISE,
 659                         RotationDirectionEnum.COUNTER_CLOCKWISE),
 660                 getSubscriber(taggedItem, ROTATION_DIRECTION, updater),
 661                 getUnsubscriber(taggedItem, ROTATION_DIRECTION, updater));
 662     }
 663
 664     private static SwingModeCharacteristic createSwingModeCharacteristic(HomekitTaggedItem taggedItem,
 665             HomekitAccessoryUpdater updater) {
 666         return new SwingModeCharacteristic(
 667                 () -> getEnumFromItem(taggedItem, SwingModeEnum.SWING_DISABLED, SwingModeEnum.SWING_ENABLED,
 668                         SwingModeEnum.SWING_DISABLED),
 669                 (value) -> setValueFromEnum(taggedItem, value, SwingModeEnum.SWING_DISABLED,
 670                         SwingModeEnum.SWING_ENABLED),
 671                 getSubscriber(taggedItem, SWING_MODE, updater), getUnsubscriber(taggedItem, SWING_MODE, updater));
 672     }
 673
 674     private static LockPhysicalControlsCharacteristic createLockPhysicalControlsCharacteristic(
 675             HomekitTaggedItem taggedItem, HomekitAccessoryUpdater updater) {
 676         return new LockPhysicalControlsCharacteristic(
 677                 () -> getEnumFromItem(taggedItem, LockPhysicalControlsEnum.CONTROL_LOCK_DISABLED,
 678                         LockPhysicalControlsEnum.CONTROL_LOCK_ENABLED, LockPhysicalControlsEnum.CONTROL_LOCK_DISABLED),
 679                 (value) -> setValueFromEnum(taggedItem, value, LockPhysicalControlsEnum.CONTROL_LOCK_DISABLED,
 680                         LockPhysicalControlsEnum.CONTROL_LOCK_ENABLED),
 681                 getSubscriber(taggedItem, LOCK_CONTROL, updater), getUnsubscriber(taggedItem, LOCK_CONTROL, updater));
 682     }
 683
 684     private static RotationSpeedCharacteristic createRotationSpeedCharacteristic(HomekitTaggedItem item,
 685             HomekitAccessoryUpdater updater) {
 686         return new RotationSpeedCharacteristic(
 687                 item.getConfigurationAsDouble(HomekitTaggedItem.MIN_VALUE,
 688                         RotationSpeedCharacteristic.DEFAULT_MIN_VALUE),
 689                 item.getConfigurationAsDouble(HomekitTaggedItem.MAX_VALUE,
 690                         RotationSpeedCharacteristic.DEFAULT_MAX_VALUE),
 691                 item.getConfigurationAsDouble(HomekitTaggedItem.STEP, RotationSpeedCharacteristic.DEFAULT_STEP),
 692                 getDoubleSupplier(item, 0), setDoubleConsumer(item), getSubscriber(item, ROTATION_SPEED, updater),
 693                 getUnsubscriber(item, ROTATION_SPEED, updater));
 694     }
 695
 696     private static SetDurationCharacteristic createDurationCharacteristic(HomekitTaggedItem taggedItem,
 697             HomekitAccessoryUpdater updater) {
 698         return new SetDurationCharacteristic(() -> {
 699             int value = getIntFromItem(taggedItem, 0);
 700             final @Nullable Map<String, Object> itemConfiguration = taggedItem.getConfiguration();
 701             if ((value == 0) && (itemConfiguration != null)) { // check for default duration
 702                 final Object duration = itemConfiguration.get(HomekitValveImpl.CONFIG_DEFAULT_DURATION);
 703                 if (duration instanceof BigDecimal) {
 704                     value = ((BigDecimal) duration).intValue();
 705                     if (taggedItem.getItem() instanceof NumberItem) {
 706                         ((NumberItem) taggedItem.getItem()).setState(new DecimalType(value));
 707                     }
 708                 }
 709             }
 710             return CompletableFuture.completedFuture(value);
 711         }, setIntConsumer(taggedItem), getSubscriber(taggedItem, DURATION, updater),
 712                 getUnsubscriber(taggedItem, DURATION, updater));
 713     }
 714
 715     private static RemainingDurationCharacteristic createRemainingDurationCharacteristic(HomekitTaggedItem taggedItem,
 716             HomekitAccessoryUpdater updater) {
 717         return new RemainingDurationCharacteristic(getIntSupplier(taggedItem, 0),
 718                 getSubscriber(taggedItem, REMAINING_DURATION, updater),
 719                 getUnsubscriber(taggedItem, REMAINING_DURATION, updater));
 720     }
 721
 722     private static VolumeCharacteristic createVolumeCharacteristic(HomekitTaggedItem taggedItem,
 723             HomekitAccessoryUpdater updater) {
 724         return new VolumeCharacteristic(getIntSupplier(taggedItem, 0),
 725                 (volume) -> ((NumberItem) taggedItem.getItem()).send(new DecimalType(volume)),
 726                 getSubscriber(taggedItem, DURATION, updater), getUnsubscriber(taggedItem, DURATION, updater));
 727     }
 728
 729     private static CoolingThresholdTemperatureCharacteristic createCoolingThresholdCharacteristic(
 730             HomekitTaggedItem taggedItem, HomekitAccessoryUpdater updater) {
 731         double minValue = HomekitCharacteristicFactory.convertToCelsius(taggedItem.getConfigurationAsDouble(
 732                 HomekitTaggedItem.MIN_VALUE, CoolingThresholdTemperatureCharacteristic.DEFAULT_MIN_VALUE));
 733         double maxValue = HomekitCharacteristicFactory.convertToCelsius(taggedItem.getConfigurationAsDouble(
 734                 HomekitTaggedItem.MAX_VALUE, CoolingThresholdTemperatureCharacteristic.DEFAULT_MAX_VALUE));
 735         return new CoolingThresholdTemperatureCharacteristic(minValue, maxValue,
 736                 taggedItem.getConfigurationAsDouble(HomekitTaggedItem.STEP,
 737                         CoolingThresholdTemperatureCharacteristic.DEFAULT_STEP),
 738                 getTemperatureSupplier(taggedItem, minValue), setTemperatureConsumer(taggedItem),
 739                 getSubscriber(taggedItem, COOLING_THRESHOLD_TEMPERATURE, updater),
 740                 getUnsubscriber(taggedItem, COOLING_THRESHOLD_TEMPERATURE, updater));
 741     }
 742
 743     private static HeatingThresholdTemperatureCharacteristic createHeatingThresholdCharacteristic(
 744             HomekitTaggedItem taggedItem, HomekitAccessoryUpdater updater) {
 745         double minValue = HomekitCharacteristicFactory.convertToCelsius(taggedItem.getConfigurationAsDouble(
 746                 HomekitTaggedItem.MIN_VALUE, HeatingThresholdTemperatureCharacteristic.DEFAULT_MIN_VALUE));
 747         double maxValue = HomekitCharacteristicFactory.convertToCelsius(taggedItem.getConfigurationAsDouble(
 748                 HomekitTaggedItem.MAX_VALUE, HeatingThresholdTemperatureCharacteristic.DEFAULT_MAX_VALUE));
 749         return new HeatingThresholdTemperatureCharacteristic(minValue, maxValue,
 750                 taggedItem.getConfigurationAsDouble(HomekitTaggedItem.STEP,
 751                         HeatingThresholdTemperatureCharacteristic.DEFAULT_STEP),
 752                 getTemperatureSupplier(taggedItem, minValue), setTemperatureConsumer(taggedItem),
 753                 getSubscriber(taggedItem, HEATING_THRESHOLD_TEMPERATURE, updater),
 754                 getUnsubscriber(taggedItem, HEATING_THRESHOLD_TEMPERATURE, updater));
 755     }
 756
 757     private static CurrentRelativeHumidityCharacteristic createRelativeHumidityCharacteristic(
 758             HomekitTaggedItem taggedItem, HomekitAccessoryUpdater updater) {
 759         return new CurrentRelativeHumidityCharacteristic(getDoubleSupplier(taggedItem, 0.0),
 760                 getSubscriber(taggedItem, RELATIVE_HUMIDITY, updater),
 761                 getUnsubscriber(taggedItem, RELATIVE_HUMIDITY, updater));
 762     }
 763
 764     private static OzoneDensityCharacteristic createOzoneDensityCharacteristic(final HomekitTaggedItem taggedItem,
 765             HomekitAccessoryUpdater updater) {
 766         return new OzoneDensityCharacteristic(
 767                 getDoubleSupplier(taggedItem,
 768                         taggedItem.getConfigurationAsDouble(HomekitTaggedItem.MIN_VALUE,
 769                                 OzoneDensityCharacteristic.DEFAULT_MIN_VALUE)),
 770                 getSubscriber(taggedItem, OZONE_DENSITY, updater), getUnsubscriber(taggedItem, OZONE_DENSITY, updater));
 771     }
 772
 773     private static NitrogenDioxideDensityCharacteristic createNitrogenDioxideDensityCharacteristic(
 774             final HomekitTaggedItem taggedItem, HomekitAccessoryUpdater updater) {
 775         return new NitrogenDioxideDensityCharacteristic(
 776                 getDoubleSupplier(taggedItem,
 777                         taggedItem.getConfigurationAsDouble(HomekitTaggedItem.MIN_VALUE,
 778                                 NitrogenDioxideDensityCharacteristic.DEFAULT_MIN_VALUE)),
 779                 getSubscriber(taggedItem, NITROGEN_DIOXIDE_DENSITY, updater),
 780                 getUnsubscriber(taggedItem, NITROGEN_DIOXIDE_DENSITY, updater));
 781     }
 782
 783     private static SulphurDioxideDensityCharacteristic createSulphurDioxideDensityCharacteristic(
 784             final HomekitTaggedItem taggedItem, HomekitAccessoryUpdater updater) {
 785         return new SulphurDioxideDensityCharacteristic(
 786                 getDoubleSupplier(taggedItem,
 787                         taggedItem.getConfigurationAsDouble(HomekitTaggedItem.MIN_VALUE,
 788                                 SulphurDioxideDensityCharacteristic.DEFAULT_MIN_VALUE)),
 789                 getSubscriber(taggedItem, SULPHUR_DIOXIDE_DENSITY, updater),
 790                 getUnsubscriber(taggedItem, SULPHUR_DIOXIDE_DENSITY, updater));
 791     }
 792
 793     private static PM25DensityCharacteristic createPM25DensityCharacteristic(final HomekitTaggedItem taggedItem,
 794             HomekitAccessoryUpdater updater) {
 795         return new PM25DensityCharacteristic(
 796                 getDoubleSupplier(taggedItem,
 797                         taggedItem.getConfigurationAsDouble(HomekitTaggedItem.MIN_VALUE,
 798                                 PM25DensityCharacteristic.DEFAULT_MIN_VALUE)),
 799                 getSubscriber(taggedItem, PM25_DENSITY, updater), getUnsubscriber(taggedItem, PM25_DENSITY, updater));
 800     }
 801
 802     private static PM10DensityCharacteristic createPM10DensityCharacteristic(final HomekitTaggedItem taggedItem,
 803             HomekitAccessoryUpdater updater) {
 804         return new PM10DensityCharacteristic(
 805                 getDoubleSupplier(taggedItem,
 806                         taggedItem.getConfigurationAsDouble(HomekitTaggedItem.MIN_VALUE,
 807                                 PM10DensityCharacteristic.DEFAULT_MIN_VALUE)),
 808                 getSubscriber(taggedItem, PM10_DENSITY, updater), getUnsubscriber(taggedItem, PM10_DENSITY, updater));
 809     }
 810
 811     private static VOCDensityCharacteristic createVOCDensityCharacteristic(final HomekitTaggedItem taggedItem,
 812             HomekitAccessoryUpdater updater) {
 813         return new VOCDensityCharacteristic(
 814                 getDoubleSupplier(taggedItem,
 815                         taggedItem.getConfigurationAsDouble(HomekitTaggedItem.MIN_VALUE,
 816                                 VOCDensityCharacteristic.DEFAULT_MIN_VALUE)),
 817                 getSubscriber(taggedItem, VOC_DENSITY, updater), getUnsubscriber(taggedItem, VOC_DENSITY, updater));
 818     }
 819
 820     private static FilterLifeLevelCharacteristic createFilterLifeLevelCharacteristic(HomekitTaggedItem taggedItem,
 821             HomekitAccessoryUpdater updater) {
 822         return new FilterLifeLevelCharacteristic(getDoubleSupplier(taggedItem, 0),
 823                 getSubscriber(taggedItem, FILTER_LIFE_LEVEL, updater),
 824                 getUnsubscriber(taggedItem, FILTER_LIFE_LEVEL, updater));
 825     }
 826
 827     private static ResetFilterIndicationCharacteristic createFilterResetCharacteristic(HomekitTaggedItem taggedItem,
 828             HomekitAccessoryUpdater updater) {
 829         return new ResetFilterIndicationCharacteristic(
 830                 (value) -> ((SwitchItem) taggedItem.getItem()).send(OnOffType.ON));
 831     }
 832
 833     private static ActiveCharacteristic createActiveCharacteristic(HomekitTaggedItem taggedItem,
 834             HomekitAccessoryUpdater updater) {
 835         return new ActiveCharacteristic(
 836                 () -> getEnumFromItem(taggedItem, ActiveEnum.ACTIVE, ActiveEnum.INACTIVE, ActiveEnum.INACTIVE),
 837                 (value) -> setValueFromEnum(taggedItem, value, ActiveEnum.ACTIVE, ActiveEnum.INACTIVE),
 838                 getSubscriber(taggedItem, ACTIVE, updater), getUnsubscriber(taggedItem, ACTIVE, updater));
 839     }
 840
 841     private static ConfiguredNameCharacteristic createConfiguredNameCharacteristic(HomekitTaggedItem taggedItem,
 842             HomekitAccessoryUpdater updater) {
 843         return new ConfiguredNameCharacteristic(() -> {
 844             final State state = taggedItem.getItem().getState();
 845             return CompletableFuture
 846                     .completedFuture(state instanceof UnDefType ? taggedItem.getName() : state.toString());
 847         }, (value) -> ((StringItem) taggedItem.getItem()).send(new StringType(value)),
 848                 getSubscriber(taggedItem, CONFIGURED_NAME, updater),
 849                 getUnsubscriber(taggedItem, CONFIGURED_NAME, updater));
 850     }
 851 }