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