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

   1 /**
   2  * Copyright (c) 2010-2023 Contributors to the openHAB project
   3  *
   4  * See the NOTICE file(s) distributed with this work for additional
   5  * information.
   6  *
   7  * This program and the accompanying materials are made available under the
   8  * terms of the Eclipse Public License 2.0 which is available at
   9  * http://www.eclipse.org/legal/epl-2.0
  10  *
  11  * SPDX-License-Identifier: EPL-2.0
  12  */
  13 package org.openhab.io.homekit.internal.accessories;
  14
  15 import static org.openhab.io.homekit.internal.HomekitCharacteristicType.CURRENT_HEATING_COOLING_STATE;
  16 import static org.openhab.io.homekit.internal.HomekitCharacteristicType.TARGET_HEATING_COOLING_STATE;
  17
  18 import java.math.BigDecimal;
  19 import java.util.ArrayList;
  20 import java.util.EnumMap;
  21 import java.util.List;
  22 import java.util.Map;
  23 import java.util.Optional;
  24 import java.util.concurrent.CompletableFuture;
  25
  26 import org.openhab.core.library.items.NumberItem;
  27 import org.openhab.core.library.items.StringItem;
  28 import org.openhab.core.library.types.DecimalType;
  29 import org.openhab.core.library.types.StringType;
  30 import org.openhab.io.homekit.internal.HomekitAccessoryUpdater;
  31 import org.openhab.io.homekit.internal.HomekitCharacteristicType;
  32 import org.openhab.io.homekit.internal.HomekitSettings;
  33 import org.openhab.io.homekit.internal.HomekitTaggedItem;
  34 import org.slf4j.Logger;
  35 import org.slf4j.LoggerFactory;
  36
  37 import io.github.hapjava.accessories.ThermostatAccessory;
  38 import io.github.hapjava.characteristics.HomekitCharacteristicChangeCallback;
  39 import io.github.hapjava.characteristics.impl.thermostat.CurrentHeatingCoolingStateEnum;
  40 import io.github.hapjava.characteristics.impl.thermostat.CurrentTemperatureCharacteristic;
  41 import io.github.hapjava.characteristics.impl.thermostat.TargetHeatingCoolingStateEnum;
  42 import io.github.hapjava.characteristics.impl.thermostat.TargetTemperatureCharacteristic;
  43 import io.github.hapjava.characteristics.impl.thermostat.TemperatureDisplayUnitEnum;
  44 import io.github.hapjava.services.impl.ThermostatService;
  45
  46 /**
  47  * Implements Thermostat as a GroupedAccessory made up of multiple items:
  48  * <ul>
  49  * <li>Current Temperature: Number type</li>
  50  * <li>Target Temperature: Number type</li>
  51  * <li>Current Heating/Cooling Mode: String type (see HomekitSettings.thermostat*Mode)</li>
  52  * <li>Target Heating/Cooling Mode: String type (see HomekitSettings.thermostat*Mode)</li>
  53  * </ul>
  54  *
  55  * @author Andy Lintner - Initial contribution
  56  */
  57 class HomekitThermostatImpl extends AbstractHomekitAccessoryImpl implements ThermostatAccessory {
  58     private final Logger logger = LoggerFactory.getLogger(HomekitThermostatImpl.class);
  59     private final Map<CurrentHeatingCoolingStateEnum, String> currentHeatingCoolingStateMapping;
  60     private final Map<TargetHeatingCoolingStateEnum, String> targetHeatingCoolingStateMapping;
  61     private final List<CurrentHeatingCoolingStateEnum> customCurrentHeatingCoolingStateList;
  62     private final List<TargetHeatingCoolingStateEnum> customTargetHeatingCoolingStateList;
  63
  64     public HomekitThermostatImpl(HomekitTaggedItem taggedItem, List<HomekitTaggedItem> mandatoryCharacteristics,
  65             HomekitAccessoryUpdater updater, HomekitSettings settings) {
  66         super(taggedItem, mandatoryCharacteristics, updater, settings);
  67         currentHeatingCoolingStateMapping = new EnumMap<>(CurrentHeatingCoolingStateEnum.class);
  68         currentHeatingCoolingStateMapping.put(CurrentHeatingCoolingStateEnum.OFF, settings.thermostatCurrentModeOff);
  69         currentHeatingCoolingStateMapping.put(CurrentHeatingCoolingStateEnum.COOL,
  70                 settings.thermostatCurrentModeCooling);
  71         currentHeatingCoolingStateMapping.put(CurrentHeatingCoolingStateEnum.HEAT,
  72                 settings.thermostatCurrentModeHeating);
  73         targetHeatingCoolingStateMapping = new EnumMap<>(TargetHeatingCoolingStateEnum.class);
  74         targetHeatingCoolingStateMapping.put(TargetHeatingCoolingStateEnum.OFF, settings.thermostatTargetModeOff);
  75         targetHeatingCoolingStateMapping.put(TargetHeatingCoolingStateEnum.COOL, settings.thermostatTargetModeCool);
  76         targetHeatingCoolingStateMapping.put(TargetHeatingCoolingStateEnum.HEAT, settings.thermostatTargetModeHeat);
  77         targetHeatingCoolingStateMapping.put(TargetHeatingCoolingStateEnum.AUTO, settings.thermostatTargetModeAuto);
  78         customCurrentHeatingCoolingStateList = new ArrayList<>();
  79         customTargetHeatingCoolingStateList = new ArrayList<>();
  80         updateMapping(CURRENT_HEATING_COOLING_STATE, currentHeatingCoolingStateMapping,
  81                 customCurrentHeatingCoolingStateList);
  82         updateMapping(TARGET_HEATING_COOLING_STATE, targetHeatingCoolingStateMapping,
  83                 customTargetHeatingCoolingStateList);
  84         this.getServices().add(new ThermostatService(this));
  85     }
  86
  87     @Override
  88     public CurrentHeatingCoolingStateEnum[] getCurrentHeatingCoolingStateValidValues() {
  89         return customCurrentHeatingCoolingStateList.isEmpty()
  90                 ? currentHeatingCoolingStateMapping.keySet().toArray(new CurrentHeatingCoolingStateEnum[0])
  91                 : customCurrentHeatingCoolingStateList.toArray(new CurrentHeatingCoolingStateEnum[0]);
  92     }
  93
  94     @Override
  95     public TargetHeatingCoolingStateEnum[] getTargetHeatingCoolingStateValidValues() {
  96         return customTargetHeatingCoolingStateList.isEmpty()
  97                 ? targetHeatingCoolingStateMapping.keySet().toArray(new TargetHeatingCoolingStateEnum[0])
  98                 : customTargetHeatingCoolingStateList.toArray(new TargetHeatingCoolingStateEnum[0]);
  99     }
 100
 101     @Override
 102     public CompletableFuture<CurrentHeatingCoolingStateEnum> getCurrentState() {
 103         return CompletableFuture.completedFuture(getKeyFromMapping(CURRENT_HEATING_COOLING_STATE,
 104                 currentHeatingCoolingStateMapping, CurrentHeatingCoolingStateEnum.OFF));
 105     }
 106
 107     @Override
 108     public CompletableFuture<Double> getCurrentTemperature() {
 109         Double state = getStateAsTemperature(HomekitCharacteristicType.CURRENT_TEMPERATURE);
 110         return CompletableFuture.completedFuture(state != null ? state : getMinCurrentTemperature());
 111     }
 112
 113     @Override
 114     public double getMinCurrentTemperature() {
 115         // Apple defines default values in Celsius. We need to convert them to Fahrenheit if openHAB is using Fahrenheit
 116         // convertToCelsius and convertFromCelsius are only converting if useFahrenheit is set to true, so no additional
 117         // check here needed
 118
 119         return HomekitCharacteristicFactory.convertToCelsius(
 120                 getAccessoryConfiguration(HomekitCharacteristicType.CURRENT_TEMPERATURE, HomekitTaggedItem.MIN_VALUE,
 121                         BigDecimal.valueOf(HomekitCharacteristicFactory
 122                                 .convertFromCelsius(CurrentTemperatureCharacteristic.DEFAULT_MIN_VALUE)))
 123                                         .doubleValue());
 124     }
 125
 126     @Override
 127     public double getMaxCurrentTemperature() {
 128         return HomekitCharacteristicFactory.convertToCelsius(
 129                 getAccessoryConfiguration(HomekitCharacteristicType.CURRENT_TEMPERATURE, HomekitTaggedItem.MAX_VALUE,
 130                         BigDecimal.valueOf(HomekitCharacteristicFactory
 131                                 .convertFromCelsius(CurrentTemperatureCharacteristic.DEFAULT_MAX_VALUE)))
 132                                         .doubleValue());
 133     }
 134
 135     @Override
 136     public double getMinStepCurrentTemperature() {
 137         return HomekitCharacteristicFactory.getTemperatureStep(
 138                 getCharacteristic(HomekitCharacteristicType.CURRENT_TEMPERATURE).get(),
 139                 TargetTemperatureCharacteristic.DEFAULT_STEP);
 140     }
 141
 142     @Override
 143     public CompletableFuture<TargetHeatingCoolingStateEnum> getTargetState() {
 144         return CompletableFuture.completedFuture(getKeyFromMapping(TARGET_HEATING_COOLING_STATE,
 145                 targetHeatingCoolingStateMapping, TargetHeatingCoolingStateEnum.OFF));
 146     }
 147
 148     @Override
 149     public CompletableFuture<TemperatureDisplayUnitEnum> getTemperatureDisplayUnit() {
 150         return CompletableFuture
 151                 .completedFuture(HomekitCharacteristicFactory.useFahrenheit() ? TemperatureDisplayUnitEnum.FAHRENHEIT
 152                         : TemperatureDisplayUnitEnum.CELSIUS);
 153     }
 154
 155     @Override
 156     public void setTemperatureDisplayUnit(TemperatureDisplayUnitEnum value) {
 157         // TODO: add support for display unit change
 158     }
 159
 160     @Override
 161     public CompletableFuture<Double> getTargetTemperature() {
 162         Double state = getStateAsTemperature(HomekitCharacteristicType.TARGET_TEMPERATURE);
 163         return CompletableFuture.completedFuture(state != null ? state : 0.0);
 164     }
 165
 166     @Override
 167     public void setTargetState(TargetHeatingCoolingStateEnum mode) {
 168         getItem(TARGET_HEATING_COOLING_STATE, StringItem.class)
 169                 .ifPresent(item -> item.send(new StringType(targetHeatingCoolingStateMapping.get(mode))));
 170     }
 171
 172     @Override
 173     public void setTargetTemperature(Double value) {
 174         final Optional<HomekitTaggedItem> characteristic = getCharacteristic(
 175                 HomekitCharacteristicType.TARGET_TEMPERATURE);
 176         if (characteristic.isPresent()) {
 177             ((NumberItem) characteristic.get().getItem())
 178                     .send(new DecimalType(BigDecimal.valueOf(HomekitCharacteristicFactory.convertFromCelsius(value))));
 179         } else {
 180             logger.warn("Missing mandatory characteristic {}", HomekitCharacteristicType.TARGET_TEMPERATURE);
 181         }
 182     }
 183
 184     @Override
 185     public double getMinTargetTemperature() {
 186         return HomekitCharacteristicFactory
 187                 .convertToCelsius(
 188                         getAccessoryConfiguration(HomekitCharacteristicType.TARGET_TEMPERATURE,
 189                                 HomekitTaggedItem.MIN_VALUE,
 190                                 BigDecimal.valueOf(HomekitCharacteristicFactory
 191                                         .convertFromCelsius(TargetTemperatureCharacteristic.DEFAULT_MIN_VALUE)))
 192                                                 .doubleValue());
 193     }
 194
 195     @Override
 196     public double getMaxTargetTemperature() {
 197         return HomekitCharacteristicFactory
 198                 .convertToCelsius(
 199                         getAccessoryConfiguration(HomekitCharacteristicType.TARGET_TEMPERATURE,
 200                                 HomekitTaggedItem.MAX_VALUE,
 201                                 BigDecimal.valueOf(HomekitCharacteristicFactory
 202                                         .convertFromCelsius(TargetTemperatureCharacteristic.DEFAULT_MAX_VALUE)))
 203                                                 .doubleValue());
 204     }
 205
 206     @Override
 207     public double getMinStepTargetTemperature() {
 208         return HomekitCharacteristicFactory.getTemperatureStep(
 209                 getCharacteristic(HomekitCharacteristicType.TARGET_TEMPERATURE).get(),
 210                 TargetTemperatureCharacteristic.DEFAULT_STEP);
 211     }
 212
 213     @Override
 214     public void subscribeCurrentState(HomekitCharacteristicChangeCallback callback) {
 215         subscribe(CURRENT_HEATING_COOLING_STATE, callback);
 216     }
 217
 218     @Override
 219     public void subscribeCurrentTemperature(HomekitCharacteristicChangeCallback callback) {
 220         subscribe(HomekitCharacteristicType.CURRENT_TEMPERATURE, callback);
 221     }
 222
 223     @Override
 224     public void subscribeTargetState(HomekitCharacteristicChangeCallback callback) {
 225         subscribe(HomekitCharacteristicType.TARGET_HEATING_COOLING_STATE, callback);
 226     }
 227
 228     @Override
 229     public void subscribeTargetTemperature(HomekitCharacteristicChangeCallback callback) {
 230         subscribe(HomekitCharacteristicType.TARGET_TEMPERATURE, callback);
 231     }
 232
 233     @Override
 234     public void subscribeTemperatureDisplayUnit(HomekitCharacteristicChangeCallback callback) {
 235         // TODO: add support for display unit change
 236     }
 237
 238     @Override
 239     public void unsubscribeCurrentState() {
 240         unsubscribe(CURRENT_HEATING_COOLING_STATE);
 241     }
 242
 243     @Override
 244     public void unsubscribeCurrentTemperature() {
 245         unsubscribe(HomekitCharacteristicType.CURRENT_TEMPERATURE);
 246     }
 247
 248     @Override
 249     public void unsubscribeTemperatureDisplayUnit() {
 250         // TODO: add support for display unit change
 251     }
 252
 253     @Override
 254     public void unsubscribeTargetState() {
 255         unsubscribe(HomekitCharacteristicType.TARGET_HEATING_COOLING_STATE);
 256     }
 257
 258     @Override
 259     public void unsubscribeTargetTemperature() {
 260         unsubscribe(HomekitCharacteristicType.TARGET_TEMPERATURE);
 261     }
 262 }