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

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