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.km200.internal.handler;
  14
  15 import static org.openhab.binding.km200.internal.KM200BindingConstants.*;
  16
  17 import java.util.ArrayList;
  18 import java.util.List;
  19
  20 import org.eclipse.jdt.annotation.NonNullByDefault;
  21 import org.eclipse.jdt.annotation.Nullable;
  22 import org.openhab.binding.km200.internal.KM200Device;
  23 import org.openhab.binding.km200.internal.KM200ServiceObject;
  24 import org.slf4j.Logger;
  25 import org.slf4j.LoggerFactory;
  26
  27 import com.google.gson.JsonArray;
  28 import com.google.gson.JsonObject;
  29
  30 /**
  31  * The KM200DataHandler is representing one service on the device
  32  *
  33  * @author Markus Eckhardt - Initial contribution
  34  */
  35 @NonNullByDefault
  36 public class KM200ServiceHandler {
  37
  38     private final Logger logger = LoggerFactory.getLogger(KM200ServiceHandler.class);
  39
  40     private final String service;
  41     private final @Nullable KM200ServiceObject parent;
  42     private final KM200Device remoteDevice;
  43
  44     public KM200ServiceHandler(String service, @Nullable KM200ServiceObject parent, KM200Device remoteDevice) {
  45         this.service = service;
  46         this.parent = parent;
  47         this.remoteDevice = remoteDevice;
  48     }
  49
  50     /**
  51      * This function starts the object's initialization
  52      */
  53     public void initObject() {
  54         JsonObject nodeRoot;
  55         if (remoteDevice.getBlacklistMap().contains(service)) {
  56             logger.debug("Blacklisted: {}", service);
  57             return;
  58         }
  59         if (null == remoteDevice.getServiceNode(service)) {
  60             logger.debug("initDevice: nodeRoot == null for service: {}", service);
  61             return;
  62         }
  63         nodeRoot = remoteDevice.getServiceNode(service);
  64         if (null != nodeRoot) {
  65             determineServiceObject(createServiceObject(nodeRoot), nodeRoot);
  66         }
  67     }
  68
  69     /**
  70      * This function checks the flags of a service on the device and creates a KM200CommObject
  71      */
  72     public KM200ServiceObject createServiceObject(JsonObject nodeRoot) {
  73         KM200ServiceObject serviceObject;
  74         String id = null, type = null;
  75         Integer writeable = 0;
  76         Integer recordable = 0;
  77         Integer readable = 1;
  78         /* check whether the node is an empty one */
  79         if (nodeRoot.toString().length() == 2) {
  80             readable = 0;
  81             id = service;
  82             type = DATA_TYPE_PROTECTED;
  83         } else {
  84             type = nodeRoot.get("type").getAsString();
  85             id = nodeRoot.get("id").getAsString();
  86         }
  87         /* Check the service features and set the flags */
  88         if (nodeRoot.has("writeable")) {
  89             Integer val = nodeRoot.get("writeable").getAsInt();
  90             logger.trace("writable: {}", val);
  91             writeable = val;
  92         }
  93         if (nodeRoot.has("recordable")) {
  94             Integer val = nodeRoot.get("recordable").getAsInt();
  95             logger.trace("recordable: {}", val);
  96             recordable = val;
  97         }
  98         logger.trace("Typ: {}", type);
  99         serviceObject = new KM200ServiceObject(id, type, readable, writeable, recordable, 0, null);
 100         serviceObject.setJSONData(nodeRoot);
 101         return serviceObject;
 102     }
 103
 104     /**
 105      * This function determines the service's capabilities
 106      */
 107     public void determineServiceObject(KM200ServiceObject serviceObject, JsonObject nodeRoot) {
 108         /* Check the service features and set the flags */
 109         String id = null;
 110         Object valObject = null;
 111         JsonObject dataObject = serviceObject.getJSONData();
 112         if (null != dataObject) {
 113             switch (serviceObject.getServiceType()) {
 114                 case DATA_TYPE_STRING_VALUE: /*
 115                                               * Check whether the type is a single value containing a
 116                                               * string value
 117                                               */
 118                     logger.trace("initDevice: type string value: {}", dataObject);
 119                     valObject = new String(nodeRoot.get("value").getAsString());
 120                     serviceObject.setValue(valObject);
 121                     if (nodeRoot.has("allowedValues")) {
 122                         List<String> valParas = new ArrayList<>();
 123                         JsonArray paras = nodeRoot.get("allowedValues").getAsJsonArray();
 124                         for (int i = 0; i < paras.size(); i++) {
 125                             String subJSON = paras.get(i).getAsString();
 126                             valParas.add(subJSON);
 127                         }
 128                         serviceObject.setValueParameter(valParas);
 129                     }
 130                     break;
 131                 case DATA_TYPE_FLOAT_VALUE: /* Check whether the type is a single value containing a float value */
 132                     logger.trace("initDevice: type float value: {}", dataObject);
 133                     valObject = nodeRoot.get("value");
 134                     try {
 135                         valObject = nodeRoot.get("value").getAsBigDecimal();
 136                         serviceObject.setValue(valObject);
 137                     } catch (NumberFormatException e) {
 138                         Double tmpObj = Double.NaN;
 139                         serviceObject.setValue(tmpObj);
 140                     }
 141                     if (nodeRoot.has("minValue") && nodeRoot.has("maxValue")) {
 142                         List<Object> valParas = new ArrayList<>();
 143                         valParas.add(nodeRoot.get("minValue").getAsBigDecimal());
 144                         valParas.add(nodeRoot.get("maxValue").getAsBigDecimal());
 145                         if (nodeRoot.has("unitOfMeasure")) {
 146                             valParas.add(nodeRoot.get("unitOfMeasure").getAsString());
 147                         }
 148                         serviceObject.setValueParameter(valParas);
 149                     }
 150                     break;
 151                 case DATA_TYPE_SWITCH_PROGRAM: /* Check whether the type is a switchProgram */
 152                     logger.trace("initDevice: type switchProgram {}", dataObject);
 153                     KM200SwitchProgramServiceHandler sPService = new KM200SwitchProgramServiceHandler();
 154                     sPService.setMaxNbOfSwitchPoints(nodeRoot.get("maxNbOfSwitchPoints").getAsInt());
 155                     sPService.setMaxNbOfSwitchPointsPerDay(nodeRoot.get("maxNbOfSwitchPointsPerDay").getAsInt());
 156                     sPService.setSwitchPointTimeRaster(nodeRoot.get("switchPointTimeRaster").getAsInt());
 157                     JsonObject propObject = nodeRoot.get("setpointProperty").getAsJsonObject();
 158                     sPService.setSetpointProperty(propObject.get("id").getAsString());
 159                     serviceObject.setValueParameter(sPService);
 160                     serviceObject.setJSONData(dataObject);
 161                     remoteDevice.virtualList.add(serviceObject);
 162                     break;
 163                 case DATA_TYPE_ERROR_LIST: /* Check whether the type is an errorList */
 164                     logger.trace("initDevice: type errorList: {}", dataObject);
 165                     KM200ErrorServiceHandler eService = new KM200ErrorServiceHandler();
 166                     eService.updateErrors(nodeRoot);
 167                     serviceObject.setValueParameter(eService);
 168                     serviceObject.setJSONData(dataObject);
 169                     remoteDevice.virtualList.add(serviceObject);
 170                     break;
 171                 case DATA_TYPE_REF_ENUM: /* Check whether the type is a refEnum */
 172                     logger.trace("initDevice: type refEnum: {}", dataObject);
 173                     JsonArray refers = nodeRoot.get("references").getAsJsonArray();
 174                     for (int i = 0; i < refers.size(); i++) {
 175                         JsonObject subJSON = refers.get(i).getAsJsonObject();
 176                         id = subJSON.get("id").getAsString();
 177                         KM200ServiceHandler serviceHandler = new KM200ServiceHandler(id, serviceObject, remoteDevice);
 178                         serviceHandler.initObject();
 179                     }
 180                     break;
 181                 case DATA_TYPE_MODULE_LIST: /* Check whether the type is a moduleList */
 182                     logger.trace("initDevice: type moduleList: {}", dataObject);
 183                     JsonArray vals = nodeRoot.get("values").getAsJsonArray();
 184                     for (int i = 0; i < vals.size(); i++) {
 185                         JsonObject subJSON = vals.get(i).getAsJsonObject();
 186                         id = subJSON.get("id").getAsString();
 187                         KM200ServiceHandler serviceHandler = new KM200ServiceHandler(id, serviceObject, remoteDevice);
 188                         serviceHandler.initObject();
 189                     }
 190                     break;
 191                 case DATA_TYPE_Y_RECORDING: /* Check whether the type is a yRecording */
 192                     logger.trace("initDevice: type yRecording: {}", dataObject);
 193                     /* have to be completed */
 194                     break;
 195                 case DATA_TYPE_SYSTEM_INFO: /* Check whether the type is a systeminfo */
 196                     logger.trace("initDevice: type systeminfo: {}", dataObject);
 197                     JsonArray sInfo = nodeRoot.get("values").getAsJsonArray();
 198                     serviceObject.setValue(sInfo);
 199                     /* have to be completed */
 200                     break;
 201                 case DATA_TYPE_ARRAY_DATA:
 202                     logger.trace("initDevice: type arrayData: {}", dataObject);
 203                     serviceObject.setJSONData(dataObject);
 204                     /* have to be completed */
 205                     break;
 206
 207                 case DATA_TYPE_E_MONITORING_LIST:
 208                     logger.trace("initDevice: type eMonitoringList: {}", dataObject);
 209                     serviceObject.setJSONData(dataObject);
 210                     /* have to be completed */
 211                     break;
 212                 case DATA_TYPE_PROTECTED:
 213                     logger.trace("initDevice: readonly");
 214                     serviceObject.setJSONData(dataObject);
 215                     break;
 216                 default: /* Unknown type */
 217                     logger.info("initDevice: type: {} unknown for service: {} Data: {}", serviceObject.getServiceType(),
 218                             service, dataObject);
 219             }
 220         }
 221         String[] servicePath = service.split("/");
 222         if (null != parent) {
 223             parent.serviceTreeMap.put(servicePath[servicePath.length - 1], serviceObject);
 224         } else {
 225             remoteDevice.serviceTreeMap.put(servicePath[servicePath.length - 1], serviceObject);
 226         }
 227     }
 228 }