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