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.digitalstrom.internal.lib.structure.scene;
  14
  15 import java.util.HashMap;
  16 import java.util.Iterator;
  17 import java.util.LinkedList;
  18 import java.util.List;
  19 import java.util.concurrent.ScheduledFuture;
  20 import java.util.concurrent.TimeUnit;
  21
  22 import org.openhab.binding.digitalstrom.internal.lib.config.Config;
  23 import org.openhab.binding.digitalstrom.internal.lib.listener.SceneStatusListener;
  24 import org.openhab.binding.digitalstrom.internal.lib.manager.ConnectionManager;
  25 import org.openhab.binding.digitalstrom.internal.lib.manager.SceneManager;
  26 import org.openhab.binding.digitalstrom.internal.lib.manager.StructureManager;
  27 import org.openhab.binding.digitalstrom.internal.lib.serverconnection.constants.JSONApiResponseKeysEnum;
  28 import org.openhab.binding.digitalstrom.internal.lib.serverconnection.impl.JSONResponseHandler;
  29 import org.openhab.binding.digitalstrom.internal.lib.structure.devices.deviceparameters.constants.ApplicationGroup;
  30 import org.openhab.binding.digitalstrom.internal.lib.structure.scene.constants.ApartmentSceneEnum;
  31 import org.openhab.binding.digitalstrom.internal.lib.structure.scene.constants.SceneEnum;
  32 import org.openhab.binding.digitalstrom.internal.lib.structure.scene.constants.ZoneSceneEnum;
  33 import org.openhab.core.common.ThreadPoolManager;
  34 import org.slf4j.Logger;
  35 import org.slf4j.LoggerFactory;
  36
  37 import com.google.gson.JsonArray;
  38 import com.google.gson.JsonObject;
  39
  40 /**
  41  * The {@link SceneDiscovery} can read out various digitalSTROM-Scene types and generates a list of theirs or manages it
  42  * by the {@link SceneManager}.
  43  *
  44  * @author Michael Ochel - Initial contribution
  45  * @author Matthias Siegele - Initial contribution
  46  */
  47 public class SceneDiscovery {
  48
  49     private final Logger logger = LoggerFactory.getLogger(SceneDiscovery.class);
  50     // fields: 0 = namedScenes, 1 = apartmentScenes, 2 = zoneScenes, 3 = reachableScenes
  51     private final char[] scenesGenerated = "0000".toCharArray();
  52
  53     private final List<InternalScene> namedScenes = new LinkedList<>();
  54     private boolean genList = false;
  55     ScheduledFuture<?> generateReachableScenesScheduledFuture;
  56
  57     private SceneManager sceneManager;
  58     private SceneStatusListener discovery;
  59
  60     public static final String NAMEND_SCENE_QUERY = "/apartment/zones/*(ZoneID)/groups/*(group)/scenes/*(scene,name)";
  61     public static final String REACHABLE_SCENE_QUERY = "/json/zone/getReachableScenes?id=";
  62     public static final String REACHABLE_GROUPS_QUERY = "/json/apartment/getReachableGroups?token=";
  63
  64     /**
  65      * Creates a new {@link SceneDiscovery} with managed scene by the {@link SceneManager}
  66      *
  67      * @param sceneManager must not be null
  68      */
  69     public SceneDiscovery(SceneManager sceneManager) {
  70         this.sceneManager = sceneManager;
  71     }
  72
  73     /**
  74      * Creates a new {@link SceneDiscovery} and generates only a list of all scenes, if genList is true.
  75      *
  76      * @param genList yes/no (true/false)
  77      */
  78     public SceneDiscovery(boolean genList) {
  79         this.genList = genList;
  80     }
  81
  82     /**
  83      * Generates all named, reachable group, apartment and zone scenes.
  84      *
  85      * @param connectionManager must not be null
  86      * @param structureManager must not be null
  87      */
  88     public void generateAllScenes(ConnectionManager connectionManager, StructureManager structureManager) {
  89         generateNamedScenes(connectionManager);
  90         generateApartmentScence();
  91         generateZoneScenes(connectionManager, structureManager);
  92         generateReachableScenes(connectionManager, structureManager);
  93     }
  94
  95     /**
  96      * Generates all named scenes.
  97      *
  98      * @param connectionManager must not be null
  99      * @return true, if successful otherwise false
 100      */
 101     public boolean generateNamedScenes(ConnectionManager connectionManager) {
 102         JsonObject responsJsonObj = connectionManager.getDigitalSTROMAPI().query(connectionManager.getSessionToken(),
 103                 NAMEND_SCENE_QUERY);
 104         if (responsJsonObj == null) {
 105             scenesGenerated[0] = '2';
 106             sceneManager.scenesGenerated(scenesGenerated);
 107             return false;
 108         } else {
 109             addScenesToList(responsJsonObj);
 110             scenesGenerated[0] = '1';
 111             sceneManager.scenesGenerated(scenesGenerated);
 112             return true;
 113         }
 114     }
 115
 116     /**
 117      * Generates all apartment scenes.
 118      */
 119     public void generateApartmentScence() {
 120         for (ApartmentSceneEnum apartmentScene : ApartmentSceneEnum.values()) {
 121
 122             InternalScene scene = new InternalScene(null, null, apartmentScene.getSceneNumber(),
 123                     "Apartment-Scene: " + apartmentScene.toString().toLowerCase().replace("_", " "));
 124             if (genList) {
 125                 this.namedScenes.add(scene);
 126             } else {
 127                 sceneDiscoverd(scene);
 128             }
 129         }
 130         scenesGenerated[1] = '1';
 131         sceneManager.scenesGenerated(scenesGenerated);
 132     }
 133
 134     private void addScenesToList(JsonObject resultJsonObj) {
 135         if (resultJsonObj.get(JSONApiResponseKeysEnum.ZONES.getKey()) != null
 136                 && resultJsonObj.get(JSONApiResponseKeysEnum.ZONES.getKey()).isJsonArray()) {
 137             JsonArray zones = resultJsonObj.get(JSONApiResponseKeysEnum.ZONES.getKey()).getAsJsonArray();
 138             for (int i = 0; i < zones.size(); i++) {
 139
 140                 if (((JsonObject) zones.get(i)).get(JSONApiResponseKeysEnum.GROUPS.getKey()).isJsonArray()) {
 141                     JsonArray groups = ((JsonObject) zones.get(i)).get(JSONApiResponseKeysEnum.GROUPS.getKey())
 142                             .getAsJsonArray();
 143
 144                     for (int j = 0; j < groups.size(); j++) {
 145
 146                         if (((JsonObject) groups.get(j)).get("scenes") != null
 147                                 && ((JsonObject) groups.get(j)).get("scenes").isJsonArray()) {
 148                             JsonArray scenes = ((JsonObject) groups.get(j)).get("scenes").getAsJsonArray();
 149                             for (int k = 0; k < scenes.size(); k++) {
 150                                 if (scenes.get(k).isJsonObject()) {
 151                                     JsonObject sceneJsonObject = ((JsonObject) scenes.get(k));
 152                                     int zoneID = ((JsonObject) zones.get(i)).get("ZoneID").getAsInt();
 153                                     short groupID = ((JsonObject) groups.get(j)).get("group").getAsShort();
 154                                     InternalScene scene = new InternalScene(zoneID, groupID,
 155                                             sceneJsonObject.get("scene").getAsShort(),
 156                                             sceneJsonObject.get("name").getAsString());
 157                                     if (genList) {
 158                                         this.namedScenes.add(scene);
 159                                     } else {
 160                                         sceneDiscoverd(scene);
 161                                     }
 162                                 }
 163                             }
 164                         }
 165                     }
 166                 }
 167             }
 168         }
 169     }
 170
 171     /**
 172      * Generates all zone scenes.
 173      *
 174      * @param connectionManager must not be null
 175      * @param structureManager must not be null
 176      * @return success true otherwise false
 177      */
 178     public boolean generateZoneScenes(ConnectionManager connectionManager, StructureManager structureManager) {
 179         HashMap<Integer, List<Short>> reachableGroups = getReachableGroups(connectionManager);
 180
 181         if (reachableGroups != null) {
 182             for (Integer zoneID : reachableGroups.keySet()) {
 183                 if (!reachableGroups.get(zoneID).isEmpty()) {
 184                     for (ZoneSceneEnum zoneScene : ZoneSceneEnum.values()) {
 185                         String sceneName = "Zone-Scene: Zone: ";
 186                         if (structureManager.getZoneName(zoneID) != null
 187                                 && !structureManager.getZoneName(zoneID).isEmpty()) {
 188                             sceneName = sceneName + structureManager.getZoneName(zoneID);
 189
 190                         } else {
 191                             sceneName = sceneName + zoneID;
 192                         }
 193                         sceneName = sceneName + " Scene: " + zoneScene.toString().toLowerCase().replace("_", " ");
 194                         InternalScene scene = new InternalScene(zoneID, null, zoneScene.getSceneNumber(), sceneName);
 195                         if (genList) {
 196                             this.namedScenes.add(scene);
 197                         } else {
 198                             sceneDiscoverd(scene);
 199                         }
 200                     }
 201                 }
 202             }
 203
 204             scenesGenerated[2] = '1';
 205             sceneManager.scenesGenerated(scenesGenerated);
 206             return true;
 207         }
 208         scenesGenerated[2] = '2';
 209         sceneManager.scenesGenerated(scenesGenerated);
 210         return false;
 211     }
 212
 213     /**
 214      *
 215      */
 216     public void stop() {
 217         if (generateReachableScenesScheduledFuture != null) {
 218             generateReachableScenesScheduledFuture.cancel(true);
 219             generateReachableScenesScheduledFuture = null;
 220         }
 221     }
 222
 223     /**
 224      * Generates all reachable scenes.
 225      *
 226      * @param connectionManager must not be null
 227      * @param structureManager must not be null
 228      */
 229     public void generateReachableScenes(final ConnectionManager connectionManager,
 230             final StructureManager structureManager) {
 231         if (generateReachableScenesScheduledFuture == null || generateReachableScenesScheduledFuture.isCancelled()) {
 232             generateReachableScenesScheduledFuture = ThreadPoolManager.getScheduledPool(Config.THREADPOOL_NAME)
 233                     .scheduleWithFixedDelay(new Runnable() {
 234
 235                         HashMap<Integer, List<Short>> reachableGroups = getReachableGroups(connectionManager);
 236                         Iterator<Integer> zoneIdInter = null;
 237                         Iterator<Short> groupIdInter = null;
 238                         Integer zoneID = null;
 239
 240                         @Override
 241                         public void run() {
 242                             if (reachableGroups != null) {
 243                                 if (zoneIdInter == null) {
 244                                     zoneIdInter = reachableGroups.keySet().iterator();
 245                                 }
 246                                 if (groupIdInter == null) {
 247                                     if (zoneIdInter.hasNext()) {
 248                                         zoneID = zoneIdInter.next();
 249                                         groupIdInter = reachableGroups.get(zoneID).iterator();
 250                                     } else {
 251                                         zoneID = null;
 252                                         scenesGenerated[3] = '1';
 253                                         sceneManager.scenesGenerated(scenesGenerated);
 254                                         generateReachableScenesScheduledFuture.cancel(true);
 255                                     }
 256                                 }
 257                                 if (zoneID != null) {
 258                                     if (groupIdInter != null) {
 259                                         Short groupID = null;
 260                                         if (groupIdInter.hasNext()) {
 261                                             groupID = groupIdInter.next();
 262                                         } else {
 263                                             groupIdInter = null;
 264                                         }
 265                                         if (groupID != null) {
 266
 267                                             if (ApplicationGroup.Color.YELLOW
 268                                                     .equals(ApplicationGroup.getGroup(groupID).getColor())) {
 269                                                 discoverScene(SceneEnum.AUTO_OFF.getSceneNumber(), groupID);
 270                                             }
 271                                             String response = connectionManager.getHttpTransport()
 272                                                     .execute(REACHABLE_SCENE_QUERY + zoneID + "&groupID=" + groupID
 273                                                             + "&token=" + connectionManager.getSessionToken());
 274                                             if (response == null) {
 275                                                 scenesGenerated[3] = '2';
 276                                                 sceneManager.scenesGenerated(scenesGenerated);
 277                                                 logger.debug(
 278                                                         "Reachable scenes for zone {} and group {} cant be generated, because the dSS does not answer",
 279                                                         zoneID, groupID);
 280                                                 generateReachableScenesScheduledFuture.cancel(true);
 281                                                 return;
 282                                             } else {
 283                                                 JsonObject responsJsonObj = JSONResponseHandler.toJsonObject(response);
 284                                                 if (JSONResponseHandler.checkResponse(responsJsonObj)) {
 285                                                     JsonObject resultJsonObj = JSONResponseHandler
 286                                                             .getResultJsonObject(responsJsonObj);
 287                                                     if (resultJsonObj
 288                                                             .get(JSONApiResponseKeysEnum.REACHABLE_SCENES.getKey())
 289                                                             .isJsonArray()) {
 290                                                         JsonArray scenes = resultJsonObj
 291                                                                 .get(JSONApiResponseKeysEnum.REACHABLE_SCENES.getKey())
 292                                                                 .getAsJsonArray();
 293                                                         if (scenes != null) {
 294                                                             for (int i = 0; i < scenes.size(); i++) {
 295                                                                 discoverScene(scenes.get(i).getAsShort(), groupID);
 296                                                             }
 297                                                         }
 298                                                     }
 299                                                 }
 300                                             }
 301                                         }
 302                                     }
 303                                 }
 304                             }
 305                         }
 306
 307                         private void discoverScene(short sceneNumber, short groupID) {
 308                             String sceneName = null;
 309                             if (SceneEnum.getScene(sceneNumber) != null) {
 310                                 if (structureManager.getZoneName(zoneID) != null
 311                                         && !structureManager.getZoneName(zoneID).isEmpty()) {
 312                                     sceneName = "Zone: " + structureManager.getZoneName(zoneID);
 313
 314                                 } else {
 315                                     sceneName = "Zone: " + zoneID;
 316                                 }
 317                                 if (structureManager.getZoneGroupName(zoneID, groupID) != null
 318                                         && !structureManager.getZoneGroupName(zoneID, groupID).isEmpty()) {
 319                                     sceneName = sceneName + " Group: "
 320                                             + structureManager.getZoneGroupName(zoneID, groupID);
 321                                 } else {
 322                                     sceneName = sceneName + " Group: " + groupID;
 323                                 }
 324                                 sceneName = sceneName + " Scene: "
 325                                         + SceneEnum.getScene(sceneNumber).toString().toLowerCase().replace("_", " ");
 326                             }
 327                             InternalScene scene = new InternalScene(zoneID, groupID, sceneNumber, sceneName);
 328
 329                             if (genList) {
 330                                 namedScenes.add(scene);
 331                             } else {
 332                                 sceneDiscoverd(scene);
 333                             }
 334                         }
 335                     }, 0, 500, TimeUnit.MILLISECONDS);
 336         }
 337     }
 338
 339     private HashMap<Integer, List<Short>> getReachableGroups(ConnectionManager connectionManager) {
 340         HashMap<Integer, List<Short>> reachableGroupsMap = null;
 341         String response = connectionManager.getHttpTransport()
 342                 .execute(SceneDiscovery.REACHABLE_GROUPS_QUERY + connectionManager.getSessionToken());
 343         if (response == null) {
 344             return null;
 345         } else {
 346             JsonObject responsJsonObj = JSONResponseHandler.toJsonObject(response);
 347             if (JSONResponseHandler.checkResponse(responsJsonObj)) {
 348                 JsonObject resultJsonObj = JSONResponseHandler.getResultJsonObject(responsJsonObj);
 349                 if (resultJsonObj.get(JSONApiResponseKeysEnum.ZONES.getKey()) instanceof JsonArray) {
 350                     JsonArray zones = (JsonArray) resultJsonObj.get(JSONApiResponseKeysEnum.ZONES.getKey());
 351                     reachableGroupsMap = new HashMap<>(zones.size());
 352                     List<Short> groupList;
 353                     for (int i = 0; i < zones.size(); i++) {
 354                         if (((JsonObject) zones.get(i))
 355                                 .get(JSONApiResponseKeysEnum.GROUPS.getKey()) instanceof JsonArray) {
 356                             JsonArray groups = (JsonArray) ((JsonObject) zones.get(i))
 357                                     .get(JSONApiResponseKeysEnum.GROUPS.getKey());
 358                             groupList = new LinkedList<>();
 359                             for (int k = 0; k < groups.size(); k++) {
 360                                 groupList.add(groups.get(k).getAsShort());
 361                             }
 362                             reachableGroupsMap.put(((JsonObject) zones.get(i)).get("zoneID").getAsInt(), groupList);
 363                         }
 364                     }
 365                 }
 366             }
 367         }
 368         return reachableGroupsMap;
 369     }
 370
 371     /**
 372      * Informs the registered {@link SceneStatusListener} as scene discovery about a new scene.
 373      *
 374      * @param scene that was discoverd
 375      */
 376     public void sceneDiscoverd(InternalScene scene) {
 377         if (scene != null) {
 378             if (SceneEnum.containsScene(scene.getSceneID())) {
 379                 if (!isStandardScene(scene.getSceneID())) {
 380                     if (this.discovery != null) {
 381                         this.discovery.onSceneAdded(scene);
 382                         logger.debug("Inform scene discovery about added scene with id: {}", scene.getID());
 383                     } else {
 384                         logger.debug(
 385                                 "Can't inform scene discovery about added scene with id: {} because scene discovery is disabled",
 386                                 scene.getID());
 387                     }
 388                 }
 389                 this.sceneManager.addInternalScene(scene);
 390             } else {
 391                 logger.error("Added scene with id: {} is a not usage scene!", scene.getID());
 392             }
 393         }
 394     }
 395
 396     private boolean isStandardScene(short sceneID) {
 397         switch (SceneEnum.getScene(sceneID)) {
 398             case INCREMENT:
 399             case DECREMENT:
 400             case STOP:
 401             case MINIMUM:
 402             case MAXIMUM:
 403             case AUTO_OFF:
 404             case DEVICE_ON:
 405             case DEVICE_OFF:
 406             case DEVICE_STOP:
 407                 return true;
 408             default:
 409                 return false;
 410         }
 411     }
 412
 413     /**
 414      * Registers the given {@link SceneStatusListener} as scene discovery.
 415      *
 416      * @param listener to register
 417      */
 418     public void registerSceneDiscovery(SceneStatusListener listener) {
 419         this.discovery = listener;
 420     }
 421
 422     /**
 423      * Unregisters the {@link SceneStatusListener} as scene discovery from this {@link InternalScene}.
 424      */
 425     public void unRegisterDiscovery() {
 426         this.discovery = null;
 427     }
 428
 429     /**
 430      * Returns the list of all generated {@link InternalScene}'s, if the list shall generated.
 431      *
 432      * @return List of all {@link InternalScene} or null
 433      */
 434     public List<InternalScene> getNamedSceneList() {
 435         if (genList) {
 436             return this.namedScenes;
 437         } else {
 438             if (sceneManager != null) {
 439                 sceneManager.getScenes();
 440             }
 441         }
 442         return null;
 443     }
 444
 445     @Override
 446     public String toString() {
 447         return this.namedScenes.toString();
 448     }
 449 }