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.yeelight.internal.lib.device;
  14
  15 import java.util.ArrayList;
  16 import java.util.List;
  17 import java.util.Map;
  18 import java.util.Map.Entry;
  19
  20 import org.openhab.binding.yeelight.internal.lib.device.connection.ConnectionBase;
  21 import org.openhab.binding.yeelight.internal.lib.enums.ActiveMode;
  22 import org.openhab.binding.yeelight.internal.lib.enums.DeviceMode;
  23 import org.openhab.binding.yeelight.internal.lib.enums.DeviceType;
  24 import org.openhab.binding.yeelight.internal.lib.enums.MethodAction;
  25 import org.openhab.binding.yeelight.internal.lib.listeners.DeviceConnectionStateListener;
  26 import org.openhab.binding.yeelight.internal.lib.listeners.DeviceStatusChangeListener;
  27 import org.slf4j.Logger;
  28 import org.slf4j.LoggerFactory;
  29
  30 import com.google.gson.JsonArray;
  31 import com.google.gson.JsonElement;
  32 import com.google.gson.JsonObject;
  33 import com.google.gson.JsonParser;
  34
  35 /**
  36  * The {@link DeviceBase} is a generic class for all devices.
  37  *
  38  * @author Coaster Li - Initial contribution
  39  * @author Daniel Walters - Correct handling of brightness
  40  * @author Joe Ho - Added duration to some commands
  41  */
  42 public abstract class DeviceBase {
  43     private final Logger logger = LoggerFactory.getLogger(DeviceBase.class);
  44
  45     private static final String TAG = DeviceBase.class.getSimpleName();
  46
  47     protected String mDeviceId;
  48     protected String mDeviceName;
  49     protected DeviceType mDeviceType;
  50     protected String mAddress;
  51     private String[] mSupportProps;
  52     protected int mPort;
  53     private int mFwVersion;
  54     protected boolean bIsOnline;
  55     protected boolean bIsAutoConnect;
  56     protected ConnectionBase mConnection;
  57     protected ConnectState mConnectState = ConnectState.DISCONNECTED;
  58     protected DeviceStatus mDeviceStatus;
  59     private Map<String, Object> mBulbInfo = null;
  60     protected List<String> mQueryList = new ArrayList<>();
  61
  62     protected int mMinCt, mMaxCt;
  63
  64     List<DeviceConnectionStateListener> mConnectionListeners = new ArrayList<>();
  65     List<DeviceStatusChangeListener> mStatusChangeListeners = new ArrayList<>();
  66
  67     public DeviceBase(String id) {
  68         mDeviceId = id;
  69         mDeviceStatus = new DeviceStatus();
  70     }
  71
  72     public DeviceBase(String id, boolean isAutoConnect) {
  73         mDeviceId = id;
  74         this.bIsAutoConnect = isAutoConnect;
  75     }
  76
  77     public void onNotify(String response) {
  78         boolean needNotify = true;
  79         JsonObject message = JsonParser.parseString(response).getAsJsonObject();
  80         try {
  81             if (message.has("method")) {
  82                 String method = message.get("method").toString().replace("\"", "");
  83                 if (method.equals("props")) {// Property notify
  84                     String params = message.get("params").toString();
  85                     JsonObject propsObject = JsonParser.parseString(params).getAsJsonObject();
  86                     for (Entry<String, JsonElement> prop : propsObject.entrySet()) {
  87                         final YeelightDeviceProperty property = YeelightDeviceProperty.fromString(prop.getKey());
  88                         if (null == property) {
  89                             logger.debug("Unhandled property: {}", prop.getKey());
  90                             continue;
  91                         }
  92
  93                         switch (property) {
  94                             case POWER:
  95                                 if (prop.getValue().toString().equals("\"off\"")) {
  96                                     mDeviceStatus.setPowerOff(true);
  97                                 } else if (prop.getValue().toString().equals("\"on\"")) {
  98                                     mDeviceStatus.setPowerOff(false);
  99                                 }
 100                                 break;
 101                             case BRIGHT:
 102                                 mDeviceStatus.setBrightness(prop.getValue().getAsInt());
 103                                 break;
 104                             case CT:
 105                                 mDeviceStatus.setCt(prop.getValue().getAsInt());
 106                                 mDeviceStatus.setMode(DeviceMode.MODE_SUNHINE);
 107                                 break;
 108                             case RGB: {
 109                                 mDeviceStatus.setMode(DeviceMode.MODE_COLOR);
 110                                 int color = prop.getValue().getAsInt();
 111                                 mDeviceStatus.setColor(color);
 112
 113                                 mDeviceStatus.setR((color >> 16) & 0xFF);
 114                                 mDeviceStatus.setG((color >> 8) & 0xFF);
 115                                 mDeviceStatus.setB(color & 0xFF);
 116                                 break;
 117                             }
 118                             case HUE:
 119                                 mDeviceStatus.setMode(DeviceMode.MODE_HSV);
 120                                 mDeviceStatus.setHue(prop.getValue().getAsInt());
 121                                 break;
 122                             case SAT:
 123                                 mDeviceStatus.setMode(DeviceMode.MODE_HSV);
 124                                 mDeviceStatus.setSat(prop.getValue().getAsInt());
 125                                 break;
 126                             case COLOR_MODE:
 127                                 switch (prop.getValue().getAsInt()) {
 128                                     case DeviceStatus.MODE_COLOR:
 129                                         mDeviceStatus.setMode(DeviceMode.MODE_COLOR);
 130                                         break;
 131                                     case DeviceStatus.MODE_COLORTEMPERATURE:
 132                                         mDeviceStatus.setMode(DeviceMode.MODE_SUNHINE);
 133                                         break;
 134                                     case DeviceStatus.MODE_HSV:
 135                                         mDeviceStatus.setMode(DeviceMode.MODE_HSV);
 136                                         break;
 137                                     default:
 138                                         break;
 139                                 }
 140                                 break;
 141                             case FLOWING:
 142                                 mDeviceStatus.setIsFlowing(prop.getValue().getAsInt() == 1);
 143                                 break;
 144                             case FLOW_PARAMS:
 145                                 // {"method":"props","params":{"flow_params":"0,0,1000,1,15935488,31,1000,1,13366016,31,1000,1,62370,31,1000,1,7995635,31"}}
 146                                 String[] flowStrs = prop.getValue().toString().replace("\"", "").split(",");
 147                                 if (flowStrs.length > 2 && (flowStrs.length - 2) % 4 == 0) {
 148                                     mDeviceStatus.setFlowCount(Integer.parseInt(flowStrs[0]));
 149                                     mDeviceStatus.setFlowEndAction(Integer.parseInt(flowStrs[1]));
 150                                     if (mDeviceStatus.getFlowItems() == null) {
 151                                         mDeviceStatus.setFlowItems(new ArrayList<>());
 152                                     }
 153                                     mDeviceStatus.getFlowItems().clear();
 154                                     for (int i = 0; i < ((flowStrs.length - 2) / 4); i++) {
 155                                         ColorFlowItem item = new ColorFlowItem();
 156                                         item.duration = Integer.valueOf(flowStrs[4 * i + 2]);
 157                                         item.mode = Integer.valueOf(flowStrs[4 * i + 3]);
 158                                         item.value = Integer.valueOf(flowStrs[4 * i + 4]);
 159                                         item.brightness = Integer.valueOf(flowStrs[4 * i + 5]);
 160                                         mDeviceStatus.getFlowItems().add(item);
 161                                     }
 162                                 }
 163                                 break;
 164                             case DELAYOFF:
 165                                 int delayOff = prop.getValue().getAsInt();
 166                                 if (delayOff > 0 && delayOff <= 60) {
 167                                     mDeviceStatus.setDelayOff(delayOff);
 168                                 } else {
 169                                     mDeviceStatus.setDelayOff(DeviceStatus.DEFAULT_NO_DELAY);
 170                                 }
 171                                 break;
 172                             case MUSIC_ON:
 173                                 mDeviceStatus.setMusicOn(prop.getValue().getAsInt() == 1);
 174                                 break;
 175                             case NAME:
 176                                 mDeviceName = prop.getValue().toString();
 177                                 break;
 178                             case BG_RGB: {
 179                                 int color = prop.getValue().getAsInt();
 180                                 mDeviceStatus.setBackgroundR((color >> 16) & 0xFF);
 181                                 mDeviceStatus.setBackgroundG((color >> 8) & 0xFF);
 182                                 mDeviceStatus.setBackgroundB(color & 0xFF);
 183                                 break;
 184                             }
 185                             case BG_HUE:
 186                                 mDeviceStatus.setBackgroundHue(prop.getValue().getAsInt());
 187
 188                                 break;
 189                             case BG_SAT:
 190                                 mDeviceStatus.setBackgroundSat(prop.getValue().getAsInt());
 191                                 break;
 192                             case BG_BRIGHT:
 193                                 mDeviceStatus.setBackgroundBrightness(prop.getValue().getAsInt());
 194                                 break;
 195                             case BG_POWER:
 196                                 if ("\"off\"".equals(prop.getValue().toString())) {
 197                                     mDeviceStatus.setBackgroundIsPowerOff(true);
 198                                 } else if ("\"on\"".equals(prop.getValue().toString())) {
 199                                     mDeviceStatus.setBackgroundIsPowerOff(false);
 200                                 }
 201                                 break;
 202                             case NL_BR:
 203                                 // when the light is switched from nightlight-mode to sunlight-mode it will send nl_br:0
 204                                 // therefore we have to ignore the case.
 205                                 final int intValue = prop.getValue().getAsInt();
 206                                 if (intValue > 0) {
 207                                     mDeviceStatus.setBrightness(intValue);
 208                                 }
 209                                 break;
 210                             case ACTIVE_MODE:
 211                                 int activeModeInt = prop.getValue().getAsInt();
 212                                 final ActiveMode activeMode = ActiveMode.values()[activeModeInt];
 213                                 mDeviceStatus.setActiveMode(activeMode);
 214                                 break;
 215                             default:
 216                                 logger.debug("Maybe unsupported property: {} - {}", property, prop.getKey());
 217                                 break;
 218                         }
 219                     }
 220                 }
 221
 222             } else if (message.has("id") && message.has("result")) {
 223                 // no method, but result : ["ok"]
 224                 JsonArray result = message.get("result").getAsJsonArray();
 225                 if (result.get(0).toString().equals("\"ok\"")) {
 226                     logger.info("######### this is control command response, don't need to notify status change!");
 227                     needNotify = false;
 228                 }
 229             }
 230
 231             if (needNotify) {
 232                 logger.info("status = {}", mDeviceStatus);
 233                 for (DeviceStatusChangeListener statusChangeListener : mStatusChangeListeners) {
 234                     statusChangeListener.onStatusChanged(mDeviceStatus);
 235                 }
 236             }
 237         } catch (Exception e) {
 238             logger.debug("Exception", e);
 239         }
 240     }
 241
 242     public void open(int duration) {
 243         mConnection.invoke(
 244                 new DeviceMethod(MethodAction.SWITCH, new Object[] { "on", DeviceMethod.EFFECT_SMOOTH, duration }));
 245     }
 246
 247     public void close(int duration) {
 248         mConnection.invoke(
 249                 new DeviceMethod(MethodAction.SWITCH, new Object[] { "off", DeviceMethod.EFFECT_SMOOTH, duration }));
 250     }
 251
 252     public void decreaseBrightness(int duration) {
 253         int bright = getDeviceStatus().getBrightness() - 10;
 254         if (bright <= 0) {
 255             close(duration);
 256         } else {
 257             setBrightness(bright, duration);
 258         }
 259     }
 260
 261     public void increaseBrightness(int duration) {
 262         int bright = getDeviceStatus().getBrightness() + 10;
 263         if (bright > 100) {
 264             bright = 100;
 265         }
 266         setBrightness(bright, duration);
 267     }
 268
 269     public void setBrightness(int brightness, int duration) {
 270         mConnection.invoke(MethodFactory.buildBrightnessMethd(brightness, DeviceMethod.EFFECT_SMOOTH, duration));
 271     }
 272
 273     public void setColor(int color, int duration) {
 274         mConnection.invoke(MethodFactory.buildRgbMethod(color, DeviceMethod.EFFECT_SMOOTH, duration));
 275     }
 276
 277     public void increaseCt(int duration) {
 278         int ct = getDeviceStatus().getCt() - ((mMaxCt - mMinCt) / 10);
 279         if (ct < mMinCt) {
 280             ct = mMinCt;
 281         }
 282         setCT(ct, duration);
 283     }
 284
 285     public void decreaseCt(int duration) {
 286         int ct = getDeviceStatus().getCt() + ((mMaxCt - mMinCt) / 10);
 287         if (ct > mMaxCt) {
 288             ct = mMaxCt;
 289         }
 290         setCT(ct, duration);
 291     }
 292
 293     public void setCT(int ct, int duration) {
 294         mConnection.invoke(MethodFactory.buildCTMethod(ct, DeviceMethod.EFFECT_SMOOTH, duration));
 295     }
 296
 297     public void connect() {
 298         setConnectionState(ConnectState.CONNECTTING);
 299         mConnection.connect();
 300     }
 301
 302     public void setConnectionState(ConnectState connectState) {
 303         logger.debug("{}: set connection state to: {}", TAG, connectState.name());
 304         if (connectState == ConnectState.DISCONNECTED) {
 305             setOnline(false);
 306         }
 307         if (mConnectState != connectState) {
 308             mConnectState = connectState;
 309             if (mConnectionListeners != null) {
 310                 for (DeviceConnectionStateListener listener : mConnectionListeners) {
 311                     listener.onConnectionStateChanged(mConnectState);
 312                 }
 313             }
 314         }
 315     }
 316
 317     public void sendCustomCommand(String action, String params) {
 318         mConnection.invokeCustom(new DeviceMethod(action, params));
 319     }
 320
 321     // ===================== setter and getter=====================
 322
 323     public String getDeviceId() {
 324         return mDeviceId;
 325     }
 326
 327     public void setDeviceName(String name) {
 328         mDeviceName = name;
 329     }
 330
 331     public String getDeviceName() {
 332         return mDeviceName;
 333     }
 334
 335     public DeviceType getDeviceType() {
 336         return mDeviceType;
 337     }
 338
 339     public String getDeviceModel() {
 340         return mDeviceType.name();
 341     }
 342
 343     public String getAddress() {
 344         return mAddress;
 345     }
 346
 347     public void setAddress(String address) {
 348         this.mAddress = address;
 349     }
 350
 351     public int getPort() {
 352         return mPort;
 353     }
 354
 355     public void setPort(int port) {
 356         this.mPort = port;
 357     }
 358
 359     public boolean isAutoConnect() {
 360         return bIsAutoConnect;
 361     }
 362
 363     public int getFwVersion() {
 364         return mFwVersion;
 365     }
 366
 367     public void setFwVersion(int fwVersion) {
 368         this.mFwVersion = fwVersion;
 369     }
 370
 371     public Map<String, Object> getBulbInfo() {
 372         return mBulbInfo;
 373     }
 374
 375     public void setBulbInfo(Map<String, Object> bulbInfo) {
 376         this.mBulbInfo = bulbInfo;
 377     }
 378
 379     public String[] getSupportProps() {
 380         return mSupportProps;
 381     }
 382
 383     public void setSupportProps(String[] supportProps) {
 384         this.mSupportProps = supportProps;
 385     }
 386
 387     public void setAutoConnect(boolean isAutoConnect) {
 388         if (bIsAutoConnect != isAutoConnect) {
 389             this.bIsAutoConnect = isAutoConnect;
 390             checkAutoConnect();
 391         }
 392     }
 393
 394     public DeviceStatus getDeviceStatus() {
 395         return mDeviceStatus;
 396     }
 397
 398     public void registerConnectStateListener(DeviceConnectionStateListener listener) {
 399         mConnectionListeners.add(listener);
 400     }
 401
 402     public void registerStatusChangedListener(DeviceStatusChangeListener listener) {
 403         mStatusChangeListeners.add(listener);
 404     }
 405
 406     public void setOnline(boolean isOnline) {
 407         bIsOnline = isOnline;
 408         checkAutoConnect();
 409     }
 410
 411     public boolean isOnline() {
 412         return bIsOnline;
 413     }
 414
 415     public ConnectState getConnectionState() {
 416         return mConnectState;
 417     }
 418
 419     public void queryStatus() {
 420         DeviceMethod cmd = MethodFactory.buildQuery(this);
 421         mQueryList.add(cmd.getCmdId());
 422         mConnection.invoke(cmd);
 423     }
 424
 425     private void checkAutoConnect() {
 426         logger.debug(
 427                 "{}: CheckAutoConnect: online: {}, autoConnect: {}, connection state: {}, device = {}, device id: {}",
 428                 TAG, bIsOnline, bIsAutoConnect, mConnectState.name(), this, this.getDeviceId());
 429         if (bIsOnline && bIsAutoConnect && mConnectState == ConnectState.DISCONNECTED) {
 430             connect();
 431         }
 432     }
 433 }