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

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