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

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