git.basschouten.com Git - openhab-addons.git/blob

   1 /**
   2  * Copyright (c) 2010-2021 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.lutron.internal.discovery;
  14
  15 import static org.openhab.binding.lutron.internal.LutronBindingConstants.*;
  16
  17 import java.net.InetAddress;
  18 import java.util.Collections;
  19 import java.util.HashMap;
  20 import java.util.Map;
  21 import java.util.Set;
  22 import java.util.regex.Matcher;
  23 import java.util.regex.Pattern;
  24
  25 import javax.jmdns.ServiceInfo;
  26
  27 import org.eclipse.jdt.annotation.NonNullByDefault;
  28 import org.eclipse.jdt.annotation.Nullable;
  29 import org.openhab.core.config.discovery.DiscoveryResult;
  30 import org.openhab.core.config.discovery.DiscoveryResultBuilder;
  31 import org.openhab.core.config.discovery.mdns.MDNSDiscoveryParticipant;
  32 import org.openhab.core.thing.Thing;
  33 import org.openhab.core.thing.ThingTypeUID;
  34 import org.openhab.core.thing.ThingUID;
  35 import org.osgi.service.component.annotations.Component;
  36 import org.slf4j.Logger;
  37 import org.slf4j.LoggerFactory;
  38
  39 /**
  40  * The {@link LutronMdnsBridgeDiscoveryService} discovers Lutron Caseta Smart Bridge, Caseta Smart Bridge Pro, RA2
  41  * Select Main Repeater, and other Lutron devices on the network using mDNS.
  42  *
  43  * @author Bob Adair - Initial contribution
  44  */
  45 @Component
  46 @NonNullByDefault
  47 public class LutronMdnsBridgeDiscoveryService implements MDNSDiscoveryParticipant {
  48
  49     // Lutron mDNS service <app>.<protocol>.<servicedomain>
  50     private static final String LUTRON_MDNS_SERVICE_TYPE = "_lutron._tcp.local.";
  51
  52     private static final String PRODFAM_CASETA = "Caseta";
  53     private static final String PRODTYP_CASETA_SB = "Smart Bridge";
  54     private static final String DEVCLASS_CASETA_SB = "08040100";
  55     private static final String PRODTYP_CASETA_SBP2 = "Smart Bridge Pro 2";
  56     private static final String DEVCLASS_CASETA_SBP2 = "08050100";
  57
  58     private static final String PRODFAM_RA2_SELECT = "RA2 Select";
  59     private static final String PRODTYP_RA2_SELECT = "Main Repeater";
  60     private static final String DEVCLASS_RA2_SELECT = "080E0401";
  61
  62     private static final String DEVCLASS_CONNECT_BRIDGE = "08090301";
  63     private static final String DEFAULT_LABEL = "Unknown Lutron bridge";
  64
  65     private static final Pattern HOSTNAME_REGEX = Pattern.compile("lutron-([0-9a-f]+)\\."); // ex: lutron-01f1529a.local
  66
  67     private final Logger logger = LoggerFactory.getLogger(LutronMdnsBridgeDiscoveryService.class);
  68
  69     @Override
  70     public Set<ThingTypeUID> getSupportedThingTypeUIDs() {
  71         return Collections.singleton(THING_TYPE_IPBRIDGE);
  72     }
  73
  74     @Override
  75     public String getServiceType() {
  76         return LUTRON_MDNS_SERVICE_TYPE;
  77     }
  78
  79     @Override
  80     public @Nullable DiscoveryResult createResult(ServiceInfo service) {
  81         if (!service.hasData()) {
  82             return null;
  83         }
  84
  85         String nice = service.getNiceTextString();
  86         String qualifiedName = service.getQualifiedName();
  87
  88         InetAddress[] ipAddresses = service.getInetAddresses();
  89         String devclass = service.getPropertyString("DEVCLASS");
  90         String codever = service.getPropertyString("CODEVER");
  91         String macaddr = service.getPropertyString("MACADDR");
  92
  93         logger.debug("Lutron mDNS bridge discovery notified of Lutron mDNS service: {}", nice);
  94         logger.trace("Lutron mDNS service qualifiedName: {}", qualifiedName);
  95         logger.trace("Lutron mDNS service ipAddresses: {} ({})", ipAddresses, ipAddresses.length);
  96         logger.trace("Lutron mDNS service property DEVCLASS: {}", devclass);
  97         logger.trace("Lutron mDNS service property CODEVER: {}", codever);
  98         logger.trace("Lutron mDNS service property MACADDR: {}", macaddr);
  99
 100         Map<String, Object> properties = new HashMap<>();
 101         String label = DEFAULT_LABEL;
 102
 103         if (ipAddresses.length < 1) {
 104             return null;
 105         }
 106         if (ipAddresses.length > 1) {
 107             logger.debug("Multiple addresses found for discovered Lutron device. Using only the first.");
 108         }
 109         properties.put(HOST, ipAddresses[0].getHostAddress());
 110
 111         String bridgeHostName = ipAddresses[0].getHostName();
 112         logger.debug("Lutron mDNS bridge hostname: {}", bridgeHostName);
 113
 114         if (DEVCLASS_CASETA_SB.equals(devclass)) {
 115             properties.put(PROPERTY_PRODFAM, PRODFAM_CASETA);
 116             properties.put(PROPERTY_PRODTYP, PRODTYP_CASETA_SB);
 117             label = PRODFAM_CASETA + " " + PRODTYP_CASETA_SB;
 118         } else if (DEVCLASS_CASETA_SBP2.equals(devclass)) {
 119             properties.put(PROPERTY_PRODFAM, PRODFAM_CASETA);
 120             properties.put(PROPERTY_PRODTYP, PRODTYP_CASETA_SBP2);
 121             label = PRODFAM_CASETA + " " + PRODTYP_CASETA_SBP2;
 122         } else if (DEVCLASS_RA2_SELECT.equals(devclass)) {
 123             properties.put(PROPERTY_PRODFAM, PRODFAM_RA2_SELECT);
 124             properties.put(PROPERTY_PRODTYP, PRODTYP_RA2_SELECT);
 125             label = PRODFAM_RA2_SELECT + " " + PRODTYP_RA2_SELECT;
 126         } else if (DEVCLASS_CONNECT_BRIDGE.equals(devclass)) {
 127             logger.debug("Lutron Connect Bridge discovered. Ignoring.");
 128             return null;
 129         } else {
 130             logger.info("Lutron device with unknown DEVCLASS discovered via mDNS: {}. Configure device manually.",
 131                     devclass);
 132             return null; // Exit if service has unknown DEVCLASS
 133         }
 134
 135         if (!bridgeHostName.equals(ipAddresses[0].getHostAddress())) {
 136             label = label + " " + bridgeHostName;
 137         }
 138
 139         if (codever != null) {
 140             properties.put(Thing.PROPERTY_FIRMWARE_VERSION, codever);
 141         }
 142
 143         if (macaddr != null) {
 144             properties.put(Thing.PROPERTY_MAC_ADDRESS, macaddr);
 145         }
 146
 147         String sn = getSerial(service);
 148         if (sn != null) {
 149             logger.trace("Lutron mDNS bridge serial number: {}", sn);
 150             properties.put(SERIAL_NUMBER, sn);
 151         } else {
 152             logger.debug("Unable to determine serial number of discovered Lutron bridge device.");
 153             return null;
 154         }
 155
 156         ThingUID uid = getThingUID(service);
 157         if (uid != null) {
 158             DiscoveryResult result = DiscoveryResultBuilder.create(uid).withLabel(label).withProperties(properties)
 159                     .withRepresentationProperty(SERIAL_NUMBER).build();
 160             logger.debug("Discovered Lutron bridge device via mDNS {}", uid);
 161             return result;
 162         } else {
 163             logger.trace("Failed to create uid for discovered Lutron bridge device");
 164             return null;
 165         }
 166     }
 167
 168     @Override
 169     public @Nullable ThingUID getThingUID(ServiceInfo service) {
 170         String serial = getSerial(service);
 171         String devclass = service.getPropertyString("DEVCLASS");
 172         if (serial == null) {
 173             return null;
 174         } else {
 175             if (DEVCLASS_CASETA_SB.equals(devclass)) {
 176                 return new ThingUID(THING_TYPE_LEAPBRIDGE, serial);
 177             } else {
 178                 return new ThingUID(THING_TYPE_IPBRIDGE, serial);
 179             }
 180         }
 181     }
 182
 183     /**
 184      * Returns the device serial number for the mDNS service by extracting it from the hostname.
 185      * Used as unique thing representation property.
 186      *
 187      * @param service Lutron mDNS service
 188      * @return String containing serial number, or null if it cannot be determined
 189      */
 190     private @Nullable String getSerial(ServiceInfo service) {
 191         InetAddress[] ipAddresses = service.getInetAddresses();
 192         if (ipAddresses.length < 1) {
 193             return null;
 194         }
 195         Matcher matcher = HOSTNAME_REGEX.matcher(ipAddresses[0].getHostName());
 196         boolean matched = matcher.find();
 197         String serialnum = null;
 198
 199         if (matched) {
 200             serialnum = matcher.group(1);
 201         }
 202         if (matched && serialnum != null && !serialnum.isEmpty()) {
 203             return serialnum;
 204         } else {
 205             return null;
 206         }
 207     }
 208 }