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