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