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