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.mielecloud.internal.handler.channel;
  14
  15 import static org.openhab.binding.mielecloud.internal.webservice.api.PowerStatus.*;
  16 import static org.openhab.binding.mielecloud.internal.webservice.api.ProgramStatus.*;
  17
  18 import java.util.Arrays;
  19 import java.util.Optional;
  20
  21 import org.eclipse.jdt.annotation.NonNullByDefault;
  22 import org.openhab.binding.mielecloud.internal.webservice.api.CoolingDeviceTemperatureState;
  23 import org.openhab.binding.mielecloud.internal.webservice.api.DeviceState;
  24 import org.openhab.binding.mielecloud.internal.webservice.api.PowerStatus;
  25 import org.openhab.binding.mielecloud.internal.webservice.api.ProgramStatus;
  26 import org.openhab.binding.mielecloud.internal.webservice.api.WineStorageDeviceTemperatureState;
  27 import org.openhab.binding.mielecloud.internal.webservice.api.json.StateType;
  28 import org.openhab.core.library.types.OnOffType;
  29 import org.openhab.core.library.types.StringType;
  30 import org.openhab.core.types.State;
  31
  32 /**
  33  * Wrapper for {@link DeviceState} handling the type conversion to {@link State} for directly filling channels.
  34  *
  35  * @author Björn Lange - Initial contribution
  36  * @author Benjamin Bolte - Add pre-heat finished, plate step, door state, door alarm and info state channel and map
  37  *         signal flags from API
  38  * @author Björn Lange - Add elapsed time channel, dish warmer and robotic vacuum cleaner thing
  39  */
  40 @NonNullByDefault
  41 public final class DeviceChannelState {
  42     private final DeviceState device;
  43     private final CoolingDeviceTemperatureState coolingTemperature;
  44     private final WineStorageDeviceTemperatureState wineTemperature;
  45
  46     public DeviceChannelState(DeviceState device) {
  47         this.device = device;
  48         this.coolingTemperature = new CoolingDeviceTemperatureState(device);
  49         this.wineTemperature = new WineStorageDeviceTemperatureState(device);
  50     }
  51
  52     public State getLightSwitch() {
  53         return ChannelTypeUtil.booleanToState(device.getLightState());
  54     }
  55
  56     public State getDoorState() {
  57         return ChannelTypeUtil.booleanToState(device.getDoorState());
  58     }
  59
  60     public State getDoorAlarm() {
  61         return ChannelTypeUtil.booleanToState(device.getDoorAlarm());
  62     }
  63
  64     public State getErrorState() {
  65         return OnOffType.from(device.hasError());
  66     }
  67
  68     public State getInfoState() {
  69         return OnOffType.from(device.hasInfo());
  70     }
  71
  72     public State getPowerOnOff() {
  73         return new StringType(getPowerStatus().getState());
  74     }
  75
  76     public State getProgramElapsedTime() {
  77         return ChannelTypeUtil.intToState(device.getElapsedTime());
  78     }
  79
  80     public State getOperationState() {
  81         return ChannelTypeUtil.stringToState(device.getStatus());
  82     }
  83
  84     public State getOperationStateRaw() {
  85         return ChannelTypeUtil.intToState(device.getStatusRaw());
  86     }
  87
  88     public State getProgramPhase() {
  89         return ChannelTypeUtil.stringToState(device.getProgramPhase());
  90     }
  91
  92     public State getProgramPhaseRaw() {
  93         return ChannelTypeUtil.intToState(device.getProgramPhaseRaw());
  94     }
  95
  96     public State getProgramActive() {
  97         return ChannelTypeUtil.stringToState(device.getSelectedProgram());
  98     }
  99
 100     public State getProgramActiveRaw() {
 101         return ChannelTypeUtil.longToState(device.getSelectedProgramId());
 102     }
 103
 104     public State getProgramActiveId() {
 105         return ChannelTypeUtil.stringToState(device.getSelectedProgramId().map(Object::toString));
 106     }
 107
 108     public State getFridgeSuperCool() {
 109         return ChannelTypeUtil.booleanToState(isInState(StateType.SUPERCOOLING, StateType.SUPERCOOLING_SUPERFREEZING));
 110     }
 111
 112     public State getFreezerSuperFreeze() {
 113         return ChannelTypeUtil.booleanToState(isInState(StateType.SUPERFREEZING, StateType.SUPERCOOLING_SUPERFREEZING));
 114     }
 115
 116     public State getFridgeTemperatureTarget() {
 117         return ChannelTypeUtil.intToTemperatureState(coolingTemperature.getFridgeTargetTemperature());
 118     }
 119
 120     public State getFreezerTemperatureTarget() {
 121         return ChannelTypeUtil.intToTemperatureState(coolingTemperature.getFreezerTargetTemperature());
 122     }
 123
 124     public State getFridgeTemperatureCurrent() {
 125         return ChannelTypeUtil.intToTemperatureState(coolingTemperature.getFridgeTemperature());
 126     }
 127
 128     public State getFreezerTemperatureCurrent() {
 129         return ChannelTypeUtil.intToTemperatureState(coolingTemperature.getFreezerTemperature());
 130     }
 131
 132     public State getProgramStartStop() {
 133         return new StringType(getProgramStartStopStatus().getState());
 134     }
 135
 136     public State getProgramStartStopPause() {
 137         return new StringType(getProgramStartStopPauseStatus().getState());
 138     }
 139
 140     public State getDelayedStartTime() {
 141         return ChannelTypeUtil.intToState(device.getStartTime());
 142     }
 143
 144     public State getDryingTarget() {
 145         return ChannelTypeUtil.stringToState(device.getDryingTarget());
 146     }
 147
 148     public State getDryingTargetRaw() {
 149         return ChannelTypeUtil.intToState(device.getDryingTargetRaw());
 150     }
 151
 152     public State hasPreHeatFinished() {
 153         return ChannelTypeUtil.booleanToState(device.hasPreHeatFinished());
 154     }
 155
 156     public State getTemperatureTarget() {
 157         return ChannelTypeUtil.intToTemperatureState(device.getTargetTemperature(0));
 158     }
 159
 160     public State getVentilationPower() {
 161         return ChannelTypeUtil.stringToState(device.getVentilationStep());
 162     }
 163
 164     public State getVentilationPowerRaw() {
 165         return ChannelTypeUtil.intToState(device.getVentilationStepRaw());
 166     }
 167
 168     public State getPlateStep(int index) {
 169         return ChannelTypeUtil.stringToState(device.getPlateStep(index));
 170     }
 171
 172     public State getPlateStepRaw(int index) {
 173         return ChannelTypeUtil.intToState(device.getPlateStepRaw(index));
 174     }
 175
 176     public State getTemperatureCurrent() {
 177         return ChannelTypeUtil.intToTemperatureState(device.getTemperature(0));
 178     }
 179
 180     public State getSpinningSpeed() {
 181         return ChannelTypeUtil.stringToState(device.getSpinningSpeed());
 182     }
 183
 184     public State getSpinningSpeedRaw() {
 185         return ChannelTypeUtil.intToState(device.getSpinningSpeedRaw());
 186     }
 187
 188     public State getBatteryLevel() {
 189         return ChannelTypeUtil.intToState(device.getBatteryLevel());
 190     }
 191
 192     public State getWineTemperatureTarget() {
 193         return ChannelTypeUtil.intToState(wineTemperature.getTargetTemperature());
 194     }
 195
 196     public State getWineTemperatureCurrent() {
 197         return ChannelTypeUtil.intToTemperatureState(wineTemperature.getTemperature());
 198     }
 199
 200     public State getWineTopTemperatureTarget() {
 201         return ChannelTypeUtil.intToTemperatureState(wineTemperature.getTopTargetTemperature());
 202     }
 203
 204     public State getWineTopTemperatureCurrent() {
 205         return ChannelTypeUtil.intToTemperatureState(wineTemperature.getTopTemperature());
 206     }
 207
 208     public State getWineMiddleTemperatureTarget() {
 209         return ChannelTypeUtil.intToTemperatureState(wineTemperature.getMiddleTargetTemperature());
 210     }
 211
 212     public State getWineMiddleTemperatureCurrent() {
 213         return ChannelTypeUtil.intToTemperatureState(wineTemperature.getMiddleTemperature());
 214     }
 215
 216     public State getWineBottomTemperatureTarget() {
 217         return ChannelTypeUtil.intToTemperatureState(wineTemperature.getBottomTargetTemperature());
 218     }
 219
 220     public State getWineBottomTemperatureCurrent() {
 221         return ChannelTypeUtil.intToTemperatureState(wineTemperature.getBottomTemperature());
 222     }
 223
 224     /**
 225      * Determines the status of the currently selected program.
 226      */
 227     private PowerStatus getPowerStatus() {
 228         if (device.isInState(StateType.OFF) || device.isInState(StateType.NOT_CONNECTED)) {
 229             return POWER_OFF;
 230         } else {
 231             return POWER_ON;
 232         }
 233     }
 234
 235     /**
 236      * Determines the status of the currently selected program respecting the possibilities started and stopped.
 237      */
 238     protected ProgramStatus getProgramStartStopStatus() {
 239         if (device.isInState(StateType.RUNNING)) {
 240             return PROGRAM_STARTED;
 241         } else {
 242             return PROGRAM_STOPPED;
 243         }
 244     }
 245
 246     /**
 247      * Determines the status of the currently selected program respecting the possibilities started, stopped and paused.
 248      */
 249     protected ProgramStatus getProgramStartStopPauseStatus() {
 250         if (device.isInState(StateType.RUNNING)) {
 251             return PROGRAM_STARTED;
 252         } else if (device.isInState(StateType.PAUSE)) {
 253             return PROGRAM_PAUSED;
 254         } else {
 255             return PROGRAM_STOPPED;
 256         }
 257     }
 258
 259     /**
 260      * Gets whether the device is in one of the given states.
 261      *
 262      * @param stateType The states to check.
 263      * @return An empty {@link Optional} if the raw status is unknown, otherwise an {@link Optional} with a value
 264      *         indicating whether the device is in one of the given states.
 265      */
 266     private Optional<Boolean> isInState(StateType... stateType) {
 267         return device.getStateType().map(it -> Arrays.asList(stateType).contains(it));
 268     }
 269 }