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.binding.homeconnect.internal.handler;
  14
  15 import static org.openhab.binding.homeconnect.internal.HomeConnectBindingConstants.*;
  16
  17 import java.util.Map;
  18 import java.util.Optional;
  19
  20 import javax.measure.UnconvertibleException;
  21
  22 import org.eclipse.jdt.annotation.NonNullByDefault;
  23 import org.openhab.binding.homeconnect.internal.client.HomeConnectApiClient;
  24 import org.openhab.binding.homeconnect.internal.client.exception.ApplianceOfflineException;
  25 import org.openhab.binding.homeconnect.internal.client.exception.AuthorizationException;
  26 import org.openhab.binding.homeconnect.internal.client.exception.CommunicationException;
  27 import org.openhab.binding.homeconnect.internal.client.model.Data;
  28 import org.openhab.binding.homeconnect.internal.type.HomeConnectDynamicStateDescriptionProvider;
  29 import org.openhab.core.library.types.OnOffType;
  30 import org.openhab.core.library.types.QuantityType;
  31 import org.openhab.core.thing.ChannelUID;
  32 import org.openhab.core.thing.Thing;
  33 import org.openhab.core.types.Command;
  34 import org.openhab.core.types.UnDefType;
  35 import org.slf4j.Logger;
  36 import org.slf4j.LoggerFactory;
  37
  38 /**
  39  * The {@link HomeConnectFridgeFreezerHandler} is responsible for handling commands, which are
  40  * sent to one of the channels of a fridge/freezer.
  41  *
  42  * @author Jonas Brüstel - Initial contribution
  43  */
  44 @NonNullByDefault
  45 public class HomeConnectFridgeFreezerHandler extends AbstractHomeConnectThingHandler {
  46
  47     private final Logger logger = LoggerFactory.getLogger(HomeConnectFridgeFreezerHandler.class);
  48
  49     public HomeConnectFridgeFreezerHandler(Thing thing,
  50             HomeConnectDynamicStateDescriptionProvider dynamicStateDescriptionProvider) {
  51         super(thing, dynamicStateDescriptionProvider);
  52     }
  53
  54     @Override
  55     protected void configureChannelUpdateHandlers(Map<String, ChannelUpdateHandler> handlers) {
  56         // register default update handlers
  57         handlers.put(CHANNEL_DOOR_STATE, defaultDoorStateChannelUpdateHandler());
  58
  59         // register fridge/freezer specific handlers
  60         handlers.put(CHANNEL_FREEZER_SETPOINT_TEMPERATURE,
  61                 (channelUID, cache) -> updateState(channelUID, cache.putIfAbsentAndGet(channelUID, () -> {
  62                     Optional<HomeConnectApiClient> apiClient = getApiClient();
  63                     if (apiClient.isPresent()) {
  64                         Data data = apiClient.get().getFreezerSetpointTemperature(getThingHaId());
  65                         if (data.getValue() != null) {
  66                             return new QuantityType<>(data.getValueAsInt(), mapTemperature(data.getUnit()));
  67                         } else {
  68                             return UnDefType.UNDEF;
  69                         }
  70                     }
  71                     return UnDefType.UNDEF;
  72                 })));
  73         handlers.put(CHANNEL_REFRIGERATOR_SETPOINT_TEMPERATURE,
  74                 (channelUID, cache) -> updateState(channelUID, cache.putIfAbsentAndGet(channelUID, () -> {
  75                     Optional<HomeConnectApiClient> apiClient = getApiClient();
  76                     if (apiClient.isPresent()) {
  77                         Data data = apiClient.get().getFridgeSetpointTemperature(getThingHaId());
  78                         if (data.getValue() != null) {
  79                             return new QuantityType<>(data.getValueAsInt(), mapTemperature(data.getUnit()));
  80                         } else {
  81                             return UnDefType.UNDEF;
  82                         }
  83                     }
  84                     return UnDefType.UNDEF;
  85                 })));
  86         handlers.put(CHANNEL_REFRIGERATOR_SUPER_MODE,
  87                 (channelUID, cache) -> updateState(channelUID, cache.putIfAbsentAndGet(channelUID, () -> {
  88                     Optional<HomeConnectApiClient> apiClient = getApiClient();
  89                     if (apiClient.isPresent()) {
  90                         Data data = apiClient.get().getFridgeSuperMode(getThingHaId());
  91                         if (data.getValue() != null) {
  92                             return OnOffType.from(data.getValueAsBoolean());
  93                         } else {
  94                             return UnDefType.UNDEF;
  95                         }
  96                     }
  97                     return UnDefType.UNDEF;
  98                 })));
  99         handlers.put(CHANNEL_FREEZER_SUPER_MODE,
 100                 (channelUID, cache) -> updateState(channelUID, cache.putIfAbsentAndGet(channelUID, () -> {
 101                     Optional<HomeConnectApiClient> apiClient = getApiClient();
 102
 103                     if (apiClient.isPresent()) {
 104                         Data data = apiClient.get().getFreezerSuperMode(getThingHaId());
 105                         if (data.getValue() != null) {
 106                             return OnOffType.from(data.getValueAsBoolean());
 107                         } else {
 108                             return UnDefType.UNDEF;
 109                         }
 110                     }
 111                     return UnDefType.UNDEF;
 112                 })));
 113     }
 114
 115     @Override
 116     protected void configureEventHandlers(Map<String, EventHandler> handlers) {
 117         // register default event handlers
 118         handlers.put(EVENT_DOOR_STATE, defaultDoorStateEventHandler());
 119         handlers.put(EVENT_FREEZER_SUPER_MODE, defaultBooleanEventHandler(CHANNEL_FREEZER_SUPER_MODE));
 120         handlers.put(EVENT_FRIDGE_SUPER_MODE, defaultBooleanEventHandler(CHANNEL_REFRIGERATOR_SUPER_MODE));
 121
 122         // register fridge/freezer specific event handlers
 123         handlers.put(EVENT_FREEZER_SETPOINT_TEMPERATURE,
 124                 event -> getLinkedChannel(CHANNEL_FREEZER_SETPOINT_TEMPERATURE)
 125                         .ifPresent(channel -> updateState(channel.getUID(),
 126                                 new QuantityType<>(event.getValueAsInt(), mapTemperature(event.getUnit())))));
 127         handlers.put(EVENT_FRIDGE_SETPOINT_TEMPERATURE,
 128                 event -> getLinkedChannel(CHANNEL_REFRIGERATOR_SETPOINT_TEMPERATURE)
 129                         .ifPresent(channel -> updateState(channel.getUID(),
 130                                 new QuantityType<>(event.getValueAsInt(), mapTemperature(event.getUnit())))));
 131     }
 132
 133     @Override
 134     protected void handleCommand(final ChannelUID channelUID, final Command command,
 135             final HomeConnectApiClient apiClient)
 136             throws CommunicationException, AuthorizationException, ApplianceOfflineException {
 137         super.handleCommand(channelUID, command, apiClient);
 138
 139         try {
 140             if (CHANNEL_REFRIGERATOR_SETPOINT_TEMPERATURE.equals(channelUID.getId())
 141                     || CHANNEL_FREEZER_SETPOINT_TEMPERATURE.equals(channelUID.getId())) {
 142                 handleTemperatureCommand(channelUID, command, apiClient);
 143             } else if (command instanceof OnOffType) {
 144                 if (CHANNEL_FREEZER_SUPER_MODE.equals(channelUID.getId())) {
 145                     apiClient.setFreezerSuperMode(getThingHaId(), OnOffType.ON.equals(command));
 146                 } else if (CHANNEL_REFRIGERATOR_SUPER_MODE.equals(channelUID.getId())) {
 147                     apiClient.setFridgeSuperMode(getThingHaId(), OnOffType.ON.equals(command));
 148                 }
 149             }
 150         } catch (UnconvertibleException e) {
 151             logger.debug("Could not set setpoint! haId={}, error={}", getThingHaId(), e.getMessage());
 152         }
 153     }
 154
 155     @Override
 156     protected void updateSelectedProgramStateDescription() {
 157         // not used
 158     }
 159
 160     @Override
 161     protected void removeSelectedProgramStateDescription() {
 162         // not used
 163     }
 164
 165     @Override
 166     public String toString() {
 167         return "HomeConnectFridgeFreezerHandler [haId: " + getThingHaId() + "]";
 168     }
 169 }