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