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

   1 /**
   2  * Copyright (c) 2010-2020 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.util.HashMap;
  19 import java.util.Map;
  20 import java.util.concurrent.CompletableFuture;
  21 import java.util.function.BiFunction;
  22 import java.util.function.Consumer;
  23 import java.util.function.Supplier;
  24
  25 import org.eclipse.jdt.annotation.NonNullByDefault;
  26 import org.eclipse.jdt.annotation.Nullable;
  27 import org.openhab.core.items.GenericItem;
  28 import org.openhab.core.items.Item;
  29 import org.openhab.core.library.items.ColorItem;
  30 import org.openhab.core.library.items.DimmerItem;
  31 import org.openhab.core.library.items.NumberItem;
  32 import org.openhab.core.library.items.SwitchItem;
  33 import org.openhab.core.library.types.DecimalType;
  34 import org.openhab.core.library.types.HSBType;
  35 import org.openhab.core.library.types.OnOffType;
  36 import org.openhab.core.library.types.OpenClosedType;
  37 import org.openhab.core.library.types.PercentType;
  38 import org.openhab.core.types.State;
  39 import org.openhab.core.types.UnDefType;
  40 import org.openhab.io.homekit.internal.HomekitAccessoryUpdater;
  41 import org.openhab.io.homekit.internal.HomekitCharacteristicType;
  42 import org.openhab.io.homekit.internal.HomekitCommandType;
  43 import org.openhab.io.homekit.internal.HomekitException;
  44 import org.openhab.io.homekit.internal.HomekitTaggedItem;
  45 import org.slf4j.Logger;
  46 import org.slf4j.LoggerFactory;
  47
  48 import io.github.hapjava.characteristics.Characteristic;
  49 import io.github.hapjava.characteristics.CharacteristicEnum;
  50 import io.github.hapjava.characteristics.ExceptionalConsumer;
  51 import io.github.hapjava.characteristics.HomekitCharacteristicChangeCallback;
  52 import io.github.hapjava.characteristics.impl.airquality.NitrogenDioxideDensityCharacteristic;
  53 import io.github.hapjava.characteristics.impl.airquality.OzoneDensityCharacteristic;
  54 import io.github.hapjava.characteristics.impl.airquality.PM10DensityCharacteristic;
  55 import io.github.hapjava.characteristics.impl.airquality.PM25DensityCharacteristic;
  56 import io.github.hapjava.characteristics.impl.airquality.SulphurDioxideDensityCharacteristic;
  57 import io.github.hapjava.characteristics.impl.airquality.VOCDensityCharacteristic;
  58 import io.github.hapjava.characteristics.impl.audio.VolumeCharacteristic;
  59 import io.github.hapjava.characteristics.impl.battery.StatusLowBatteryCharacteristic;
  60 import io.github.hapjava.characteristics.impl.battery.StatusLowBatteryEnum;
  61 import io.github.hapjava.characteristics.impl.carbondioxidesensor.CarbonDioxideLevelCharacteristic;
  62 import io.github.hapjava.characteristics.impl.carbondioxidesensor.CarbonDioxidePeakLevelCharacteristic;
  63 import io.github.hapjava.characteristics.impl.carbonmonoxidesensor.CarbonMonoxideLevelCharacteristic;
  64 import io.github.hapjava.characteristics.impl.carbonmonoxidesensor.CarbonMonoxidePeakLevelCharacteristic;
  65 import io.github.hapjava.characteristics.impl.common.NameCharacteristic;
  66 import io.github.hapjava.characteristics.impl.common.ObstructionDetectedCharacteristic;
  67 import io.github.hapjava.characteristics.impl.common.StatusActiveCharacteristic;
  68 import io.github.hapjava.characteristics.impl.common.StatusFaultCharacteristic;
  69 import io.github.hapjava.characteristics.impl.common.StatusFaultEnum;
  70 import io.github.hapjava.characteristics.impl.common.StatusTamperedCharacteristic;
  71 import io.github.hapjava.characteristics.impl.common.StatusTamperedEnum;
  72 import io.github.hapjava.characteristics.impl.fan.*;
  73 import io.github.hapjava.characteristics.impl.lightbulb.BrightnessCharacteristic;
  74 import io.github.hapjava.characteristics.impl.lightbulb.ColorTemperatureCharacteristic;
  75 import io.github.hapjava.characteristics.impl.lightbulb.HueCharacteristic;
  76 import io.github.hapjava.characteristics.impl.lightbulb.SaturationCharacteristic;
  77 import io.github.hapjava.characteristics.impl.thermostat.CoolingThresholdTemperatureCharacteristic;
  78 import io.github.hapjava.characteristics.impl.thermostat.HeatingThresholdTemperatureCharacteristic;
  79 import io.github.hapjava.characteristics.impl.valve.RemainingDurationCharacteristic;
  80 import io.github.hapjava.characteristics.impl.valve.SetDurationCharacteristic;
  81 import io.github.hapjava.characteristics.impl.windowcovering.CurrentHorizontalTiltAngleCharacteristic;
  82 import io.github.hapjava.characteristics.impl.windowcovering.CurrentVerticalTiltAngleCharacteristic;
  83 import io.github.hapjava.characteristics.impl.windowcovering.HoldPositionCharacteristic;
  84 import io.github.hapjava.characteristics.impl.windowcovering.TargetHorizontalTiltAngleCharacteristic;
  85 import io.github.hapjava.characteristics.impl.windowcovering.TargetVerticalTiltAngleCharacteristic;
  86
  87 /**
  88  * Creates a optional characteristics .
  89  *
  90  * @author Eugen Freiter - Initial contribution
  91  */
  92 @NonNullByDefault
  93 @SuppressWarnings("deprecation")
  94 public class HomekitCharacteristicFactory {
  95     private static final Logger logger = LoggerFactory.getLogger(HomekitCharacteristicFactory.class);
  96
  97     // List of optional characteristics and corresponding method to create them.
  98     private final static Map<HomekitCharacteristicType, BiFunction<HomekitTaggedItem, HomekitAccessoryUpdater, Characteristic>> optional = new HashMap<HomekitCharacteristicType, BiFunction<HomekitTaggedItem, HomekitAccessoryUpdater, Characteristic>>() {
  99         {
 100             put(NAME, HomekitCharacteristicFactory::createNameCharacteristic);
 101             put(BATTERY_LOW_STATUS, HomekitCharacteristicFactory::createStatusLowBatteryCharacteristic);
 102             put(FAULT_STATUS, HomekitCharacteristicFactory::createStatusFaultCharacteristic);
 103             put(TAMPERED_STATUS, HomekitCharacteristicFactory::createStatusTamperedCharacteristic);
 104             put(ACTIVE_STATUS, HomekitCharacteristicFactory::createStatusActiveCharacteristic);
 105             put(CARBON_MONOXIDE_LEVEL, HomekitCharacteristicFactory::createCarbonMonoxideLevelCharacteristic);
 106             put(CARBON_MONOXIDE_PEAK_LEVEL, HomekitCharacteristicFactory::createCarbonMonoxidePeakLevelCharacteristic);
 107             put(CARBON_DIOXIDE_LEVEL, HomekitCharacteristicFactory::createCarbonDioxideLevelCharacteristic);
 108             put(CARBON_DIOXIDE_PEAK_LEVEL, HomekitCharacteristicFactory::createCarbonDioxidePeakLevelCharacteristic);
 109             put(HOLD_POSITION, HomekitCharacteristicFactory::createHoldPositionCharacteristic);
 110             put(OBSTRUCTION_STATUS, HomekitCharacteristicFactory::createObstructionDetectedCharacteristic);
 111             put(CURRENT_HORIZONTAL_TILT_ANGLE,
 112                     HomekitCharacteristicFactory::createCurrentHorizontalTiltAngleCharacteristic);
 113             put(CURRENT_VERTICAL_TILT_ANGLE,
 114                     HomekitCharacteristicFactory::createCurrentVerticalTiltAngleCharacteristic);
 115             put(TARGET_HORIZONTAL_TILT_ANGLE,
 116                     HomekitCharacteristicFactory::createTargetHorizontalTiltAngleCharacteristic);
 117             put(TARGET_VERTICAL_TILT_ANGLE, HomekitCharacteristicFactory::createTargetVerticalTiltAngleCharacteristic);
 118             put(HUE, HomekitCharacteristicFactory::createHueCharacteristic);
 119             put(BRIGHTNESS, HomekitCharacteristicFactory::createBrightnessCharacteristic);
 120             put(SATURATION, HomekitCharacteristicFactory::createSaturationCharacteristic);
 121             put(COLOR_TEMPERATURE, HomekitCharacteristicFactory::createColorTemperatureCharacteristic);
 122             put(CURRENT_FAN_STATE, HomekitCharacteristicFactory::createCurrentFanStateCharacteristic);
 123             put(TARGET_FAN_STATE, HomekitCharacteristicFactory::createTargetFanStateCharacteristic);
 124             put(ROTATION_DIRECTION, HomekitCharacteristicFactory::createRotationDirectionCharacteristic);
 125             put(ROTATION_SPEED, HomekitCharacteristicFactory::createRotationSpeedCharacteristic);
 126             put(SWING_MODE, HomekitCharacteristicFactory::createSwingModeCharacteristic);
 127             put(LOCK_CONTROL, HomekitCharacteristicFactory::createLockPhysicalControlsCharacteristic);
 128             put(DURATION, HomekitCharacteristicFactory::createDurationCharacteristic);
 129             put(VOLUME, HomekitCharacteristicFactory::createVolumeCharacteristic);
 130             put(COOLING_THRESHOLD_TEMPERATURE, HomekitCharacteristicFactory::createCoolingThresholdCharacteristic);
 131             put(HEATING_THRESHOLD_TEMPERATURE, HomekitCharacteristicFactory::createHeatingThresholdCharacteristic);
 132             put(REMAINING_DURATION, HomekitCharacteristicFactory::createRemainingDurationCharacteristic);
 133             put(OZONE_DENSITY, HomekitCharacteristicFactory::createOzoneDensityCharacteristic);
 134             put(NITROGEN_DIOXIDE_DENSITY, HomekitCharacteristicFactory::createNitrogenDioxideDensityCharacteristic);
 135             put(SULPHUR_DIOXIDE_DENSITY, HomekitCharacteristicFactory::createSulphurDioxideDensityCharacteristic);
 136             put(PM25_DENSITY, HomekitCharacteristicFactory::createPM25DensityCharacteristic);
 137             put(PM10_DENSITY, HomekitCharacteristicFactory::createPM10DensityCharacteristic);
 138             put(VOC_DENSITY, HomekitCharacteristicFactory::createVOCDensityCharacteristic);
 139             // LEGACY
 140             put(OLD_BATTERY_LOW_STATUS, HomekitCharacteristicFactory::createStatusLowBatteryCharacteristic);
 141         }
 142     };
 143
 144     /**
 145      * create optional HomeKit characteristic
 146      *
 147      * @param item corresponding OH item
 148      * @param updater update to keep OH item and HomeKit characteristic in sync
 149      * @return HomeKit characteristic
 150      */
 151     public static Characteristic createCharacteristic(HomekitTaggedItem item, HomekitAccessoryUpdater updater)
 152             throws HomekitException {
 153         final @Nullable HomekitCharacteristicType type = item.getCharacteristicType();
 154         logger.trace("CreateCharacteristic, type {} item {}", type, item);
 155         if (optional.containsKey(type)) {
 156             return optional.get(type).apply(item, updater);
 157         }
 158         logger.warn("Unsupported optional characteristic. Accessory type {}, characteristic type {}",
 159                 item.getAccessoryType(), type);
 160         throw new HomekitException("Unsupported optional characteristic. Characteristic type \"" + type + "\"");
 161     }
 162
 163     // METHODS TO CREATE SINGLE CHARACTERISTIC FROM OH ITEM
 164
 165     // supporting methods
 166     private static <T extends CharacteristicEnum> CompletableFuture<T> getEnumFromItem(HomekitTaggedItem item,
 167             T offEnum, T onEnum, T defaultEnum) {
 168         final State state = item.getItem().getState();
 169         if (state instanceof OnOffType) {
 170             return CompletableFuture.completedFuture(state.equals(OnOffType.OFF) ? offEnum : onEnum);
 171         } else if (state instanceof OpenClosedType) {
 172             return CompletableFuture.completedFuture(state.equals(OpenClosedType.CLOSED) ? offEnum : onEnum);
 173         } else if (state instanceof DecimalType) {
 174             return CompletableFuture.completedFuture(((DecimalType) state).intValue() == 0 ? offEnum : onEnum);
 175         } else if (state instanceof UnDefType) {
 176             return CompletableFuture.completedFuture(defaultEnum);
 177         }
 178         logger.warn(
 179                 "Item state {} is not supported. Only OnOffType,OpenClosedType and Decimal (0/1) are supported. Ignore item {}",
 180                 state, item.getName());
 181         return CompletableFuture.completedFuture(defaultEnum);
 182     }
 183
 184     private static void setValueFromEnum(HomekitTaggedItem taggedItem, CharacteristicEnum value,
 185             CharacteristicEnum offEnum, CharacteristicEnum onEnum) {
 186         if (taggedItem.getItem() instanceof SwitchItem) {
 187             if (value.equals(offEnum)) {
 188                 ((SwitchItem) taggedItem.getItem()).send(OnOffType.OFF);
 189             } else if (value.equals(onEnum)) {
 190                 ((SwitchItem) taggedItem.getItem()).send(OnOffType.ON);
 191             } else {
 192                 logger.warn("Enum value {} is not supported. Only following values are supported: {},{}", value,
 193                         offEnum, onEnum);
 194             }
 195         } else if (taggedItem.getItem() instanceof NumberItem) {
 196             ((NumberItem) taggedItem.getItem()).send(new DecimalType(value.getCode()));
 197         } else {
 198             logger.warn("Item type {} is not supported. Only Switch and Number item types are supported.",
 199                     taggedItem.getItem().getType());
 200         }
 201     }
 202
 203     private static int getIntFromItem(HomekitTaggedItem taggedItem) {
 204         int value = 0;
 205         final State state = taggedItem.getItem().getState();
 206         if (state instanceof PercentType) {
 207             value = ((PercentType) state).intValue();
 208         } else if (state instanceof DecimalType) {
 209             value = ((DecimalType) state).intValue();
 210         } else if (state instanceof UnDefType) {
 211             logger.debug("Item state {} is UNDEF {}.", state, taggedItem.getName());
 212         } else {
 213             logger.warn(
 214                     "Item state {} is not supported for {}. Only PercentType and DecimalType (0/100) are supported.",
 215                     state, taggedItem.getName());
 216         }
 217         return value;
 218     }
 219
 220     private static Supplier<CompletableFuture<Integer>> getIntSupplier(HomekitTaggedItem taggedItem) {
 221         return () -> CompletableFuture.completedFuture(getIntFromItem(taggedItem));
 222     }
 223
 224     private static ExceptionalConsumer<Integer> setIntConsumer(HomekitTaggedItem taggedItem) {
 225         return (value) -> {
 226             if (taggedItem.getItem() instanceof NumberItem) {
 227                 ((NumberItem) taggedItem.getItem()).send(new DecimalType(value));
 228             } else {
 229                 logger.warn("Item type {} is not supported for {}. Only NumberItem is supported.",
 230                         taggedItem.getItem().getType(), taggedItem.getName());
 231             }
 232         };
 233     }
 234
 235     private static ExceptionalConsumer<Integer> setPercentConsumer(HomekitTaggedItem taggedItem) {
 236         return (value) -> {
 237             if (taggedItem.getItem() instanceof NumberItem) {
 238                 ((NumberItem) taggedItem.getItem()).send(new DecimalType(value));
 239             } else if (taggedItem.getItem() instanceof DimmerItem) {
 240                 ((DimmerItem) taggedItem.getItem()).send(new PercentType(value));
 241             } else {
 242                 logger.warn("Item type {} is not supported for {}. Only DimmerItem and NumberItem are supported.",
 243                         taggedItem.getItem().getType(), taggedItem.getName());
 244             }
 245         };
 246     }
 247
 248     private static Supplier<CompletableFuture<Double>> getDoubleSupplier(HomekitTaggedItem taggedItem) {
 249         return () -> {
 250             final @Nullable DecimalType value = taggedItem.getItem().getStateAs(DecimalType.class);
 251             return CompletableFuture.completedFuture(value != null ? value.doubleValue() : 0.0);
 252         };
 253     }
 254
 255     private static ExceptionalConsumer<Double> setDoubleConsumer(HomekitTaggedItem taggedItem) {
 256         return (value) -> {
 257             if (taggedItem.getItem() instanceof NumberItem) {
 258                 ((NumberItem) taggedItem.getItem()).send(new DecimalType(value));
 259             } else {
 260                 logger.warn("Item type {} is not supported for {}. Only Number type is supported.",
 261                         taggedItem.getItem().getType(), taggedItem.getName());
 262             }
 263         };
 264     }
 265
 266     protected static Consumer<HomekitCharacteristicChangeCallback> getSubscriber(HomekitTaggedItem taggedItem,
 267             HomekitCharacteristicType key, HomekitAccessoryUpdater updater) {
 268         return (callback) -> updater.subscribe((GenericItem) taggedItem.getItem(), key.getTag(), callback);
 269     }
 270
 271     protected static Runnable getUnsubscriber(HomekitTaggedItem taggedItem, HomekitCharacteristicType key,
 272             HomekitAccessoryUpdater updater) {
 273         return () -> updater.unsubscribe((GenericItem) taggedItem.getItem(), key.getTag());
 274     }
 275
 276     // create method for characteristic
 277     private static StatusLowBatteryCharacteristic createStatusLowBatteryCharacteristic(HomekitTaggedItem taggedItem,
 278             HomekitAccessoryUpdater updater) {
 279         return new StatusLowBatteryCharacteristic(
 280                 () -> getEnumFromItem(taggedItem, StatusLowBatteryEnum.NORMAL, StatusLowBatteryEnum.LOW,
 281                         StatusLowBatteryEnum.NORMAL),
 282                 getSubscriber(taggedItem, BATTERY_LOW_STATUS, updater),
 283                 getUnsubscriber(taggedItem, BATTERY_LOW_STATUS, updater));
 284     }
 285
 286     private static StatusFaultCharacteristic createStatusFaultCharacteristic(HomekitTaggedItem taggedItem,
 287             HomekitAccessoryUpdater updater) {
 288         return new StatusFaultCharacteristic(
 289                 () -> getEnumFromItem(taggedItem, StatusFaultEnum.NO_FAULT, StatusFaultEnum.GENERAL_FAULT,
 290                         StatusFaultEnum.NO_FAULT),
 291                 getSubscriber(taggedItem, FAULT_STATUS, updater), getUnsubscriber(taggedItem, FAULT_STATUS, updater));
 292     }
 293
 294     private static StatusTamperedCharacteristic createStatusTamperedCharacteristic(HomekitTaggedItem taggedItem,
 295             HomekitAccessoryUpdater updater) {
 296         return new StatusTamperedCharacteristic(
 297                 () -> getEnumFromItem(taggedItem, StatusTamperedEnum.NOT_TAMPERED, StatusTamperedEnum.TAMPERED,
 298                         StatusTamperedEnum.NOT_TAMPERED),
 299                 getSubscriber(taggedItem, TAMPERED_STATUS, updater),
 300                 getUnsubscriber(taggedItem, TAMPERED_STATUS, updater));
 301     }
 302
 303     private static ObstructionDetectedCharacteristic createObstructionDetectedCharacteristic(
 304             HomekitTaggedItem taggedItem, HomekitAccessoryUpdater updater) {
 305         return new ObstructionDetectedCharacteristic(
 306                 () -> CompletableFuture.completedFuture(taggedItem.getItem().getState() == OnOffType.ON
 307                         || taggedItem.getItem().getState() == OpenClosedType.OPEN),
 308                 getSubscriber(taggedItem, OBSTRUCTION_STATUS, updater),
 309                 getUnsubscriber(taggedItem, OBSTRUCTION_STATUS, updater));
 310     }
 311
 312     private static StatusActiveCharacteristic createStatusActiveCharacteristic(HomekitTaggedItem taggedItem,
 313             HomekitAccessoryUpdater updater) {
 314         return new StatusActiveCharacteristic(
 315                 () -> CompletableFuture.completedFuture(taggedItem.getItem().getState() == OnOffType.ON
 316                         || taggedItem.getItem().getState() == OpenClosedType.OPEN),
 317                 getSubscriber(taggedItem, ACTIVE_STATUS, updater), getUnsubscriber(taggedItem, ACTIVE_STATUS, updater));
 318     }
 319
 320     private static NameCharacteristic createNameCharacteristic(HomekitTaggedItem taggedItem,
 321             HomekitAccessoryUpdater updater) {
 322         return new NameCharacteristic(() -> {
 323             final State state = taggedItem.getItem().getState();
 324             return CompletableFuture.completedFuture(state instanceof UnDefType ? "" : state.toString());
 325         });
 326     }
 327
 328     private static HoldPositionCharacteristic createHoldPositionCharacteristic(HomekitTaggedItem taggedItem,
 329             HomekitAccessoryUpdater updater) {
 330         return new HoldPositionCharacteristic(value -> ((SwitchItem) taggedItem.getItem()).send(OnOffType.from(value)));
 331     }
 332
 333     private static CarbonMonoxideLevelCharacteristic createCarbonMonoxideLevelCharacteristic(
 334             HomekitTaggedItem taggedItem, HomekitAccessoryUpdater updater) {
 335         return new CarbonMonoxideLevelCharacteristic(getDoubleSupplier(taggedItem),
 336                 getSubscriber(taggedItem, CARBON_DIOXIDE_LEVEL, updater),
 337                 getUnsubscriber(taggedItem, CARBON_DIOXIDE_LEVEL, updater));
 338     }
 339
 340     private static CarbonMonoxidePeakLevelCharacteristic createCarbonMonoxidePeakLevelCharacteristic(
 341             HomekitTaggedItem taggedItem, HomekitAccessoryUpdater updater) {
 342         return new CarbonMonoxidePeakLevelCharacteristic(getDoubleSupplier(taggedItem),
 343                 getSubscriber(taggedItem, CARBON_DIOXIDE_PEAK_LEVEL, updater),
 344                 getUnsubscriber(taggedItem, CARBON_DIOXIDE_PEAK_LEVEL, updater));
 345     }
 346
 347     private static CarbonDioxideLevelCharacteristic createCarbonDioxideLevelCharacteristic(HomekitTaggedItem taggedItem,
 348             HomekitAccessoryUpdater updater) {
 349         return new CarbonDioxideLevelCharacteristic(getDoubleSupplier(taggedItem),
 350                 getSubscriber(taggedItem, CARBON_MONOXIDE_LEVEL, updater),
 351                 getUnsubscriber(taggedItem, CARBON_MONOXIDE_LEVEL, updater));
 352     }
 353
 354     private static CarbonDioxidePeakLevelCharacteristic createCarbonDioxidePeakLevelCharacteristic(
 355             HomekitTaggedItem taggedItem, HomekitAccessoryUpdater updater) {
 356         return new CarbonDioxidePeakLevelCharacteristic(getDoubleSupplier(taggedItem),
 357                 getSubscriber(taggedItem, CARBON_MONOXIDE_PEAK_LEVEL, updater),
 358                 getUnsubscriber(taggedItem, CARBON_MONOXIDE_PEAK_LEVEL, updater));
 359     }
 360
 361     private static CurrentHorizontalTiltAngleCharacteristic createCurrentHorizontalTiltAngleCharacteristic(
 362             HomekitTaggedItem taggedItem, HomekitAccessoryUpdater updater) {
 363         return new CurrentHorizontalTiltAngleCharacteristic(getIntSupplier(taggedItem),
 364                 getSubscriber(taggedItem, CURRENT_HORIZONTAL_TILT_ANGLE, updater),
 365                 getUnsubscriber(taggedItem, CURRENT_HORIZONTAL_TILT_ANGLE, updater));
 366     }
 367
 368     private static CurrentVerticalTiltAngleCharacteristic createCurrentVerticalTiltAngleCharacteristic(
 369             HomekitTaggedItem taggedItem, HomekitAccessoryUpdater updater) {
 370         return new CurrentVerticalTiltAngleCharacteristic(getIntSupplier(taggedItem),
 371                 getSubscriber(taggedItem, CURRENT_VERTICAL_TILT_ANGLE, updater),
 372                 getUnsubscriber(taggedItem, CURRENT_VERTICAL_TILT_ANGLE, updater));
 373     }
 374
 375     private static TargetHorizontalTiltAngleCharacteristic createTargetHorizontalTiltAngleCharacteristic(
 376             HomekitTaggedItem taggedItem, HomekitAccessoryUpdater updater) {
 377         return new TargetHorizontalTiltAngleCharacteristic(getIntSupplier(taggedItem), setIntConsumer(taggedItem),
 378                 getSubscriber(taggedItem, TARGET_HORIZONTAL_TILT_ANGLE, updater),
 379                 getUnsubscriber(taggedItem, TARGET_HORIZONTAL_TILT_ANGLE, updater));
 380     }
 381
 382     private static TargetVerticalTiltAngleCharacteristic createTargetVerticalTiltAngleCharacteristic(
 383             HomekitTaggedItem taggedItem, HomekitAccessoryUpdater updater) {
 384         return new TargetVerticalTiltAngleCharacteristic(getIntSupplier(taggedItem), setIntConsumer(taggedItem),
 385                 getSubscriber(taggedItem, TARGET_HORIZONTAL_TILT_ANGLE, updater),
 386                 getUnsubscriber(taggedItem, TARGET_HORIZONTAL_TILT_ANGLE, updater));
 387     }
 388
 389     private static HueCharacteristic createHueCharacteristic(HomekitTaggedItem taggedItem,
 390             HomekitAccessoryUpdater updater) {
 391         return new HueCharacteristic(() -> {
 392             double value = 0.0;
 393             State state = taggedItem.getItem().getState();
 394             if (state instanceof HSBType) {
 395                 value = ((HSBType) state).getHue().doubleValue();
 396             }
 397             return CompletableFuture.completedFuture(value);
 398         }, (hue) -> {
 399             if (taggedItem.getItem() instanceof ColorItem) {
 400                 taggedItem.sendCommandProxy(HomekitCommandType.HUE_COMMAND, new DecimalType(hue));
 401             } else {
 402                 logger.warn("Item type {} is not supported for {}. Only Color type is supported.",
 403                         taggedItem.getItem().getType(), taggedItem.getName());
 404             }
 405         }, getSubscriber(taggedItem, HUE, updater), getUnsubscriber(taggedItem, HUE, updater));
 406     }
 407
 408     private static BrightnessCharacteristic createBrightnessCharacteristic(HomekitTaggedItem taggedItem,
 409             HomekitAccessoryUpdater updater) {
 410         return new BrightnessCharacteristic(() -> {
 411             int value = 0;
 412             final State state = taggedItem.getItem().getState();
 413             if (state instanceof HSBType) {
 414                 value = ((HSBType) state).getBrightness().intValue();
 415             } else if (state instanceof PercentType) {
 416                 value = ((PercentType) state).intValue();
 417             }
 418             return CompletableFuture.completedFuture(value);
 419         }, (brightness) -> {
 420             final Item item = taggedItem.getItem();
 421             if (item instanceof DimmerItem) {
 422                 taggedItem.sendCommandProxy(HomekitCommandType.BRIGHTNESS_COMMAND, new PercentType(brightness));
 423             } else {
 424                 logger.warn("Item type {} is not supported for {}. Only ColorItem and DimmerItem are supported.",
 425                         item.getType(), taggedItem.getName());
 426             }
 427         }, getSubscriber(taggedItem, BRIGHTNESS, updater), getUnsubscriber(taggedItem, BRIGHTNESS, updater));
 428     }
 429
 430     private static SaturationCharacteristic createSaturationCharacteristic(HomekitTaggedItem taggedItem,
 431             HomekitAccessoryUpdater updater) {
 432         return new SaturationCharacteristic(() -> {
 433             double value = 0.0;
 434             State state = taggedItem.getItem().getState();
 435             if (state instanceof HSBType) {
 436                 value = ((HSBType) state).getSaturation().doubleValue();
 437             } else if (state instanceof PercentType) {
 438                 value = ((PercentType) state).doubleValue();
 439             }
 440             return CompletableFuture.completedFuture(value);
 441         }, (saturation) -> {
 442             if (taggedItem.getItem() instanceof ColorItem) {
 443                 taggedItem.sendCommandProxy(HomekitCommandType.SATURATION_COMMAND,
 444                         new PercentType(saturation.intValue()));
 445             } else {
 446                 logger.warn("Item type {} is not supported for {}. Only Color type is supported.",
 447                         taggedItem.getItem().getType(), taggedItem.getName());
 448             }
 449         }, getSubscriber(taggedItem, SATURATION, updater), getUnsubscriber(taggedItem, SATURATION, updater));
 450     }
 451
 452     private static ColorTemperatureCharacteristic createColorTemperatureCharacteristic(HomekitTaggedItem taggedItem,
 453             HomekitAccessoryUpdater updater) {
 454         return new ColorTemperatureCharacteristic(getIntSupplier(taggedItem), setIntConsumer(taggedItem),
 455                 getSubscriber(taggedItem, COLOR_TEMPERATURE, updater),
 456                 getUnsubscriber(taggedItem, COLOR_TEMPERATURE, updater));
 457     }
 458
 459     private static CurrentFanStateCharacteristic createCurrentFanStateCharacteristic(HomekitTaggedItem taggedItem,
 460             HomekitAccessoryUpdater updater) {
 461         return new CurrentFanStateCharacteristic(() -> {
 462             final @Nullable DecimalType value = taggedItem.getItem().getStateAs(DecimalType.class);
 463             @Nullable
 464             CurrentFanStateEnum currentFanStateEnum = value != null ? CurrentFanStateEnum.fromCode(value.intValue())
 465                     : null;
 466             if (currentFanStateEnum == null) {
 467                 currentFanStateEnum = CurrentFanStateEnum.INACTIVE;
 468             }
 469             return CompletableFuture.completedFuture(currentFanStateEnum);
 470         }, getSubscriber(taggedItem, CURRENT_FAN_STATE, updater),
 471                 getUnsubscriber(taggedItem, CURRENT_FAN_STATE, updater));
 472     }
 473
 474     private static TargetFanStateCharacteristic createTargetFanStateCharacteristic(HomekitTaggedItem taggedItem,
 475             HomekitAccessoryUpdater updater) {
 476         return new TargetFanStateCharacteristic(() -> {
 477             final @Nullable DecimalType value = taggedItem.getItem().getStateAs(DecimalType.class);
 478             @Nullable
 479             TargetFanStateEnum targetFanStateEnum = value != null ? TargetFanStateEnum.fromCode(value.intValue())
 480                     : null;
 481             if (targetFanStateEnum == null) {
 482                 targetFanStateEnum = TargetFanStateEnum.AUTO;
 483             }
 484             return CompletableFuture.completedFuture(targetFanStateEnum);
 485         }, (targetState) -> {
 486             if (taggedItem.getItem() instanceof NumberItem) {
 487                 ((NumberItem) taggedItem.getItem()).send(new DecimalType(targetState.getCode()));
 488             } else {
 489                 logger.warn("Item type {} is not supported for {}. Only Number type is supported.",
 490                         taggedItem.getItem().getType(), taggedItem.getName());
 491             }
 492         }, getSubscriber(taggedItem, TARGET_FAN_STATE, updater),
 493                 getUnsubscriber(taggedItem, TARGET_FAN_STATE, updater));
 494     }
 495
 496     private static RotationDirectionCharacteristic createRotationDirectionCharacteristic(HomekitTaggedItem taggedItem,
 497             HomekitAccessoryUpdater updater) {
 498         return new RotationDirectionCharacteristic(
 499                 () -> getEnumFromItem(taggedItem, RotationDirectionEnum.CLOCKWISE,
 500                         RotationDirectionEnum.COUNTER_CLOCKWISE, RotationDirectionEnum.CLOCKWISE),
 501                 (value) -> setValueFromEnum(taggedItem, value, RotationDirectionEnum.CLOCKWISE,
 502                         RotationDirectionEnum.COUNTER_CLOCKWISE),
 503                 getSubscriber(taggedItem, ROTATION_DIRECTION, updater),
 504                 getUnsubscriber(taggedItem, ROTATION_DIRECTION, updater));
 505     }
 506
 507     private static SwingModeCharacteristic createSwingModeCharacteristic(HomekitTaggedItem taggedItem,
 508             HomekitAccessoryUpdater updater) {
 509         return new SwingModeCharacteristic(
 510                 () -> getEnumFromItem(taggedItem, SwingModeEnum.SWING_DISABLED, SwingModeEnum.SWING_ENABLED,
 511                         SwingModeEnum.SWING_DISABLED),
 512                 (value) -> setValueFromEnum(taggedItem, value, SwingModeEnum.SWING_DISABLED,
 513                         SwingModeEnum.SWING_ENABLED),
 514                 getSubscriber(taggedItem, SWING_MODE, updater), getUnsubscriber(taggedItem, SWING_MODE, updater));
 515     }
 516
 517     private static LockPhysicalControlsCharacteristic createLockPhysicalControlsCharacteristic(
 518             HomekitTaggedItem taggedItem, HomekitAccessoryUpdater updater) {
 519         return new LockPhysicalControlsCharacteristic(
 520                 () -> getEnumFromItem(taggedItem, LockPhysicalControlsEnum.CONTROL_LOCK_DISABLED,
 521                         LockPhysicalControlsEnum.CONTROL_LOCK_ENABLED, LockPhysicalControlsEnum.CONTROL_LOCK_DISABLED),
 522                 (value) -> setValueFromEnum(taggedItem, value, LockPhysicalControlsEnum.CONTROL_LOCK_DISABLED,
 523                         LockPhysicalControlsEnum.CONTROL_LOCK_ENABLED),
 524                 getSubscriber(taggedItem, LOCK_CONTROL, updater), getUnsubscriber(taggedItem, LOCK_CONTROL, updater));
 525     }
 526
 527     private static RotationSpeedCharacteristic createRotationSpeedCharacteristic(HomekitTaggedItem item,
 528             HomekitAccessoryUpdater updater) {
 529         return new RotationSpeedCharacteristic(getIntSupplier(item), setPercentConsumer(item),
 530                 getSubscriber(item, ROTATION_SPEED, updater), getUnsubscriber(item, ROTATION_SPEED, updater));
 531     }
 532
 533     private static SetDurationCharacteristic createDurationCharacteristic(HomekitTaggedItem taggedItem,
 534             HomekitAccessoryUpdater updater) {
 535         return new SetDurationCharacteristic(() -> {
 536             int value = getIntFromItem(taggedItem);
 537             final @Nullable Map<String, Object> itemConfiguration = taggedItem.getConfiguration();
 538             if ((value == 0) && (itemConfiguration != null)) { // check for default duration
 539                 final Object duration = itemConfiguration.get(HomekitValveImpl.CONFIG_DEFAULT_DURATION);
 540                 if (duration instanceof BigDecimal) {
 541                     value = ((BigDecimal) duration).intValue();
 542                     if (taggedItem.getItem() instanceof NumberItem) {
 543                         ((NumberItem) taggedItem.getItem()).setState(new DecimalType(value));
 544                     }
 545                 }
 546             }
 547             return CompletableFuture.completedFuture(value);
 548         }, setIntConsumer(taggedItem), getSubscriber(taggedItem, DURATION, updater),
 549                 getUnsubscriber(taggedItem, DURATION, updater));
 550     }
 551
 552     private static RemainingDurationCharacteristic createRemainingDurationCharacteristic(HomekitTaggedItem taggedItem,
 553             HomekitAccessoryUpdater updater) {
 554         return new RemainingDurationCharacteristic(getIntSupplier(taggedItem),
 555                 getSubscriber(taggedItem, REMAINING_DURATION, updater),
 556                 getUnsubscriber(taggedItem, REMAINING_DURATION, updater));
 557     }
 558
 559     private static VolumeCharacteristic createVolumeCharacteristic(HomekitTaggedItem taggedItem,
 560             HomekitAccessoryUpdater updater) {
 561         return new VolumeCharacteristic(getIntSupplier(taggedItem),
 562                 (volume) -> ((NumberItem) taggedItem.getItem()).send(new DecimalType(volume)),
 563                 getSubscriber(taggedItem, DURATION, updater), getUnsubscriber(taggedItem, DURATION, updater));
 564     }
 565
 566     private static CoolingThresholdTemperatureCharacteristic createCoolingThresholdCharacteristic(
 567             HomekitTaggedItem taggedItem, HomekitAccessoryUpdater updater) {
 568         return new CoolingThresholdTemperatureCharacteristic(
 569                 taggedItem.getConfigurationAsDouble(HomekitTaggedItem.MIN_VALUE,
 570                         CoolingThresholdTemperatureCharacteristic.DEFAULT_MIN_VALUE),
 571                 taggedItem.getConfigurationAsDouble(HomekitTaggedItem.MAX_VALUE,
 572                         CoolingThresholdTemperatureCharacteristic.DEFAULT_MAX_VALUE),
 573                 taggedItem.getConfigurationAsDouble(HomekitTaggedItem.STEP,
 574                         CoolingThresholdTemperatureCharacteristic.DEFAULT_STEP),
 575                 getDoubleSupplier(taggedItem), setDoubleConsumer(taggedItem),
 576                 getSubscriber(taggedItem, COOLING_THRESHOLD_TEMPERATURE, updater),
 577                 getUnsubscriber(taggedItem, COOLING_THRESHOLD_TEMPERATURE, updater));
 578     }
 579
 580     private static HeatingThresholdTemperatureCharacteristic createHeatingThresholdCharacteristic(
 581             HomekitTaggedItem taggedItem, HomekitAccessoryUpdater updater) {
 582         return new HeatingThresholdTemperatureCharacteristic(
 583                 taggedItem.getConfigurationAsDouble(HomekitTaggedItem.MIN_VALUE,
 584                         HeatingThresholdTemperatureCharacteristic.DEFAULT_MIN_VALUE),
 585                 taggedItem.getConfigurationAsDouble(HomekitTaggedItem.MAX_VALUE,
 586                         HeatingThresholdTemperatureCharacteristic.DEFAULT_MAX_VALUE),
 587                 taggedItem.getConfigurationAsDouble(HomekitTaggedItem.STEP,
 588                         HeatingThresholdTemperatureCharacteristic.DEFAULT_STEP),
 589                 getDoubleSupplier(taggedItem), setDoubleConsumer(taggedItem),
 590                 getSubscriber(taggedItem, HEATING_THRESHOLD_TEMPERATURE, updater),
 591                 getUnsubscriber(taggedItem, HEATING_THRESHOLD_TEMPERATURE, updater));
 592     }
 593
 594     private static OzoneDensityCharacteristic createOzoneDensityCharacteristic(final HomekitTaggedItem taggedItem,
 595             HomekitAccessoryUpdater updater) {
 596         return new OzoneDensityCharacteristic(getDoubleSupplier(taggedItem),
 597                 getSubscriber(taggedItem, OZONE_DENSITY, updater), getUnsubscriber(taggedItem, OZONE_DENSITY, updater));
 598     }
 599
 600     private static NitrogenDioxideDensityCharacteristic createNitrogenDioxideDensityCharacteristic(
 601             final HomekitTaggedItem taggedItem, HomekitAccessoryUpdater updater) {
 602         return new NitrogenDioxideDensityCharacteristic(getDoubleSupplier(taggedItem),
 603                 getSubscriber(taggedItem, NITROGEN_DIOXIDE_DENSITY, updater),
 604                 getUnsubscriber(taggedItem, NITROGEN_DIOXIDE_DENSITY, updater));
 605     }
 606
 607     private static SulphurDioxideDensityCharacteristic createSulphurDioxideDensityCharacteristic(
 608             final HomekitTaggedItem taggedItem, HomekitAccessoryUpdater updater) {
 609         return new SulphurDioxideDensityCharacteristic(getDoubleSupplier(taggedItem),
 610                 getSubscriber(taggedItem, SULPHUR_DIOXIDE_DENSITY, updater),
 611                 getUnsubscriber(taggedItem, SULPHUR_DIOXIDE_DENSITY, updater));
 612     }
 613
 614     private static PM25DensityCharacteristic createPM25DensityCharacteristic(final HomekitTaggedItem taggedItem,
 615             HomekitAccessoryUpdater updater) {
 616         return new PM25DensityCharacteristic(getDoubleSupplier(taggedItem),
 617                 getSubscriber(taggedItem, PM25_DENSITY, updater), getUnsubscriber(taggedItem, PM25_DENSITY, updater));
 618     }
 619
 620     private static PM10DensityCharacteristic createPM10DensityCharacteristic(final HomekitTaggedItem taggedItem,
 621             HomekitAccessoryUpdater updater) {
 622         return new PM10DensityCharacteristic(getDoubleSupplier(taggedItem),
 623                 getSubscriber(taggedItem, PM10_DENSITY, updater), getUnsubscriber(taggedItem, PM10_DENSITY, updater));
 624     }
 625
 626     private static VOCDensityCharacteristic createVOCDensityCharacteristic(final HomekitTaggedItem taggedItem,
 627             HomekitAccessoryUpdater updater) {
 628         return new VOCDensityCharacteristic(getDoubleSupplier(taggedItem),
 629                 getSubscriber(taggedItem, VOC_DENSITY, updater), getUnsubscriber(taggedItem, VOC_DENSITY, updater));
 630     }
 631 }