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