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

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