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

   1 /**
   2  * Copyright (c) 2010-2023 Contributors to the openHAB project
   3  *
   4  * See the NOTICE file(s) distributed with this work for additional
   5  * information.
   6  *
   7  * This program and the accompanying materials are made available under the
   8  * terms of the Eclipse Public License 2.0 which is available at
   9  * http://www.eclipse.org/legal/epl-2.0
  10  *
  11  * SPDX-License-Identifier: EPL-2.0
  12  */
  13 package org.openhab.io.homekit.internal.accessories;
  14
  15 import static org.openhab.io.homekit.internal.HomekitCharacteristicType.*;
  16
  17 import java.math.BigDecimal;
  18 import java.math.RoundingMode;
  19 import java.util.EnumMap;
  20 import java.util.HashMap;
  21 import java.util.List;
  22 import java.util.Map;
  23 import java.util.concurrent.CompletableFuture;
  24 import java.util.function.BiFunction;
  25 import java.util.function.Consumer;
  26 import java.util.function.Supplier;
  27
  28 import javax.measure.Quantity;
  29 import javax.measure.Unit;
  30
  31 import org.eclipse.jdt.annotation.NonNullByDefault;
  32 import org.eclipse.jdt.annotation.Nullable;
  33 import org.openhab.core.items.GenericItem;
  34 import org.openhab.core.items.Item;
  35 import org.openhab.core.library.items.ColorItem;
  36 import org.openhab.core.library.items.DimmerItem;
  37 import org.openhab.core.library.items.NumberItem;
  38 import org.openhab.core.library.items.RollershutterItem;
  39 import org.openhab.core.library.items.StringItem;
  40 import org.openhab.core.library.items.SwitchItem;
  41 import org.openhab.core.library.types.DecimalType;
  42 import org.openhab.core.library.types.HSBType;
  43 import org.openhab.core.library.types.IncreaseDecreaseType;
  44 import org.openhab.core.library.types.OnOffType;
  45 import org.openhab.core.library.types.OpenClosedType;
  46 import org.openhab.core.library.types.PercentType;
  47 import org.openhab.core.library.types.QuantityType;
  48 import org.openhab.core.library.types.StopMoveType;
  49 import org.openhab.core.library.types.StringType;
  50 import org.openhab.core.library.unit.ImperialUnits;
  51 import org.openhab.core.library.unit.SIUnits;
  52 import org.openhab.core.library.unit.Units;
  53 import org.openhab.core.types.State;
  54 import org.openhab.core.types.UnDefType;
  55 import org.openhab.io.homekit.Homekit;
  56 import org.openhab.io.homekit.internal.HomekitAccessoryUpdater;
  57 import org.openhab.io.homekit.internal.HomekitCharacteristicType;
  58 import org.openhab.io.homekit.internal.HomekitCommandType;
  59 import org.openhab.io.homekit.internal.HomekitException;
  60 import org.openhab.io.homekit.internal.HomekitImpl;
  61 import org.openhab.io.homekit.internal.HomekitTaggedItem;
  62 import org.osgi.framework.FrameworkUtil;
  63 import org.slf4j.Logger;
  64 import org.slf4j.LoggerFactory;
  65
  66 import io.github.hapjava.characteristics.Characteristic;
  67 import io.github.hapjava.characteristics.CharacteristicEnum;
  68 import io.github.hapjava.characteristics.ExceptionalConsumer;
  69 import io.github.hapjava.characteristics.HomekitCharacteristicChangeCallback;
  70 import io.github.hapjava.characteristics.impl.airquality.NitrogenDioxideDensityCharacteristic;
  71 import io.github.hapjava.characteristics.impl.airquality.OzoneDensityCharacteristic;
  72 import io.github.hapjava.characteristics.impl.airquality.PM10DensityCharacteristic;
  73 import io.github.hapjava.characteristics.impl.airquality.PM25DensityCharacteristic;
  74 import io.github.hapjava.characteristics.impl.airquality.SulphurDioxideDensityCharacteristic;
  75 import io.github.hapjava.characteristics.impl.airquality.VOCDensityCharacteristic;
  76 import io.github.hapjava.characteristics.impl.audio.MuteCharacteristic;
  77 import io.github.hapjava.characteristics.impl.audio.VolumeCharacteristic;
  78 import io.github.hapjava.characteristics.impl.battery.StatusLowBatteryCharacteristic;
  79 import io.github.hapjava.characteristics.impl.battery.StatusLowBatteryEnum;
  80 import io.github.hapjava.characteristics.impl.carbondioxidesensor.CarbonDioxideLevelCharacteristic;
  81 import io.github.hapjava.characteristics.impl.carbondioxidesensor.CarbonDioxidePeakLevelCharacteristic;
  82 import io.github.hapjava.characteristics.impl.carbonmonoxidesensor.CarbonMonoxideLevelCharacteristic;
  83 import io.github.hapjava.characteristics.impl.carbonmonoxidesensor.CarbonMonoxidePeakLevelCharacteristic;
  84 import io.github.hapjava.characteristics.impl.common.ActiveCharacteristic;
  85 import io.github.hapjava.characteristics.impl.common.ActiveEnum;
  86 import io.github.hapjava.characteristics.impl.common.ActiveIdentifierCharacteristic;
  87 import io.github.hapjava.characteristics.impl.common.ConfiguredNameCharacteristic;
  88 import io.github.hapjava.characteristics.impl.common.IdentifierCharacteristic;
  89 import io.github.hapjava.characteristics.impl.common.IsConfiguredCharacteristic;
  90 import io.github.hapjava.characteristics.impl.common.IsConfiguredEnum;
  91 import io.github.hapjava.characteristics.impl.common.NameCharacteristic;
  92 import io.github.hapjava.characteristics.impl.common.ObstructionDetectedCharacteristic;
  93 import io.github.hapjava.characteristics.impl.common.StatusActiveCharacteristic;
  94 import io.github.hapjava.characteristics.impl.common.StatusFaultCharacteristic;
  95 import io.github.hapjava.characteristics.impl.common.StatusFaultEnum;
  96 import io.github.hapjava.characteristics.impl.common.StatusTamperedCharacteristic;
  97 import io.github.hapjava.characteristics.impl.common.StatusTamperedEnum;
  98 import io.github.hapjava.characteristics.impl.fan.CurrentFanStateCharacteristic;
  99 import io.github.hapjava.characteristics.impl.fan.CurrentFanStateEnum;
 100 import io.github.hapjava.characteristics.impl.fan.LockPhysicalControlsCharacteristic;
 101 import io.github.hapjava.characteristics.impl.fan.LockPhysicalControlsEnum;
 102 import io.github.hapjava.characteristics.impl.fan.RotationDirectionCharacteristic;
 103 import io.github.hapjava.characteristics.impl.fan.RotationDirectionEnum;
 104 import io.github.hapjava.characteristics.impl.fan.RotationSpeedCharacteristic;
 105 import io.github.hapjava.characteristics.impl.fan.SwingModeCharacteristic;
 106 import io.github.hapjava.characteristics.impl.fan.SwingModeEnum;
 107 import io.github.hapjava.characteristics.impl.fan.TargetFanStateCharacteristic;
 108 import io.github.hapjava.characteristics.impl.fan.TargetFanStateEnum;
 109 import io.github.hapjava.characteristics.impl.filtermaintenance.FilterLifeLevelCharacteristic;
 110 import io.github.hapjava.characteristics.impl.filtermaintenance.ResetFilterIndicationCharacteristic;
 111 import io.github.hapjava.characteristics.impl.humiditysensor.CurrentRelativeHumidityCharacteristic;
 112 import io.github.hapjava.characteristics.impl.inputsource.CurrentVisibilityStateCharacteristic;
 113 import io.github.hapjava.characteristics.impl.inputsource.CurrentVisibilityStateEnum;
 114 import io.github.hapjava.characteristics.impl.inputsource.InputDeviceTypeCharacteristic;
 115 import io.github.hapjava.characteristics.impl.inputsource.InputDeviceTypeEnum;
 116 import io.github.hapjava.characteristics.impl.inputsource.InputSourceTypeCharacteristic;
 117 import io.github.hapjava.characteristics.impl.inputsource.InputSourceTypeEnum;
 118 import io.github.hapjava.characteristics.impl.inputsource.TargetVisibilityStateCharacteristic;
 119 import io.github.hapjava.characteristics.impl.inputsource.TargetVisibilityStateEnum;
 120 import io.github.hapjava.characteristics.impl.lightbulb.BrightnessCharacteristic;
 121 import io.github.hapjava.characteristics.impl.lightbulb.ColorTemperatureCharacteristic;
 122 import io.github.hapjava.characteristics.impl.lightbulb.HueCharacteristic;
 123 import io.github.hapjava.characteristics.impl.lightbulb.SaturationCharacteristic;
 124 import io.github.hapjava.characteristics.impl.slat.CurrentTiltAngleCharacteristic;
 125 import io.github.hapjava.characteristics.impl.slat.TargetTiltAngleCharacteristic;
 126 import io.github.hapjava.characteristics.impl.television.ClosedCaptionsCharacteristic;
 127 import io.github.hapjava.characteristics.impl.television.ClosedCaptionsEnum;
 128 import io.github.hapjava.characteristics.impl.television.CurrentMediaStateCharacteristic;
 129 import io.github.hapjava.characteristics.impl.television.CurrentMediaStateEnum;
 130 import io.github.hapjava.characteristics.impl.television.PictureModeCharacteristic;
 131 import io.github.hapjava.characteristics.impl.television.PictureModeEnum;
 132 import io.github.hapjava.characteristics.impl.television.PowerModeCharacteristic;
 133 import io.github.hapjava.characteristics.impl.television.PowerModeEnum;
 134 import io.github.hapjava.characteristics.impl.television.RemoteKeyCharacteristic;
 135 import io.github.hapjava.characteristics.impl.television.RemoteKeyEnum;
 136 import io.github.hapjava.characteristics.impl.television.SleepDiscoveryModeCharacteristic;
 137 import io.github.hapjava.characteristics.impl.television.SleepDiscoveryModeEnum;
 138 import io.github.hapjava.characteristics.impl.television.TargetMediaStateCharacteristic;
 139 import io.github.hapjava.characteristics.impl.television.TargetMediaStateEnum;
 140 import io.github.hapjava.characteristics.impl.televisionspeaker.VolumeControlTypeCharacteristic;
 141 import io.github.hapjava.characteristics.impl.televisionspeaker.VolumeControlTypeEnum;
 142 import io.github.hapjava.characteristics.impl.televisionspeaker.VolumeSelectorCharacteristic;
 143 import io.github.hapjava.characteristics.impl.televisionspeaker.VolumeSelectorEnum;
 144 import io.github.hapjava.characteristics.impl.thermostat.CoolingThresholdTemperatureCharacteristic;
 145 import io.github.hapjava.characteristics.impl.thermostat.HeatingThresholdTemperatureCharacteristic;
 146 import io.github.hapjava.characteristics.impl.valve.RemainingDurationCharacteristic;
 147 import io.github.hapjava.characteristics.impl.valve.SetDurationCharacteristic;
 148 import io.github.hapjava.characteristics.impl.windowcovering.CurrentHorizontalTiltAngleCharacteristic;
 149 import io.github.hapjava.characteristics.impl.windowcovering.CurrentVerticalTiltAngleCharacteristic;
 150 import io.github.hapjava.characteristics.impl.windowcovering.HoldPositionCharacteristic;
 151 import io.github.hapjava.characteristics.impl.windowcovering.TargetHorizontalTiltAngleCharacteristic;
 152 import io.github.hapjava.characteristics.impl.windowcovering.TargetVerticalTiltAngleCharacteristic;
 153 import tech.units.indriya.unit.UnitDimension;
 154
 155 /**
 156  * Creates an optional characteristics .
 157  *
 158  * @author Eugen Freiter - Initial contribution
 159  */
 160 @NonNullByDefault
 161 public class HomekitCharacteristicFactory {
 162     private static final Logger logger = LoggerFactory.getLogger(HomekitCharacteristicFactory.class);
 163
 164     // List of optional characteristics and corresponding method to create them.
 165     private static final Map<HomekitCharacteristicType, BiFunction<HomekitTaggedItem, HomekitAccessoryUpdater, Characteristic>> optional = new HashMap<HomekitCharacteristicType, BiFunction<HomekitTaggedItem, HomekitAccessoryUpdater, Characteristic>>() {
 166         {
 167             put(NAME, HomekitCharacteristicFactory::createNameCharacteristic);
 168             put(BATTERY_LOW_STATUS, HomekitCharacteristicFactory::createStatusLowBatteryCharacteristic);
 169             put(FAULT_STATUS, HomekitCharacteristicFactory::createStatusFaultCharacteristic);
 170             put(TAMPERED_STATUS, HomekitCharacteristicFactory::createStatusTamperedCharacteristic);
 171             put(ACTIVE_STATUS, HomekitCharacteristicFactory::createStatusActiveCharacteristic);
 172             put(CARBON_MONOXIDE_LEVEL, HomekitCharacteristicFactory::createCarbonMonoxideLevelCharacteristic);
 173             put(CARBON_MONOXIDE_PEAK_LEVEL, HomekitCharacteristicFactory::createCarbonMonoxidePeakLevelCharacteristic);
 174             put(CARBON_DIOXIDE_LEVEL, HomekitCharacteristicFactory::createCarbonDioxideLevelCharacteristic);
 175             put(CARBON_DIOXIDE_PEAK_LEVEL, HomekitCharacteristicFactory::createCarbonDioxidePeakLevelCharacteristic);
 176             put(HOLD_POSITION, HomekitCharacteristicFactory::createHoldPositionCharacteristic);
 177             put(OBSTRUCTION_STATUS, HomekitCharacteristicFactory::createObstructionDetectedCharacteristic);
 178             put(CURRENT_HORIZONTAL_TILT_ANGLE,
 179                     HomekitCharacteristicFactory::createCurrentHorizontalTiltAngleCharacteristic);
 180             put(CURRENT_VERTICAL_TILT_ANGLE,
 181                     HomekitCharacteristicFactory::createCurrentVerticalTiltAngleCharacteristic);
 182             put(TARGET_HORIZONTAL_TILT_ANGLE,
 183                     HomekitCharacteristicFactory::createTargetHorizontalTiltAngleCharacteristic);
 184             put(TARGET_VERTICAL_TILT_ANGLE, HomekitCharacteristicFactory::createTargetVerticalTiltAngleCharacteristic);
 185             put(CURRENT_TILT_ANGLE, HomekitCharacteristicFactory::createCurrentTiltAngleCharacteristic);
 186             put(TARGET_TILT_ANGLE, HomekitCharacteristicFactory::createTargetTiltAngleCharacteristic);
 187             put(HUE, HomekitCharacteristicFactory::createHueCharacteristic);
 188             put(BRIGHTNESS, HomekitCharacteristicFactory::createBrightnessCharacteristic);
 189             put(SATURATION, HomekitCharacteristicFactory::createSaturationCharacteristic);
 190             put(COLOR_TEMPERATURE, HomekitCharacteristicFactory::createColorTemperatureCharacteristic);
 191             put(CURRENT_FAN_STATE, HomekitCharacteristicFactory::createCurrentFanStateCharacteristic);
 192             put(TARGET_FAN_STATE, HomekitCharacteristicFactory::createTargetFanStateCharacteristic);
 193             put(ROTATION_DIRECTION, HomekitCharacteristicFactory::createRotationDirectionCharacteristic);
 194             put(ROTATION_SPEED, HomekitCharacteristicFactory::createRotationSpeedCharacteristic);
 195             put(SWING_MODE, HomekitCharacteristicFactory::createSwingModeCharacteristic);
 196             put(LOCK_CONTROL, HomekitCharacteristicFactory::createLockPhysicalControlsCharacteristic);
 197             put(DURATION, HomekitCharacteristicFactory::createDurationCharacteristic);
 198             put(VOLUME, HomekitCharacteristicFactory::createVolumeCharacteristic);
 199             put(COOLING_THRESHOLD_TEMPERATURE, HomekitCharacteristicFactory::createCoolingThresholdCharacteristic);
 200             put(HEATING_THRESHOLD_TEMPERATURE, HomekitCharacteristicFactory::createHeatingThresholdCharacteristic);
 201             put(RELATIVE_HUMIDITY, HomekitCharacteristicFactory::createRelativeHumidityCharacteristic);
 202             put(REMAINING_DURATION, HomekitCharacteristicFactory::createRemainingDurationCharacteristic);
 203             put(OZONE_DENSITY, HomekitCharacteristicFactory::createOzoneDensityCharacteristic);
 204             put(NITROGEN_DIOXIDE_DENSITY, HomekitCharacteristicFactory::createNitrogenDioxideDensityCharacteristic);
 205             put(SULPHUR_DIOXIDE_DENSITY, HomekitCharacteristicFactory::createSulphurDioxideDensityCharacteristic);
 206             put(PM25_DENSITY, HomekitCharacteristicFactory::createPM25DensityCharacteristic);
 207             put(PM10_DENSITY, HomekitCharacteristicFactory::createPM10DensityCharacteristic);
 208             put(VOC_DENSITY, HomekitCharacteristicFactory::createVOCDensityCharacteristic);
 209             put(FILTER_LIFE_LEVEL, HomekitCharacteristicFactory::createFilterLifeLevelCharacteristic);
 210             put(FILTER_RESET_INDICATION, HomekitCharacteristicFactory::createFilterResetCharacteristic);
 211             put(ACTIVE, HomekitCharacteristicFactory::createActiveCharacteristic);
 212             put(CONFIGURED_NAME, HomekitCharacteristicFactory::createConfiguredNameCharacteristic);
 213             put(ACTIVE_IDENTIFIER, HomekitCharacteristicFactory::createActiveIdentifierCharacteristic);
 214             put(REMOTE_KEY, HomekitCharacteristicFactory::createRemoteKeyCharacteristic);
 215             put(SLEEP_DISCOVERY_MODE, HomekitCharacteristicFactory::createSleepDiscoveryModeCharacteristic);
 216             put(POWER_MODE, HomekitCharacteristicFactory::createPowerModeCharacteristic);
 217             put(CLOSED_CAPTIONS, HomekitCharacteristicFactory::createClosedCaptionsCharacteristic);
 218             put(PICTURE_MODE, HomekitCharacteristicFactory::createPictureModeCharacteristic);
 219             put(CONFIGURED, HomekitCharacteristicFactory::createIsConfiguredCharacteristic);
 220             put(INPUT_SOURCE_TYPE, HomekitCharacteristicFactory::createInputSourceTypeCharacteristic);
 221             put(CURRENT_VISIBILITY, HomekitCharacteristicFactory::createCurrentVisibilityStateCharacteristic);
 222             put(IDENTIFIER, HomekitCharacteristicFactory::createIdentifierCharacteristic);
 223             put(INPUT_DEVICE_TYPE, HomekitCharacteristicFactory::createInputDeviceTypeCharacteristic);
 224             put(TARGET_VISIBILITY_STATE, HomekitCharacteristicFactory::createTargetVisibilityStateCharacteristic);
 225             put(VOLUME_SELECTOR, HomekitCharacteristicFactory::createVolumeSelectorCharacteristic);
 226             put(VOLUME_CONTROL_TYPE, HomekitCharacteristicFactory::createVolumeControlTypeCharacteristic);
 227             put(CURRENT_MEDIA_STATE, HomekitCharacteristicFactory::createCurrentMediaStateCharacteristic);
 228             put(TARGET_MEDIA_STATE, HomekitCharacteristicFactory::createTargetMediaStateCharacteristic);
 229             put(MUTE, HomekitCharacteristicFactory::createMuteCharacteristic);
 230         }
 231     };
 232
 233     public static @Nullable Characteristic createNullableCharacteristic(HomekitTaggedItem item,
 234             HomekitAccessoryUpdater updater) {
 235         final @Nullable HomekitCharacteristicType type = item.getCharacteristicType();
 236         logger.trace("Create characteristic {}", item);
 237         if (optional.containsKey(type)) {
 238             return optional.get(type).apply(item, updater);
 239         }
 240         return null;
 241     }
 242
 243     /**
 244      * Create HomeKit characteristic
 245      *
 246      * @param item corresponding OH item
 247      * @param updater update to keep OH item and HomeKit characteristic in sync
 248      * @return HomeKit characteristic
 249      */
 250     public static Characteristic createCharacteristic(HomekitTaggedItem item, HomekitAccessoryUpdater updater)
 251             throws HomekitException {
 252         Characteristic characteristic = createNullableCharacteristic(item, updater);
 253         if (characteristic != null) {
 254             return characteristic;
 255         }
 256         final @Nullable HomekitCharacteristicType type = item.getCharacteristicType();
 257         logger.warn("Unsupported optional characteristic from item {}. Accessory type {}, characteristic type {}",
 258                 item.getName(), item.getAccessoryType(), type.getTag());
 259         throw new HomekitException(
 260                 "Unsupported optional characteristic. Characteristic type \"" + type.getTag() + "\"");
 261     }
 262
 263     public static <T extends Enum<T>> Map<T, String> createMapping(HomekitTaggedItem item, Class<T> klazz) {
 264         EnumMap<T, String> map = new EnumMap(klazz);
 265         for (var k : klazz.getEnumConstants()) {
 266             map.put(k, k.toString());
 267         }
 268         var configuration = item.getConfiguration();
 269         if (configuration != null) {
 270             updateMapping(configuration, map);
 271         }
 272         return map;
 273     }
 274
 275     /**
 276      * Update mapping with values from item configuration.
 277      * It checks for all keys from the mapping whether there is configuration at item with the same key and if yes,
 278      * replace the value.
 279      *
 280      * @param configuration tagged item configuration
 281      * @param map mapping to update
 282      * @param customEnumList list to store custom state enumeration
 283      */
 284     public static <T> void updateMapping(Map<String, Object> configuration, Map<T, String> map,
 285             @Nullable List<T> customEnumList) {
 286         map.forEach((k, current_value) -> {
 287             final Object new_value = configuration.get(k.toString());
 288             if (new_value instanceof String) {
 289                 map.put(k, (String) new_value);
 290                 if (customEnumList != null) {
 291                     customEnumList.add(k);
 292                 }
 293             }
 294         });
 295     }
 296
 297     public static <T> void updateMapping(Map<String, Object> configuration, Map<T, String> map) {
 298         updateMapping(configuration, map, null);
 299     }
 300
 301     /**
 302      * Takes item state as value and retrieves the key for that value from mapping.
 303      * E.g. used to map StringItem value to HomeKit Enum
 304      *
 305      * @param characteristicType characteristicType to identify item
 306      * @param mapping mapping
 307      * @param defaultValue default value if nothing found in mapping
 308      * @param <T> type of the result derived from
 309      * @return key for the value
 310      */
 311     public static <T> T getKeyFromMapping(HomekitTaggedItem item, Map<T, String> mapping, T defaultValue) {
 312         final State state = item.getItem().getState();
 313         logger.trace("getKeyFromMapping: characteristic {}, state {}, mapping {}", item.getAccessoryType().getTag(),
 314                 state, mapping);
 315         if (state instanceof StringType) {
 316             return mapping.entrySet().stream().filter(entry -> state.toString().equalsIgnoreCase(entry.getValue()))
 317                     .findAny().map(Map.Entry::getKey).orElseGet(() -> {
 318                         logger.warn(
 319                                 "Wrong value {} for {} characteristic of the item {}. Expected one of following {}. Returning {}.",
 320                                 state.toString(), item.getAccessoryType().getTag(), item.getName(), mapping.values(),
 321                                 defaultValue);
 322                         return defaultValue;
 323                     });
 324         }
 325         return defaultValue;
 326     }
 327
 328     // METHODS TO CREATE SINGLE CHARACTERISTIC FROM OH ITEM
 329
 330     // supporting methods
 331
 332     public static boolean useFahrenheit() {
 333         return FrameworkUtil.getBundle(HomekitImpl.class).getBundleContext()
 334                 .getServiceReference(Homekit.class.getName()).getProperty("useFahrenheitTemperature") == Boolean.TRUE;
 335     }
 336
 337     private static <T extends CharacteristicEnum> CompletableFuture<T> getEnumFromItem(HomekitTaggedItem item,
 338             Map<T, String> mapping, T defaultValue) {
 339         return CompletableFuture.completedFuture(getKeyFromMapping(item, mapping, defaultValue));
 340     }
 341
 342     private static <T extends CharacteristicEnum> CompletableFuture<T> getEnumFromItem(HomekitTaggedItem item,
 343             T offEnum, T onEnum, T defaultEnum) {
 344         final State state = item.getItem().getState();
 345         if (state instanceof OnOffType) {
 346             return CompletableFuture
 347                     .completedFuture(state.equals(item.isInverted() ? OnOffType.ON : OnOffType.OFF) ? offEnum : onEnum);
 348         } else if (state instanceof OpenClosedType) {
 349             return CompletableFuture.completedFuture(
 350                     state.equals(item.isInverted() ? OpenClosedType.OPEN : OpenClosedType.CLOSED) ? offEnum : onEnum);
 351         } else if (state instanceof DecimalType) {
 352             return CompletableFuture.completedFuture(((DecimalType) state).intValue() == 0 ? offEnum : onEnum);
 353         } else if (state instanceof UnDefType) {
 354             return CompletableFuture.completedFuture(defaultEnum);
 355         }
 356         logger.warn(
 357                 "Item state {} is not supported. Only OnOffType,OpenClosedType and Decimal (0/1) are supported. Ignore item {}",
 358                 state, item.getName());
 359         return CompletableFuture.completedFuture(defaultEnum);
 360     }
 361
 362     private static <T extends Enum<T>> void setValueFromEnum(HomekitTaggedItem taggedItem, T value,
 363             Map<T, String> map) {
 364         taggedItem.send(new StringType(map.get(value)));
 365     }
 366
 367     private static void setValueFromEnum(HomekitTaggedItem taggedItem, CharacteristicEnum value,
 368             CharacteristicEnum offEnum, CharacteristicEnum onEnum) {
 369         if (taggedItem.getBaseItem() instanceof SwitchItem) {
 370             if (value.equals(offEnum)) {
 371                 taggedItem.send(taggedItem.isInverted() ? OnOffType.ON : OnOffType.OFF);
 372             } else if (value.equals(onEnum)) {
 373                 taggedItem.send(taggedItem.isInverted() ? OnOffType.OFF : OnOffType.ON);
 374             } else {
 375                 logger.warn("Enum value {} is not supported for {}. Only following values are supported: {},{}", value,
 376                         taggedItem.getName(), offEnum, onEnum);
 377             }
 378         } else if (taggedItem.getBaseItem() instanceof NumberItem) {
 379             taggedItem.send(new DecimalType(value.getCode()));
 380         } else {
 381             logger.warn("Item {} of type {} is not supported. Only Switch and Number item types are supported.",
 382                     taggedItem.getName(), taggedItem.getBaseItem().getType());
 383         }
 384     }
 385
 386     private static int getIntFromItem(HomekitTaggedItem taggedItem, int defaultValue) {
 387         int value = defaultValue;
 388         final State state = taggedItem.getItem().getState();
 389         if (state instanceof PercentType) {
 390             value = ((PercentType) state).intValue();
 391         } else if (state instanceof DecimalType) {
 392             value = ((DecimalType) state).intValue();
 393         } else if (state instanceof UnDefType) {
 394             logger.debug("Item state {} is UNDEF {}. Returning default value {}", state, taggedItem.getName(),
 395                     defaultValue);
 396         } else {
 397             logger.warn(
 398                     "Item state {} is not supported for {}. Only PercentType and DecimalType (0/100) are supported.",
 399                     state, taggedItem.getName());
 400         }
 401         return value;
 402     }
 403
 404     /** special method for tilts. it converts percentage to angle */
 405     private static int getAngleFromItem(HomekitTaggedItem taggedItem, int defaultValue) {
 406         int value = defaultValue;
 407         final State state = taggedItem.getItem().getState();
 408         if (state instanceof PercentType) {
 409             value = (int) ((((PercentType) state).intValue() * 90.0) / 50.0 - 90.0);
 410         } else {
 411             value = getIntFromItem(taggedItem, defaultValue);
 412         }
 413         return value;
 414     }
 415
 416     private static <T extends Quantity<T>> double convertAndRound(double value, Unit<T> from, Unit<T> to) {
 417         double rawValue = from.equals(to) ? value : from.getConverterTo(to).convert(value);
 418         return new BigDecimal(rawValue).setScale(1, RoundingMode.HALF_UP).doubleValue();
 419     }
 420
 421     public static @Nullable Double stateAsTemperature(@Nullable State state) {
 422         if (state == null || state instanceof UnDefType) {
 423             return null;
 424         }
 425
 426         if (state instanceof QuantityType<?>) {
 427             final QuantityType<?> qt = (QuantityType<?>) state;
 428             if (qt.getDimension().equals(UnitDimension.TEMPERATURE)) {
 429                 return qt.toUnit(SIUnits.CELSIUS).doubleValue();
 430             }
 431         }
 432
 433         return convertToCelsius(state.as(DecimalType.class).doubleValue());
 434     }
 435
 436     public static double convertToCelsius(double degrees) {
 437         return convertAndRound(degrees, useFahrenheit() ? ImperialUnits.FAHRENHEIT : SIUnits.CELSIUS, SIUnits.CELSIUS);
 438     }
 439
 440     public static double convertFromCelsius(double degrees) {
 441         return convertAndRound(degrees, SIUnits.CELSIUS, useFahrenheit() ? ImperialUnits.FAHRENHEIT : SIUnits.CELSIUS);
 442     }
 443
 444     public static double getTemperatureStep(HomekitTaggedItem taggedItem, double defaultValue) {
 445         return taggedItem.getConfigurationAsQuantity(HomekitTaggedItem.STEP,
 446                 new QuantityType(defaultValue, SIUnits.CELSIUS), true).doubleValue();
 447     }
 448
 449     private static Supplier<CompletableFuture<Integer>> getAngleSupplier(HomekitTaggedItem taggedItem,
 450             int defaultValue) {
 451         return () -> CompletableFuture.completedFuture(getAngleFromItem(taggedItem, defaultValue));
 452     }
 453
 454     private static Supplier<CompletableFuture<Integer>> getIntSupplier(HomekitTaggedItem taggedItem, int defaultValue) {
 455         return () -> CompletableFuture.completedFuture(getIntFromItem(taggedItem, defaultValue));
 456     }
 457
 458     private static ExceptionalConsumer<Integer> setIntConsumer(HomekitTaggedItem taggedItem) {
 459         return (value) -> {
 460             if (taggedItem.getBaseItem() instanceof NumberItem) {
 461                 taggedItem.send(new DecimalType(value));
 462             } else {
 463                 logger.warn("Item type {} is not supported for {}. Only NumberItem is supported.",
 464                         taggedItem.getBaseItem().getType(), taggedItem.getName());
 465             }
 466         };
 467     }
 468
 469     private static ExceptionalConsumer<Integer> setPercentConsumer(HomekitTaggedItem taggedItem) {
 470         return (value) -> {
 471             if (taggedItem.getBaseItem() instanceof NumberItem) {
 472                 taggedItem.send(new DecimalType(value));
 473             } else if (taggedItem.getBaseItem() instanceof DimmerItem) {
 474                 taggedItem.send(new PercentType(value));
 475             } else {
 476                 logger.warn("Item type {} is not supported for {}. Only DimmerItem and NumberItem are supported.",
 477                         taggedItem.getBaseItem().getType(), taggedItem.getName());
 478             }
 479         };
 480     }
 481
 482     private static ExceptionalConsumer<Integer> setAngleConsumer(HomekitTaggedItem taggedItem) {
 483         return (value) -> {
 484             if (taggedItem.getBaseItem() instanceof NumberItem) {
 485                 taggedItem.send(new DecimalType(value));
 486             } else if (taggedItem.getBaseItem() instanceof DimmerItem) {
 487                 value = (int) (value * 50.0 / 90.0 + 50.0);
 488                 taggedItem.send(new PercentType(value));
 489             } else {
 490                 logger.warn("Item type {} is not supported for {}. Only DimmerItem and NumberItem are supported.",
 491                         taggedItem.getBaseItem().getType(), taggedItem.getName());
 492             }
 493         };
 494     }
 495
 496     private static Supplier<CompletableFuture<Double>> getDoubleSupplier(HomekitTaggedItem taggedItem,
 497             double defaultValue) {
 498         return () -> {
 499             final State state = taggedItem.getItem().getState();
 500             double value = defaultValue;
 501             if (state instanceof PercentType) {
 502                 value = ((PercentType) state).doubleValue();
 503             } else if (state instanceof DecimalType) {
 504                 value = ((DecimalType) state).doubleValue();
 505             } else if (state instanceof QuantityType) {
 506                 value = ((QuantityType) state).doubleValue();
 507             }
 508             return CompletableFuture.completedFuture(value);
 509         };
 510     }
 511
 512     private static ExceptionalConsumer<Double> setDoubleConsumer(HomekitTaggedItem taggedItem) {
 513         return (value) -> {
 514             if (taggedItem.getBaseItem() instanceof NumberItem) {
 515                 taggedItem.send(new DecimalType(value.doubleValue()));
 516             } else if (taggedItem.getBaseItem() instanceof DimmerItem) {
 517                 taggedItem.send(new PercentType(value.intValue()));
 518             } else {
 519                 logger.warn("Item type {} is not supported for {}. Only Number and Dimmer type are supported.",
 520                         taggedItem.getBaseItem().getType(), taggedItem.getName());
 521             }
 522         };
 523     }
 524
 525     private static Supplier<CompletableFuture<Double>> getTemperatureSupplier(HomekitTaggedItem taggedItem,
 526             double defaultValue) {
 527         return () -> {
 528             final @Nullable Double value = stateAsTemperature(taggedItem.getItem().getState());
 529             return CompletableFuture.completedFuture(value != null ? value : defaultValue);
 530         };
 531     }
 532
 533     private static ExceptionalConsumer<Double> setTemperatureConsumer(HomekitTaggedItem taggedItem) {
 534         return (value) -> {
 535             if (taggedItem.getBaseItem() instanceof NumberItem) {
 536                 taggedItem.send(new DecimalType(convertFromCelsius(value)));
 537             } else {
 538                 logger.warn("Item type {} is not supported for {}. Only Number type is supported.",
 539                         taggedItem.getBaseItem().getType(), taggedItem.getName());
 540             }
 541         };
 542     }
 543
 544     protected static Consumer<HomekitCharacteristicChangeCallback> getSubscriber(HomekitTaggedItem taggedItem,
 545             HomekitCharacteristicType key, HomekitAccessoryUpdater updater) {
 546         return (callback) -> updater.subscribe((GenericItem) taggedItem.getItem(), key.getTag(), callback);
 547     }
 548
 549     protected static Runnable getUnsubscriber(HomekitTaggedItem taggedItem, HomekitCharacteristicType key,
 550             HomekitAccessoryUpdater updater) {
 551         return () -> updater.unsubscribe((GenericItem) taggedItem.getItem(), key.getTag());
 552     }
 553
 554     // create method for characteristic
 555     private static StatusLowBatteryCharacteristic createStatusLowBatteryCharacteristic(HomekitTaggedItem taggedItem,
 556             HomekitAccessoryUpdater updater) {
 557         BigDecimal lowThreshold = taggedItem.getConfiguration(HomekitTaggedItem.BATTERY_LOW_THRESHOLD,
 558                 BigDecimal.valueOf(20));
 559         BooleanItemReader lowBatteryReader = new BooleanItemReader(taggedItem.getItem(),
 560                 taggedItem.isInverted() ? OnOffType.OFF : OnOffType.ON,
 561                 taggedItem.isInverted() ? OpenClosedType.CLOSED : OpenClosedType.OPEN, lowThreshold, true);
 562         return new StatusLowBatteryCharacteristic(
 563                 () -> CompletableFuture.completedFuture(
 564                         lowBatteryReader.getValue() ? StatusLowBatteryEnum.LOW : StatusLowBatteryEnum.NORMAL),
 565                 getSubscriber(taggedItem, BATTERY_LOW_STATUS, updater),
 566                 getUnsubscriber(taggedItem, BATTERY_LOW_STATUS, updater));
 567     }
 568
 569     private static StatusFaultCharacteristic createStatusFaultCharacteristic(HomekitTaggedItem taggedItem,
 570             HomekitAccessoryUpdater updater) {
 571         return new StatusFaultCharacteristic(
 572                 () -> getEnumFromItem(taggedItem, StatusFaultEnum.NO_FAULT, StatusFaultEnum.GENERAL_FAULT,
 573                         StatusFaultEnum.NO_FAULT),
 574                 getSubscriber(taggedItem, FAULT_STATUS, updater), getUnsubscriber(taggedItem, FAULT_STATUS, updater));
 575     }
 576
 577     private static StatusTamperedCharacteristic createStatusTamperedCharacteristic(HomekitTaggedItem taggedItem,
 578             HomekitAccessoryUpdater updater) {
 579         return new StatusTamperedCharacteristic(
 580                 () -> getEnumFromItem(taggedItem, StatusTamperedEnum.NOT_TAMPERED, StatusTamperedEnum.TAMPERED,
 581                         StatusTamperedEnum.NOT_TAMPERED),
 582                 getSubscriber(taggedItem, TAMPERED_STATUS, updater),
 583                 getUnsubscriber(taggedItem, TAMPERED_STATUS, updater));
 584     }
 585
 586     private static ObstructionDetectedCharacteristic createObstructionDetectedCharacteristic(
 587             HomekitTaggedItem taggedItem, HomekitAccessoryUpdater updater) {
 588         return new ObstructionDetectedCharacteristic(
 589                 () -> CompletableFuture.completedFuture(taggedItem.getItem().getState() == OnOffType.ON
 590                         || taggedItem.getItem().getState() == OpenClosedType.OPEN),
 591                 getSubscriber(taggedItem, OBSTRUCTION_STATUS, updater),
 592                 getUnsubscriber(taggedItem, OBSTRUCTION_STATUS, updater));
 593     }
 594
 595     private static StatusActiveCharacteristic createStatusActiveCharacteristic(HomekitTaggedItem taggedItem,
 596             HomekitAccessoryUpdater updater) {
 597         return new StatusActiveCharacteristic(
 598                 () -> CompletableFuture.completedFuture(taggedItem.getItem().getState() == OnOffType.ON
 599                         || taggedItem.getItem().getState() == OpenClosedType.OPEN),
 600                 getSubscriber(taggedItem, ACTIVE_STATUS, updater), getUnsubscriber(taggedItem, ACTIVE_STATUS, updater));
 601     }
 602
 603     private static NameCharacteristic createNameCharacteristic(HomekitTaggedItem taggedItem,
 604             HomekitAccessoryUpdater updater) {
 605         return new NameCharacteristic(() -> {
 606             final State state = taggedItem.getItem().getState();
 607             return CompletableFuture.completedFuture(state instanceof UnDefType ? "" : state.toString());
 608         });
 609     }
 610
 611     private static HoldPositionCharacteristic createHoldPositionCharacteristic(HomekitTaggedItem taggedItem,
 612             HomekitAccessoryUpdater updater) {
 613         final Item item = taggedItem.getBaseItem();
 614         if (!(item instanceof SwitchItem || item instanceof RollershutterItem)) {
 615             logger.warn(
 616                     "Item {} cannot be used for the HoldPosition characteristic; only SwitchItem and RollershutterItem are supported. Hold requests will be ignored.",
 617                     item.getName());
 618         }
 619
 620         return new HoldPositionCharacteristic(value -> {
 621             if (!value) {
 622                 return;
 623             }
 624
 625             if (item instanceof SwitchItem) {
 626                 ((SwitchItem) item).send(OnOffType.ON);
 627             } else if (item instanceof RollershutterItem) {
 628                 ((RollershutterItem) item).send(StopMoveType.STOP);
 629             }
 630         });
 631     }
 632
 633     private static CarbonMonoxideLevelCharacteristic createCarbonMonoxideLevelCharacteristic(
 634             HomekitTaggedItem taggedItem, HomekitAccessoryUpdater updater) {
 635         return new CarbonMonoxideLevelCharacteristic(
 636                 getDoubleSupplier(taggedItem,
 637                         taggedItem.getConfigurationAsDouble(HomekitTaggedItem.MIN_VALUE,
 638                                 CarbonMonoxideLevelCharacteristic.DEFAULT_MIN_VALUE)),
 639                 getSubscriber(taggedItem, CARBON_DIOXIDE_LEVEL, updater),
 640                 getUnsubscriber(taggedItem, CARBON_DIOXIDE_LEVEL, updater));
 641     }
 642
 643     private static CarbonMonoxidePeakLevelCharacteristic createCarbonMonoxidePeakLevelCharacteristic(
 644             HomekitTaggedItem taggedItem, HomekitAccessoryUpdater updater) {
 645         return new CarbonMonoxidePeakLevelCharacteristic(
 646                 getDoubleSupplier(taggedItem,
 647                         taggedItem.getConfigurationAsDouble(HomekitTaggedItem.MIN_VALUE,
 648                                 CarbonMonoxidePeakLevelCharacteristic.DEFAULT_MIN_VALUE)),
 649                 getSubscriber(taggedItem, CARBON_DIOXIDE_PEAK_LEVEL, updater),
 650                 getUnsubscriber(taggedItem, CARBON_DIOXIDE_PEAK_LEVEL, updater));
 651     }
 652
 653     private static CarbonDioxideLevelCharacteristic createCarbonDioxideLevelCharacteristic(HomekitTaggedItem taggedItem,
 654             HomekitAccessoryUpdater updater) {
 655         return new CarbonDioxideLevelCharacteristic(
 656                 getDoubleSupplier(taggedItem,
 657                         taggedItem.getConfigurationAsDouble(HomekitTaggedItem.MIN_VALUE,
 658                                 CarbonDioxideLevelCharacteristic.DEFAULT_MIN_VALUE)),
 659                 getSubscriber(taggedItem, CARBON_MONOXIDE_LEVEL, updater),
 660                 getUnsubscriber(taggedItem, CARBON_MONOXIDE_LEVEL, updater));
 661     }
 662
 663     private static CarbonDioxidePeakLevelCharacteristic createCarbonDioxidePeakLevelCharacteristic(
 664             HomekitTaggedItem taggedItem, HomekitAccessoryUpdater updater) {
 665         return new CarbonDioxidePeakLevelCharacteristic(
 666                 getDoubleSupplier(taggedItem,
 667                         taggedItem.getConfigurationAsDouble(HomekitTaggedItem.MIN_VALUE,
 668                                 CarbonDioxidePeakLevelCharacteristic.DEFAULT_MIN_VALUE)),
 669                 getSubscriber(taggedItem, CARBON_MONOXIDE_PEAK_LEVEL, updater),
 670                 getUnsubscriber(taggedItem, CARBON_MONOXIDE_PEAK_LEVEL, updater));
 671     }
 672
 673     private static CurrentHorizontalTiltAngleCharacteristic createCurrentHorizontalTiltAngleCharacteristic(
 674             HomekitTaggedItem taggedItem, HomekitAccessoryUpdater updater) {
 675         return new CurrentHorizontalTiltAngleCharacteristic(getAngleSupplier(taggedItem, 0),
 676                 getSubscriber(taggedItem, CURRENT_HORIZONTAL_TILT_ANGLE, updater),
 677                 getUnsubscriber(taggedItem, CURRENT_HORIZONTAL_TILT_ANGLE, updater));
 678     }
 679
 680     private static CurrentVerticalTiltAngleCharacteristic createCurrentVerticalTiltAngleCharacteristic(
 681             HomekitTaggedItem taggedItem, HomekitAccessoryUpdater updater) {
 682         return new CurrentVerticalTiltAngleCharacteristic(getAngleSupplier(taggedItem, 0),
 683                 getSubscriber(taggedItem, CURRENT_VERTICAL_TILT_ANGLE, updater),
 684                 getUnsubscriber(taggedItem, CURRENT_VERTICAL_TILT_ANGLE, updater));
 685     }
 686
 687     private static TargetHorizontalTiltAngleCharacteristic createTargetHorizontalTiltAngleCharacteristic(
 688             HomekitTaggedItem taggedItem, HomekitAccessoryUpdater updater) {
 689         return new TargetHorizontalTiltAngleCharacteristic(getAngleSupplier(taggedItem, 0),
 690                 setAngleConsumer(taggedItem), getSubscriber(taggedItem, TARGET_HORIZONTAL_TILT_ANGLE, updater),
 691                 getUnsubscriber(taggedItem, TARGET_HORIZONTAL_TILT_ANGLE, updater));
 692     }
 693
 694     private static TargetVerticalTiltAngleCharacteristic createTargetVerticalTiltAngleCharacteristic(
 695             HomekitTaggedItem taggedItem, HomekitAccessoryUpdater updater) {
 696         return new TargetVerticalTiltAngleCharacteristic(getAngleSupplier(taggedItem, 0), setAngleConsumer(taggedItem),
 697                 getSubscriber(taggedItem, TARGET_HORIZONTAL_TILT_ANGLE, updater),
 698                 getUnsubscriber(taggedItem, TARGET_HORIZONTAL_TILT_ANGLE, updater));
 699     }
 700
 701     private static CurrentTiltAngleCharacteristic createCurrentTiltAngleCharacteristic(HomekitTaggedItem taggedItem,
 702             HomekitAccessoryUpdater updater) {
 703         return new CurrentTiltAngleCharacteristic(getAngleSupplier(taggedItem, 0),
 704                 getSubscriber(taggedItem, CURRENT_TILT_ANGLE, updater),
 705                 getUnsubscriber(taggedItem, CURRENT_TILT_ANGLE, updater));
 706     }
 707
 708     private static TargetTiltAngleCharacteristic createTargetTiltAngleCharacteristic(HomekitTaggedItem taggedItem,
 709             HomekitAccessoryUpdater updater) {
 710         return new TargetTiltAngleCharacteristic(getAngleSupplier(taggedItem, 0), setAngleConsumer(taggedItem),
 711                 getSubscriber(taggedItem, TARGET_TILT_ANGLE, updater),
 712                 getUnsubscriber(taggedItem, TARGET_TILT_ANGLE, updater));
 713     }
 714
 715     private static HueCharacteristic createHueCharacteristic(HomekitTaggedItem taggedItem,
 716             HomekitAccessoryUpdater updater) {
 717         return new HueCharacteristic(() -> {
 718             double value = 0.0;
 719             State state = taggedItem.getItem().getState();
 720             if (state instanceof HSBType) {
 721                 value = ((HSBType) state).getHue().doubleValue();
 722             }
 723             return CompletableFuture.completedFuture(value);
 724         }, (hue) -> {
 725             if (taggedItem.getBaseItem() instanceof ColorItem) {
 726                 taggedItem.sendCommandProxy(HomekitCommandType.HUE_COMMAND, new DecimalType(hue));
 727             } else {
 728                 logger.warn("Item type {} is not supported for {}. Only Color type is supported.",
 729                         taggedItem.getBaseItem().getType(), taggedItem.getName());
 730             }
 731         }, getSubscriber(taggedItem, HUE, updater), getUnsubscriber(taggedItem, HUE, updater));
 732     }
 733
 734     private static BrightnessCharacteristic createBrightnessCharacteristic(HomekitTaggedItem taggedItem,
 735             HomekitAccessoryUpdater updater) {
 736         return new BrightnessCharacteristic(() -> {
 737             int value = 0;
 738             final State state = taggedItem.getItem().getState();
 739             if (state instanceof HSBType) {
 740                 value = ((HSBType) state).getBrightness().intValue();
 741             } else if (state instanceof PercentType) {
 742                 value = ((PercentType) state).intValue();
 743             }
 744             return CompletableFuture.completedFuture(value);
 745         }, (brightness) -> {
 746             if (taggedItem.getBaseItem() instanceof DimmerItem) {
 747                 taggedItem.sendCommandProxy(HomekitCommandType.BRIGHTNESS_COMMAND, new PercentType(brightness));
 748             } else {
 749                 logger.warn("Item type {} is not supported for {}. Only ColorItem and DimmerItem are supported.",
 750                         taggedItem.getBaseItem().getType(), taggedItem.getName());
 751             }
 752         }, getSubscriber(taggedItem, BRIGHTNESS, updater), getUnsubscriber(taggedItem, BRIGHTNESS, updater));
 753     }
 754
 755     private static SaturationCharacteristic createSaturationCharacteristic(HomekitTaggedItem taggedItem,
 756             HomekitAccessoryUpdater updater) {
 757         return new SaturationCharacteristic(() -> {
 758             double value = 0.0;
 759             State state = taggedItem.getItem().getState();
 760             if (state instanceof HSBType) {
 761                 value = ((HSBType) state).getSaturation().doubleValue();
 762             } else if (state instanceof PercentType) {
 763                 value = ((PercentType) state).doubleValue();
 764             }
 765             return CompletableFuture.completedFuture(value);
 766         }, (saturation) -> {
 767             if (taggedItem.getBaseItem() instanceof ColorItem) {
 768                 taggedItem.sendCommandProxy(HomekitCommandType.SATURATION_COMMAND,
 769                         new PercentType(saturation.intValue()));
 770             } else {
 771                 logger.warn("Item type {} is not supported for {}. Only Color type is supported.",
 772                         taggedItem.getBaseItem().getType(), taggedItem.getName());
 773             }
 774         }, getSubscriber(taggedItem, SATURATION, updater), getUnsubscriber(taggedItem, SATURATION, updater));
 775     }
 776
 777     private static ColorTemperatureCharacteristic createColorTemperatureCharacteristic(HomekitTaggedItem taggedItem,
 778             HomekitAccessoryUpdater updater) {
 779         final boolean inverted = taggedItem.isInverted();
 780
 781         int minValue = taggedItem
 782                 .getConfigurationAsQuantity(HomekitTaggedItem.MIN_VALUE,
 783                         new QuantityType(ColorTemperatureCharacteristic.DEFAULT_MIN_VALUE, Units.MIRED), false)
 784                 .intValue();
 785         int maxValue = taggedItem
 786                 .getConfigurationAsQuantity(HomekitTaggedItem.MAX_VALUE,
 787                         new QuantityType(ColorTemperatureCharacteristic.DEFAULT_MAX_VALUE, Units.MIRED), false)
 788                 .intValue();
 789
 790         // It's common to swap these if you're providing in Kelvin instead of mired
 791         if (minValue > maxValue) {
 792             int temp = minValue;
 793             minValue = maxValue;
 794             maxValue = temp;
 795         }
 796
 797         final int finalMinValue = minValue;
 798         final int range = maxValue - minValue;
 799
 800         return new ColorTemperatureCharacteristic(minValue, maxValue, () -> {
 801             int value = finalMinValue;
 802             final State state = taggedItem.getItem().getState();
 803             if (state instanceof QuantityType<?>) {
 804                 // Number:Temperature
 805                 QuantityType<?> qt = (QuantityType<?>) state;
 806                 qt = qt.toInvertibleUnit(Units.MIRED);
 807                 if (qt == null) {
 808                     logger.warn("Item {}'s state '{}' is not convertible to mireds.", taggedItem.getName(), state);
 809                 } else {
 810                     value = qt.intValue();
 811                 }
 812             } else if (state instanceof PercentType) {
 813                 double percent = ((PercentType) state).doubleValue();
 814                 // invert so that 0% == coolest
 815                 if (inverted) {
 816                     percent = 100.0 - percent;
 817                 }
 818
 819                 // Dimmer
 820                 // scale to the originally configured range
 821                 value = (int) (percent * range / 100) + finalMinValue;
 822             } else if (state instanceof DecimalType) {
 823                 value = ((DecimalType) state).intValue();
 824             }
 825             return CompletableFuture.completedFuture(value);
 826         }, (value) -> {
 827             if (taggedItem.getBaseItem() instanceof DimmerItem) {
 828                 // scale to a percent
 829                 double percent = (((double) value) - finalMinValue) * 100 / range;
 830                 if (inverted) {
 831                     percent = 100.0 - percent;
 832                 }
 833                 taggedItem.send(new PercentType(BigDecimal.valueOf(percent)));
 834             } else if (taggedItem.getBaseItem() instanceof NumberItem) {
 835                 taggedItem.send(new QuantityType(value, Units.MIRED));
 836             }
 837         }, getSubscriber(taggedItem, COLOR_TEMPERATURE, updater),
 838                 getUnsubscriber(taggedItem, COLOR_TEMPERATURE, updater));
 839     }
 840
 841     private static CurrentFanStateCharacteristic createCurrentFanStateCharacteristic(HomekitTaggedItem taggedItem,
 842             HomekitAccessoryUpdater updater) {
 843         return new CurrentFanStateCharacteristic(() -> {
 844             final @Nullable DecimalType value = taggedItem.getItem().getStateAs(DecimalType.class);
 845             @Nullable
 846             CurrentFanStateEnum currentFanStateEnum = value != null ? CurrentFanStateEnum.fromCode(value.intValue())
 847                     : null;
 848             if (currentFanStateEnum == null) {
 849                 currentFanStateEnum = CurrentFanStateEnum.INACTIVE;
 850             }
 851             return CompletableFuture.completedFuture(currentFanStateEnum);
 852         }, getSubscriber(taggedItem, CURRENT_FAN_STATE, updater),
 853                 getUnsubscriber(taggedItem, CURRENT_FAN_STATE, updater));
 854     }
 855
 856     private static TargetFanStateCharacteristic createTargetFanStateCharacteristic(HomekitTaggedItem taggedItem,
 857             HomekitAccessoryUpdater updater) {
 858         return new TargetFanStateCharacteristic(
 859                 () -> getEnumFromItem(taggedItem, TargetFanStateEnum.MANUAL, TargetFanStateEnum.AUTO,
 860                         TargetFanStateEnum.AUTO),
 861                 (targetState) -> setValueFromEnum(taggedItem, targetState, TargetFanStateEnum.MANUAL,
 862                         TargetFanStateEnum.AUTO),
 863                 getSubscriber(taggedItem, TARGET_FAN_STATE, updater),
 864                 getUnsubscriber(taggedItem, TARGET_FAN_STATE, updater));
 865     }
 866
 867     private static RotationDirectionCharacteristic createRotationDirectionCharacteristic(HomekitTaggedItem taggedItem,
 868             HomekitAccessoryUpdater updater) {
 869         return new RotationDirectionCharacteristic(
 870                 () -> getEnumFromItem(taggedItem, RotationDirectionEnum.CLOCKWISE,
 871                         RotationDirectionEnum.COUNTER_CLOCKWISE, RotationDirectionEnum.CLOCKWISE),
 872                 (value) -> setValueFromEnum(taggedItem, value, RotationDirectionEnum.CLOCKWISE,
 873                         RotationDirectionEnum.COUNTER_CLOCKWISE),
 874                 getSubscriber(taggedItem, ROTATION_DIRECTION, updater),
 875                 getUnsubscriber(taggedItem, ROTATION_DIRECTION, updater));
 876     }
 877
 878     private static SwingModeCharacteristic createSwingModeCharacteristic(HomekitTaggedItem taggedItem,
 879             HomekitAccessoryUpdater updater) {
 880         return new SwingModeCharacteristic(
 881                 () -> getEnumFromItem(taggedItem, SwingModeEnum.SWING_DISABLED, SwingModeEnum.SWING_ENABLED,
 882                         SwingModeEnum.SWING_DISABLED),
 883                 (value) -> setValueFromEnum(taggedItem, value, SwingModeEnum.SWING_DISABLED,
 884                         SwingModeEnum.SWING_ENABLED),
 885                 getSubscriber(taggedItem, SWING_MODE, updater), getUnsubscriber(taggedItem, SWING_MODE, updater));
 886     }
 887
 888     private static LockPhysicalControlsCharacteristic createLockPhysicalControlsCharacteristic(
 889             HomekitTaggedItem taggedItem, HomekitAccessoryUpdater updater) {
 890         return new LockPhysicalControlsCharacteristic(
 891                 () -> getEnumFromItem(taggedItem, LockPhysicalControlsEnum.CONTROL_LOCK_DISABLED,
 892                         LockPhysicalControlsEnum.CONTROL_LOCK_ENABLED, LockPhysicalControlsEnum.CONTROL_LOCK_DISABLED),
 893                 (value) -> setValueFromEnum(taggedItem, value, LockPhysicalControlsEnum.CONTROL_LOCK_DISABLED,
 894                         LockPhysicalControlsEnum.CONTROL_LOCK_ENABLED),
 895                 getSubscriber(taggedItem, LOCK_CONTROL, updater), getUnsubscriber(taggedItem, LOCK_CONTROL, updater));
 896     }
 897
 898     private static RotationSpeedCharacteristic createRotationSpeedCharacteristic(HomekitTaggedItem item,
 899             HomekitAccessoryUpdater updater) {
 900         return new RotationSpeedCharacteristic(
 901                 item.getConfigurationAsDouble(HomekitTaggedItem.MIN_VALUE,
 902                         RotationSpeedCharacteristic.DEFAULT_MIN_VALUE),
 903                 item.getConfigurationAsDouble(HomekitTaggedItem.MAX_VALUE,
 904                         RotationSpeedCharacteristic.DEFAULT_MAX_VALUE),
 905                 item.getConfigurationAsDouble(HomekitTaggedItem.STEP, RotationSpeedCharacteristic.DEFAULT_STEP),
 906                 getDoubleSupplier(item, 0), setDoubleConsumer(item), getSubscriber(item, ROTATION_SPEED, updater),
 907                 getUnsubscriber(item, ROTATION_SPEED, updater));
 908     }
 909
 910     private static SetDurationCharacteristic createDurationCharacteristic(HomekitTaggedItem taggedItem,
 911             HomekitAccessoryUpdater updater) {
 912         return new SetDurationCharacteristic(() -> {
 913             int value = getIntFromItem(taggedItem, 0);
 914             final @Nullable Map<String, Object> itemConfiguration = taggedItem.getConfiguration();
 915             if ((value == 0) && (itemConfiguration != null)) { // check for default duration
 916                 final Object duration = itemConfiguration.get(HomekitValveImpl.CONFIG_DEFAULT_DURATION);
 917                 if (duration instanceof BigDecimal) {
 918                     value = ((BigDecimal) duration).intValue();
 919                     if (taggedItem.getItem() instanceof NumberItem) {
 920                         ((NumberItem) taggedItem.getItem()).setState(new DecimalType(value));
 921                     }
 922                 }
 923             }
 924             return CompletableFuture.completedFuture(value);
 925         }, setIntConsumer(taggedItem), getSubscriber(taggedItem, DURATION, updater),
 926                 getUnsubscriber(taggedItem, DURATION, updater));
 927     }
 928
 929     private static RemainingDurationCharacteristic createRemainingDurationCharacteristic(HomekitTaggedItem taggedItem,
 930             HomekitAccessoryUpdater updater) {
 931         return new RemainingDurationCharacteristic(getIntSupplier(taggedItem, 0),
 932                 getSubscriber(taggedItem, REMAINING_DURATION, updater),
 933                 getUnsubscriber(taggedItem, REMAINING_DURATION, updater));
 934     }
 935
 936     private static VolumeCharacteristic createVolumeCharacteristic(HomekitTaggedItem taggedItem,
 937             HomekitAccessoryUpdater updater) {
 938         return new VolumeCharacteristic(getIntSupplier(taggedItem, 0),
 939                 (volume) -> ((NumberItem) taggedItem.getItem()).send(new DecimalType(volume)),
 940                 getSubscriber(taggedItem, DURATION, updater), getUnsubscriber(taggedItem, DURATION, updater));
 941     }
 942
 943     private static CoolingThresholdTemperatureCharacteristic createCoolingThresholdCharacteristic(
 944             HomekitTaggedItem taggedItem, HomekitAccessoryUpdater updater) {
 945         double minValue = HomekitCharacteristicFactory.convertToCelsius(taggedItem.getConfigurationAsDouble(
 946                 HomekitTaggedItem.MIN_VALUE, CoolingThresholdTemperatureCharacteristic.DEFAULT_MIN_VALUE));
 947         double maxValue = HomekitCharacteristicFactory.convertToCelsius(taggedItem.getConfigurationAsDouble(
 948                 HomekitTaggedItem.MAX_VALUE, CoolingThresholdTemperatureCharacteristic.DEFAULT_MAX_VALUE));
 949         double step = getTemperatureStep(taggedItem, CoolingThresholdTemperatureCharacteristic.DEFAULT_STEP);
 950         return new CoolingThresholdTemperatureCharacteristic(minValue, maxValue, step,
 951                 getTemperatureSupplier(taggedItem, minValue), setTemperatureConsumer(taggedItem),
 952                 getSubscriber(taggedItem, COOLING_THRESHOLD_TEMPERATURE, updater),
 953                 getUnsubscriber(taggedItem, COOLING_THRESHOLD_TEMPERATURE, updater));
 954     }
 955
 956     private static HeatingThresholdTemperatureCharacteristic createHeatingThresholdCharacteristic(
 957             HomekitTaggedItem taggedItem, HomekitAccessoryUpdater updater) {
 958         double minValue = HomekitCharacteristicFactory.convertToCelsius(taggedItem.getConfigurationAsDouble(
 959                 HomekitTaggedItem.MIN_VALUE, HeatingThresholdTemperatureCharacteristic.DEFAULT_MIN_VALUE));
 960         double maxValue = HomekitCharacteristicFactory.convertToCelsius(taggedItem.getConfigurationAsDouble(
 961                 HomekitTaggedItem.MAX_VALUE, HeatingThresholdTemperatureCharacteristic.DEFAULT_MAX_VALUE));
 962         double step = getTemperatureStep(taggedItem, HeatingThresholdTemperatureCharacteristic.DEFAULT_STEP);
 963         return new HeatingThresholdTemperatureCharacteristic(minValue, maxValue, step,
 964                 getTemperatureSupplier(taggedItem, minValue), setTemperatureConsumer(taggedItem),
 965                 getSubscriber(taggedItem, HEATING_THRESHOLD_TEMPERATURE, updater),
 966                 getUnsubscriber(taggedItem, HEATING_THRESHOLD_TEMPERATURE, updater));
 967     }
 968
 969     private static CurrentRelativeHumidityCharacteristic createRelativeHumidityCharacteristic(
 970             HomekitTaggedItem taggedItem, HomekitAccessoryUpdater updater) {
 971         return new CurrentRelativeHumidityCharacteristic(getDoubleSupplier(taggedItem, 0.0),
 972                 getSubscriber(taggedItem, RELATIVE_HUMIDITY, updater),
 973                 getUnsubscriber(taggedItem, RELATIVE_HUMIDITY, updater));
 974     }
 975
 976     private static OzoneDensityCharacteristic createOzoneDensityCharacteristic(final HomekitTaggedItem taggedItem,
 977             HomekitAccessoryUpdater updater) {
 978         return new OzoneDensityCharacteristic(
 979                 getDoubleSupplier(taggedItem,
 980                         taggedItem.getConfigurationAsDouble(HomekitTaggedItem.MIN_VALUE,
 981                                 OzoneDensityCharacteristic.DEFAULT_MIN_VALUE)),
 982                 getSubscriber(taggedItem, OZONE_DENSITY, updater), getUnsubscriber(taggedItem, OZONE_DENSITY, updater));
 983     }
 984
 985     private static NitrogenDioxideDensityCharacteristic createNitrogenDioxideDensityCharacteristic(
 986             final HomekitTaggedItem taggedItem, HomekitAccessoryUpdater updater) {
 987         return new NitrogenDioxideDensityCharacteristic(
 988                 getDoubleSupplier(taggedItem,
 989                         taggedItem.getConfigurationAsDouble(HomekitTaggedItem.MIN_VALUE,
 990                                 NitrogenDioxideDensityCharacteristic.DEFAULT_MIN_VALUE)),
 991                 getSubscriber(taggedItem, NITROGEN_DIOXIDE_DENSITY, updater),
 992                 getUnsubscriber(taggedItem, NITROGEN_DIOXIDE_DENSITY, updater));
 993     }
 994
 995     private static SulphurDioxideDensityCharacteristic createSulphurDioxideDensityCharacteristic(
 996             final HomekitTaggedItem taggedItem, HomekitAccessoryUpdater updater) {
 997         return new SulphurDioxideDensityCharacteristic(
 998                 getDoubleSupplier(taggedItem,
 999                         taggedItem.getConfigurationAsDouble(HomekitTaggedItem.MIN_VALUE,
1000                                 SulphurDioxideDensityCharacteristic.DEFAULT_MIN_VALUE)),
1001                 getSubscriber(taggedItem, SULPHUR_DIOXIDE_DENSITY, updater),
1002                 getUnsubscriber(taggedItem, SULPHUR_DIOXIDE_DENSITY, updater));
1003     }
1004
1005     private static PM25DensityCharacteristic createPM25DensityCharacteristic(final HomekitTaggedItem taggedItem,
1006             HomekitAccessoryUpdater updater) {
1007         return new PM25DensityCharacteristic(
1008                 getDoubleSupplier(taggedItem,
1009                         taggedItem.getConfigurationAsDouble(HomekitTaggedItem.MIN_VALUE,
1010                                 PM25DensityCharacteristic.DEFAULT_MIN_VALUE)),
1011                 getSubscriber(taggedItem, PM25_DENSITY, updater), getUnsubscriber(taggedItem, PM25_DENSITY, updater));
1012     }
1013
1014     private static PM10DensityCharacteristic createPM10DensityCharacteristic(final HomekitTaggedItem taggedItem,
1015             HomekitAccessoryUpdater updater) {
1016         return new PM10DensityCharacteristic(
1017                 getDoubleSupplier(taggedItem,
1018                         taggedItem.getConfigurationAsDouble(HomekitTaggedItem.MIN_VALUE,
1019                                 PM10DensityCharacteristic.DEFAULT_MIN_VALUE)),
1020                 getSubscriber(taggedItem, PM10_DENSITY, updater), getUnsubscriber(taggedItem, PM10_DENSITY, updater));
1021     }
1022
1023     private static VOCDensityCharacteristic createVOCDensityCharacteristic(final HomekitTaggedItem taggedItem,
1024             HomekitAccessoryUpdater updater) {
1025         return new VOCDensityCharacteristic(
1026                 taggedItem.getConfigurationAsDouble(HomekitTaggedItem.MIN_VALUE,
1027                         VOCDensityCharacteristic.DEFAULT_MIN_VALUE),
1028                 taggedItem.getConfigurationAsDouble(HomekitTaggedItem.MAX_VALUE,
1029                         VOCDensityCharacteristic.DEFAULT_MAX_VALUE),
1030                 taggedItem.getConfigurationAsDouble(HomekitTaggedItem.STEP, VOCDensityCharacteristic.DEFAULT_STEP),
1031                 getDoubleSupplier(taggedItem,
1032                         taggedItem.getConfigurationAsDouble(HomekitTaggedItem.MIN_VALUE,
1033                                 VOCDensityCharacteristic.DEFAULT_MIN_VALUE)),
1034                 getSubscriber(taggedItem, VOC_DENSITY, updater), getUnsubscriber(taggedItem, VOC_DENSITY, updater));
1035     }
1036
1037     private static FilterLifeLevelCharacteristic createFilterLifeLevelCharacteristic(HomekitTaggedItem taggedItem,
1038             HomekitAccessoryUpdater updater) {
1039         return new FilterLifeLevelCharacteristic(getDoubleSupplier(taggedItem, 0),
1040                 getSubscriber(taggedItem, FILTER_LIFE_LEVEL, updater),
1041                 getUnsubscriber(taggedItem, FILTER_LIFE_LEVEL, updater));
1042     }
1043
1044     private static ResetFilterIndicationCharacteristic createFilterResetCharacteristic(HomekitTaggedItem taggedItem,
1045             HomekitAccessoryUpdater updater) {
1046         return new ResetFilterIndicationCharacteristic(
1047                 (value) -> ((SwitchItem) taggedItem.getItem()).send(OnOffType.ON));
1048     }
1049
1050     private static ActiveCharacteristic createActiveCharacteristic(HomekitTaggedItem taggedItem,
1051             HomekitAccessoryUpdater updater) {
1052         return new ActiveCharacteristic(
1053                 () -> getEnumFromItem(taggedItem, ActiveEnum.INACTIVE, ActiveEnum.ACTIVE, ActiveEnum.INACTIVE),
1054                 (value) -> setValueFromEnum(taggedItem, value, ActiveEnum.INACTIVE, ActiveEnum.ACTIVE),
1055                 getSubscriber(taggedItem, ACTIVE, updater), getUnsubscriber(taggedItem, ACTIVE, updater));
1056     }
1057
1058     private static ConfiguredNameCharacteristic createConfiguredNameCharacteristic(HomekitTaggedItem taggedItem,
1059             HomekitAccessoryUpdater updater) {
1060         return new ConfiguredNameCharacteristic(() -> {
1061             final State state = taggedItem.getItem().getState();
1062             return CompletableFuture
1063                     .completedFuture(state instanceof UnDefType ? taggedItem.getName() : state.toString());
1064         }, (value) -> ((StringItem) taggedItem.getItem()).send(new StringType(value)),
1065                 getSubscriber(taggedItem, CONFIGURED_NAME, updater),
1066                 getUnsubscriber(taggedItem, CONFIGURED_NAME, updater));
1067     }
1068
1069     private static ActiveIdentifierCharacteristic createActiveIdentifierCharacteristic(HomekitTaggedItem taggedItem,
1070             HomekitAccessoryUpdater updater) {
1071         return new ActiveIdentifierCharacteristic(getIntSupplier(taggedItem, 1), setIntConsumer(taggedItem),
1072                 getSubscriber(taggedItem, ACTIVE_IDENTIFIER, updater),
1073                 getUnsubscriber(taggedItem, ACTIVE_IDENTIFIER, updater));
1074     }
1075
1076     private static RemoteKeyCharacteristic createRemoteKeyCharacteristic(HomekitTaggedItem taggedItem,
1077             HomekitAccessoryUpdater updater) {
1078         var map = createMapping(taggedItem, RemoteKeyEnum.class);
1079         return new RemoteKeyCharacteristic((value) -> setValueFromEnum(taggedItem, value, map));
1080     }
1081
1082     private static SleepDiscoveryModeCharacteristic createSleepDiscoveryModeCharacteristic(HomekitTaggedItem taggedItem,
1083             HomekitAccessoryUpdater updater) {
1084         return new SleepDiscoveryModeCharacteristic(
1085                 () -> getEnumFromItem(taggedItem, SleepDiscoveryModeEnum.NOT_DISCOVERABLE,
1086                         SleepDiscoveryModeEnum.ALWAYS_DISCOVERABLE, SleepDiscoveryModeEnum.ALWAYS_DISCOVERABLE),
1087                 getSubscriber(taggedItem, SLEEP_DISCOVERY_MODE, updater),
1088                 getUnsubscriber(taggedItem, SLEEP_DISCOVERY_MODE, updater));
1089     }
1090
1091     private static PowerModeCharacteristic createPowerModeCharacteristic(HomekitTaggedItem taggedItem,
1092             HomekitAccessoryUpdater updater) {
1093         return new PowerModeCharacteristic(
1094                 (value) -> setValueFromEnum(taggedItem, value, PowerModeEnum.HIDE, PowerModeEnum.SHOW));
1095     }
1096
1097     private static ClosedCaptionsCharacteristic createClosedCaptionsCharacteristic(HomekitTaggedItem taggedItem,
1098             HomekitAccessoryUpdater updater) {
1099         return new ClosedCaptionsCharacteristic(
1100                 () -> getEnumFromItem(taggedItem, ClosedCaptionsEnum.DISABLED, ClosedCaptionsEnum.ENABLED,
1101                         ClosedCaptionsEnum.DISABLED),
1102                 (value) -> setValueFromEnum(taggedItem, value, ClosedCaptionsEnum.DISABLED, ClosedCaptionsEnum.ENABLED),
1103                 getSubscriber(taggedItem, CLOSED_CAPTIONS, updater),
1104                 getUnsubscriber(taggedItem, CLOSED_CAPTIONS, updater));
1105     }
1106
1107     private static PictureModeCharacteristic createPictureModeCharacteristic(HomekitTaggedItem taggedItem,
1108             HomekitAccessoryUpdater updater) {
1109         var map = createMapping(taggedItem, PictureModeEnum.class);
1110         return new PictureModeCharacteristic(() -> getEnumFromItem(taggedItem, map, PictureModeEnum.OTHER),
1111                 (value) -> setValueFromEnum(taggedItem, value, map), getSubscriber(taggedItem, PICTURE_MODE, updater),
1112                 getUnsubscriber(taggedItem, PICTURE_MODE, updater));
1113     }
1114
1115     private static IsConfiguredCharacteristic createIsConfiguredCharacteristic(HomekitTaggedItem taggedItem,
1116             HomekitAccessoryUpdater updater) {
1117         return new IsConfiguredCharacteristic(
1118                 () -> getEnumFromItem(taggedItem, IsConfiguredEnum.NOT_CONFIGURED, IsConfiguredEnum.CONFIGURED,
1119                         IsConfiguredEnum.NOT_CONFIGURED),
1120                 (value) -> setValueFromEnum(taggedItem, value, IsConfiguredEnum.NOT_CONFIGURED,
1121                         IsConfiguredEnum.CONFIGURED),
1122                 getSubscriber(taggedItem, CONFIGURED, updater), getUnsubscriber(taggedItem, CONFIGURED, updater));
1123     }
1124
1125     private static InputSourceTypeCharacteristic createInputSourceTypeCharacteristic(HomekitTaggedItem taggedItem,
1126             HomekitAccessoryUpdater updater) {
1127         var map = createMapping(taggedItem, InputSourceTypeEnum.class);
1128         return new InputSourceTypeCharacteristic(() -> getEnumFromItem(taggedItem, map, InputSourceTypeEnum.OTHER),
1129                 getSubscriber(taggedItem, INPUT_SOURCE_TYPE, updater),
1130                 getUnsubscriber(taggedItem, INPUT_SOURCE_TYPE, updater));
1131     }
1132
1133     private static CurrentVisibilityStateCharacteristic createCurrentVisibilityStateCharacteristic(
1134             HomekitTaggedItem taggedItem, HomekitAccessoryUpdater updater) {
1135         return new CurrentVisibilityStateCharacteristic(
1136                 () -> getEnumFromItem(taggedItem, CurrentVisibilityStateEnum.HIDDEN, CurrentVisibilityStateEnum.SHOWN,
1137                         CurrentVisibilityStateEnum.HIDDEN),
1138                 getSubscriber(taggedItem, CURRENT_VISIBILITY, updater),
1139                 getUnsubscriber(taggedItem, CURRENT_VISIBILITY, updater));
1140     }
1141
1142     private static IdentifierCharacteristic createIdentifierCharacteristic(HomekitTaggedItem taggedItem,
1143             HomekitAccessoryUpdater updater) {
1144         return new IdentifierCharacteristic(getIntSupplier(taggedItem, 1));
1145     }
1146
1147     private static InputDeviceTypeCharacteristic createInputDeviceTypeCharacteristic(HomekitTaggedItem taggedItem,
1148             HomekitAccessoryUpdater updater) {
1149         var mapping = createMapping(taggedItem, InputDeviceTypeEnum.class);
1150         return new InputDeviceTypeCharacteristic(() -> getEnumFromItem(taggedItem, mapping, InputDeviceTypeEnum.OTHER),
1151                 getSubscriber(taggedItem, INPUT_DEVICE_TYPE, updater),
1152                 getUnsubscriber(taggedItem, INPUT_DEVICE_TYPE, updater));
1153     }
1154
1155     private static TargetVisibilityStateCharacteristic createTargetVisibilityStateCharacteristic(
1156             HomekitTaggedItem taggedItem, HomekitAccessoryUpdater updater) {
1157         return new TargetVisibilityStateCharacteristic(
1158                 () -> getEnumFromItem(taggedItem, TargetVisibilityStateEnum.HIDDEN, TargetVisibilityStateEnum.SHOWN,
1159                         TargetVisibilityStateEnum.HIDDEN),
1160                 (value) -> setValueFromEnum(taggedItem, value, TargetVisibilityStateEnum.HIDDEN,
1161                         TargetVisibilityStateEnum.SHOWN),
1162                 getSubscriber(taggedItem, TARGET_VISIBILITY_STATE, updater),
1163                 getUnsubscriber(taggedItem, TARGET_VISIBILITY_STATE, updater));
1164     }
1165
1166     private static VolumeSelectorCharacteristic createVolumeSelectorCharacteristic(HomekitTaggedItem taggedItem,
1167             HomekitAccessoryUpdater updater) {
1168         if (taggedItem.getItem() instanceof DimmerItem) {
1169             return new VolumeSelectorCharacteristic((value) -> taggedItem
1170                     .send(value.equals(VolumeSelectorEnum.INCREMENT) ? IncreaseDecreaseType.INCREASE
1171                             : IncreaseDecreaseType.DECREASE));
1172         } else {
1173             var map = createMapping(taggedItem, VolumeSelectorEnum.class);
1174             return new VolumeSelectorCharacteristic((value) -> setValueFromEnum(taggedItem, value, map));
1175         }
1176     }
1177
1178     private static VolumeControlTypeCharacteristic createVolumeControlTypeCharacteristic(HomekitTaggedItem taggedItem,
1179             HomekitAccessoryUpdater updater) {
1180         var map = createMapping(taggedItem, VolumeControlTypeEnum.class);
1181         return new VolumeControlTypeCharacteristic(() -> getEnumFromItem(taggedItem, map, VolumeControlTypeEnum.NONE),
1182                 getSubscriber(taggedItem, VOLUME_CONTROL_TYPE, updater),
1183                 getUnsubscriber(taggedItem, VOLUME_CONTROL_TYPE, updater));
1184     }
1185
1186     private static CurrentMediaStateCharacteristic createCurrentMediaStateCharacteristic(HomekitTaggedItem taggedItem,
1187             HomekitAccessoryUpdater updater) {
1188         var map = createMapping(taggedItem, CurrentMediaStateEnum.class);
1189         return new CurrentMediaStateCharacteristic(
1190                 () -> getEnumFromItem(taggedItem, map, CurrentMediaStateEnum.UNKNOWN),
1191                 getSubscriber(taggedItem, CURRENT_MEDIA_STATE, updater),
1192                 getUnsubscriber(taggedItem, CURRENT_MEDIA_STATE, updater));
1193     }
1194
1195     private static TargetMediaStateCharacteristic createTargetMediaStateCharacteristic(HomekitTaggedItem taggedItem,
1196             HomekitAccessoryUpdater updater) {
1197         var map = createMapping(taggedItem, TargetMediaStateEnum.class);
1198         return new TargetMediaStateCharacteristic(() -> getEnumFromItem(taggedItem, map, TargetMediaStateEnum.STOP),
1199                 (value) -> setValueFromEnum(taggedItem, value, map),
1200                 getSubscriber(taggedItem, TARGET_MEDIA_STATE, updater),
1201                 getUnsubscriber(taggedItem, TARGET_MEDIA_STATE, updater));
1202     }
1203
1204     private static MuteCharacteristic createMuteCharacteristic(HomekitTaggedItem taggedItem,
1205             HomekitAccessoryUpdater updater) {
1206         BooleanItemReader muteReader = new BooleanItemReader(taggedItem.getItem(),
1207                 taggedItem.isInverted() ? OnOffType.OFF : OnOffType.ON,
1208                 taggedItem.isInverted() ? OpenClosedType.CLOSED : OpenClosedType.OPEN);
1209         return new MuteCharacteristic(() -> CompletableFuture.completedFuture(muteReader.getValue()),
1210                 (value) -> taggedItem.send(value ? OnOffType.ON : OnOffType.OFF),
1211                 getSubscriber(taggedItem, MUTE, updater), getUnsubscriber(taggedItem, MUTE, updater));
1212     }
1213 }