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.mqtt.homeassistant.internal.component;
  14
  15 import java.math.BigDecimal;
  16 import java.math.MathContext;
  17 import java.util.List;
  18 import java.util.Objects;
  19
  20 import org.eclipse.jdt.annotation.NonNullByDefault;
  21 import org.eclipse.jdt.annotation.Nullable;
  22 import org.openhab.binding.mqtt.generic.ChannelStateUpdateListener;
  23 import org.openhab.binding.mqtt.generic.values.TextValue;
  24 import org.openhab.binding.mqtt.homeassistant.internal.exception.UnsupportedComponentException;
  25 import org.openhab.core.library.types.DecimalType;
  26 import org.openhab.core.library.types.HSBType;
  27 import org.openhab.core.library.types.OnOffType;
  28 import org.openhab.core.library.types.PercentType;
  29 import org.openhab.core.library.types.QuantityType;
  30 import org.openhab.core.library.types.StringType;
  31 import org.openhab.core.library.unit.Units;
  32 import org.openhab.core.thing.ChannelUID;
  33 import org.openhab.core.types.Command;
  34 import org.openhab.core.types.State;
  35 import org.openhab.core.types.UnDefType;
  36 import org.slf4j.Logger;
  37 import org.slf4j.LoggerFactory;
  38
  39 import com.google.gson.JsonSyntaxException;
  40 import com.google.gson.annotations.SerializedName;
  41
  42 /**
  43  * A MQTT light, following the https://www.home-assistant.io/components/light.mqtt/ specification.
  44  *
  45  * Specifically, the JSON schema. All channels are synthetic, and wrap the single internal raw
  46  * state.
  47  *
  48  * @author Cody Cutrer - Initial contribution
  49  */
  50 @NonNullByDefault
  51 public class JSONSchemaLight extends AbstractRawSchemaLight {
  52     private static final BigDecimal SCALE_FACTOR = new BigDecimal("2.55"); // string to not lose precision
  53     private static final BigDecimal BIG_DECIMAL_HUNDRED = new BigDecimal(100);
  54
  55     private final Logger logger = LoggerFactory.getLogger(JSONSchemaLight.class);
  56
  57     private static class JSONState {
  58         protected static class Color {
  59             protected @Nullable Integer r, g, b, c, w;
  60             protected @Nullable BigDecimal x, y, h, s;
  61         }
  62
  63         protected @Nullable String state;
  64         protected @Nullable Integer brightness;
  65         @SerializedName("color_mode")
  66         protected @Nullable LightColorMode colorMode;
  67         @SerializedName("color_temp")
  68         protected @Nullable Integer colorTemp;
  69         protected @Nullable Color color;
  70         protected @Nullable String effect;
  71         protected @Nullable Integer transition;
  72     }
  73
  74     TextValue colorModeValue;
  75
  76     public JSONSchemaLight(ComponentFactory.ComponentConfiguration builder) {
  77         super(builder);
  78         colorModeValue = new TextValue();
  79     }
  80
  81     @Override
  82     protected void buildChannels() {
  83         List<LightColorMode> supportedColorModes = channelConfiguration.supportedColorModes;
  84         if (supportedColorModes != null && supportedColorModes.contains(LightColorMode.COLOR_MODE_COLOR_TEMP)) {
  85             colorModeValue = new TextValue(
  86                     supportedColorModes.stream().map(LightColorMode::serializedName).toArray(String[]::new));
  87             buildChannel(COLOR_MODE_CHANNEL_ID, colorModeValue, "Color Mode", this).isAdvanced(true).build();
  88         }
  89
  90         if (channelConfiguration.colorMode) {
  91             if (supportedColorModes == null || channelConfiguration.supportedColorModes.isEmpty()) {
  92                 throw new UnsupportedComponentException("JSON schema light with color modes '" + getHaID()
  93                         + "' does not define supported_color_modes!");
  94             }
  95
  96             if (LightColorMode.hasColorChannel(supportedColorModes)) {
  97                 hasColorChannel = true;
  98             }
  99
 100             if (supportedColorModes.contains(LightColorMode.COLOR_MODE_COLOR_TEMP)) {
 101                 buildChannel(COLOR_TEMP_CHANNEL_ID, colorTempValue, "Color Temperature", this)
 102                         .commandTopic(DUMMY_TOPIC, true, 1).commandFilter(command -> handleColorTempCommand(command))
 103                         .build();
 104             }
 105         }
 106
 107         if (hasColorChannel) {
 108             buildChannel(COLOR_CHANNEL_ID, colorValue, "Color", this).commandTopic(DUMMY_TOPIC, true, 1)
 109                     .commandFilter(this::handleCommand).build();
 110         } else if (channelConfiguration.brightness) {
 111             brightnessChannel = buildChannel(BRIGHTNESS_CHANNEL_ID, brightnessValue, "Brightness", this)
 112                     .commandTopic(DUMMY_TOPIC, true, 1).commandFilter(this::handleCommand).build();
 113         } else {
 114             onOffChannel = buildChannel(ON_OFF_CHANNEL_ID, onOffValue, "On/Off State", this)
 115                     .commandTopic(DUMMY_TOPIC, true, 1).commandFilter(this::handleCommand).build();
 116         }
 117
 118         if (effectValue != null) {
 119             buildChannel(EFFECT_CHANNEL_ID, Objects.requireNonNull(effectValue), "Lighting Effect", this)
 120                     .commandTopic(DUMMY_TOPIC, true, 1).commandFilter(command -> handleEffectCommand(command)).build();
 121
 122         }
 123     }
 124
 125     private boolean handleEffectCommand(Command command) {
 126         if (command instanceof StringType) {
 127             JSONState json = new JSONState();
 128             json.state = "ON";
 129             json.effect = command.toString();
 130             publishState(json);
 131         }
 132         return false;
 133     }
 134
 135     @Override
 136     protected void publishState(HSBType state) {
 137         JSONState json = new JSONState();
 138
 139         logger.trace("Publishing new state {} of light {} to MQTT.", state, getName());
 140         if (state.getBrightness().equals(PercentType.ZERO)) {
 141             json.state = "OFF";
 142         } else {
 143             json.state = "ON";
 144             if (channelConfiguration.brightness || (channelConfiguration.supportedColorModes != null
 145                     && (channelConfiguration.supportedColorModes.contains(LightColorMode.COLOR_MODE_HS)
 146                             || channelConfiguration.supportedColorModes.contains(LightColorMode.COLOR_MODE_XY)))) {
 147                 json.brightness = state.getBrightness().toBigDecimal()
 148                         .multiply(new BigDecimal(channelConfiguration.brightnessScale))
 149                         .divide(new BigDecimal(100), MathContext.DECIMAL128).intValue();
 150             }
 151
 152             if (hasColorChannel) {
 153                 json.color = new JSONState.Color();
 154                 if (channelConfiguration.supportedColorModes.contains(LightColorMode.COLOR_MODE_HS)) {
 155                     json.color.h = state.getHue().toBigDecimal();
 156                     json.color.s = state.getSaturation().toBigDecimal().divide(BIG_DECIMAL_HUNDRED);
 157                 } else if (LightColorMode.hasRGB(Objects.requireNonNull(channelConfiguration.supportedColorModes))) {
 158                     var rgb = state.toRGB();
 159                     json.color.r = rgb[0].toBigDecimal().multiply(SCALE_FACTOR).intValue();
 160                     json.color.g = rgb[1].toBigDecimal().multiply(SCALE_FACTOR).intValue();
 161                     json.color.b = rgb[2].toBigDecimal().multiply(SCALE_FACTOR).intValue();
 162                 } else { // if (channelConfiguration.supportedColorModes.contains(COLOR_MODE_XY))
 163                     var xy = state.toXY();
 164                     json.color.x = xy[0].toBigDecimal().divide(BIG_DECIMAL_HUNDRED);
 165                     json.color.y = xy[1].toBigDecimal().divide(BIG_DECIMAL_HUNDRED);
 166                 }
 167             }
 168         }
 169
 170         publishState(json);
 171     }
 172
 173     private void publishState(JSONState json) {
 174         String command = getGson().toJson(json);
 175         logger.debug("Publishing new state '{}' of light {} to MQTT.", command, getName());
 176         rawChannel.getState().publishValue(new StringType(command));
 177     }
 178
 179     @Override
 180     protected boolean handleCommand(Command command) {
 181         JSONState json = new JSONState();
 182         if (command.getClass().equals(OnOffType.class)) {
 183             json.state = command.toString();
 184         } else if (command.getClass().equals(PercentType.class)) {
 185             if (command.equals(PercentType.ZERO)) {
 186                 json.state = "OFF";
 187             } else {
 188                 json.state = "ON";
 189                 if (channelConfiguration.brightness) {
 190                     json.brightness = ((PercentType) command).toBigDecimal()
 191                             .multiply(new BigDecimal(channelConfiguration.brightnessScale))
 192                             .divide(new BigDecimal(100), MathContext.DECIMAL128).intValue();
 193                 }
 194             }
 195         } else {
 196             return super.handleCommand(command);
 197         }
 198
 199         String jsonCommand = getGson().toJson(json);
 200         logger.debug("Publishing new state '{}' of light {} to MQTT.", jsonCommand, getName());
 201         rawChannel.getState().publishValue(new StringType(jsonCommand));
 202         return false;
 203     }
 204
 205     private boolean handleColorTempCommand(Command command) {
 206         JSONState json = new JSONState();
 207
 208         if (command instanceof DecimalType) {
 209             command = new QuantityType<>(((DecimalType) command).toBigDecimal(), Units.MIRED);
 210         }
 211         if (command instanceof QuantityType) {
 212             QuantityType<?> mireds = ((QuantityType<?>) command).toInvertibleUnit(Units.MIRED);
 213             if (mireds == null) {
 214                 logger.warn("Unable to convert {} to mireds", command);
 215                 return false;
 216             }
 217             json.state = "ON";
 218             json.colorTemp = mireds.toBigDecimal().intValue();
 219         } else {
 220             return false;
 221         }
 222
 223         String jsonCommand = getGson().toJson(json);
 224         logger.debug("Publishing new state '{}' of light {} to MQTT.", jsonCommand, getName());
 225         rawChannel.getState().publishValue(new StringType(jsonCommand));
 226         return false;
 227     }
 228
 229     @Override
 230     public void updateChannelState(ChannelUID channel, State state) {
 231         ChannelStateUpdateListener listener = this.channelStateUpdateListener;
 232
 233         @Nullable
 234         JSONState jsonState;
 235         try {
 236             jsonState = getGson().fromJson(state.toString(), JSONState.class);
 237
 238             if (jsonState == null) {
 239                 logger.warn("JSON light state for '{}' is empty.", getHaID());
 240                 return;
 241             }
 242         } catch (JsonSyntaxException e) {
 243             logger.warn("Cannot parse JSON light state '{}' for '{}'.", state, getHaID());
 244             return;
 245         }
 246
 247         if (effectValue != null) {
 248             if (jsonState.effect != null) {
 249                 effectValue.update(new StringType(jsonState.effect));
 250                 listener.updateChannelState(buildChannelUID(EFFECT_CHANNEL_ID), effectValue.getChannelState());
 251             } else {
 252                 listener.updateChannelState(buildChannelUID(EFFECT_CHANNEL_ID), UnDefType.NULL);
 253             }
 254         }
 255
 256         boolean off = false;
 257         if (jsonState.state != null) {
 258             onOffValue.update(onOffValue.parseCommand(new StringType(jsonState.state)));
 259             off = onOffValue.getChannelState().equals(OnOffType.OFF);
 260             if (brightnessValue.getChannelState() instanceof UnDefType) {
 261                 brightnessValue.update(off ? PercentType.ZERO : PercentType.HUNDRED);
 262             }
 263             if (colorValue.getChannelState() instanceof UnDefType) {
 264                 colorValue.update(off ? HSBType.BLACK : HSBType.WHITE);
 265             }
 266         }
 267
 268         PercentType brightness;
 269         if (off) {
 270             brightness = PercentType.ZERO;
 271         } else if (brightnessValue.getChannelState() instanceof PercentType percentValue) {
 272             brightness = percentValue;
 273         } else {
 274             brightness = PercentType.HUNDRED;
 275         }
 276
 277         if (jsonState.brightness != null) {
 278             if (!off) {
 279                 brightness = (PercentType) brightnessValue
 280                         .parseMessage(new DecimalType(Objects.requireNonNull(jsonState.brightness)));
 281             }
 282             brightnessValue.update(brightness);
 283             if (colorValue.getChannelState() instanceof HSBType) {
 284                 HSBType color = (HSBType) colorValue.getChannelState();
 285                 colorValue.update(new HSBType(color.getHue(), color.getSaturation(), brightness));
 286             } else {
 287                 colorValue.update(new HSBType(DecimalType.ZERO, PercentType.ZERO, brightness));
 288             }
 289         }
 290
 291         if (jsonState.colorTemp != null) {
 292             colorTempValue.update(new QuantityType(Objects.requireNonNull(jsonState.colorTemp), Units.MIRED));
 293             listener.updateChannelState(buildChannelUID(COLOR_TEMP_CHANNEL_ID), colorTempValue.getChannelState());
 294
 295             colorModeValue.update(new StringType(LightColorMode.COLOR_MODE_COLOR_TEMP.serializedName()));
 296         }
 297
 298         if (jsonState.color != null) {
 299             // This corresponds to "deprecated" color mode handling, since we're not checking which color
 300             // mode is currently active.
 301             // HS is highest priority, then XY, then RGB
 302             // See
 303             // https://github.com/home-assistant/core/blob/4f965f0eca09f0d12ae1c98c6786054063a36b44/homeassistant/components/mqtt/light/schema_json.py#L258
 304             if (jsonState.color.h != null && jsonState.color.s != null) {
 305                 colorValue.update(new HSBType(new DecimalType(Objects.requireNonNull(jsonState.color.h)),
 306                         new PercentType(Objects.requireNonNull(jsonState.color.s)), brightness));
 307                 colorModeValue.update(new StringType(LightColorMode.COLOR_MODE_HS.serializedName()));
 308             } else if (jsonState.color.x != null && jsonState.color.y != null) {
 309                 HSBType newColor = HSBType.fromXY(jsonState.color.x.floatValue(), jsonState.color.y.floatValue());
 310                 colorValue.update(new HSBType(newColor.getHue(), newColor.getSaturation(), brightness));
 311                 colorModeValue.update(new StringType(LightColorMode.COLOR_MODE_XY.serializedName()));
 312             } else if (jsonState.color.r != null && jsonState.color.g != null && jsonState.color.b != null) {
 313                 colorValue.update(HSBType.fromRGB(jsonState.color.r, jsonState.color.g, jsonState.color.b));
 314                 colorModeValue.update(new StringType(LightColorMode.COLOR_MODE_RGB.serializedName()));
 315             }
 316         }
 317
 318         if (jsonState.colorMode != null) {
 319             colorModeValue.update(new StringType(jsonState.colorMode.serializedName()));
 320         }
 321
 322         listener.updateChannelState(buildChannelUID(COLOR_MODE_CHANNEL_ID), colorModeValue.getChannelState());
 323
 324         if (hasColorChannel) {
 325             listener.updateChannelState(buildChannelUID(COLOR_CHANNEL_ID), colorValue.getChannelState());
 326         } else if (brightnessChannel != null) {
 327             listener.updateChannelState(buildChannelUID(BRIGHTNESS_CHANNEL_ID), brightnessValue.getChannelState());
 328         } else {
 329             listener.updateChannelState(buildChannelUID(ON_OFF_CHANNEL_ID), onOffValue.getChannelState());
 330         }
 331     }
 332 }