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.onkyo.internal.discovery;
  14
  15 import static org.openhab.binding.onkyo.internal.OnkyoBindingConstants.*;
  16
  17 import java.util.Arrays;
  18 import java.util.HashMap;
  19 import java.util.HashSet;
  20 import java.util.Map;
  21 import java.util.Set;
  22
  23 import org.apache.commons.lang3.StringUtils;
  24 import org.eclipse.jdt.annotation.NonNullByDefault;
  25 import org.eclipse.jdt.annotation.Nullable;
  26 import org.jupnp.model.meta.RemoteDevice;
  27 import org.openhab.binding.onkyo.internal.OnkyoModel;
  28 import org.openhab.core.config.discovery.DiscoveryResult;
  29 import org.openhab.core.config.discovery.DiscoveryResultBuilder;
  30 import org.openhab.core.config.discovery.upnp.UpnpDiscoveryParticipant;
  31 import org.openhab.core.thing.ThingTypeUID;
  32 import org.openhab.core.thing.ThingUID;
  33 import org.osgi.service.component.ComponentContext;
  34 import org.osgi.service.component.annotations.Activate;
  35 import org.osgi.service.component.annotations.Component;
  36 import org.slf4j.Logger;
  37 import org.slf4j.LoggerFactory;
  38
  39 /**
  40  * An UpnpDiscoveryParticipant which allows to discover Onkyo AVRs.
  41  *
  42  * @author Paul Frank - Initial contribution
  43  */
  44 @NonNullByDefault
  45 @Component
  46 public class OnkyoUpnpDiscoveryParticipant implements UpnpDiscoveryParticipant {
  47
  48     private final Logger logger = LoggerFactory.getLogger(OnkyoUpnpDiscoveryParticipant.class);
  49
  50     private boolean isAutoDiscoveryEnabled;
  51     private Set<ThingTypeUID> supportedThingTypes;
  52
  53     public OnkyoUpnpDiscoveryParticipant() {
  54         this.isAutoDiscoveryEnabled = true;
  55         this.supportedThingTypes = SUPPORTED_THING_TYPES_UIDS;
  56     }
  57
  58     /**
  59      * Called at the service activation.
  60      *
  61      * @param componentContext
  62      */
  63     @Activate
  64     protected void activate(ComponentContext componentContext) {
  65         if (componentContext.getProperties() != null) {
  66             String autoDiscoveryPropertyValue = (String) componentContext.getProperties().get("enableAutoDiscovery");
  67             if (autoDiscoveryPropertyValue != null && !autoDiscoveryPropertyValue.isEmpty()) {
  68                 isAutoDiscoveryEnabled = Boolean.valueOf(autoDiscoveryPropertyValue);
  69             }
  70         }
  71         supportedThingTypes = isAutoDiscoveryEnabled ? SUPPORTED_THING_TYPES_UIDS : new HashSet<>();
  72     }
  73
  74     @Override
  75     public Set<ThingTypeUID> getSupportedThingTypeUIDs() {
  76         return supportedThingTypes;
  77     }
  78
  79     @Override
  80     public @Nullable DiscoveryResult createResult(RemoteDevice device) {
  81         DiscoveryResult result = null;
  82         ThingUID thingUid = getThingUID(device);
  83         if (thingUid != null) {
  84             String friendlyName = device.getDetails().getFriendlyName();
  85             String label = friendlyName == null || friendlyName.isEmpty() ? device.getDisplayString() : friendlyName;
  86             Map<String, Object> properties = new HashMap<>(2, 1);
  87             properties.put(HOST_PARAMETER, device.getIdentity().getDescriptorURL().getHost());
  88             properties.put(UDN_PARAMETER, device.getIdentity().getUdn().getIdentifierString());
  89
  90             result = DiscoveryResultBuilder.create(thingUid).withLabel(label).withProperties(properties).build();
  91         }
  92
  93         return result;
  94     }
  95
  96     @Override
  97     public @Nullable ThingUID getThingUID(RemoteDevice device) {
  98         ThingUID result = null;
  99         if (isAutoDiscoveryEnabled) {
 100             String manufacturer = device.getDetails().getManufacturerDetails().getManufacturer();
 101             if (manufacturer != null && manufacturer.toLowerCase().contains(MANUFACTURER.toLowerCase())) {
 102                 logger.debug("Manufacturer matched: search: {}, device value: {}.", MANUFACTURER, manufacturer);
 103                 String type = device.getType().getType();
 104                 if (type != null && type.toLowerCase().contains(UPNP_DEVICE_TYPE.toLowerCase())) {
 105                     logger.debug("Device type matched: search: {}, device value: {}.", UPNP_DEVICE_TYPE, type);
 106
 107                     String deviceModel = device.getDetails().getModelDetails() != null
 108                             ? device.getDetails().getModelDetails().getModelName()
 109                             : null;
 110
 111                     logger.debug("Device model: {}.", deviceModel);
 112
 113                     ThingTypeUID thingTypeUID = findThingType(deviceModel);
 114                     result = new ThingUID(thingTypeUID, device.getIdentity().getUdn().getIdentifierString());
 115                 }
 116             }
 117         }
 118
 119         return result;
 120     }
 121
 122     private ThingTypeUID findThingType(@Nullable String deviceModel) {
 123         ThingTypeUID thingTypeUID = THING_TYPE_ONKYO_UNSUPPORTED;
 124
 125         for (ThingTypeUID thingType : SUPPORTED_THING_TYPES_UIDS) {
 126             if (thingType.getId().equalsIgnoreCase(deviceModel)) {
 127                 return thingType;
 128             }
 129         }
 130
 131         if (isSupportedDeviceModel(deviceModel)) {
 132             thingTypeUID = THING_TYPE_ONKYOAV;
 133         }
 134
 135         return thingTypeUID;
 136     }
 137
 138     /**
 139      * Return true only if the given device model is supported.
 140      *
 141      * @param deviceModel
 142      * @return
 143      */
 144     private boolean isSupportedDeviceModel(final @Nullable String deviceModel) {
 145         return deviceModel != null && !deviceModel.isBlank() && Arrays.stream(OnkyoModel.values())
 146                 .anyMatch(model -> StringUtils.startsWithIgnoreCase(deviceModel, model.getId()));
 147     }
 148 }