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

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