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

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