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.wemo.internal.discovery;
  14
  15 import static org.openhab.binding.wemo.internal.WemoBindingConstants.*;
  16 import static org.openhab.binding.wemo.internal.WemoUtil.*;
  17
  18 import java.io.StringReader;
  19 import java.net.URL;
  20 import java.util.Collections;
  21 import java.util.HashMap;
  22 import java.util.Map;
  23 import java.util.Set;
  24 import java.util.concurrent.ScheduledFuture;
  25 import java.util.concurrent.TimeUnit;
  26
  27 import javax.xml.parsers.DocumentBuilder;
  28 import javax.xml.parsers.DocumentBuilderFactory;
  29
  30 import org.eclipse.jdt.annotation.NonNullByDefault;
  31 import org.eclipse.jdt.annotation.Nullable;
  32 import org.openhab.binding.wemo.internal.handler.WemoBridgeHandler;
  33 import org.openhab.binding.wemo.internal.http.WemoHttpCall;
  34 import org.openhab.core.config.discovery.AbstractDiscoveryService;
  35 import org.openhab.core.config.discovery.DiscoveryResult;
  36 import org.openhab.core.config.discovery.DiscoveryResultBuilder;
  37 import org.openhab.core.io.transport.upnp.UpnpIOParticipant;
  38 import org.openhab.core.io.transport.upnp.UpnpIOService;
  39 import org.openhab.core.thing.ThingTypeUID;
  40 import org.openhab.core.thing.ThingUID;
  41 import org.slf4j.Logger;
  42 import org.slf4j.LoggerFactory;
  43 import org.w3c.dom.CharacterData;
  44 import org.w3c.dom.Document;
  45 import org.w3c.dom.Element;
  46 import org.w3c.dom.Node;
  47 import org.w3c.dom.NodeList;
  48 import org.xml.sax.InputSource;
  49
  50 /**
  51  * The {@link WemoLinkDiscoveryService} is responsible for discovering new and
  52  * removed WeMo devices connected to the WeMo Link Bridge.
  53  *
  54  * @author Hans-Jörg Merk - Initial contribution
  55  *
  56  */
  57 @NonNullByDefault
  58 public class WemoLinkDiscoveryService extends AbstractDiscoveryService implements UpnpIOParticipant {
  59
  60     private final Logger logger = LoggerFactory.getLogger(WemoLinkDiscoveryService.class);
  61
  62     public static final Set<ThingTypeUID> SUPPORTED_THING_TYPES = Collections.singleton(THING_TYPE_MZ100);
  63
  64     public static final String NORMALIZE_ID_REGEX = "[^a-zA-Z0-9_]";
  65
  66     /**
  67      * Maximum time to search for devices in seconds.
  68      */
  69     private static final int SEARCH_TIME = 20;
  70
  71     /**
  72      * Scan interval for scanning job in seconds.
  73      */
  74     private static final int SCAN_INTERVAL = 120;
  75
  76     /**
  77      * The handler for WeMo Link bridge
  78      */
  79     private final WemoBridgeHandler wemoBridgeHandler;
  80
  81     /**
  82      * Job which will do the background scanning
  83      */
  84     private final WemoLinkScan scanningRunnable;
  85
  86     /**
  87      * Schedule for scanning
  88      */
  89     private @Nullable ScheduledFuture<?> scanningJob;
  90
  91     /**
  92      * The Upnp service
  93      */
  94     private UpnpIOService service;
  95
  96     private final WemoHttpCall wemoHttpCaller;
  97
  98     public WemoLinkDiscoveryService(WemoBridgeHandler wemoBridgeHandler, UpnpIOService upnpIOService,
  99             WemoHttpCall wemoHttpCaller) {
 100         super(SEARCH_TIME);
 101         this.service = upnpIOService;
 102         this.wemoBridgeHandler = wemoBridgeHandler;
 103
 104         this.wemoHttpCaller = wemoHttpCaller;
 105
 106         this.scanningRunnable = new WemoLinkScan();
 107         this.activate(null);
 108     }
 109
 110     public Set<ThingTypeUID> getSupportedThingTypeUIDs() {
 111         return SUPPORTED_THING_TYPES;
 112     }
 113
 114     @Override
 115     public void startScan() {
 116         logger.trace("Starting WeMoEndDevice discovery on WeMo Link {}", wemoBridgeHandler.getThing().getUID());
 117         try {
 118             String devUDN = "uuid:" + wemoBridgeHandler.getThing().getConfiguration().get(UDN).toString();
 119             logger.trace("devUDN = '{}'", devUDN);
 120
 121             String soapHeader = "\"urn:Belkin:service:bridge:1#GetEndDevices\"";
 122             String content = "<?xml version=\"1.0\"?>"
 123                     + "<s:Envelope xmlns:s=\"http://schemas.xmlsoap.org/soap/envelope/\" s:encodingStyle=\"http://schemas.xmlsoap.org/soap/encoding/\">"
 124                     + "<s:Body>" + "<u:GetEndDevices xmlns:u=\"urn:Belkin:service:bridge:1\">" + "<DevUDN>" + devUDN
 125                     + "</DevUDN><ReqListType>PAIRED_LIST</ReqListType>" + "</u:GetEndDevices>" + "</s:Body>"
 126                     + "</s:Envelope>";
 127
 128             URL descriptorURL = service.getDescriptorURL(this);
 129
 130             if (descriptorURL != null) {
 131                 String deviceURL = substringBefore(descriptorURL.toString(), "/setup.xml");
 132                 String wemoURL = deviceURL + "/upnp/control/bridge1";
 133
 134                 String endDeviceRequest = wemoHttpCaller.executeCall(wemoURL, soapHeader, content);
 135
 136                 logger.trace("endDeviceRequest answered '{}'", endDeviceRequest);
 137
 138                 try {
 139                     String stringParser = substringBetween(endDeviceRequest, "<DeviceLists>", "</DeviceLists>");
 140
 141                     stringParser = unescapeXml(stringParser);
 142
 143                     // check if there are already paired devices with WeMo Link
 144                     if ("0".equals(stringParser)) {
 145                         logger.debug("There are no devices connected with WeMo Link. Exit discovery");
 146                         return;
 147                     }
 148
 149                     // Build parser for received <DeviceList>
 150                     DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
 151                     // see
 152                     // https://cheatsheetseries.owasp.org/cheatsheets/XML_External_Entity_Prevention_Cheat_Sheet.html
 153                     dbf.setFeature("http://xml.org/sax/features/external-general-entities", false);
 154                     dbf.setFeature("http://xml.org/sax/features/external-parameter-entities", false);
 155                     dbf.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", false);
 156                     dbf.setXIncludeAware(false);
 157                     dbf.setExpandEntityReferences(false);
 158                     DocumentBuilder db = dbf.newDocumentBuilder();
 159                     InputSource is = new InputSource();
 160                     is.setCharacterStream(new StringReader(stringParser));
 161
 162                     Document doc = db.parse(is);
 163                     NodeList nodes = doc.getElementsByTagName("DeviceInfo");
 164
 165                     // iterate the devices
 166                     for (int i = 0; i < nodes.getLength(); i++) {
 167                         Element element = (Element) nodes.item(i);
 168
 169                         NodeList deviceIndex = element.getElementsByTagName("DeviceIndex");
 170                         Element line = (Element) deviceIndex.item(0);
 171                         logger.trace("DeviceIndex: {}", getCharacterDataFromElement(line));
 172
 173                         NodeList deviceID = element.getElementsByTagName("DeviceID");
 174                         line = (Element) deviceID.item(0);
 175                         String endDeviceID = getCharacterDataFromElement(line);
 176                         logger.trace("DeviceID: {}", endDeviceID);
 177
 178                         NodeList friendlyName = element.getElementsByTagName("FriendlyName");
 179                         line = (Element) friendlyName.item(0);
 180                         String endDeviceName = getCharacterDataFromElement(line);
 181                         logger.trace("FriendlyName: {}", endDeviceName);
 182
 183                         NodeList vendor = element.getElementsByTagName("Manufacturer");
 184                         line = (Element) vendor.item(0);
 185                         String endDeviceVendor = getCharacterDataFromElement(line);
 186                         logger.trace("Manufacturer: {}", endDeviceVendor);
 187
 188                         NodeList model = element.getElementsByTagName("ModelCode");
 189                         line = (Element) model.item(0);
 190                         String endDeviceModelID = getCharacterDataFromElement(line);
 191                         endDeviceModelID = endDeviceModelID.replaceAll(NORMALIZE_ID_REGEX, "_");
 192
 193                         logger.trace("ModelCode: {}", endDeviceModelID);
 194
 195                         if (SUPPORTED_THING_TYPES.contains(new ThingTypeUID(BINDING_ID, endDeviceModelID))) {
 196                             logger.debug("Discovered a WeMo LED Light thing with ID '{}'", endDeviceID);
 197
 198                             ThingUID bridgeUID = wemoBridgeHandler.getThing().getUID();
 199                             ThingTypeUID thingTypeUID = new ThingTypeUID(BINDING_ID, endDeviceModelID);
 200
 201                             if (thingTypeUID.equals(THING_TYPE_MZ100)) {
 202                                 String thingLightId = endDeviceID;
 203                                 ThingUID thingUID = new ThingUID(thingTypeUID, bridgeUID, thingLightId);
 204
 205                                 Map<String, Object> properties = new HashMap<>(1);
 206                                 properties.put(DEVICE_ID, endDeviceID);
 207
 208                                 DiscoveryResult discoveryResult = DiscoveryResultBuilder.create(thingUID)
 209                                         .withProperties(properties).withBridge(wemoBridgeHandler.getThing().getUID())
 210                                         .withLabel(endDeviceName).build();
 211
 212                                 thingDiscovered(discoveryResult);
 213                             }
 214                         } else {
 215                             logger.debug("Discovered an unsupported device :");
 216                             logger.debug("DeviceIndex : {}", getCharacterDataFromElement(line));
 217                             logger.debug("DeviceID    : {}", endDeviceID);
 218                             logger.debug("FriendlyName: {}", endDeviceName);
 219                             logger.debug("Manufacturer: {}", endDeviceVendor);
 220                             logger.debug("ModelCode   : {}", endDeviceModelID);
 221                         }
 222
 223                     }
 224                 } catch (Exception e) {
 225                     logger.warn("Failed to parse endDevices for bridge '{}'", wemoBridgeHandler.getThing().getUID(), e);
 226                 }
 227             }
 228         } catch (Exception e) {
 229             logger.warn("Failed to get endDevices for bridge '{}'", wemoBridgeHandler.getThing().getUID(), e);
 230         }
 231     }
 232
 233     @Override
 234     protected void startBackgroundDiscovery() {
 235         logger.trace("Start WeMo device background discovery");
 236
 237         ScheduledFuture<?> job = scanningJob;
 238
 239         if (job == null || job.isCancelled()) {
 240             this.scanningJob = scheduler.scheduleWithFixedDelay(this.scanningRunnable,
 241                     LINK_DISCOVERY_SERVICE_INITIAL_DELAY, SCAN_INTERVAL, TimeUnit.SECONDS);
 242         } else {
 243             logger.trace("scanningJob active");
 244         }
 245     }
 246
 247     @Override
 248     protected void stopBackgroundDiscovery() {
 249         logger.debug("Stop WeMo device background discovery");
 250
 251         ScheduledFuture<?> job = scanningJob;
 252         if (job != null && !job.isCancelled()) {
 253             job.cancel(true);
 254         }
 255         scanningJob = null;
 256     }
 257
 258     @Override
 259     public String getUDN() {
 260         return (String) this.wemoBridgeHandler.getThing().getConfiguration().get(UDN);
 261     }
 262
 263     @Override
 264     public void onServiceSubscribed(@Nullable String service, boolean succeeded) {
 265     }
 266
 267     @Override
 268     public void onValueReceived(@Nullable String variable, @Nullable String value, @Nullable String service) {
 269     }
 270
 271     @Override
 272     public void onStatusChanged(boolean status) {
 273     }
 274
 275     public static String getCharacterDataFromElement(Element e) {
 276         Node child = e.getFirstChild();
 277         if (child instanceof CharacterData) {
 278             CharacterData cd = (CharacterData) child;
 279             return cd.getData();
 280         }
 281         return "?";
 282     }
 283
 284     public class WemoLinkScan implements Runnable {
 285         @Override
 286         public void run() {
 287             startScan();
 288         }
 289     }
 290 }