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

   1 /**
   2  * Copyright (c) 2010-2022 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 java.lang.String.format;
  16 import static java.util.Collections.emptyList;
  17 import static org.openhab.binding.homeconnect.internal.HomeConnectBindingConstants.*;
  18
  19 import java.util.ArrayList;
  20 import java.util.List;
  21 import java.util.Map;
  22 import java.util.Optional;
  23
  24 import org.eclipse.jdt.annotation.NonNullByDefault;
  25 import org.openhab.binding.homeconnect.internal.client.HomeConnectApiClient;
  26 import org.openhab.binding.homeconnect.internal.client.exception.ApplianceOfflineException;
  27 import org.openhab.binding.homeconnect.internal.client.exception.AuthorizationException;
  28 import org.openhab.binding.homeconnect.internal.client.exception.CommunicationException;
  29 import org.openhab.binding.homeconnect.internal.client.model.AvailableProgramOption;
  30 import org.openhab.binding.homeconnect.internal.client.model.Data;
  31 import org.openhab.binding.homeconnect.internal.type.HomeConnectDynamicStateDescriptionProvider;
  32 import org.openhab.core.library.types.OnOffType;
  33 import org.openhab.core.library.types.PercentType;
  34 import org.openhab.core.library.types.StringType;
  35 import org.openhab.core.thing.ChannelUID;
  36 import org.openhab.core.thing.Thing;
  37 import org.openhab.core.types.Command;
  38 import org.openhab.core.types.StateOption;
  39 import org.openhab.core.types.UnDefType;
  40 import org.slf4j.Logger;
  41 import org.slf4j.LoggerFactory;
  42
  43 /**
  44  * The {@link HomeConnectHoodHandler} is responsible for handling commands, which are
  45  * sent to one of the channels of a hood.
  46  *
  47  * @author Jonas Brüstel - Initial contribution
  48  */
  49 @NonNullByDefault
  50 public class HomeConnectHoodHandler extends AbstractHomeConnectThingHandler {
  51
  52     private static final String START_VENTING_INTENSIVE_STAGE_PAYLOAD_TEMPLATE = "\n" + "{\n" + "    \"data\": {\n"
  53             + "        \"key\": \"Cooking.Common.Program.Hood.Venting\",\n" + "        \"options\": [\n"
  54             + "            {\n" + "                \"key\": \"Cooking.Common.Option.Hood.IntensiveLevel\",\n"
  55             + "                \"value\": \"%s\"\n" + "            }\n" + "        ]\n" + "    }\n" + "}";
  56
  57     private static final String START_VENTING_STAGE_PAYLOAD_TEMPLATE = "\n" + "{\n" + "    \"data\": {\n"
  58             + "        \"key\": \"Cooking.Common.Program.Hood.Venting\",\n" + "        \"options\": [\n"
  59             + "            {\n" + "                \"key\": \"Cooking.Common.Option.Hood.VentingLevel\",\n"
  60             + "                \"value\": \"%s\"\n" + "            }\n" + "        ]\n" + "    }\n" + "}";
  61
  62     private final Logger logger = LoggerFactory.getLogger(HomeConnectHoodHandler.class);
  63
  64     public HomeConnectHoodHandler(Thing thing,
  65             HomeConnectDynamicStateDescriptionProvider dynamicStateDescriptionProvider) {
  66         super(thing, dynamicStateDescriptionProvider);
  67     }
  68
  69     @Override
  70     protected void configureChannelUpdateHandlers(Map<String, ChannelUpdateHandler> handlers) {
  71         // register default update handlers
  72         handlers.put(CHANNEL_OPERATION_STATE, defaultOperationStateChannelUpdateHandler());
  73         handlers.put(CHANNEL_POWER_STATE, defaultPowerStateChannelUpdateHandler());
  74         handlers.put(CHANNEL_REMOTE_START_ALLOWANCE_STATE, defaultRemoteStartAllowanceChannelUpdateHandler());
  75         handlers.put(CHANNEL_REMOTE_CONTROL_ACTIVE_STATE, defaultRemoteControlActiveStateChannelUpdateHandler());
  76         handlers.put(CHANNEL_LOCAL_CONTROL_ACTIVE_STATE, defaultLocalControlActiveStateChannelUpdateHandler());
  77         handlers.put(CHANNEL_ACTIVE_PROGRAM_STATE, defaultActiveProgramStateUpdateHandler());
  78         handlers.put(CHANNEL_AMBIENT_LIGHT_STATE, defaultAmbientLightChannelUpdateHandler());
  79         handlers.put(CHANNEL_FUNCTIONAL_LIGHT_STATE,
  80                 (channelUID, cache) -> updateState(channelUID, cache.putIfAbsentAndGet(channelUID, () -> {
  81                     Optional<HomeConnectApiClient> apiClient = getApiClient();
  82                     if (apiClient.isPresent()) {
  83                         Data data = apiClient.get().getFunctionalLightState(getThingHaId());
  84                         if (data.getValue() != null) {
  85                             boolean enabled = data.getValueAsBoolean();
  86                             if (enabled) {
  87                                 Data brightnessData = apiClient.get().getFunctionalLightBrightnessState(getThingHaId());
  88                                 getLinkedChannel(CHANNEL_FUNCTIONAL_LIGHT_BRIGHTNESS_STATE)
  89                                         .ifPresent(channel -> updateState(channel.getUID(),
  90                                                 new PercentType(brightnessData.getValueAsInt())));
  91                             }
  92                             return OnOffType.from(enabled);
  93                         } else {
  94                             return UnDefType.UNDEF;
  95                         }
  96                     } else {
  97                         return UnDefType.UNDEF;
  98                     }
  99                 })));
 100     }
 101
 102     @Override
 103     protected void configureEventHandlers(Map<String, EventHandler> handlers) {
 104         // register default SSE event handlers
 105         handlers.put(EVENT_REMOTE_CONTROL_START_ALLOWED,
 106                 defaultBooleanEventHandler(CHANNEL_REMOTE_START_ALLOWANCE_STATE));
 107         handlers.put(EVENT_REMOTE_CONTROL_ACTIVE, defaultBooleanEventHandler(CHANNEL_REMOTE_CONTROL_ACTIVE_STATE));
 108         handlers.put(EVENT_LOCAL_CONTROL_ACTIVE, defaultBooleanEventHandler(CHANNEL_LOCAL_CONTROL_ACTIVE_STATE));
 109         handlers.put(EVENT_OPERATION_STATE, defaultOperationStateEventHandler());
 110         handlers.put(EVENT_ACTIVE_PROGRAM, defaultActiveProgramEventHandler());
 111         handlers.put(EVENT_POWER_STATE, defaultPowerStateEventHandler());
 112         handlers.put(EVENT_FUNCTIONAL_LIGHT_STATE, defaultBooleanEventHandler(CHANNEL_FUNCTIONAL_LIGHT_STATE));
 113         handlers.put(EVENT_FUNCTIONAL_LIGHT_BRIGHTNESS_STATE,
 114                 defaultPercentHandler(CHANNEL_FUNCTIONAL_LIGHT_BRIGHTNESS_STATE));
 115         handlers.put(EVENT_AMBIENT_LIGHT_STATE, defaultBooleanEventHandler(CHANNEL_AMBIENT_LIGHT_STATE));
 116         handlers.put(EVENT_AMBIENT_LIGHT_BRIGHTNESS_STATE,
 117                 defaultPercentHandler(CHANNEL_AMBIENT_LIGHT_BRIGHTNESS_STATE));
 118         handlers.put(EVENT_AMBIENT_LIGHT_COLOR_STATE, defaultAmbientLightColorStateEventHandler());
 119         handlers.put(EVENT_AMBIENT_LIGHT_CUSTOM_COLOR_STATE, defaultAmbientLightCustomColorStateEventHandler());
 120
 121         // register hood specific SSE event handlers
 122         handlers.put(EVENT_HOOD_INTENSIVE_LEVEL,
 123                 event -> getLinkedChannel(CHANNEL_HOOD_INTENSIVE_LEVEL).ifPresent(channel -> {
 124                     String hoodIntensiveLevel = event.getValue();
 125                     if (hoodIntensiveLevel != null) {
 126                         updateState(channel.getUID(), new StringType(mapStageStringType(hoodIntensiveLevel)));
 127                     } else {
 128                         updateState(channel.getUID(), UnDefType.UNDEF);
 129                     }
 130                 }));
 131         handlers.put(EVENT_HOOD_VENTING_LEVEL,
 132                 event -> getLinkedChannel(CHANNEL_HOOD_VENTING_LEVEL).ifPresent(channel -> {
 133                     String hoodVentingLevel = event.getValue();
 134                     if (hoodVentingLevel != null) {
 135                         updateState(channel.getUID(), new StringType(mapStageStringType(hoodVentingLevel)));
 136                     } else {
 137                         updateState(channel.getUID(), UnDefType.UNDEF);
 138                     }
 139                 }));
 140     }
 141
 142     @Override
 143     protected void handleCommand(final ChannelUID channelUID, final Command command,
 144             final HomeConnectApiClient apiClient)
 145             throws CommunicationException, AuthorizationException, ApplianceOfflineException {
 146         super.handleCommand(channelUID, command, apiClient);
 147
 148         handlePowerCommand(channelUID, command, apiClient, STATE_POWER_OFF);
 149
 150         // light commands
 151         handleLightCommands(channelUID, command, apiClient);
 152
 153         // program options
 154         if (command instanceof StringType && CHANNEL_HOOD_ACTIONS_STATE.equals(channelUID.getId())) {
 155             String operationState = getOperationState();
 156             if (OPERATION_STATE_INACTIVE.equals(operationState) || OPERATION_STATE_RUN.equals(operationState)) {
 157                 if (COMMAND_STOP.equalsIgnoreCase(command.toFullString())) {
 158                     apiClient.stopProgram(getThingHaId());
 159                 }
 160             } else {
 161                 logger.debug("Device can not handle command {} in current operation state ({}). thing={}, haId={}",
 162                         command, operationState, getThingLabel(), getThingHaId());
 163             }
 164
 165             // These command always start the hood - even if appliance is turned off
 166             if (COMMAND_AUTOMATIC.equalsIgnoreCase(command.toFullString())) {
 167                 apiClient.startProgram(getThingHaId(), PROGRAM_HOOD_AUTOMATIC);
 168             } else if (COMMAND_DELAYED_SHUT_OFF.equalsIgnoreCase(command.toFullString())) {
 169                 apiClient.startProgram(getThingHaId(), PROGRAM_HOOD_DELAYED_SHUT_OFF);
 170             } else if (COMMAND_VENTING_1.equalsIgnoreCase(command.toFullString())) {
 171                 apiClient.startCustomProgram(getThingHaId(),
 172                         format(START_VENTING_STAGE_PAYLOAD_TEMPLATE, STAGE_FAN_STAGE_01));
 173             } else if (COMMAND_VENTING_2.equalsIgnoreCase(command.toFullString())) {
 174                 apiClient.startCustomProgram(getThingHaId(),
 175                         format(START_VENTING_STAGE_PAYLOAD_TEMPLATE, STAGE_FAN_STAGE_02));
 176             } else if (COMMAND_VENTING_3.equalsIgnoreCase(command.toFullString())) {
 177                 apiClient.startCustomProgram(getThingHaId(),
 178                         format(START_VENTING_STAGE_PAYLOAD_TEMPLATE, STAGE_FAN_STAGE_03));
 179             } else if (COMMAND_VENTING_4.equalsIgnoreCase(command.toFullString())) {
 180                 apiClient.startCustomProgram(getThingHaId(),
 181                         format(START_VENTING_STAGE_PAYLOAD_TEMPLATE, STAGE_FAN_STAGE_04));
 182             } else if (COMMAND_VENTING_5.equalsIgnoreCase(command.toFullString())) {
 183                 apiClient.startCustomProgram(getThingHaId(),
 184                         format(START_VENTING_STAGE_PAYLOAD_TEMPLATE, STAGE_FAN_STAGE_05));
 185             } else if (COMMAND_VENTING_INTENSIVE_1.equalsIgnoreCase(command.toFullString())) {
 186                 apiClient.startCustomProgram(getThingHaId(),
 187                         format(START_VENTING_INTENSIVE_STAGE_PAYLOAD_TEMPLATE, STAGE_INTENSIVE_STAGE_1));
 188             } else if (COMMAND_VENTING_INTENSIVE_2.equalsIgnoreCase(command.toFullString())) {
 189                 apiClient.startCustomProgram(getThingHaId(),
 190                         format(START_VENTING_INTENSIVE_STAGE_PAYLOAD_TEMPLATE, STAGE_INTENSIVE_STAGE_2));
 191             } else {
 192                 logger.info("Start custom program. command={} haId={}", command.toFullString(), getThingHaId());
 193                 apiClient.startCustomProgram(getThingHaId(), command.toFullString());
 194             }
 195         }
 196     }
 197
 198     @Override
 199     protected void updateSelectedProgramStateDescription() {
 200         // update hood program actions
 201         if (isBridgeOffline() || !isThingAccessibleViaServerSentEvents()) {
 202             return;
 203         }
 204
 205         Optional<HomeConnectApiClient> apiClient = getApiClient();
 206         if (apiClient.isPresent()) {
 207             try {
 208                 ArrayList<StateOption> stateOptions = new ArrayList<>();
 209                 getPrograms().forEach(availableProgram -> {
 210                     if (PROGRAM_HOOD_AUTOMATIC.equals(availableProgram.getKey())) {
 211                         stateOptions.add(new StateOption(COMMAND_AUTOMATIC, mapStringType(availableProgram.getKey())));
 212                     } else if (PROGRAM_HOOD_DELAYED_SHUT_OFF.equals(availableProgram.getKey())) {
 213                         stateOptions.add(
 214                                 new StateOption(COMMAND_DELAYED_SHUT_OFF, mapStringType(availableProgram.getKey())));
 215                     } else if (PROGRAM_HOOD_VENTING.equals(availableProgram.getKey())) {
 216                         try {
 217                             List<AvailableProgramOption> availableProgramOptions = apiClient.get()
 218                                     .getProgramOptions(getThingHaId(), PROGRAM_HOOD_VENTING);
 219                             if (availableProgramOptions == null || availableProgramOptions.isEmpty()) {
 220                                 throw new CommunicationException("Program " + PROGRAM_HOOD_VENTING + " is unsupported");
 221                             }
 222                             availableProgramOptions.forEach(option -> {
 223                                 if (OPTION_HOOD_VENTING_LEVEL.equalsIgnoreCase(option.getKey())) {
 224                                     option.getAllowedValues().stream().filter(s -> !STAGE_FAN_OFF.equalsIgnoreCase(s))
 225                                             .forEach(s -> stateOptions.add(createVentingStateOption(s)));
 226                                 } else if (OPTION_HOOD_INTENSIVE_LEVEL.equalsIgnoreCase(option.getKey())) {
 227                                     option.getAllowedValues().stream()
 228                                             .filter(s -> !STAGE_INTENSIVE_STAGE_OFF.equalsIgnoreCase(s))
 229                                             .forEach(s -> stateOptions.add(createVentingStateOption(s)));
 230                                 }
 231                             });
 232                         } catch (CommunicationException | ApplianceOfflineException | AuthorizationException e) {
 233                             logger.warn("Could not fetch hood program options. error={}", e.getMessage());
 234                             stateOptions.add(createVentingStateOption(STAGE_FAN_STAGE_01));
 235                             stateOptions.add(createVentingStateOption(STAGE_FAN_STAGE_02));
 236                             stateOptions.add(createVentingStateOption(STAGE_FAN_STAGE_03));
 237                             stateOptions.add(createVentingStateOption(STAGE_FAN_STAGE_04));
 238                             stateOptions.add(createVentingStateOption(STAGE_FAN_STAGE_05));
 239                             stateOptions.add(createVentingStateOption(STAGE_INTENSIVE_STAGE_1));
 240                             stateOptions.add(createVentingStateOption(STAGE_INTENSIVE_STAGE_2));
 241                         }
 242                     }
 243                 });
 244                 stateOptions.add(new StateOption(COMMAND_STOP, "Stop"));
 245
 246                 getThingChannel(CHANNEL_HOOD_ACTIONS_STATE).ifPresent(channel -> getDynamicStateDescriptionProvider()
 247                         .setStateOptions(channel.getUID(), stateOptions));
 248             } catch (CommunicationException | ApplianceOfflineException | AuthorizationException e) {
 249                 logger.debug("Could not fetch available programs. thing={}, haId={}, error={}", getThingLabel(),
 250                         getThingHaId(), e.getMessage());
 251                 removeSelectedProgramStateDescription();
 252             }
 253         } else {
 254             removeSelectedProgramStateDescription();
 255         }
 256     }
 257
 258     @Override
 259     protected void removeSelectedProgramStateDescription() {
 260         getThingChannel(CHANNEL_HOOD_ACTIONS_STATE).ifPresent(
 261                 channel -> getDynamicStateDescriptionProvider().setStateOptions(channel.getUID(), emptyList()));
 262     }
 263
 264     @Override
 265     public String toString() {
 266         return "HomeConnectHoodHandler [haId: " + getThingHaId() + "]";
 267     }
 268
 269     @Override
 270     protected void resetProgramStateChannels(boolean offline) {
 271         super.resetProgramStateChannels(offline);
 272         getLinkedChannel(CHANNEL_ACTIVE_PROGRAM_STATE).ifPresent(c -> updateState(c.getUID(), UnDefType.UNDEF));
 273         getLinkedChannel(CHANNEL_HOOD_INTENSIVE_LEVEL).ifPresent(c -> updateState(c.getUID(), UnDefType.UNDEF));
 274         getLinkedChannel(CHANNEL_HOOD_VENTING_LEVEL).ifPresent(c -> updateState(c.getUID(), UnDefType.UNDEF));
 275     }
 276
 277     private StateOption createVentingStateOption(String optionKey) {
 278         String label = mapStringType(PROGRAM_HOOD_VENTING);
 279
 280         if (STAGE_FAN_STAGE_01.equalsIgnoreCase(optionKey)) {
 281             return new StateOption(COMMAND_VENTING_1,
 282                     format("%s (Level %s)", label, mapStageStringType(STAGE_FAN_STAGE_01)));
 283         } else if (STAGE_FAN_STAGE_02.equalsIgnoreCase(optionKey)) {
 284             return new StateOption(COMMAND_VENTING_2,
 285                     format("%s (Level %s)", label, mapStageStringType(STAGE_FAN_STAGE_02)));
 286         } else if (STAGE_FAN_STAGE_03.equalsIgnoreCase(optionKey)) {
 287             return new StateOption(COMMAND_VENTING_3,
 288                     format("%s (Level %s)", label, mapStageStringType(STAGE_FAN_STAGE_03)));
 289         } else if (STAGE_FAN_STAGE_04.equalsIgnoreCase(optionKey)) {
 290             return new StateOption(COMMAND_VENTING_4,
 291                     format("%s (Level %s)", label, mapStageStringType(STAGE_FAN_STAGE_04)));
 292         } else if (STAGE_FAN_STAGE_05.equalsIgnoreCase(optionKey)) {
 293             return new StateOption(COMMAND_VENTING_5,
 294                     format("%s (Level %s)", label, mapStageStringType(STAGE_FAN_STAGE_05)));
 295         } else if (STAGE_INTENSIVE_STAGE_1.equalsIgnoreCase(optionKey)) {
 296             return new StateOption(COMMAND_VENTING_INTENSIVE_1,
 297                     format("%s (Intensive level %s)", label, mapStageStringType(STAGE_INTENSIVE_STAGE_1)));
 298         } else {
 299             return new StateOption(COMMAND_VENTING_INTENSIVE_2,
 300                     format("%s (Intensive level %s)", label, mapStageStringType(STAGE_INTENSIVE_STAGE_2)));
 301         }
 302     }
 303 }