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

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