[knx] performance and resource improvements (#114)

* improvements
* performance improvements in DeviceThingHandler

Signed-off-by: Jan N. Klug <[email protected]>

bundles/org.smarthomej.binding.knx/src/main/java/org/smarthomej/binding/knx/internal/channel/GroupAddressConfiguration.java

@@ -13,41 +13,107 @@
  */
 package org.smarthomej.binding.knx.internal.channel;
 
+import java.util.HashSet;
+import java.util.Set;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
 import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.eclipse.jdt.annotation.Nullable;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import tuwien.auto.calimero.GroupAddress;
+import tuwien.auto.calimero.KNXFormatException;
 
 /**
- * Data structure representing a single group address configuration within a channel configuration parameter.
+ * Data structure representing the content of a channel's group address configuration.
  *
  * @author Simon Kaufmann - initial contribution and API.
  *
  */
 @NonNullByDefault
 public class GroupAddressConfiguration {
+ public static final Logger LOGGER = LoggerFactory.getLogger(GroupAddressConfiguration.class);
+
+ private static final Pattern PATTERN_GA_CONFIGURATION = Pattern.compile(
+ "^((?<dpt>[1-9][0-9]{0,2}\\.[0-9]{3,4}):)?(?<read>\\<)?(?<mainGA>[0-9]{1,5}(/[0-9]{1,4}){0,2})(?<listenGAs>(\\+(\\<?[0-9]{1,5}(/[0-9]{1,4}){0,2}))*)$");
+ private static final Pattern PATTERN_LISTEN_GA = Pattern
+ .compile("\\+((?<read>\\<)?(?<GA>[0-9]{1,5}(/[0-9]{1,4}){0,2}))");
+
+ private final @Nullable String dpt;
+ private final GroupAddress mainGA;
+ private final Set<GroupAddress> listenGAs;
+ private final Set<GroupAddress> readGAs;
 
- private final String ga;
- private final boolean read;
+ private GroupAddressConfiguration(@Nullable String dpt, GroupAddress mainGA, Set<GroupAddress> listenGAs,
+ Set<GroupAddress> readGAs) {
+ this.dpt = dpt;
+ this.mainGA = mainGA;
+ this.listenGAs = listenGAs;
+ this.readGAs = readGAs;
+ }
+
+ public @Nullable String getDPT() {
+ return dpt;
+ }
 
- public GroupAddressConfiguration(String ga, boolean read) {
- super();
- this.ga = ga;
- this.read = read;
+ public GroupAddress getMainGA() {
+ return mainGA;
  }
 
- /**
- * The group address.
- *
- * @return the group address.
- */
- public String getGA() {
- return ga;
+ public Set<GroupAddress> getListenGAs() {
+ return listenGAs;
  }
 
- /**
- * Denotes whether the group address is marked to be actively read from.
- *
- * @return {@code true} if read requests should be issued to this address
- */
- public boolean isRead() {
- return read;
+ public Set<GroupAddress> getReadGAs() {
+ return readGAs;
+ }
+
+ public static @Nullable GroupAddressConfiguration parse(@Nullable Object configuration) {
+ if (!(configuration instanceof String)) {
+ return null;
+ }
+
+ Matcher matcher = PATTERN_GA_CONFIGURATION.matcher(((String) configuration).replace(" ", ""));
+ if (matcher.matches()) {
+ // Listen GAs
+ String input = matcher.group("listenGAs");
+ Matcher m2 = PATTERN_LISTEN_GA.matcher(input);
+ Set<GroupAddress> listenGAs = new HashSet<>();
+ Set<GroupAddress> readGAs = new HashSet<>();
+ while (m2.find()) {
+ String ga = m2.group("GA");
+ try {
+ GroupAddress groupAddress = new GroupAddress(ga);
+ listenGAs.add(groupAddress);
+ if (m2.group("read") != null) {
+ readGAs.add(groupAddress);
+ }
+ } catch (KNXFormatException e) {
+ LOGGER.warn("Failed to create GroupAddress from {}", ga);
+ return null;
+ }
+ }
+
+ // Main GA
+ String mainGA = matcher.group("mainGA");
+ try {
+ GroupAddress groupAddress = new GroupAddress(mainGA);
+ listenGAs.add(groupAddress); // also listening to main GA
+ if (matcher.group("read") != null) {
+ readGAs.add(groupAddress); // also reading main GA
+ }
+ return new GroupAddressConfiguration(matcher.group("dpt"), groupAddress, listenGAs, readGAs);
+ } catch (KNXFormatException e) {
+ LOGGER.warn("Failed to create GroupAddress from {}", mainGA);
+ return null;
+ }
+
+ } else {
+ LOGGER.warn("Failed parsing channel configuration '{}'.", configuration);
+ }
+
+ return null;
  }
 }

bundles/org.smarthomej.binding.knx/src/main/java/org/smarthomej/binding/knx/internal/channel/KNXChannel.java

@@ -0,0 +1,140 @@
+/**
+ * Copyright (c) 2010-2021 Contributors to the openHAB project
+ * Copyright (c) 2021 Contributors to the SmartHome/J project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.smarthomej.binding.knx.internal.channel;
+
+import static java.util.stream.Collectors.*;
+import static org.smarthomej.binding.knx.internal.KNXBindingConstants.CONTROL_CHANNEL_TYPES;
+import static org.smarthomej.binding.knx.internal.KNXBindingConstants.GA;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.eclipse.jdt.annotation.Nullable;
+import org.openhab.core.config.core.Configuration;
+import org.openhab.core.thing.Channel;
+import org.openhab.core.thing.ChannelUID;
+import org.openhab.core.types.Type;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.smarthomej.binding.knx.internal.client.InboundSpec;
+import org.smarthomej.binding.knx.internal.client.OutboundSpec;
+import org.smarthomej.binding.knx.internal.dpt.KNXCoreTypeMapper;
+
+import tuwien.auto.calimero.GroupAddress;
+
+/**
+ * Meta-data abstraction for the KNX channel configurations.
+ *
+ * @author Simon Kaufmann - initial contribution and API
+ * @author Jan N. Klug - refactored from type definition to channel instance
+ *
+ */
+@NonNullByDefault
+public abstract class KNXChannel {
+ private final Logger logger = LoggerFactory.getLogger(KNXChannel.class);
+ private final Set<String> gaKeys;
+
+ private final Map<String, GroupAddressConfiguration> groupAddressConfigurations = new HashMap<>();
+ private final Set<GroupAddress> listenAddresses = new HashSet<>();
+ private final Set<GroupAddress> writeAddresses = new HashSet<>();
+ private final String channelType;
+ private final ChannelUID channelUID;
+ private final boolean isControl;
+
+ KNXChannel(Channel channel) {
+ this(Set.of(GA), channel);
+ }
+
+ KNXChannel(Set<String> gaKeys, Channel channel) {
+ this.gaKeys = gaKeys;
+
+ // this is safe because we already checked the presence of the ChannelTypeUID before
+ this.channelType = Objects.requireNonNull(channel.getChannelTypeUID()).getId();
+ this.channelUID = channel.getUID();
+ this.isControl = CONTROL_CHANNEL_TYPES.contains(channelType);
+
+ // build map of ChannelConfigurations and GA lists
+ Configuration configuration = channel.getConfiguration();
+ gaKeys.forEach(key -> {
+ GroupAddressConfiguration groupAddressConfiguration = GroupAddressConfiguration
+ .parse(configuration.get(key));
+ if (groupAddressConfiguration != null) {
+ groupAddressConfigurations.put(key, groupAddressConfiguration);
+ // store address configuration for re-use
+ listenAddresses.addAll(groupAddressConfiguration.getListenGAs());
+ writeAddresses.add(groupAddressConfiguration.getMainGA());
+ }
+ });
+ }
+
+ public String getChannelType() {
+ return channelType;
+ }
+
+ public ChannelUID getChannelUID() {
+ return channelUID;
+ }
+
+ public boolean isControl() {
+ return isControl;
+ }
+
+ public final Set<GroupAddress> getAllGroupAddresses() {
+ return listenAddresses;
+ }
+
+ public final Set<GroupAddress> getWriteAddresses() {
+ return writeAddresses;
+ }
+
+ public final @Nullable OutboundSpec getCommandSpec(Type command) {
+ logger.trace("getCommandSpec checking keys '{}' for command '{}' ({})", gaKeys, command, command.getClass());
+ for (Map.Entry<String, GroupAddressConfiguration> entry : groupAddressConfigurations.entrySet()) {
+ String dpt = Objects.requireNonNullElse(entry.getValue().getDPT(), getDefaultDPT(entry.getKey()));
+ Set<Class<? extends Type>> expectedTypeClass = KNXCoreTypeMapper.getAllowedTypes(dpt);
+ if (expectedTypeClass.contains(command.getClass())) {
+ logger.trace("getCommandSpec key '{}' has expectedTypeClass '{}', matching command '{}' and dpt '{}'",
+ entry.getKey(), expectedTypeClass, command, dpt);
+ return new WriteSpecImpl(entry.getValue(), dpt, command);
+ }
+ }
+ logger.trace("getCommandSpec no Spec found!");
+ return null;
+ }
+
+ public final List<InboundSpec> getReadSpec() {
+ return groupAddressConfigurations.entrySet().stream()
+ .map(entry -> new ReadRequestSpecImpl(entry.getValue(), getDefaultDPT(entry.getKey())))
+ .filter(spec -> !spec.getGroupAddresses().isEmpty()).collect(toList());
+ }
+
+ public final @Nullable InboundSpec getListenSpec(GroupAddress groupAddress) {
+ return groupAddressConfigurations.entrySet().stream()
+ .map(entry -> new ListenSpecImpl(entry.getValue(), getDefaultDPT(entry.getKey())))
+ .filter(spec -> spec.getGroupAddresses().contains(groupAddress)).findFirst().orElse(null);
+ }
+
+ public final @Nullable OutboundSpec getResponseSpec(GroupAddress groupAddress, Type value) {
+ return groupAddressConfigurations.entrySet().stream()
+ .map(entry -> new ReadResponseSpecImpl(entry.getValue(), getDefaultDPT(entry.getKey()), value))
+ .filter(spec -> spec.matchesDestination(groupAddress)).findFirst().orElse(null);
+ }
+
+ protected abstract String getDefaultDPT(String gaConfigKey);
+}