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

   1 /**
   2  * Copyright (c) 2010-2024 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.ArrayList;
  20 import java.util.EnumMap;
  21 import java.util.HashMap;
  22 import java.util.List;
  23 import java.util.Map;
  24 import java.util.Objects;
  25 import java.util.concurrent.CompletableFuture;
  26 import java.util.function.BiFunction;
  27 import java.util.function.Consumer;
  28 import java.util.function.Supplier;
  29
  30 import javax.measure.Quantity;
  31 import javax.measure.Unit;
  32 import javax.measure.quantity.Temperature;
  33
  34 import org.eclipse.jdt.annotation.NonNullByDefault;
  35 import org.eclipse.jdt.annotation.Nullable;
  36 import org.openhab.core.items.GenericItem;
  37 import org.openhab.core.items.Item;
  38 import org.openhab.core.library.items.ColorItem;
  39 import org.openhab.core.library.items.DimmerItem;
  40 import org.openhab.core.library.items.NumberItem;
  41 import org.openhab.core.library.items.RollershutterItem;
  42 import org.openhab.core.library.items.StringItem;
  43 import org.openhab.core.library.items.SwitchItem;
  44 import org.openhab.core.library.types.DecimalType;
  45 import org.openhab.core.library.types.HSBType;
  46 import org.openhab.core.library.types.IncreaseDecreaseType;
  47 import org.openhab.core.library.types.OnOffType;
  48 import org.openhab.core.library.types.OpenClosedType;
  49 import org.openhab.core.library.types.PercentType;
  50 import org.openhab.core.library.types.QuantityType;
  51 import org.openhab.core.library.types.StopMoveType;
  52 import org.openhab.core.library.types.StringType;
  53 import org.openhab.core.library.unit.ImperialUnits;
  54 import org.openhab.core.library.unit.SIUnits;
  55 import org.openhab.core.library.unit.Units;
  56 import org.openhab.core.types.State;
  57 import org.openhab.core.types.UnDefType;
  58 import org.openhab.io.homekit.Homekit;
  59 import org.openhab.io.homekit.internal.HomekitAccessoryUpdater;
  60 import org.openhab.io.homekit.internal.HomekitCharacteristicType;
  61 import org.openhab.io.homekit.internal.HomekitCommandType;
  62 import org.openhab.io.homekit.internal.HomekitException;
  63 import org.openhab.io.homekit.internal.HomekitImpl;
  64 import org.openhab.io.homekit.internal.HomekitTaggedItem;
  65 import org.osgi.framework.FrameworkUtil;
  66 import org.slf4j.Logger;
  67 import org.slf4j.LoggerFactory;
  68
  69 import io.github.hapjava.characteristics.Characteristic;
  70 import io.github.hapjava.characteristics.CharacteristicEnum;
  71 import io.github.hapjava.characteristics.ExceptionalConsumer;
  72 import io.github.hapjava.characteristics.HomekitCharacteristicChangeCallback;
  73 import io.github.hapjava.characteristics.impl.accessoryinformation.FirmwareRevisionCharacteristic;
  74 import io.github.hapjava.characteristics.impl.accessoryinformation.HardwareRevisionCharacteristic;
  75 import io.github.hapjava.characteristics.impl.accessoryinformation.IdentifyCharacteristic;
  76 import io.github.hapjava.characteristics.impl.accessoryinformation.ManufacturerCharacteristic;
  77 import io.github.hapjava.characteristics.impl.accessoryinformation.ModelCharacteristic;
  78 import io.github.hapjava.characteristics.impl.accessoryinformation.SerialNumberCharacteristic;
  79 import io.github.hapjava.characteristics.impl.airquality.NitrogenDioxideDensityCharacteristic;
  80 import io.github.hapjava.characteristics.impl.airquality.OzoneDensityCharacteristic;
  81 import io.github.hapjava.characteristics.impl.airquality.PM10DensityCharacteristic;
  82 import io.github.hapjava.characteristics.impl.airquality.PM25DensityCharacteristic;
  83 import io.github.hapjava.characteristics.impl.airquality.SulphurDioxideDensityCharacteristic;
  84 import io.github.hapjava.characteristics.impl.airquality.VOCDensityCharacteristic;
  85 import io.github.hapjava.characteristics.impl.audio.MuteCharacteristic;
  86 import io.github.hapjava.characteristics.impl.audio.VolumeCharacteristic;
  87 import io.github.hapjava.characteristics.impl.battery.StatusLowBatteryCharacteristic;
  88 import io.github.hapjava.characteristics.impl.battery.StatusLowBatteryEnum;
  89 import io.github.hapjava.characteristics.impl.carbondioxidesensor.CarbonDioxideLevelCharacteristic;
  90 import io.github.hapjava.characteristics.impl.carbondioxidesensor.CarbonDioxidePeakLevelCharacteristic;
  91 import io.github.hapjava.characteristics.impl.carbonmonoxidesensor.CarbonMonoxideLevelCharacteristic;
  92 import io.github.hapjava.characteristics.impl.carbonmonoxidesensor.CarbonMonoxidePeakLevelCharacteristic;
  93 import io.github.hapjava.characteristics.impl.common.ActiveCharacteristic;
  94 import io.github.hapjava.characteristics.impl.common.ActiveEnum;
  95 import io.github.hapjava.characteristics.impl.common.ActiveIdentifierCharacteristic;
  96 import io.github.hapjava.characteristics.impl.common.ConfiguredNameCharacteristic;
  97 import io.github.hapjava.characteristics.impl.common.IdentifierCharacteristic;
  98 import io.github.hapjava.characteristics.impl.common.IsConfiguredCharacteristic;
  99 import io.github.hapjava.characteristics.impl.common.IsConfiguredEnum;
 100 import io.github.hapjava.characteristics.impl.common.NameCharacteristic;
 101 import io.github.hapjava.characteristics.impl.common.ObstructionDetectedCharacteristic;
 102 import io.github.hapjava.characteristics.impl.common.StatusActiveCharacteristic;
 103 import io.github.hapjava.characteristics.impl.common.StatusFaultCharacteristic;
 104 import io.github.hapjava.characteristics.impl.common.StatusFaultEnum;
 105 import io.github.hapjava.characteristics.impl.common.StatusTamperedCharacteristic;
 106 import io.github.hapjava.characteristics.impl.common.StatusTamperedEnum;
 107 import io.github.hapjava.characteristics.impl.fan.CurrentFanStateCharacteristic;
 108 import io.github.hapjava.characteristics.impl.fan.CurrentFanStateEnum;
 109 import io.github.hapjava.characteristics.impl.fan.LockPhysicalControlsCharacteristic;
 110 import io.github.hapjava.characteristics.impl.fan.LockPhysicalControlsEnum;
 111 import io.github.hapjava.characteristics.impl.fan.RotationDirectionCharacteristic;
 112 import io.github.hapjava.characteristics.impl.fan.RotationDirectionEnum;
 113 import io.github.hapjava.characteristics.impl.fan.RotationSpeedCharacteristic;
 114 import io.github.hapjava.characteristics.impl.fan.SwingModeCharacteristic;
 115 import io.github.hapjava.characteristics.impl.fan.SwingModeEnum;
 116 import io.github.hapjava.characteristics.impl.fan.TargetFanStateCharacteristic;
 117 import io.github.hapjava.characteristics.impl.fan.TargetFanStateEnum;
 118 import io.github.hapjava.characteristics.impl.filtermaintenance.FilterLifeLevelCharacteristic;
 119 import io.github.hapjava.characteristics.impl.filtermaintenance.ResetFilterIndicationCharacteristic;
 120 import io.github.hapjava.characteristics.impl.humiditysensor.CurrentRelativeHumidityCharacteristic;
 121 import io.github.hapjava.characteristics.impl.humiditysensor.TargetRelativeHumidityCharacteristic;
 122 import io.github.hapjava.characteristics.impl.inputsource.CurrentVisibilityStateCharacteristic;
 123 import io.github.hapjava.characteristics.impl.inputsource.CurrentVisibilityStateEnum;
 124 import io.github.hapjava.characteristics.impl.inputsource.InputDeviceTypeCharacteristic;
 125 import io.github.hapjava.characteristics.impl.inputsource.InputDeviceTypeEnum;
 126 import io.github.hapjava.characteristics.impl.inputsource.InputSourceTypeCharacteristic;
 127 import io.github.hapjava.characteristics.impl.inputsource.InputSourceTypeEnum;
 128 import io.github.hapjava.characteristics.impl.inputsource.TargetVisibilityStateCharacteristic;
 129 import io.github.hapjava.characteristics.impl.inputsource.TargetVisibilityStateEnum;
 130 import io.github.hapjava.characteristics.impl.lightbulb.BrightnessCharacteristic;
 131 import io.github.hapjava.characteristics.impl.lightbulb.ColorTemperatureCharacteristic;
 132 import io.github.hapjava.characteristics.impl.lightbulb.HueCharacteristic;
 133 import io.github.hapjava.characteristics.impl.lightbulb.SaturationCharacteristic;
 134 import io.github.hapjava.characteristics.impl.slat.CurrentTiltAngleCharacteristic;
 135 import io.github.hapjava.characteristics.impl.slat.TargetTiltAngleCharacteristic;
 136 import io.github.hapjava.characteristics.impl.television.ClosedCaptionsCharacteristic;
 137 import io.github.hapjava.characteristics.impl.television.ClosedCaptionsEnum;
 138 import io.github.hapjava.characteristics.impl.television.CurrentMediaStateCharacteristic;
 139 import io.github.hapjava.characteristics.impl.television.CurrentMediaStateEnum;
 140 import io.github.hapjava.characteristics.impl.television.PictureModeCharacteristic;
 141 import io.github.hapjava.characteristics.impl.television.PictureModeEnum;
 142 import io.github.hapjava.characteristics.impl.television.PowerModeCharacteristic;
 143 import io.github.hapjava.characteristics.impl.television.PowerModeEnum;
 144 import io.github.hapjava.characteristics.impl.television.RemoteKeyCharacteristic;
 145 import io.github.hapjava.characteristics.impl.television.RemoteKeyEnum;
 146 import io.github.hapjava.characteristics.impl.television.SleepDiscoveryModeCharacteristic;
 147 import io.github.hapjava.characteristics.impl.television.SleepDiscoveryModeEnum;
 148 import io.github.hapjava.characteristics.impl.television.TargetMediaStateCharacteristic;
 149 import io.github.hapjava.characteristics.impl.television.TargetMediaStateEnum;
 150 import io.github.hapjava.characteristics.impl.televisionspeaker.VolumeControlTypeCharacteristic;
 151 import io.github.hapjava.characteristics.impl.televisionspeaker.VolumeControlTypeEnum;
 152 import io.github.hapjava.characteristics.impl.televisionspeaker.VolumeSelectorCharacteristic;
 153 import io.github.hapjava.characteristics.impl.televisionspeaker.VolumeSelectorEnum;
 154 import io.github.hapjava.characteristics.impl.thermostat.CoolingThresholdTemperatureCharacteristic;
 155 import io.github.hapjava.characteristics.impl.thermostat.CurrentHeatingCoolingStateCharacteristic;
 156 import io.github.hapjava.characteristics.impl.thermostat.CurrentHeatingCoolingStateEnum;
 157 import io.github.hapjava.characteristics.impl.thermostat.CurrentTemperatureCharacteristic;
 158 import io.github.hapjava.characteristics.impl.thermostat.HeatingThresholdTemperatureCharacteristic;
 159 import io.github.hapjava.characteristics.impl.thermostat.TargetHeatingCoolingStateCharacteristic;
 160 import io.github.hapjava.characteristics.impl.thermostat.TargetHeatingCoolingStateEnum;
 161 import io.github.hapjava.characteristics.impl.thermostat.TargetTemperatureCharacteristic;
 162 import io.github.hapjava.characteristics.impl.thermostat.TemperatureDisplayUnitCharacteristic;
 163 import io.github.hapjava.characteristics.impl.thermostat.TemperatureDisplayUnitEnum;
 164 import io.github.hapjava.characteristics.impl.valve.RemainingDurationCharacteristic;
 165 import io.github.hapjava.characteristics.impl.valve.SetDurationCharacteristic;
 166 import io.github.hapjava.characteristics.impl.windowcovering.CurrentHorizontalTiltAngleCharacteristic;
 167 import io.github.hapjava.characteristics.impl.windowcovering.CurrentVerticalTiltAngleCharacteristic;
 168 import io.github.hapjava.characteristics.impl.windowcovering.HoldPositionCharacteristic;
 169 import io.github.hapjava.characteristics.impl.windowcovering.TargetHorizontalTiltAngleCharacteristic;
 170 import io.github.hapjava.characteristics.impl.windowcovering.TargetVerticalTiltAngleCharacteristic;
 171
 172 /**
 173  * Creates an optional characteristics .
 174  *
 175  * @author Eugen Freiter - Initial contribution
 176  */
 177 @NonNullByDefault
 178 public class HomekitCharacteristicFactory {
 179     private static final Logger LOGGER = LoggerFactory.getLogger(HomekitCharacteristicFactory.class);
 180
 181     // List of optional characteristics and corresponding method to create them.
 182     private static final Map<HomekitCharacteristicType, BiFunction<HomekitTaggedItem, HomekitAccessoryUpdater, Characteristic>> OPTIONAL = new HashMap<>() {
 183         {
 184             put(ACTIVE, HomekitCharacteristicFactory::createActiveCharacteristic);
 185             put(ACTIVE_IDENTIFIER, HomekitCharacteristicFactory::createActiveIdentifierCharacteristic);
 186             put(ACTIVE_STATUS, HomekitCharacteristicFactory::createStatusActiveCharacteristic);
 187             put(BATTERY_LOW_STATUS, HomekitCharacteristicFactory::createStatusLowBatteryCharacteristic);
 188             put(BRIGHTNESS, HomekitCharacteristicFactory::createBrightnessCharacteristic);
 189             put(CARBON_DIOXIDE_LEVEL, HomekitCharacteristicFactory::createCarbonDioxideLevelCharacteristic);
 190             put(CARBON_DIOXIDE_PEAK_LEVEL, HomekitCharacteristicFactory::createCarbonDioxidePeakLevelCharacteristic);
 191             put(CARBON_MONOXIDE_LEVEL, HomekitCharacteristicFactory::createCarbonMonoxideLevelCharacteristic);
 192             put(CARBON_MONOXIDE_PEAK_LEVEL, HomekitCharacteristicFactory::createCarbonMonoxidePeakLevelCharacteristic);
 193             put(CLOSED_CAPTIONS, HomekitCharacteristicFactory::createClosedCaptionsCharacteristic);
 194             put(COLOR_TEMPERATURE, HomekitCharacteristicFactory::createColorTemperatureCharacteristic);
 195             put(CONFIGURED, HomekitCharacteristicFactory::createIsConfiguredCharacteristic);
 196             put(CONFIGURED_NAME, HomekitCharacteristicFactory::createConfiguredNameCharacteristic);
 197             put(COOLING_THRESHOLD_TEMPERATURE, HomekitCharacteristicFactory::createCoolingThresholdCharacteristic);
 198             put(CURRENT_HEATING_COOLING_STATE,
 199                     HomekitCharacteristicFactory::createCurrentHeatingCoolingStateCharacteristic);
 200             put(CURRENT_FAN_STATE, HomekitCharacteristicFactory::createCurrentFanStateCharacteristic);
 201             put(CURRENT_HORIZONTAL_TILT_ANGLE,
 202                     HomekitCharacteristicFactory::createCurrentHorizontalTiltAngleCharacteristic);
 203             put(CURRENT_MEDIA_STATE, HomekitCharacteristicFactory::createCurrentMediaStateCharacteristic);
 204             put(CURRENT_TILT_ANGLE, HomekitCharacteristicFactory::createCurrentTiltAngleCharacteristic);
 205             put(CURRENT_VERTICAL_TILT_ANGLE,
 206                     HomekitCharacteristicFactory::createCurrentVerticalTiltAngleCharacteristic);
 207             put(CURRENT_VISIBILITY, HomekitCharacteristicFactory::createCurrentVisibilityStateCharacteristic);
 208             put(CURRENT_TEMPERATURE, HomekitCharacteristicFactory::createCurrentTemperatureCharacteristic);
 209             put(DURATION, HomekitCharacteristicFactory::createDurationCharacteristic);
 210             put(FAULT_STATUS, HomekitCharacteristicFactory::createStatusFaultCharacteristic);
 211             put(FIRMWARE_REVISION, HomekitCharacteristicFactory::createFirmwareRevisionCharacteristic);
 212             put(FILTER_LIFE_LEVEL, HomekitCharacteristicFactory::createFilterLifeLevelCharacteristic);
 213             put(FILTER_RESET_INDICATION, HomekitCharacteristicFactory::createFilterResetCharacteristic);
 214             put(HARDWARE_REVISION, HomekitCharacteristicFactory::createHardwareRevisionCharacteristic);
 215             put(HEATING_THRESHOLD_TEMPERATURE, HomekitCharacteristicFactory::createHeatingThresholdCharacteristic);
 216             put(HOLD_POSITION, HomekitCharacteristicFactory::createHoldPositionCharacteristic);
 217             put(HUE, HomekitCharacteristicFactory::createHueCharacteristic);
 218             put(IDENTIFIER, HomekitCharacteristicFactory::createIdentifierCharacteristic);
 219             put(IDENTIFY, HomekitCharacteristicFactory::createIdentifyCharacteristic);
 220             put(INPUT_DEVICE_TYPE, HomekitCharacteristicFactory::createInputDeviceTypeCharacteristic);
 221             put(INPUT_SOURCE_TYPE, HomekitCharacteristicFactory::createInputSourceTypeCharacteristic);
 222             put(LOCK_CONTROL, HomekitCharacteristicFactory::createLockPhysicalControlsCharacteristic);
 223             put(MANUFACTURER, HomekitCharacteristicFactory::createManufacturerCharacteristic);
 224             put(MODEL, HomekitCharacteristicFactory::createModelCharacteristic);
 225             put(MUTE, HomekitCharacteristicFactory::createMuteCharacteristic);
 226             put(NAME, HomekitCharacteristicFactory::createNameCharacteristic);
 227             put(NITROGEN_DIOXIDE_DENSITY, HomekitCharacteristicFactory::createNitrogenDioxideDensityCharacteristic);
 228             put(OBSTRUCTION_STATUS, HomekitCharacteristicFactory::createObstructionDetectedCharacteristic);
 229             put(OZONE_DENSITY, HomekitCharacteristicFactory::createOzoneDensityCharacteristic);
 230             put(PICTURE_MODE, HomekitCharacteristicFactory::createPictureModeCharacteristic);
 231             put(PM10_DENSITY, HomekitCharacteristicFactory::createPM10DensityCharacteristic);
 232             put(PM25_DENSITY, HomekitCharacteristicFactory::createPM25DensityCharacteristic);
 233             put(POWER_MODE, HomekitCharacteristicFactory::createPowerModeCharacteristic);
 234             put(REMAINING_DURATION, HomekitCharacteristicFactory::createRemainingDurationCharacteristic);
 235             put(REMOTE_KEY, HomekitCharacteristicFactory::createRemoteKeyCharacteristic);
 236             put(RELATIVE_HUMIDITY, HomekitCharacteristicFactory::createRelativeHumidityCharacteristic);
 237             put(ROTATION_DIRECTION, HomekitCharacteristicFactory::createRotationDirectionCharacteristic);
 238             put(ROTATION_SPEED, HomekitCharacteristicFactory::createRotationSpeedCharacteristic);
 239             put(SATURATION, HomekitCharacteristicFactory::createSaturationCharacteristic);
 240             put(SERIAL_NUMBER, HomekitCharacteristicFactory::createSerialNumberCharacteristic);
 241             put(SLEEP_DISCOVERY_MODE, HomekitCharacteristicFactory::createSleepDiscoveryModeCharacteristic);
 242             put(SULPHUR_DIOXIDE_DENSITY, HomekitCharacteristicFactory::createSulphurDioxideDensityCharacteristic);
 243             put(SWING_MODE, HomekitCharacteristicFactory::createSwingModeCharacteristic);
 244             put(TAMPERED_STATUS, HomekitCharacteristicFactory::createStatusTamperedCharacteristic);
 245             put(TARGET_FAN_STATE, HomekitCharacteristicFactory::createTargetFanStateCharacteristic);
 246             put(TARGET_HEATING_COOLING_STATE,
 247                     HomekitCharacteristicFactory::createTargetHeatingCoolingStateCharacteristic);
 248             put(TARGET_HORIZONTAL_TILT_ANGLE,
 249                     HomekitCharacteristicFactory::createTargetHorizontalTiltAngleCharacteristic);
 250             put(TARGET_MEDIA_STATE, HomekitCharacteristicFactory::createTargetMediaStateCharacteristic);
 251             put(TARGET_RELATIVE_HUMIDITY, HomekitCharacteristicFactory::createTargetRelativeHumidityCharacteristic);
 252             put(TARGET_TEMPERATURE, HomekitCharacteristicFactory::createTargetTemperatureCharacteristic);
 253             put(TARGET_TILT_ANGLE, HomekitCharacteristicFactory::createTargetTiltAngleCharacteristic);
 254             put(TARGET_VERTICAL_TILT_ANGLE, HomekitCharacteristicFactory::createTargetVerticalTiltAngleCharacteristic);
 255             put(TARGET_VISIBILITY_STATE, HomekitCharacteristicFactory::createTargetVisibilityStateCharacteristic);
 256             put(TEMPERATURE_UNIT, HomekitCharacteristicFactory::createTemperatureDisplayUnitCharacteristic);
 257             put(VOC_DENSITY, HomekitCharacteristicFactory::createVOCDensityCharacteristic);
 258             put(VOLUME, HomekitCharacteristicFactory::createVolumeCharacteristic);
 259             put(VOLUME_CONTROL_TYPE, HomekitCharacteristicFactory::createVolumeControlTypeCharacteristic);
 260             put(VOLUME_SELECTOR, HomekitCharacteristicFactory::createVolumeSelectorCharacteristic);
 261         }
 262     };
 263
 264     public static @Nullable Characteristic createNullableCharacteristic(HomekitTaggedItem item,
 265             HomekitAccessoryUpdater updater) {
 266         final @Nullable HomekitCharacteristicType type = item.getCharacteristicType();
 267         LOGGER.trace("Create characteristic {}", item);
 268         if (OPTIONAL.containsKey(type)) {
 269             return OPTIONAL.get(type).apply(item, updater);
 270         }
 271         return null;
 272     }
 273
 274     /**
 275      * Create HomeKit characteristic
 276      *
 277      * @param item corresponding OH item
 278      * @param updater update to keep OH item and HomeKit characteristic in sync
 279      * @return HomeKit characteristic
 280      */
 281     public static Characteristic createCharacteristic(HomekitTaggedItem item, HomekitAccessoryUpdater updater)
 282             throws HomekitException {
 283         Characteristic characteristic = createNullableCharacteristic(item, updater);
 284         if (characteristic != null) {
 285             return characteristic;
 286         }
 287         final @Nullable HomekitCharacteristicType type = item.getCharacteristicType();
 288         LOGGER.warn("Unsupported optional characteristic from item {}. Accessory type {}, characteristic type {}",
 289                 item.getName(), item.getAccessoryType(), type.getTag());
 290         throw new HomekitException(
 291                 "Unsupported optional characteristic. Characteristic type \"" + type.getTag() + "\"");
 292     }
 293
 294     /**
 295      * Create an EnumMap for a particular CharacteristicEnum.
 296      *
 297      * By default, the map will simply be from the Enum value to the string version of its value.
 298      * If the item is a Number item, though, the values will the be underlying integer code
 299      * for the item, as a String.
 300      * Then the item's metadata will be inspected, applying any custom mappings.
 301      * Finally, if customEnumList is supplied, it will be filled out with those mappings
 302      * that are actually referenced in the metadata.
 303      *
 304      * @param item
 305      * @param klazz The HAP-Java Enum for the characteristic.
 306      * @param customEnumList Optional output list of which enums are explicitly mentioned.
 307      * @param inverted Default-invert the 0/1 values of the HAP enum when linked to a Switch or Contact item.
 308      *            This is set by the addon when creating mappings for specific characteristics where the 0 and 1
 309      *            values for the enum do not map naturally to 0/OFF/CLOSED and 1/ON/OPEN of openHAB items.
 310      *            Note that this is separate from the inverted item-level metadata configuration, which can be
 311      *            thought of independently as applying on top of this setting. It essentially "multiplies" out,
 312      *            but can also be thought of as simply swapping whichever value OFF/CLOSED and ON/OPEN are
 313      *            associated with, which has already been set.
 314      * @return
 315      */
 316     public static <T extends Enum<T> & CharacteristicEnum> Map<T, String> createMapping(HomekitTaggedItem item,
 317             Class<T> klazz, @Nullable List<T> customEnumList, boolean inverted) {
 318         EnumMap<T, String> map = new EnumMap(klazz);
 319         var dataTypes = item.getBaseItem().getAcceptedDataTypes();
 320         boolean switchType = dataTypes.contains(OnOffType.class);
 321         boolean contactType = dataTypes.contains(OpenClosedType.class);
 322         boolean percentType = dataTypes.contains(PercentType.class);
 323         boolean numberType = dataTypes.contains(DecimalType.class) || percentType || switchType || contactType;
 324
 325         if (item.isInverted()) {
 326             inverted = !inverted;
 327         }
 328         String onValue = switchType ? OnOffType.ON.toString() : OpenClosedType.OPEN.toString();
 329         String offValue = switchType ? OnOffType.OFF.toString() : OpenClosedType.CLOSED.toString();
 330
 331         for (var k : klazz.getEnumConstants()) {
 332             if (numberType) {
 333                 int code = k.getCode();
 334                 if ((switchType || contactType) && code == 0) {
 335                     map.put(k, inverted ? onValue : offValue);
 336                 } else if ((switchType || contactType) && code == 1) {
 337                     map.put(k, inverted ? offValue : onValue);
 338                 } else if (percentType && code == 0) {
 339                     map.put(k, "OFF");
 340                 } else if (percentType && code == 1) {
 341                     map.put(k, "ON");
 342                 } else {
 343                     map.put(k, Integer.toString(code));
 344                 }
 345             } else {
 346                 map.put(k, k.toString());
 347             }
 348         }
 349         var configuration = item.getConfiguration();
 350         if (configuration != null) {
 351             map.forEach((k, current_value) -> {
 352                 final Object newValue = configuration.get(k.toString());
 353                 if (newValue instanceof String || newValue instanceof Number) {
 354                     map.put(k, newValue.toString());
 355                     if (customEnumList != null) {
 356                         customEnumList.add(k);
 357                     }
 358                 }
 359             });
 360         }
 361         if (customEnumList != null && customEnumList.isEmpty()) {
 362             customEnumList.addAll(map.keySet());
 363         }
 364         LOGGER.debug("Created {} mapping for item {} ({}): {}", klazz.getSimpleName(), item.getName(),
 365                 item.getBaseItem().getClass().getSimpleName(), map);
 366         return map;
 367     }
 368
 369     public static <T extends Enum<T> & CharacteristicEnum> Map<T, String> createMapping(HomekitTaggedItem item,
 370             Class<T> klazz) {
 371         return createMapping(item, klazz, null, false);
 372     }
 373
 374     public static <T extends Enum<T> & CharacteristicEnum> Map<T, String> createMapping(HomekitTaggedItem item,
 375             Class<T> klazz, @Nullable List<T> customEnumList) {
 376         return createMapping(item, klazz, customEnumList, false);
 377     }
 378
 379     public static <T extends Enum<T> & CharacteristicEnum> Map<T, String> createMapping(HomekitTaggedItem item,
 380             Class<T> klazz, boolean inverted) {
 381         return createMapping(item, klazz, null, inverted);
 382     }
 383
 384     /**
 385      * Takes item state as value and retrieves the key for that value from mapping.
 386      * E.g. used to map StringItem value to HomeKit Enum
 387      *
 388      * @param item item
 389      * @param mapping mapping
 390      * @param defaultValue default value if nothing found in mapping
 391      * @param <T> type of the result derived from
 392      * @return key for the value
 393      */
 394     public static <T> T getKeyFromMapping(HomekitTaggedItem item, Map<T, String> mapping, T defaultValue) {
 395         final State state = item.getItem().getState();
 396         LOGGER.trace("getKeyFromMapping: characteristic {}, state {}, mapping {}", item.getAccessoryType().getTag(),
 397                 state, mapping);
 398
 399         String value;
 400         if (state instanceof UnDefType) {
 401             return defaultValue;
 402         } else if (state instanceof StringType || state instanceof OnOffType || state instanceof OpenClosedType) {
 403             value = state.toString();
 404         } else if (state.getClass().equals(PercentType.class)) {
 405             // We specifically want PercentType, but _not_ HSBType, so don't use instanceof
 406             value = state.as(OnOffType.class).toString();
 407         } else if (state.getClass().equals(DecimalType.class)) {
 408             // We specifically want DecimalType, but _not_ PercentType or HSBType, so don't use instanceof
 409             value = Integer.toString(((DecimalType) state).intValue());
 410         } else {
 411             LOGGER.warn(
 412                     "Wrong value type {} ({}) for {} characteristic of the item {}. Expected StringItem, NumberItem, or SwitchItem.",
 413                     state.toString(), state.getClass().getSimpleName(), item.getAccessoryType().getTag(),
 414                     item.getName());
 415             return defaultValue;
 416         }
 417
 418         return mapping.entrySet().stream().filter(entry -> value.equalsIgnoreCase(entry.getValue())).findAny()
 419                 .map(Map.Entry::getKey).orElseGet(() -> {
 420                     LOGGER.warn(
 421                             "Wrong value {} for {} characteristic of the item {}. Expected one of following {}. Returning {}.",
 422                             state.toString(), item.getAccessoryType().getTag(), item.getName(), mapping.values(),
 423                             defaultValue);
 424                     return defaultValue;
 425                 });
 426     }
 427
 428     // supporting methods
 429
 430     public static boolean useFahrenheit() {
 431         return Boolean.TRUE.equals(FrameworkUtil.getBundle(HomekitImpl.class).getBundleContext()
 432                 .getServiceReference(Homekit.class.getName()).getProperty("useFahrenheitTemperature"));
 433     }
 434
 435     public static TemperatureDisplayUnitCharacteristic createSystemTemperatureDisplayUnitCharacteristic() {
 436         return new TemperatureDisplayUnitCharacteristic(() -> CompletableFuture
 437                 .completedFuture(HomekitCharacteristicFactory.useFahrenheit() ? TemperatureDisplayUnitEnum.FAHRENHEIT
 438                         : TemperatureDisplayUnitEnum.CELSIUS),
 439                 (value) -> {
 440                 }, (cb) -> {
 441                 }, () -> {
 442                 });
 443     }
 444
 445     public static Unit<Temperature> getSystemTemperatureUnit() {
 446         return useFahrenheit() ? ImperialUnits.FAHRENHEIT : SIUnits.CELSIUS;
 447     }
 448
 449     private static <T extends CharacteristicEnum> CompletableFuture<T> getEnumFromItem(HomekitTaggedItem item,
 450             Map<T, String> mapping, T defaultValue) {
 451         return CompletableFuture.completedFuture(getKeyFromMapping(item, mapping, defaultValue));
 452     }
 453
 454     public static <T extends Enum<T>> void setValueFromEnum(HomekitTaggedItem taggedItem, T value, Map<T, String> map) {
 455         if (taggedItem.getBaseItem() instanceof NumberItem) {
 456             taggedItem.send(new DecimalType(Objects.requireNonNull(map.get(value))));
 457         } else if (taggedItem.getBaseItem() instanceof SwitchItem) {
 458             taggedItem.send(OnOffType.from(Objects.requireNonNull(map.get(value))));
 459         } else {
 460             taggedItem.send(new StringType(map.get(value)));
 461         }
 462     }
 463
 464     private static int getIntFromItem(HomekitTaggedItem taggedItem, int defaultValue) {
 465         int value = defaultValue;
 466         final State state = taggedItem.getItem().getState();
 467         if (state instanceof PercentType stateAsPercentType) {
 468             value = stateAsPercentType.intValue();
 469         } else if (state instanceof DecimalType stateAsDecimalType) {
 470             value = stateAsDecimalType.intValue();
 471         } else if (state instanceof UnDefType) {
 472             LOGGER.debug("Item state {} is UNDEF {}. Returning default value {}", state, taggedItem.getName(),
 473                     defaultValue);
 474         } else {
 475             LOGGER.warn(
 476                     "Item state {} is not supported for {}. Only PercentType and DecimalType (0/100) are supported.",
 477                     state, taggedItem.getName());
 478         }
 479         return value;
 480     }
 481
 482     /** special method for tilts. it converts percentage to angle */
 483     private static int getAngleFromItem(HomekitTaggedItem taggedItem, int defaultValue) {
 484         int value = defaultValue;
 485         final State state = taggedItem.getItem().getState();
 486         if (state instanceof PercentType stateAsPercentType) {
 487             value = (int) ((stateAsPercentType.intValue() * 90.0) / 50.0 - 90.0);
 488         } else {
 489             value = getIntFromItem(taggedItem, defaultValue);
 490         }
 491         return value;
 492     }
 493
 494     private static <T extends Quantity<T>> double convertAndRound(double value, Unit<T> from, Unit<T> to) {
 495         double rawValue = from.equals(to) ? value : from.getConverterTo(to).convert(value);
 496         return new BigDecimal(rawValue).setScale(1, RoundingMode.HALF_UP).doubleValue();
 497     }
 498
 499     public static @Nullable Double stateAsTemperature(@Nullable State state) {
 500         if (state == null || state instanceof UnDefType) {
 501             return null;
 502         }
 503
 504         if (state instanceof QuantityType<?> qt) {
 505             if (qt.getDimension().equals(SIUnits.CELSIUS.getDimension())) {
 506                 return qt.toUnit(SIUnits.CELSIUS).doubleValue();
 507             }
 508         }
 509
 510         return convertToCelsius(state.as(DecimalType.class).doubleValue());
 511     }
 512
 513     public static double convertToCelsius(double degrees) {
 514         return convertAndRound(degrees, getSystemTemperatureUnit(), SIUnits.CELSIUS);
 515     }
 516
 517     public static double convertFromCelsius(double degrees) {
 518         return convertAndRound(degrees, SIUnits.CELSIUS, getSystemTemperatureUnit());
 519     }
 520
 521     public static double getTemperatureStep(HomekitTaggedItem taggedItem, double defaultValue) {
 522         return taggedItem.getConfigurationAsQuantity(HomekitTaggedItem.STEP,
 523                 new QuantityType(defaultValue, SIUnits.CELSIUS), true).doubleValue();
 524     }
 525
 526     private static Supplier<CompletableFuture<Integer>> getAngleSupplier(HomekitTaggedItem taggedItem,
 527             int defaultValue) {
 528         return () -> CompletableFuture.completedFuture(getAngleFromItem(taggedItem, defaultValue));
 529     }
 530
 531     private static Supplier<CompletableFuture<Integer>> getIntSupplier(HomekitTaggedItem taggedItem, int defaultValue) {
 532         return () -> CompletableFuture.completedFuture(getIntFromItem(taggedItem, defaultValue));
 533     }
 534
 535     private static ExceptionalConsumer<Integer> setIntConsumer(HomekitTaggedItem taggedItem) {
 536         return (value) -> {
 537             if (taggedItem.getBaseItem() instanceof NumberItem) {
 538                 taggedItem.send(new DecimalType(value));
 539             } else {
 540                 LOGGER.warn("Item type {} is not supported for {}. Only NumberItem is supported.",
 541                         taggedItem.getBaseItem().getType(), taggedItem.getName());
 542             }
 543         };
 544     }
 545
 546     private static ExceptionalConsumer<Integer> setPercentConsumer(HomekitTaggedItem taggedItem) {
 547         return (value) -> {
 548             if (taggedItem.getBaseItem() instanceof NumberItem) {
 549                 taggedItem.send(new DecimalType(value));
 550             } else if (taggedItem.getBaseItem() instanceof DimmerItem) {
 551                 taggedItem.send(new PercentType(value));
 552             } else {
 553                 LOGGER.warn("Item type {} is not supported for {}. Only DimmerItem and NumberItem are supported.",
 554                         taggedItem.getBaseItem().getType(), taggedItem.getName());
 555             }
 556         };
 557     }
 558
 559     private static ExceptionalConsumer<Integer> setAngleConsumer(HomekitTaggedItem taggedItem) {
 560         return (value) -> {
 561             if (taggedItem.getBaseItem() instanceof NumberItem) {
 562                 taggedItem.send(new DecimalType(value));
 563             } else if (taggedItem.getBaseItem() instanceof DimmerItem) {
 564                 value = (int) (value * 50.0 / 90.0 + 50.0);
 565                 taggedItem.send(new PercentType(value));
 566             } else {
 567                 LOGGER.warn("Item type {} is not supported for {}. Only DimmerItem and NumberItem are supported.",
 568                         taggedItem.getBaseItem().getType(), taggedItem.getName());
 569             }
 570         };
 571     }
 572
 573     private static Supplier<CompletableFuture<Double>> getDoubleSupplier(HomekitTaggedItem taggedItem,
 574             double defaultValue) {
 575         return () -> {
 576             final State state = taggedItem.getItem().getState();
 577             double value = defaultValue;
 578             if (state instanceof PercentType stateAsPercentType) {
 579                 value = stateAsPercentType.doubleValue();
 580             } else if (state instanceof DecimalType stateAsDecimalType) {
 581                 value = stateAsDecimalType.doubleValue();
 582             } else if (state instanceof QuantityType stateAsQuantityType) {
 583                 value = stateAsQuantityType.doubleValue();
 584             }
 585             return CompletableFuture.completedFuture(value);
 586         };
 587     }
 588
 589     private static ExceptionalConsumer<Double> setDoubleConsumer(HomekitTaggedItem taggedItem) {
 590         return (value) -> {
 591             if (taggedItem.getBaseItem() instanceof NumberItem) {
 592                 taggedItem.send(new DecimalType(value.doubleValue()));
 593             } else if (taggedItem.getBaseItem() instanceof DimmerItem) {
 594                 taggedItem.send(new PercentType(value.intValue()));
 595             } else {
 596                 LOGGER.warn("Item type {} is not supported for {}. Only Number and Dimmer type are supported.",
 597                         taggedItem.getBaseItem().getType(), taggedItem.getName());
 598             }
 599         };
 600     }
 601
 602     private static Supplier<CompletableFuture<Double>> getTemperatureSupplier(HomekitTaggedItem taggedItem,
 603             double defaultValue) {
 604         return () -> {
 605             final @Nullable Double value = stateAsTemperature(taggedItem.getItem().getState());
 606             return CompletableFuture.completedFuture(value != null ? value : defaultValue);
 607         };
 608     }
 609
 610     private static ExceptionalConsumer<Double> setTemperatureConsumer(HomekitTaggedItem taggedItem) {
 611         return (value) -> {
 612             Item baseItem = taggedItem.getBaseItem();
 613             if (baseItem instanceof NumberItem baseAsNumberItem) {
 614                 if (baseAsNumberItem.getUnit() != null) {
 615                     taggedItem.send(new QuantityType(value, SIUnits.CELSIUS));
 616                 } else {
 617                     taggedItem.send(new DecimalType(convertFromCelsius(value)));
 618                 }
 619             } else {
 620                 LOGGER.warn("Item type {} is not supported for {}. Only Number type is supported.",
 621                         taggedItem.getBaseItem().getType(), taggedItem.getName());
 622             }
 623         };
 624     }
 625
 626     protected static Consumer<HomekitCharacteristicChangeCallback> getSubscriber(HomekitTaggedItem taggedItem,
 627             HomekitCharacteristicType key, HomekitAccessoryUpdater updater) {
 628         return (callback) -> updater.subscribe((GenericItem) taggedItem.getItem(), key.getTag(), callback);
 629     }
 630
 631     protected static Runnable getUnsubscriber(HomekitTaggedItem taggedItem, HomekitCharacteristicType key,
 632             HomekitAccessoryUpdater updater) {
 633         return () -> updater.unsubscribe((GenericItem) taggedItem.getItem(), key.getTag());
 634     }
 635
 636     // METHODS TO CREATE SINGLE CHARACTERISTIC FROM OPENHAB ITEM
 637
 638     private static ActiveCharacteristic createActiveCharacteristic(HomekitTaggedItem taggedItem,
 639             HomekitAccessoryUpdater updater) {
 640         var map = createMapping(taggedItem, ActiveEnum.class, false);
 641         return new ActiveCharacteristic(() -> getEnumFromItem(taggedItem, map, ActiveEnum.INACTIVE),
 642                 (value) -> setValueFromEnum(taggedItem, value, map), getSubscriber(taggedItem, ACTIVE, updater),
 643                 getUnsubscriber(taggedItem, ACTIVE, updater));
 644     }
 645
 646     private static ActiveIdentifierCharacteristic createActiveIdentifierCharacteristic(HomekitTaggedItem taggedItem,
 647             HomekitAccessoryUpdater updater) {
 648         return new ActiveIdentifierCharacteristic(getIntSupplier(taggedItem, 1), setIntConsumer(taggedItem),
 649                 getSubscriber(taggedItem, ACTIVE_IDENTIFIER, updater),
 650                 getUnsubscriber(taggedItem, ACTIVE_IDENTIFIER, updater));
 651     }
 652
 653     private static BrightnessCharacteristic createBrightnessCharacteristic(HomekitTaggedItem taggedItem,
 654             HomekitAccessoryUpdater updater) {
 655         return new BrightnessCharacteristic(() -> {
 656             int value = 0;
 657             final State state = taggedItem.getItem().getState();
 658             if (state instanceof HSBType stateAsHSBType) {
 659                 value = stateAsHSBType.getBrightness().intValue();
 660             } else if (state instanceof PercentType stateAsPercentType) {
 661                 value = stateAsPercentType.intValue();
 662             }
 663             return CompletableFuture.completedFuture(value);
 664         }, (brightness) -> {
 665             if (taggedItem.getBaseItem() instanceof DimmerItem) {
 666                 taggedItem.sendCommandProxy(HomekitCommandType.BRIGHTNESS_COMMAND, new PercentType(brightness));
 667             } else {
 668                 LOGGER.warn("Item type {} is not supported for {}. Only ColorItem and DimmerItem are supported.",
 669                         taggedItem.getBaseItem().getType(), taggedItem.getName());
 670             }
 671         }, getSubscriber(taggedItem, BRIGHTNESS, updater), getUnsubscriber(taggedItem, BRIGHTNESS, updater));
 672     }
 673
 674     private static CarbonDioxideLevelCharacteristic createCarbonDioxideLevelCharacteristic(HomekitTaggedItem taggedItem,
 675             HomekitAccessoryUpdater updater) {
 676         return new CarbonDioxideLevelCharacteristic(
 677                 getDoubleSupplier(taggedItem,
 678                         taggedItem.getConfigurationAsDouble(HomekitTaggedItem.MIN_VALUE,
 679                                 CarbonDioxideLevelCharacteristic.DEFAULT_MIN_VALUE)),
 680                 getSubscriber(taggedItem, CARBON_MONOXIDE_LEVEL, updater),
 681                 getUnsubscriber(taggedItem, CARBON_MONOXIDE_LEVEL, updater));
 682     }
 683
 684     private static CarbonDioxidePeakLevelCharacteristic createCarbonDioxidePeakLevelCharacteristic(
 685             HomekitTaggedItem taggedItem, HomekitAccessoryUpdater updater) {
 686         return new CarbonDioxidePeakLevelCharacteristic(
 687                 getDoubleSupplier(taggedItem,
 688                         taggedItem.getConfigurationAsDouble(HomekitTaggedItem.MIN_VALUE,
 689                                 CarbonDioxidePeakLevelCharacteristic.DEFAULT_MIN_VALUE)),
 690                 getSubscriber(taggedItem, CARBON_MONOXIDE_PEAK_LEVEL, updater),
 691                 getUnsubscriber(taggedItem, CARBON_MONOXIDE_PEAK_LEVEL, updater));
 692     }
 693
 694     private static CarbonMonoxideLevelCharacteristic createCarbonMonoxideLevelCharacteristic(
 695             HomekitTaggedItem taggedItem, HomekitAccessoryUpdater updater) {
 696         return new CarbonMonoxideLevelCharacteristic(
 697                 getDoubleSupplier(taggedItem,
 698                         taggedItem.getConfigurationAsDouble(HomekitTaggedItem.MIN_VALUE,
 699                                 CarbonMonoxideLevelCharacteristic.DEFAULT_MIN_VALUE)),
 700                 getSubscriber(taggedItem, CARBON_DIOXIDE_LEVEL, updater),
 701                 getUnsubscriber(taggedItem, CARBON_DIOXIDE_LEVEL, updater));
 702     }
 703
 704     private static CarbonMonoxidePeakLevelCharacteristic createCarbonMonoxidePeakLevelCharacteristic(
 705             HomekitTaggedItem taggedItem, HomekitAccessoryUpdater updater) {
 706         return new CarbonMonoxidePeakLevelCharacteristic(
 707                 getDoubleSupplier(taggedItem,
 708                         taggedItem.getConfigurationAsDouble(HomekitTaggedItem.MIN_VALUE,
 709                                 CarbonMonoxidePeakLevelCharacteristic.DEFAULT_MIN_VALUE)),
 710                 getSubscriber(taggedItem, CARBON_DIOXIDE_PEAK_LEVEL, updater),
 711                 getUnsubscriber(taggedItem, CARBON_DIOXIDE_PEAK_LEVEL, updater));
 712     }
 713
 714     private static ClosedCaptionsCharacteristic createClosedCaptionsCharacteristic(HomekitTaggedItem taggedItem,
 715             HomekitAccessoryUpdater updater) {
 716         var map = createMapping(taggedItem, ClosedCaptionsEnum.class);
 717         return new ClosedCaptionsCharacteristic(() -> getEnumFromItem(taggedItem, map, ClosedCaptionsEnum.DISABLED),
 718                 (value) -> setValueFromEnum(taggedItem, value, map),
 719                 getSubscriber(taggedItem, CLOSED_CAPTIONS, updater),
 720                 getUnsubscriber(taggedItem, CLOSED_CAPTIONS, updater));
 721     }
 722
 723     private static ColorTemperatureCharacteristic createColorTemperatureCharacteristic(HomekitTaggedItem taggedItem,
 724             HomekitAccessoryUpdater updater) {
 725         final boolean inverted = taggedItem.isInverted();
 726
 727         int minValue = taggedItem
 728                 .getConfigurationAsQuantity(HomekitTaggedItem.MIN_VALUE,
 729                         new QuantityType(ColorTemperatureCharacteristic.DEFAULT_MIN_VALUE, Units.MIRED), false)
 730                 .intValue();
 731         int maxValue = taggedItem
 732                 .getConfigurationAsQuantity(HomekitTaggedItem.MAX_VALUE,
 733                         new QuantityType(ColorTemperatureCharacteristic.DEFAULT_MAX_VALUE, Units.MIRED), false)
 734                 .intValue();
 735
 736         // It's common to swap these if you're providing in Kelvin instead of mired
 737         if (minValue > maxValue) {
 738             int temp = minValue;
 739             minValue = maxValue;
 740             maxValue = temp;
 741         }
 742
 743         final int finalMinValue = minValue;
 744         final int range = maxValue - minValue;
 745
 746         return new ColorTemperatureCharacteristic(minValue, maxValue, () -> {
 747             int value = finalMinValue;
 748             final State state = taggedItem.getItem().getState();
 749             if (state instanceof QuantityType<?> qt) {
 750                 // Number:Temperature
 751                 qt = qt.toInvertibleUnit(Units.MIRED);
 752                 if (qt == null) {
 753                     LOGGER.warn("Item {}'s state '{}' is not convertible to mireds.", taggedItem.getName(), state);
 754                 } else {
 755                     value = qt.intValue();
 756                 }
 757             } else if (state instanceof PercentType stateAsPercentType) {
 758                 double percent = stateAsPercentType.doubleValue();
 759                 // invert so that 0% == coolest
 760                 if (inverted) {
 761                     percent = 100.0 - percent;
 762                 }
 763
 764                 // Dimmer
 765                 // scale to the originally configured range
 766                 value = (int) (percent * range / 100) + finalMinValue;
 767             } else if (state instanceof DecimalType stateAsDecimalType) {
 768                 value = stateAsDecimalType.intValue();
 769             }
 770             return CompletableFuture.completedFuture(value);
 771         }, (value) -> {
 772             if (taggedItem.getBaseItem() instanceof DimmerItem) {
 773                 // scale to a percent
 774                 double percent = (((double) value) - finalMinValue) * 100 / range;
 775                 if (inverted) {
 776                     percent = 100.0 - percent;
 777                 }
 778                 taggedItem.send(new PercentType(BigDecimal.valueOf(percent)));
 779             } else if (taggedItem.getBaseItem() instanceof NumberItem) {
 780                 taggedItem.send(new QuantityType(value, Units.MIRED));
 781             }
 782         }, getSubscriber(taggedItem, COLOR_TEMPERATURE, updater),
 783                 getUnsubscriber(taggedItem, COLOR_TEMPERATURE, updater));
 784     }
 785
 786     private static ConfiguredNameCharacteristic createConfiguredNameCharacteristic(HomekitTaggedItem taggedItem,
 787             HomekitAccessoryUpdater updater) {
 788         return new ConfiguredNameCharacteristic(() -> {
 789             final State state = taggedItem.getItem().getState();
 790             return CompletableFuture
 791                     .completedFuture(state instanceof UnDefType ? taggedItem.getName() : state.toString());
 792         }, (value) -> ((StringItem) taggedItem.getItem()).send(new StringType(value)),
 793                 getSubscriber(taggedItem, CONFIGURED_NAME, updater),
 794                 getUnsubscriber(taggedItem, CONFIGURED_NAME, updater));
 795     }
 796
 797     private static CoolingThresholdTemperatureCharacteristic createCoolingThresholdCharacteristic(
 798             HomekitTaggedItem taggedItem, HomekitAccessoryUpdater updater) {
 799         double minValue = taggedItem.getConfigurationAsQuantity(HomekitTaggedItem.MIN_VALUE,
 800                 Objects.requireNonNull(
 801                         new QuantityType(CoolingThresholdTemperatureCharacteristic.DEFAULT_MIN_VALUE, SIUnits.CELSIUS)
 802                                 .toUnit(getSystemTemperatureUnit())),
 803                 false).toUnit(SIUnits.CELSIUS).doubleValue();
 804         double maxValue = taggedItem.getConfigurationAsQuantity(HomekitTaggedItem.MAX_VALUE,
 805                 Objects.requireNonNull(
 806                         new QuantityType(CoolingThresholdTemperatureCharacteristic.DEFAULT_MAX_VALUE, SIUnits.CELSIUS)
 807                                 .toUnit(getSystemTemperatureUnit())),
 808                 false).toUnit(SIUnits.CELSIUS).doubleValue();
 809         double step = taggedItem
 810                 .getConfigurationAsQuantity(HomekitTaggedItem.STEP,
 811                         Objects.requireNonNull(new QuantityType(CoolingThresholdTemperatureCharacteristic.DEFAULT_STEP,
 812                                 SIUnits.CELSIUS).toUnit(getSystemTemperatureUnit())),
 813                         true)
 814                 .toUnit(SIUnits.CELSIUS).doubleValue();
 815         return new CoolingThresholdTemperatureCharacteristic(minValue, maxValue, step,
 816                 getTemperatureSupplier(taggedItem, minValue), setTemperatureConsumer(taggedItem),
 817                 getSubscriber(taggedItem, COOLING_THRESHOLD_TEMPERATURE, updater),
 818                 getUnsubscriber(taggedItem, COOLING_THRESHOLD_TEMPERATURE, updater));
 819     }
 820
 821     private static CurrentHeatingCoolingStateCharacteristic createCurrentHeatingCoolingStateCharacteristic(
 822             HomekitTaggedItem taggedItem, HomekitAccessoryUpdater updater) {
 823         List<CurrentHeatingCoolingStateEnum> validValues = new ArrayList<>();
 824         var map = createMapping(taggedItem, CurrentHeatingCoolingStateEnum.class, validValues);
 825         return new CurrentHeatingCoolingStateCharacteristic(validValues.toArray(new CurrentHeatingCoolingStateEnum[0]),
 826                 () -> getEnumFromItem(taggedItem, map, CurrentHeatingCoolingStateEnum.OFF),
 827                 getSubscriber(taggedItem, CURRENT_HEATING_COOLING_STATE, updater),
 828                 getUnsubscriber(taggedItem, CURRENT_HEATING_COOLING_STATE, updater));
 829     }
 830
 831     private static CurrentFanStateCharacteristic createCurrentFanStateCharacteristic(HomekitTaggedItem taggedItem,
 832             HomekitAccessoryUpdater updater) {
 833         var map = createMapping(taggedItem, CurrentFanStateEnum.class);
 834         return new CurrentFanStateCharacteristic(() -> getEnumFromItem(taggedItem, map, CurrentFanStateEnum.INACTIVE),
 835                 getSubscriber(taggedItem, CURRENT_FAN_STATE, updater),
 836                 getUnsubscriber(taggedItem, CURRENT_FAN_STATE, updater));
 837     }
 838
 839     private static CurrentHorizontalTiltAngleCharacteristic createCurrentHorizontalTiltAngleCharacteristic(
 840             HomekitTaggedItem taggedItem, HomekitAccessoryUpdater updater) {
 841         return new CurrentHorizontalTiltAngleCharacteristic(getAngleSupplier(taggedItem, 0),
 842                 getSubscriber(taggedItem, CURRENT_HORIZONTAL_TILT_ANGLE, updater),
 843                 getUnsubscriber(taggedItem, CURRENT_HORIZONTAL_TILT_ANGLE, updater));
 844     }
 845
 846     private static CurrentMediaStateCharacteristic createCurrentMediaStateCharacteristic(HomekitTaggedItem taggedItem,
 847             HomekitAccessoryUpdater updater) {
 848         var map = createMapping(taggedItem, CurrentMediaStateEnum.class);
 849         return new CurrentMediaStateCharacteristic(
 850                 () -> getEnumFromItem(taggedItem, map, CurrentMediaStateEnum.UNKNOWN),
 851                 getSubscriber(taggedItem, CURRENT_MEDIA_STATE, updater),
 852                 getUnsubscriber(taggedItem, CURRENT_MEDIA_STATE, updater));
 853     }
 854
 855     private static CurrentTemperatureCharacteristic createCurrentTemperatureCharacteristic(HomekitTaggedItem taggedItem,
 856             HomekitAccessoryUpdater updater) {
 857         double minValue = taggedItem
 858                 .getConfigurationAsQuantity(HomekitTaggedItem.MIN_VALUE,
 859                         Objects.requireNonNull(
 860                                 new QuantityType(CurrentTemperatureCharacteristic.DEFAULT_MIN_VALUE, SIUnits.CELSIUS)
 861                                         .toUnit(getSystemTemperatureUnit())),
 862                         false)
 863                 .toUnit(SIUnits.CELSIUS).doubleValue();
 864         double maxValue = taggedItem
 865                 .getConfigurationAsQuantity(HomekitTaggedItem.MAX_VALUE,
 866                         Objects.requireNonNull(
 867                                 new QuantityType(CurrentTemperatureCharacteristic.DEFAULT_MAX_VALUE, SIUnits.CELSIUS)
 868                                         .toUnit(getSystemTemperatureUnit())),
 869                         false)
 870                 .toUnit(SIUnits.CELSIUS).doubleValue();
 871         double step = taggedItem
 872                 .getConfigurationAsQuantity(HomekitTaggedItem.STEP,
 873                         Objects.requireNonNull(
 874                                 new QuantityType(CurrentTemperatureCharacteristic.DEFAULT_STEP, SIUnits.CELSIUS)
 875                                         .toUnit(getSystemTemperatureUnit())),
 876                         true)
 877                 .toUnit(SIUnits.CELSIUS).doubleValue();
 878         return new CurrentTemperatureCharacteristic(minValue, maxValue, step,
 879                 getTemperatureSupplier(taggedItem, minValue), getSubscriber(taggedItem, TARGET_TEMPERATURE, updater),
 880                 getUnsubscriber(taggedItem, TARGET_TEMPERATURE, updater));
 881     }
 882
 883     private static CurrentTiltAngleCharacteristic createCurrentTiltAngleCharacteristic(HomekitTaggedItem taggedItem,
 884             HomekitAccessoryUpdater updater) {
 885         return new CurrentTiltAngleCharacteristic(getAngleSupplier(taggedItem, 0),
 886                 getSubscriber(taggedItem, CURRENT_TILT_ANGLE, updater),
 887                 getUnsubscriber(taggedItem, CURRENT_TILT_ANGLE, updater));
 888     }
 889
 890     private static CurrentVerticalTiltAngleCharacteristic createCurrentVerticalTiltAngleCharacteristic(
 891             HomekitTaggedItem taggedItem, HomekitAccessoryUpdater updater) {
 892         return new CurrentVerticalTiltAngleCharacteristic(getAngleSupplier(taggedItem, 0),
 893                 getSubscriber(taggedItem, CURRENT_VERTICAL_TILT_ANGLE, updater),
 894                 getUnsubscriber(taggedItem, CURRENT_VERTICAL_TILT_ANGLE, updater));
 895     }
 896
 897     private static CurrentVisibilityStateCharacteristic createCurrentVisibilityStateCharacteristic(
 898             HomekitTaggedItem taggedItem, HomekitAccessoryUpdater updater) {
 899         var map = createMapping(taggedItem, CurrentVisibilityStateEnum.class, true);
 900         return new CurrentVisibilityStateCharacteristic(
 901                 () -> getEnumFromItem(taggedItem, map, CurrentVisibilityStateEnum.HIDDEN),
 902                 getSubscriber(taggedItem, CURRENT_VISIBILITY, updater),
 903                 getUnsubscriber(taggedItem, CURRENT_VISIBILITY, updater));
 904     }
 905
 906     private static SetDurationCharacteristic createDurationCharacteristic(HomekitTaggedItem taggedItem,
 907             HomekitAccessoryUpdater updater) {
 908         return new SetDurationCharacteristic(() -> {
 909             int value = getIntFromItem(taggedItem, 0);
 910             final @Nullable Map<String, Object> itemConfiguration = taggedItem.getConfiguration();
 911             if ((value == 0) && (itemConfiguration != null)) { // check for default duration
 912                 final Object duration = itemConfiguration.get(HomekitValveImpl.CONFIG_DEFAULT_DURATION);
 913                 if (duration instanceof BigDecimal durationAsBigDecimal) {
 914                     value = durationAsBigDecimal.intValue();
 915                     if (taggedItem.getItem() instanceof NumberItem taggedNumberItem) {
 916                         taggedNumberItem.setState(new DecimalType(value));
 917                     }
 918                 }
 919             }
 920             return CompletableFuture.completedFuture(value);
 921         }, setIntConsumer(taggedItem), getSubscriber(taggedItem, DURATION, updater),
 922                 getUnsubscriber(taggedItem, DURATION, updater));
 923     }
 924
 925     private static FilterLifeLevelCharacteristic createFilterLifeLevelCharacteristic(HomekitTaggedItem taggedItem,
 926             HomekitAccessoryUpdater updater) {
 927         return new FilterLifeLevelCharacteristic(getDoubleSupplier(taggedItem, 0),
 928                 getSubscriber(taggedItem, FILTER_LIFE_LEVEL, updater),
 929                 getUnsubscriber(taggedItem, FILTER_LIFE_LEVEL, updater));
 930     }
 931
 932     private static ResetFilterIndicationCharacteristic createFilterResetCharacteristic(HomekitTaggedItem taggedItem,
 933             HomekitAccessoryUpdater updater) {
 934         return new ResetFilterIndicationCharacteristic(
 935                 (value) -> ((SwitchItem) taggedItem.getBaseItem()).send(OnOffType.ON));
 936     }
 937
 938     private static FirmwareRevisionCharacteristic createFirmwareRevisionCharacteristic(HomekitTaggedItem taggedItem,
 939             HomekitAccessoryUpdater updater) {
 940         return new FirmwareRevisionCharacteristic(() -> {
 941             final State state = taggedItem.getItem().getState();
 942             return CompletableFuture.completedFuture(state instanceof UnDefType ? "" : state.toString());
 943         });
 944     }
 945
 946     private static HardwareRevisionCharacteristic createHardwareRevisionCharacteristic(HomekitTaggedItem taggedItem,
 947             HomekitAccessoryUpdater updater) {
 948         return new HardwareRevisionCharacteristic(() -> {
 949             final State state = taggedItem.getItem().getState();
 950             return CompletableFuture.completedFuture(state instanceof UnDefType ? "" : state.toString());
 951         });
 952     }
 953
 954     private static HeatingThresholdTemperatureCharacteristic createHeatingThresholdCharacteristic(
 955             HomekitTaggedItem taggedItem, HomekitAccessoryUpdater updater) {
 956         double minValue = taggedItem.getConfigurationAsQuantity(HomekitTaggedItem.MIN_VALUE,
 957                 Objects.requireNonNull(
 958                         new QuantityType(HeatingThresholdTemperatureCharacteristic.DEFAULT_MIN_VALUE, SIUnits.CELSIUS)
 959                                 .toUnit(getSystemTemperatureUnit())),
 960                 false).toUnit(SIUnits.CELSIUS).doubleValue();
 961         double maxValue = taggedItem.getConfigurationAsQuantity(HomekitTaggedItem.MAX_VALUE,
 962                 Objects.requireNonNull(
 963                         new QuantityType(HeatingThresholdTemperatureCharacteristic.DEFAULT_MAX_VALUE, SIUnits.CELSIUS)
 964                                 .toUnit(getSystemTemperatureUnit())),
 965                 false).toUnit(SIUnits.CELSIUS).doubleValue();
 966         double step = taggedItem
 967                 .getConfigurationAsQuantity(HomekitTaggedItem.STEP,
 968                         Objects.requireNonNull(new QuantityType(HeatingThresholdTemperatureCharacteristic.DEFAULT_STEP,
 969                                 SIUnits.CELSIUS).toUnit(getSystemTemperatureUnit())),
 970                         true)
 971                 .toUnit(SIUnits.CELSIUS).doubleValue();
 972         return new HeatingThresholdTemperatureCharacteristic(minValue, maxValue, step,
 973                 getTemperatureSupplier(taggedItem, minValue), setTemperatureConsumer(taggedItem),
 974                 getSubscriber(taggedItem, HEATING_THRESHOLD_TEMPERATURE, updater),
 975                 getUnsubscriber(taggedItem, HEATING_THRESHOLD_TEMPERATURE, updater));
 976     }
 977
 978     private static HoldPositionCharacteristic createHoldPositionCharacteristic(HomekitTaggedItem taggedItem,
 979             HomekitAccessoryUpdater updater) {
 980         final Item item = taggedItem.getBaseItem();
 981         if (!(item instanceof SwitchItem || item instanceof RollershutterItem)) {
 982             LOGGER.warn(
 983                     "Item {} cannot be used for the HoldPosition characteristic; only SwitchItem and RollershutterItem are supported. Hold requests will be ignored.",
 984                     item.getName());
 985         }
 986
 987         return new HoldPositionCharacteristic(value -> {
 988             if (!value) {
 989                 return;
 990             }
 991
 992             if (item instanceof SwitchItem switchItem) {
 993                 switchItem.send(OnOffType.ON);
 994             } else if (item instanceof RollershutterItem rollershutterItem) {
 995                 rollershutterItem.send(StopMoveType.STOP);
 996             }
 997         });
 998     }
 999
1000     private static HueCharacteristic createHueCharacteristic(HomekitTaggedItem taggedItem,
1001             HomekitAccessoryUpdater updater) {
1002         return new HueCharacteristic(() -> {
1003             double value = 0.0;
1004             State state = taggedItem.getItem().getState();
1005             if (state instanceof HSBType stateAsHSBType) {
1006                 value = stateAsHSBType.getHue().doubleValue();
1007             }
1008             return CompletableFuture.completedFuture(value);
1009         }, (hue) -> {
1010             if (taggedItem.getBaseItem() instanceof ColorItem) {
1011                 taggedItem.sendCommandProxy(HomekitCommandType.HUE_COMMAND, new DecimalType(hue));
1012             } else {
1013                 LOGGER.warn("Item type {} is not supported for {}. Only Color type is supported.",
1014                         taggedItem.getBaseItem().getType(), taggedItem.getName());
1015             }
1016         }, getSubscriber(taggedItem, HUE, updater), getUnsubscriber(taggedItem, HUE, updater));
1017     }
1018
1019     private static IdentifierCharacteristic createIdentifierCharacteristic(HomekitTaggedItem taggedItem,
1020             HomekitAccessoryUpdater updater) {
1021         return new IdentifierCharacteristic(getIntSupplier(taggedItem, 1));
1022     }
1023
1024     private static IdentifyCharacteristic createIdentifyCharacteristic(HomekitTaggedItem taggedItem,
1025             HomekitAccessoryUpdater updater) {
1026         return new IdentifyCharacteristic((value) -> ((SwitchItem) taggedItem.getBaseItem()).send(OnOffType.ON));
1027     }
1028
1029     private static InputDeviceTypeCharacteristic createInputDeviceTypeCharacteristic(HomekitTaggedItem taggedItem,
1030             HomekitAccessoryUpdater updater) {
1031         var map = createMapping(taggedItem, InputDeviceTypeEnum.class);
1032         return new InputDeviceTypeCharacteristic(() -> getEnumFromItem(taggedItem, map, InputDeviceTypeEnum.OTHER),
1033                 getSubscriber(taggedItem, INPUT_DEVICE_TYPE, updater),
1034                 getUnsubscriber(taggedItem, INPUT_DEVICE_TYPE, updater));
1035     }
1036
1037     private static InputSourceTypeCharacteristic createInputSourceTypeCharacteristic(HomekitTaggedItem taggedItem,
1038             HomekitAccessoryUpdater updater) {
1039         var map = createMapping(taggedItem, InputSourceTypeEnum.class);
1040         return new InputSourceTypeCharacteristic(() -> getEnumFromItem(taggedItem, map, InputSourceTypeEnum.OTHER),
1041                 getSubscriber(taggedItem, INPUT_SOURCE_TYPE, updater),
1042                 getUnsubscriber(taggedItem, INPUT_SOURCE_TYPE, updater));
1043     }
1044
1045     private static IsConfiguredCharacteristic createIsConfiguredCharacteristic(HomekitTaggedItem taggedItem,
1046             HomekitAccessoryUpdater updater) {
1047         var map = createMapping(taggedItem, IsConfiguredEnum.class);
1048         return new IsConfiguredCharacteristic(() -> getEnumFromItem(taggedItem, map, IsConfiguredEnum.NOT_CONFIGURED),
1049                 (value) -> setValueFromEnum(taggedItem, value, map), getSubscriber(taggedItem, CONFIGURED, updater),
1050                 getUnsubscriber(taggedItem, CONFIGURED, updater));
1051     }
1052
1053     private static LockPhysicalControlsCharacteristic createLockPhysicalControlsCharacteristic(
1054             HomekitTaggedItem taggedItem, HomekitAccessoryUpdater updater) {
1055         var map = createMapping(taggedItem, LockPhysicalControlsEnum.class);
1056         return new LockPhysicalControlsCharacteristic(
1057                 () -> getEnumFromItem(taggedItem, map, LockPhysicalControlsEnum.CONTROL_LOCK_DISABLED),
1058                 (value) -> setValueFromEnum(taggedItem, value, map), getSubscriber(taggedItem, LOCK_CONTROL, updater),
1059                 getUnsubscriber(taggedItem, LOCK_CONTROL, updater));
1060     }
1061
1062     private static ManufacturerCharacteristic createManufacturerCharacteristic(HomekitTaggedItem taggedItem,
1063             HomekitAccessoryUpdater updater) {
1064         return new ManufacturerCharacteristic(() -> {
1065             final State state = taggedItem.getItem().getState();
1066             return CompletableFuture.completedFuture(state instanceof UnDefType ? "" : state.toString());
1067         });
1068     }
1069
1070     private static ModelCharacteristic createModelCharacteristic(HomekitTaggedItem taggedItem,
1071             HomekitAccessoryUpdater updater) {
1072         return new ModelCharacteristic(() -> {
1073             final State state = taggedItem.getItem().getState();
1074             return CompletableFuture.completedFuture(state instanceof UnDefType ? "" : state.toString());
1075         });
1076     }
1077
1078     private static MuteCharacteristic createMuteCharacteristic(HomekitTaggedItem taggedItem,
1079             HomekitAccessoryUpdater updater) {
1080         BooleanItemReader muteReader = new BooleanItemReader(taggedItem.getItem(),
1081                 OnOffType.from(!taggedItem.isInverted()),
1082                 taggedItem.isInverted() ? OpenClosedType.CLOSED : OpenClosedType.OPEN);
1083         return new MuteCharacteristic(() -> CompletableFuture.completedFuture(muteReader.getValue()),
1084                 (value) -> taggedItem.send(OnOffType.from(value)), getSubscriber(taggedItem, MUTE, updater),
1085                 getUnsubscriber(taggedItem, MUTE, updater));
1086     }
1087
1088     private static NameCharacteristic createNameCharacteristic(HomekitTaggedItem taggedItem,
1089             HomekitAccessoryUpdater updater) {
1090         return new NameCharacteristic(() -> {
1091             final State state = taggedItem.getItem().getState();
1092             return CompletableFuture.completedFuture(state instanceof UnDefType ? "" : state.toString());
1093         });
1094     }
1095
1096     private static NitrogenDioxideDensityCharacteristic createNitrogenDioxideDensityCharacteristic(
1097             final HomekitTaggedItem taggedItem, HomekitAccessoryUpdater updater) {
1098         return new NitrogenDioxideDensityCharacteristic(
1099                 getDoubleSupplier(taggedItem,
1100                         taggedItem.getConfigurationAsDouble(HomekitTaggedItem.MIN_VALUE,
1101                                 NitrogenDioxideDensityCharacteristic.DEFAULT_MIN_VALUE)),
1102                 getSubscriber(taggedItem, NITROGEN_DIOXIDE_DENSITY, updater),
1103                 getUnsubscriber(taggedItem, NITROGEN_DIOXIDE_DENSITY, updater));
1104     }
1105
1106     private static ObstructionDetectedCharacteristic createObstructionDetectedCharacteristic(
1107             HomekitTaggedItem taggedItem, HomekitAccessoryUpdater updater) {
1108         return new ObstructionDetectedCharacteristic(
1109                 () -> CompletableFuture.completedFuture(taggedItem.getItem().getState() == OnOffType.ON
1110                         || taggedItem.getItem().getState() == OpenClosedType.OPEN),
1111                 getSubscriber(taggedItem, OBSTRUCTION_STATUS, updater),
1112                 getUnsubscriber(taggedItem, OBSTRUCTION_STATUS, updater));
1113     }
1114
1115     private static OzoneDensityCharacteristic createOzoneDensityCharacteristic(final HomekitTaggedItem taggedItem,
1116             HomekitAccessoryUpdater updater) {
1117         return new OzoneDensityCharacteristic(
1118                 getDoubleSupplier(taggedItem,
1119                         taggedItem.getConfigurationAsDouble(HomekitTaggedItem.MIN_VALUE,
1120                                 OzoneDensityCharacteristic.DEFAULT_MIN_VALUE)),
1121                 getSubscriber(taggedItem, OZONE_DENSITY, updater), getUnsubscriber(taggedItem, OZONE_DENSITY, updater));
1122     }
1123
1124     private static PM10DensityCharacteristic createPM10DensityCharacteristic(final HomekitTaggedItem taggedItem,
1125             HomekitAccessoryUpdater updater) {
1126         return new PM10DensityCharacteristic(
1127                 getDoubleSupplier(taggedItem,
1128                         taggedItem.getConfigurationAsDouble(HomekitTaggedItem.MIN_VALUE,
1129                                 PM10DensityCharacteristic.DEFAULT_MIN_VALUE)),
1130                 getSubscriber(taggedItem, PM10_DENSITY, updater), getUnsubscriber(taggedItem, PM10_DENSITY, updater));
1131     }
1132
1133     private static PM25DensityCharacteristic createPM25DensityCharacteristic(final HomekitTaggedItem taggedItem,
1134             HomekitAccessoryUpdater updater) {
1135         return new PM25DensityCharacteristic(
1136                 getDoubleSupplier(taggedItem,
1137                         taggedItem.getConfigurationAsDouble(HomekitTaggedItem.MIN_VALUE,
1138                                 PM25DensityCharacteristic.DEFAULT_MIN_VALUE)),
1139                 getSubscriber(taggedItem, PM25_DENSITY, updater), getUnsubscriber(taggedItem, PM25_DENSITY, updater));
1140     }
1141
1142     private static CurrentRelativeHumidityCharacteristic createRelativeHumidityCharacteristic(
1143             HomekitTaggedItem taggedItem, HomekitAccessoryUpdater updater) {
1144         return new CurrentRelativeHumidityCharacteristic(getDoubleSupplier(taggedItem, 0.0),
1145                 getSubscriber(taggedItem, RELATIVE_HUMIDITY, updater),
1146                 getUnsubscriber(taggedItem, RELATIVE_HUMIDITY, updater));
1147     }
1148
1149     private static PictureModeCharacteristic createPictureModeCharacteristic(HomekitTaggedItem taggedItem,
1150             HomekitAccessoryUpdater updater) {
1151         var map = createMapping(taggedItem, PictureModeEnum.class);
1152         return new PictureModeCharacteristic(() -> getEnumFromItem(taggedItem, map, PictureModeEnum.OTHER),
1153                 (value) -> setValueFromEnum(taggedItem, value, map), getSubscriber(taggedItem, PICTURE_MODE, updater),
1154                 getUnsubscriber(taggedItem, PICTURE_MODE, updater));
1155     }
1156
1157     private static PowerModeCharacteristic createPowerModeCharacteristic(HomekitTaggedItem taggedItem,
1158             HomekitAccessoryUpdater updater) {
1159         var map = createMapping(taggedItem, PowerModeEnum.class, true);
1160         return new PowerModeCharacteristic((value) -> setValueFromEnum(taggedItem, value, map));
1161     }
1162
1163     private static RemainingDurationCharacteristic createRemainingDurationCharacteristic(HomekitTaggedItem taggedItem,
1164             HomekitAccessoryUpdater updater) {
1165         return new RemainingDurationCharacteristic(getIntSupplier(taggedItem, 0),
1166                 getSubscriber(taggedItem, REMAINING_DURATION, updater),
1167                 getUnsubscriber(taggedItem, REMAINING_DURATION, updater));
1168     }
1169
1170     private static RemoteKeyCharacteristic createRemoteKeyCharacteristic(HomekitTaggedItem taggedItem,
1171             HomekitAccessoryUpdater updater) {
1172         var map = createMapping(taggedItem, RemoteKeyEnum.class);
1173         return new RemoteKeyCharacteristic((value) -> setValueFromEnum(taggedItem, value, map));
1174     }
1175
1176     private static RotationDirectionCharacteristic createRotationDirectionCharacteristic(HomekitTaggedItem taggedItem,
1177             HomekitAccessoryUpdater updater) {
1178         var map = createMapping(taggedItem, RotationDirectionEnum.class);
1179         return new RotationDirectionCharacteristic(
1180                 () -> getEnumFromItem(taggedItem, map, RotationDirectionEnum.CLOCKWISE),
1181                 (value) -> setValueFromEnum(taggedItem, value, map),
1182                 getSubscriber(taggedItem, ROTATION_DIRECTION, updater),
1183                 getUnsubscriber(taggedItem, ROTATION_DIRECTION, updater));
1184     }
1185
1186     private static RotationSpeedCharacteristic createRotationSpeedCharacteristic(HomekitTaggedItem item,
1187             HomekitAccessoryUpdater updater) {
1188         return new RotationSpeedCharacteristic(
1189                 item.getConfigurationAsDouble(HomekitTaggedItem.MIN_VALUE,
1190                         RotationSpeedCharacteristic.DEFAULT_MIN_VALUE),
1191                 item.getConfigurationAsDouble(HomekitTaggedItem.MAX_VALUE,
1192                         RotationSpeedCharacteristic.DEFAULT_MAX_VALUE),
1193                 item.getConfigurationAsDouble(HomekitTaggedItem.STEP, RotationSpeedCharacteristic.DEFAULT_STEP),
1194                 getDoubleSupplier(item, 0), setDoubleConsumer(item), getSubscriber(item, ROTATION_SPEED, updater),
1195                 getUnsubscriber(item, ROTATION_SPEED, updater));
1196     }
1197
1198     private static SaturationCharacteristic createSaturationCharacteristic(HomekitTaggedItem taggedItem,
1199             HomekitAccessoryUpdater updater) {
1200         return new SaturationCharacteristic(() -> {
1201             double value = 0.0;
1202             State state = taggedItem.getItem().getState();
1203             if (state instanceof HSBType stateAsHSBType) {
1204                 value = stateAsHSBType.getSaturation().doubleValue();
1205             } else if (state instanceof PercentType stateAsPercentType) {
1206                 value = stateAsPercentType.doubleValue();
1207             }
1208             return CompletableFuture.completedFuture(value);
1209         }, (saturation) -> {
1210             if (taggedItem.getBaseItem() instanceof ColorItem) {
1211                 taggedItem.sendCommandProxy(HomekitCommandType.SATURATION_COMMAND,
1212                         new PercentType(saturation.intValue()));
1213             } else {
1214                 LOGGER.warn("Item type {} is not supported for {}. Only Color type is supported.",
1215                         taggedItem.getBaseItem().getType(), taggedItem.getName());
1216             }
1217         }, getSubscriber(taggedItem, SATURATION, updater), getUnsubscriber(taggedItem, SATURATION, updater));
1218     }
1219
1220     private static SerialNumberCharacteristic createSerialNumberCharacteristic(HomekitTaggedItem taggedItem,
1221             HomekitAccessoryUpdater updater) {
1222         return new SerialNumberCharacteristic(() -> {
1223             final State state = taggedItem.getItem().getState();
1224             return CompletableFuture.completedFuture(state instanceof UnDefType ? "" : state.toString());
1225         });
1226     }
1227
1228     private static SleepDiscoveryModeCharacteristic createSleepDiscoveryModeCharacteristic(HomekitTaggedItem taggedItem,
1229             HomekitAccessoryUpdater updater) {
1230         var map = createMapping(taggedItem, SleepDiscoveryModeEnum.class);
1231         return new SleepDiscoveryModeCharacteristic(
1232                 () -> getEnumFromItem(taggedItem, map, SleepDiscoveryModeEnum.ALWAYS_DISCOVERABLE),
1233                 getSubscriber(taggedItem, SLEEP_DISCOVERY_MODE, updater),
1234                 getUnsubscriber(taggedItem, SLEEP_DISCOVERY_MODE, updater));
1235     }
1236
1237     private static StatusActiveCharacteristic createStatusActiveCharacteristic(HomekitTaggedItem taggedItem,
1238             HomekitAccessoryUpdater updater) {
1239         return new StatusActiveCharacteristic(
1240                 () -> CompletableFuture.completedFuture(taggedItem.getItem().getState() == OnOffType.ON
1241                         || taggedItem.getItem().getState() == OpenClosedType.OPEN),
1242                 getSubscriber(taggedItem, ACTIVE_STATUS, updater), getUnsubscriber(taggedItem, ACTIVE_STATUS, updater));
1243     }
1244
1245     private static StatusFaultCharacteristic createStatusFaultCharacteristic(HomekitTaggedItem taggedItem,
1246             HomekitAccessoryUpdater updater) {
1247         var map = createMapping(taggedItem, StatusFaultEnum.class);
1248         return new StatusFaultCharacteristic(() -> getEnumFromItem(taggedItem, map, StatusFaultEnum.NO_FAULT),
1249                 getSubscriber(taggedItem, FAULT_STATUS, updater), getUnsubscriber(taggedItem, FAULT_STATUS, updater));
1250     }
1251
1252     private static StatusLowBatteryCharacteristic createStatusLowBatteryCharacteristic(HomekitTaggedItem taggedItem,
1253             HomekitAccessoryUpdater updater) {
1254         BigDecimal lowThreshold = taggedItem.getConfiguration(HomekitTaggedItem.BATTERY_LOW_THRESHOLD,
1255                 BigDecimal.valueOf(20));
1256         BooleanItemReader lowBatteryReader = new BooleanItemReader(taggedItem.getItem(),
1257                 OnOffType.from(!taggedItem.isInverted()),
1258                 taggedItem.isInverted() ? OpenClosedType.CLOSED : OpenClosedType.OPEN, lowThreshold, true);
1259         return new StatusLowBatteryCharacteristic(
1260                 () -> CompletableFuture.completedFuture(
1261                         lowBatteryReader.getValue() ? StatusLowBatteryEnum.LOW : StatusLowBatteryEnum.NORMAL),
1262                 getSubscriber(taggedItem, BATTERY_LOW_STATUS, updater),
1263                 getUnsubscriber(taggedItem, BATTERY_LOW_STATUS, updater));
1264     }
1265
1266     private static StatusTamperedCharacteristic createStatusTamperedCharacteristic(HomekitTaggedItem taggedItem,
1267             HomekitAccessoryUpdater updater) {
1268         var map = createMapping(taggedItem, StatusTamperedEnum.class);
1269         return new StatusTamperedCharacteristic(() -> getEnumFromItem(taggedItem, map, StatusTamperedEnum.NOT_TAMPERED),
1270                 getSubscriber(taggedItem, TAMPERED_STATUS, updater),
1271                 getUnsubscriber(taggedItem, TAMPERED_STATUS, updater));
1272     }
1273
1274     private static SulphurDioxideDensityCharacteristic createSulphurDioxideDensityCharacteristic(
1275             final HomekitTaggedItem taggedItem, HomekitAccessoryUpdater updater) {
1276         return new SulphurDioxideDensityCharacteristic(
1277                 getDoubleSupplier(taggedItem,
1278                         taggedItem.getConfigurationAsDouble(HomekitTaggedItem.MIN_VALUE,
1279                                 SulphurDioxideDensityCharacteristic.DEFAULT_MIN_VALUE)),
1280                 getSubscriber(taggedItem, SULPHUR_DIOXIDE_DENSITY, updater),
1281                 getUnsubscriber(taggedItem, SULPHUR_DIOXIDE_DENSITY, updater));
1282     }
1283
1284     private static SwingModeCharacteristic createSwingModeCharacteristic(HomekitTaggedItem taggedItem,
1285             HomekitAccessoryUpdater updater) {
1286         var map = createMapping(taggedItem, SwingModeEnum.class);
1287         return new SwingModeCharacteristic(() -> getEnumFromItem(taggedItem, map, SwingModeEnum.SWING_DISABLED),
1288                 (value) -> setValueFromEnum(taggedItem, value, map), getSubscriber(taggedItem, SWING_MODE, updater),
1289                 getUnsubscriber(taggedItem, SWING_MODE, updater));
1290     }
1291
1292     private static TargetFanStateCharacteristic createTargetFanStateCharacteristic(HomekitTaggedItem taggedItem,
1293             HomekitAccessoryUpdater updater) {
1294         var map = createMapping(taggedItem, TargetFanStateEnum.class);
1295         return new TargetFanStateCharacteristic(() -> getEnumFromItem(taggedItem, map, TargetFanStateEnum.AUTO),
1296                 (targetState) -> setValueFromEnum(taggedItem, targetState, map),
1297                 getSubscriber(taggedItem, TARGET_FAN_STATE, updater),
1298                 getUnsubscriber(taggedItem, TARGET_FAN_STATE, updater));
1299     }
1300
1301     private static TargetHeatingCoolingStateCharacteristic createTargetHeatingCoolingStateCharacteristic(
1302             HomekitTaggedItem taggedItem, HomekitAccessoryUpdater updater) {
1303         List<TargetHeatingCoolingStateEnum> validValues = new ArrayList<>();
1304         var map = createMapping(taggedItem, TargetHeatingCoolingStateEnum.class, validValues);
1305         return new TargetHeatingCoolingStateCharacteristic(validValues.toArray(new TargetHeatingCoolingStateEnum[0]),
1306                 () -> getEnumFromItem(taggedItem, map, TargetHeatingCoolingStateEnum.OFF),
1307                 (value) -> setValueFromEnum(taggedItem, value, map),
1308                 getSubscriber(taggedItem, TARGET_HEATING_COOLING_STATE, updater),
1309                 getUnsubscriber(taggedItem, TARGET_HEATING_COOLING_STATE, updater));
1310     }
1311
1312     private static TargetHorizontalTiltAngleCharacteristic createTargetHorizontalTiltAngleCharacteristic(
1313             HomekitTaggedItem taggedItem, HomekitAccessoryUpdater updater) {
1314         return new TargetHorizontalTiltAngleCharacteristic(getAngleSupplier(taggedItem, 0),
1315                 setAngleConsumer(taggedItem), getSubscriber(taggedItem, TARGET_HORIZONTAL_TILT_ANGLE, updater),
1316                 getUnsubscriber(taggedItem, TARGET_HORIZONTAL_TILT_ANGLE, updater));
1317     }
1318
1319     private static TargetMediaStateCharacteristic createTargetMediaStateCharacteristic(HomekitTaggedItem taggedItem,
1320             HomekitAccessoryUpdater updater) {
1321         var map = createMapping(taggedItem, TargetMediaStateEnum.class);
1322         return new TargetMediaStateCharacteristic(() -> getEnumFromItem(taggedItem, map, TargetMediaStateEnum.STOP),
1323                 (value) -> setValueFromEnum(taggedItem, value, map),
1324                 getSubscriber(taggedItem, TARGET_MEDIA_STATE, updater),
1325                 getUnsubscriber(taggedItem, TARGET_MEDIA_STATE, updater));
1326     }
1327
1328     private static TargetRelativeHumidityCharacteristic createTargetRelativeHumidityCharacteristic(
1329             HomekitTaggedItem item, HomekitAccessoryUpdater updater) {
1330         return new TargetRelativeHumidityCharacteristic(getDoubleSupplier(item, 0), setDoubleConsumer(item),
1331                 getSubscriber(item, TARGET_RELATIVE_HUMIDITY, updater),
1332                 getUnsubscriber(item, TARGET_RELATIVE_HUMIDITY, updater));
1333     }
1334
1335     private static TargetTemperatureCharacteristic createTargetTemperatureCharacteristic(HomekitTaggedItem taggedItem,
1336             HomekitAccessoryUpdater updater) {
1337         double minValue = taggedItem
1338                 .getConfigurationAsQuantity(HomekitTaggedItem.MIN_VALUE,
1339                         Objects.requireNonNull(
1340                                 new QuantityType(TargetTemperatureCharacteristic.DEFAULT_MIN_VALUE, SIUnits.CELSIUS)
1341                                         .toUnit(getSystemTemperatureUnit())),
1342                         false)
1343                 .toUnit(SIUnits.CELSIUS).doubleValue();
1344         double maxValue = taggedItem
1345                 .getConfigurationAsQuantity(HomekitTaggedItem.MAX_VALUE,
1346                         Objects.requireNonNull(
1347                                 new QuantityType(TargetTemperatureCharacteristic.DEFAULT_MAX_VALUE, SIUnits.CELSIUS)
1348                                         .toUnit(getSystemTemperatureUnit())),
1349                         false)
1350                 .toUnit(SIUnits.CELSIUS).doubleValue();
1351         double step = taggedItem
1352                 .getConfigurationAsQuantity(HomekitTaggedItem.STEP,
1353                         Objects.requireNonNull(
1354                                 new QuantityType(TargetTemperatureCharacteristic.DEFAULT_STEP, SIUnits.CELSIUS)
1355                                         .toUnit(getSystemTemperatureUnit())),
1356                         true)
1357                 .toUnit(SIUnits.CELSIUS).doubleValue();
1358         return new TargetTemperatureCharacteristic(minValue, maxValue, step,
1359                 getTemperatureSupplier(taggedItem, minValue), setTemperatureConsumer(taggedItem),
1360                 getSubscriber(taggedItem, TARGET_TEMPERATURE, updater),
1361                 getUnsubscriber(taggedItem, TARGET_TEMPERATURE, updater));
1362     }
1363
1364     private static TargetTiltAngleCharacteristic createTargetTiltAngleCharacteristic(HomekitTaggedItem taggedItem,
1365             HomekitAccessoryUpdater updater) {
1366         return new TargetTiltAngleCharacteristic(getAngleSupplier(taggedItem, 0), setAngleConsumer(taggedItem),
1367                 getSubscriber(taggedItem, TARGET_TILT_ANGLE, updater),
1368                 getUnsubscriber(taggedItem, TARGET_TILT_ANGLE, updater));
1369     }
1370
1371     private static TargetVerticalTiltAngleCharacteristic createTargetVerticalTiltAngleCharacteristic(
1372             HomekitTaggedItem taggedItem, HomekitAccessoryUpdater updater) {
1373         return new TargetVerticalTiltAngleCharacteristic(getAngleSupplier(taggedItem, 0), setAngleConsumer(taggedItem),
1374                 getSubscriber(taggedItem, TARGET_HORIZONTAL_TILT_ANGLE, updater),
1375                 getUnsubscriber(taggedItem, TARGET_HORIZONTAL_TILT_ANGLE, updater));
1376     }
1377
1378     private static TargetVisibilityStateCharacteristic createTargetVisibilityStateCharacteristic(
1379             HomekitTaggedItem taggedItem, HomekitAccessoryUpdater updater) {
1380         var map = createMapping(taggedItem, TargetVisibilityStateEnum.class, true);
1381         return new TargetVisibilityStateCharacteristic(
1382                 () -> getEnumFromItem(taggedItem, map, TargetVisibilityStateEnum.HIDDEN),
1383                 (value) -> setValueFromEnum(taggedItem, value, map),
1384                 getSubscriber(taggedItem, TARGET_VISIBILITY_STATE, updater),
1385                 getUnsubscriber(taggedItem, TARGET_VISIBILITY_STATE, updater));
1386     }
1387
1388     private static TemperatureDisplayUnitCharacteristic createTemperatureDisplayUnitCharacteristic(
1389             HomekitTaggedItem taggedItem, HomekitAccessoryUpdater updater) {
1390         var map = createMapping(taggedItem, TemperatureDisplayUnitEnum.class, true);
1391         return new TemperatureDisplayUnitCharacteristic(
1392                 () -> getEnumFromItem(taggedItem, map,
1393                         useFahrenheit() ? TemperatureDisplayUnitEnum.FAHRENHEIT : TemperatureDisplayUnitEnum.CELSIUS),
1394                 (value) -> setValueFromEnum(taggedItem, value, map),
1395                 getSubscriber(taggedItem, TEMPERATURE_UNIT, updater),
1396                 getUnsubscriber(taggedItem, TEMPERATURE_UNIT, updater));
1397     }
1398
1399     private static VOCDensityCharacteristic createVOCDensityCharacteristic(final HomekitTaggedItem taggedItem,
1400             HomekitAccessoryUpdater updater) {
1401         return new VOCDensityCharacteristic(
1402                 taggedItem.getConfigurationAsDouble(HomekitTaggedItem.MIN_VALUE,
1403                         VOCDensityCharacteristic.DEFAULT_MIN_VALUE),
1404                 taggedItem.getConfigurationAsDouble(HomekitTaggedItem.MAX_VALUE,
1405                         VOCDensityCharacteristic.DEFAULT_MAX_VALUE),
1406                 taggedItem.getConfigurationAsDouble(HomekitTaggedItem.STEP, VOCDensityCharacteristic.DEFAULT_STEP),
1407                 getDoubleSupplier(taggedItem,
1408                         taggedItem.getConfigurationAsDouble(HomekitTaggedItem.MIN_VALUE,
1409                                 VOCDensityCharacteristic.DEFAULT_MIN_VALUE)),
1410                 getSubscriber(taggedItem, VOC_DENSITY, updater), getUnsubscriber(taggedItem, VOC_DENSITY, updater));
1411     }
1412
1413     private static VolumeCharacteristic createVolumeCharacteristic(HomekitTaggedItem taggedItem,
1414             HomekitAccessoryUpdater updater) {
1415         return new VolumeCharacteristic(getIntSupplier(taggedItem, 0),
1416                 (volume) -> ((NumberItem) taggedItem.getItem()).send(new DecimalType(volume)),
1417                 getSubscriber(taggedItem, DURATION, updater), getUnsubscriber(taggedItem, DURATION, updater));
1418     }
1419
1420     private static VolumeSelectorCharacteristic createVolumeSelectorCharacteristic(HomekitTaggedItem taggedItem,
1421             HomekitAccessoryUpdater updater) {
1422         if (taggedItem.getItem() instanceof DimmerItem) {
1423             return new VolumeSelectorCharacteristic((value) -> taggedItem
1424                     .send(value.equals(VolumeSelectorEnum.INCREMENT) ? IncreaseDecreaseType.INCREASE
1425                             : IncreaseDecreaseType.DECREASE));
1426         } else {
1427             var map = createMapping(taggedItem, VolumeSelectorEnum.class);
1428             return new VolumeSelectorCharacteristic((value) -> setValueFromEnum(taggedItem, value, map));
1429         }
1430     }
1431
1432     private static VolumeControlTypeCharacteristic createVolumeControlTypeCharacteristic(HomekitTaggedItem taggedItem,
1433             HomekitAccessoryUpdater updater) {
1434         var map = createMapping(taggedItem, VolumeControlTypeEnum.class);
1435         return new VolumeControlTypeCharacteristic(() -> getEnumFromItem(taggedItem, map, VolumeControlTypeEnum.NONE),
1436                 getSubscriber(taggedItem, VOLUME_CONTROL_TYPE, updater),
1437                 getUnsubscriber(taggedItem, VOLUME_CONTROL_TYPE, updater));
1438     }
1439 }