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

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