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.dscalarm.internal.factory;
  14
  15 import static org.openhab.binding.dscalarm.internal.DSCAlarmBindingConstants.SUPPORTED_THING_TYPES_UIDS;
  16
  17 import java.util.HashMap;
  18 import java.util.Hashtable;
  19 import java.util.Map;
  20
  21 import org.openhab.binding.dscalarm.internal.DSCAlarmBindingConstants;
  22 import org.openhab.binding.dscalarm.internal.config.DSCAlarmPartitionConfiguration;
  23 import org.openhab.binding.dscalarm.internal.config.DSCAlarmZoneConfiguration;
  24 import org.openhab.binding.dscalarm.internal.config.EnvisalinkBridgeConfiguration;
  25 import org.openhab.binding.dscalarm.internal.config.IT100BridgeConfiguration;
  26 import org.openhab.binding.dscalarm.internal.config.TCPServerBridgeConfiguration;
  27 import org.openhab.binding.dscalarm.internal.discovery.DSCAlarmDiscoveryService;
  28 import org.openhab.binding.dscalarm.internal.handler.DSCAlarmBaseBridgeHandler;
  29 import org.openhab.binding.dscalarm.internal.handler.EnvisalinkBridgeHandler;
  30 import org.openhab.binding.dscalarm.internal.handler.IT100BridgeHandler;
  31 import org.openhab.binding.dscalarm.internal.handler.KeypadThingHandler;
  32 import org.openhab.binding.dscalarm.internal.handler.PanelThingHandler;
  33 import org.openhab.binding.dscalarm.internal.handler.PartitionThingHandler;
  34 import org.openhab.binding.dscalarm.internal.handler.TCPServerBridgeHandler;
  35 import org.openhab.binding.dscalarm.internal.handler.ZoneThingHandler;
  36 import org.openhab.core.config.core.Configuration;
  37 import org.openhab.core.config.discovery.DiscoveryService;
  38 import org.openhab.core.io.transport.serial.SerialPortManager;
  39 import org.openhab.core.thing.Bridge;
  40 import org.openhab.core.thing.Thing;
  41 import org.openhab.core.thing.ThingTypeUID;
  42 import org.openhab.core.thing.ThingUID;
  43 import org.openhab.core.thing.binding.BaseThingHandlerFactory;
  44 import org.openhab.core.thing.binding.ThingHandler;
  45 import org.openhab.core.thing.binding.ThingHandlerFactory;
  46 import org.osgi.framework.ServiceRegistration;
  47 import org.osgi.service.component.annotations.Activate;
  48 import org.osgi.service.component.annotations.Component;
  49 import org.osgi.service.component.annotations.Reference;
  50 import org.slf4j.Logger;
  51 import org.slf4j.LoggerFactory;
  52
  53 /**
  54  * The {@link DSCAlarmHandlerFactory} is responsible for creating things and thing. handlers.
  55  *
  56  * @author Russell Stephens - Initial Contribution
  57  */
  58 @Component(service = ThingHandlerFactory.class, configurationPid = "binding.dscalarm")
  59 public class DSCAlarmHandlerFactory extends BaseThingHandlerFactory {
  60
  61     private final Logger logger = LoggerFactory.getLogger(DSCAlarmHandlerFactory.class);
  62     private final Map<ThingUID, ServiceRegistration<?>> discoveryServiceRegistrations = new HashMap<>();
  63
  64     private final SerialPortManager serialPortManager;
  65
  66     @Activate
  67     public DSCAlarmHandlerFactory(final @Reference SerialPortManager serialPortManager) {
  68         this.serialPortManager = serialPortManager;
  69     }
  70
  71     @Override
  72     public Thing createThing(ThingTypeUID thingTypeUID, Configuration configuration, ThingUID thingUID,
  73             ThingUID bridgeUID) {
  74         if (DSCAlarmBindingConstants.ENVISALINKBRIDGE_THING_TYPE.equals(thingTypeUID)) {
  75             ThingUID envisalinkBridgeUID = getEnvisalinkBridgeThingUID(thingTypeUID, thingUID, configuration);
  76             logger.debug("createThing(): ENVISALINK_BRIDGE: Creating an '{}' type Thing - {}", thingTypeUID,
  77                     envisalinkBridgeUID.getId());
  78             return super.createThing(thingTypeUID, configuration, envisalinkBridgeUID, null);
  79         } else if (DSCAlarmBindingConstants.IT100BRIDGE_THING_TYPE.equals(thingTypeUID)) {
  80             ThingUID it100BridgeUID = getIT100BridgeThingUID(thingTypeUID, thingUID, configuration);
  81             logger.debug("createThing(): IT100_BRIDGE: Creating an '{}' type Thing - {}", thingTypeUID,
  82                     it100BridgeUID.getId());
  83             return super.createThing(thingTypeUID, configuration, it100BridgeUID, null);
  84         } else if (DSCAlarmBindingConstants.TCPSERVERBRIDGE_THING_TYPE.equals(thingTypeUID)) {
  85             ThingUID tcpServerBridgeUID = getTCPServerBridgeThingUID(thingTypeUID, thingUID, configuration);
  86             logger.debug("createThing(): TCP_SERVER_BRIDGE: Creating an '{}' type Thing - {}", thingTypeUID,
  87                     tcpServerBridgeUID.getId());
  88             return super.createThing(thingTypeUID, configuration, tcpServerBridgeUID, null);
  89         } else if (DSCAlarmBindingConstants.PANEL_THING_TYPE.equals(thingTypeUID)) {
  90             ThingUID panelThingUID = getDSCAlarmPanelUID(thingTypeUID, thingUID, configuration, bridgeUID);
  91             logger.debug("createThing(): PANEL_THING: Creating '{}' type Thing - {}", thingTypeUID,
  92                     panelThingUID.getId());
  93             return super.createThing(thingTypeUID, configuration, panelThingUID, bridgeUID);
  94         } else if (DSCAlarmBindingConstants.PARTITION_THING_TYPE.equals(thingTypeUID)) {
  95             ThingUID partitionThingUID = getDSCAlarmPartitionUID(thingTypeUID, thingUID, configuration, bridgeUID);
  96             logger.debug("createThing(): PARTITION_THING: Creating '{}' type Thing - {}", thingTypeUID,
  97                     partitionThingUID.getId());
  98             return super.createThing(thingTypeUID, configuration, partitionThingUID, bridgeUID);
  99         } else if (DSCAlarmBindingConstants.ZONE_THING_TYPE.equals(thingTypeUID)) {
 100             ThingUID zoneThingUID = getDSCAlarmZoneUID(thingTypeUID, thingUID, configuration, bridgeUID);
 101             logger.debug("createThing(): ZONE_THING: Creating '{}' type Thing - {}", thingTypeUID,
 102                     zoneThingUID.getId());
 103             return super.createThing(thingTypeUID, configuration, zoneThingUID, bridgeUID);
 104         } else if (DSCAlarmBindingConstants.KEYPAD_THING_TYPE.equals(thingTypeUID)) {
 105             ThingUID keypadThingUID = getDSCAlarmKeypadUID(thingTypeUID, thingUID, configuration, bridgeUID);
 106             logger.debug("createThing(): KEYPAD_THING: Creating '{}' type Thing - {}", thingTypeUID,
 107                     keypadThingUID.getId());
 108             return super.createThing(thingTypeUID, configuration, keypadThingUID, bridgeUID);
 109         }
 110
 111         throw new IllegalArgumentException(
 112                 "createThing(): The thing type " + thingTypeUID + " is not supported by the DSC Alarm binding.");
 113     }
 114
 115     @Override
 116     public boolean supportsThingType(ThingTypeUID thingTypeUID) {
 117         return SUPPORTED_THING_TYPES_UIDS.contains(thingTypeUID);
 118     }
 119
 120     /**
 121      * Get the Envisalink Bridge Thing UID.
 122      *
 123      * @param thingTypeUID
 124      * @param thingUID
 125      * @param configuration
 126      * @return thingUID
 127      */
 128     private ThingUID getEnvisalinkBridgeThingUID(ThingTypeUID thingTypeUID, ThingUID thingUID,
 129             Configuration configuration) {
 130         if (thingUID == null) {
 131             String ipAddress = (String) configuration.get(EnvisalinkBridgeConfiguration.IP_ADDRESS);
 132             String bridgeID = ipAddress.replace('.', '_');
 133             thingUID = new ThingUID(thingTypeUID, bridgeID);
 134         }
 135         return thingUID;
 136     }
 137
 138     /**
 139      * Get the IT-100 Bridge Thing UID.
 140      *
 141      * @param thingTypeUID
 142      * @param thingUID
 143      * @param configuration
 144      * @return thingUID
 145      */
 146     private ThingUID getIT100BridgeThingUID(ThingTypeUID thingTypeUID, ThingUID thingUID, Configuration configuration) {
 147         if (thingUID == null) {
 148             String serialPort = (String) configuration.get(IT100BridgeConfiguration.SERIAL_PORT);
 149             String bridgeID = serialPort.replace('.', '_');
 150             thingUID = new ThingUID(thingTypeUID, bridgeID);
 151         }
 152         return thingUID;
 153     }
 154
 155     /**
 156      * Get the IT-100 Bridge Thing UID.
 157      *
 158      * @param thingTypeUID
 159      * @param thingUID
 160      * @param configuration
 161      * @return thingUID
 162      */
 163     private ThingUID getTCPServerBridgeThingUID(ThingTypeUID thingTypeUID, ThingUID thingUID,
 164             Configuration configuration) {
 165         if (thingUID == null) {
 166             String ipAddress = (String) configuration.get(TCPServerBridgeConfiguration.IP_ADDRESS);
 167             String port = (String) configuration.get(TCPServerBridgeConfiguration.PORT);
 168             String bridgeID = ipAddress.replace('.', '_') + "_" + port;
 169             thingUID = new ThingUID(thingTypeUID, bridgeID);
 170         }
 171         return thingUID;
 172     }
 173
 174     /**
 175      * Get the Panel Thing UID.
 176      *
 177      * @param thingTypeUID
 178      * @param thingUID
 179      * @param configuration
 180      * @param bridgeUID
 181      * @return thingUID
 182      */
 183     private ThingUID getDSCAlarmPanelUID(ThingTypeUID thingTypeUID, ThingUID thingUID, Configuration configuration,
 184             ThingUID bridgeUID) {
 185         if (thingUID == null) {
 186             String panelId = "panel";
 187             thingUID = new ThingUID(thingTypeUID, panelId, bridgeUID.getId());
 188         }
 189         return thingUID;
 190     }
 191
 192     /**
 193      * Get the Partition Thing UID.
 194      *
 195      * @param thingTypeUID
 196      * @param thingUID
 197      * @param configuration
 198      * @param bridgeUID
 199      * @return thingUID
 200      */
 201     private ThingUID getDSCAlarmPartitionUID(ThingTypeUID thingTypeUID, ThingUID thingUID, Configuration configuration,
 202             ThingUID bridgeUID) {
 203         if (thingUID == null) {
 204             String partitionId = "partition"
 205                     + (String) configuration.get(DSCAlarmPartitionConfiguration.PARTITION_NUMBER);
 206             thingUID = new ThingUID(thingTypeUID, partitionId, bridgeUID.getId());
 207         }
 208         return thingUID;
 209     }
 210
 211     /**
 212      * Get the Zone Thing UID.
 213      *
 214      * @param thingTypeUID
 215      * @param thingUID
 216      * @param configuration
 217      * @param bridgeUID
 218      * @return thingUID
 219      */
 220     private ThingUID getDSCAlarmZoneUID(ThingTypeUID thingTypeUID, ThingUID thingUID, Configuration configuration,
 221             ThingUID bridgeUID) {
 222         if (thingUID == null) {
 223             String zoneId = "zone" + (String) configuration.get(DSCAlarmZoneConfiguration.ZONE_NUMBER);
 224             thingUID = new ThingUID(thingTypeUID, zoneId, bridgeUID.getId());
 225         }
 226         return thingUID;
 227     }
 228
 229     /**
 230      * Get the Keypad Thing UID.
 231      *
 232      * @param thingTypeUID
 233      * @param thingUID
 234      * @param configuration
 235      * @param bridgeUID
 236      * @return thingUID
 237      */
 238     private ThingUID getDSCAlarmKeypadUID(ThingTypeUID thingTypeUID, ThingUID thingUID, Configuration configuration,
 239             ThingUID bridgeUID) {
 240         if (thingUID == null) {
 241             String keypadId = "keypad";
 242             thingUID = new ThingUID(thingTypeUID, keypadId, bridgeUID.getId());
 243         }
 244         return thingUID;
 245     }
 246
 247     /**
 248      * Register the Thing Discovery Service for a bridge.
 249      *
 250      * @param dscAlarmBridgeHandler
 251      */
 252     private void registerDSCAlarmDiscoveryService(DSCAlarmBaseBridgeHandler dscAlarmBridgeHandler) {
 253         DSCAlarmDiscoveryService discoveryService = new DSCAlarmDiscoveryService(dscAlarmBridgeHandler);
 254         discoveryService.activate();
 255
 256         ServiceRegistration<?> discoveryServiceRegistration = bundleContext
 257                 .registerService(DiscoveryService.class.getName(), discoveryService, new Hashtable<>());
 258         discoveryServiceRegistrations.put(dscAlarmBridgeHandler.getThing().getUID(), discoveryServiceRegistration);
 259
 260         logger.debug("registerDSCAlarmDiscoveryService(): Bridge Handler - {}, Class Name - {}, Discovery Service - {}",
 261                 dscAlarmBridgeHandler, DiscoveryService.class.getName(), discoveryService);
 262     }
 263
 264     @Override
 265     protected ThingHandler createHandler(Thing thing) {
 266         ThingTypeUID thingTypeUID = thing.getThingTypeUID();
 267
 268         if (thingTypeUID.equals(DSCAlarmBindingConstants.ENVISALINKBRIDGE_THING_TYPE)) {
 269             EnvisalinkBridgeHandler handler = new EnvisalinkBridgeHandler((Bridge) thing);
 270             registerDSCAlarmDiscoveryService(handler);
 271             logger.debug("createHandler(): ENVISALINKBRIDGE_THING: ThingHandler created for {}", thingTypeUID);
 272             return handler;
 273         } else if (thingTypeUID.equals(DSCAlarmBindingConstants.IT100BRIDGE_THING_TYPE)) {
 274             IT100BridgeHandler handler = new IT100BridgeHandler((Bridge) thing, serialPortManager);
 275             registerDSCAlarmDiscoveryService(handler);
 276             logger.debug("createHandler(): IT100BRIDGE_THING: ThingHandler created for {}", thingTypeUID);
 277             return handler;
 278         } else if (thingTypeUID.equals(DSCAlarmBindingConstants.TCPSERVERBRIDGE_THING_TYPE)) {
 279             TCPServerBridgeHandler handler = new TCPServerBridgeHandler((Bridge) thing);
 280             registerDSCAlarmDiscoveryService(handler);
 281             logger.debug("createHandler(): TCPSERVERBRIDGE_THING: ThingHandler created for {}", thingTypeUID);
 282             return handler;
 283         } else if (thingTypeUID.equals(DSCAlarmBindingConstants.PANEL_THING_TYPE)) {
 284             logger.debug("createHandler(): PANEL_THING: ThingHandler created for {}", thingTypeUID);
 285             return new PanelThingHandler(thing);
 286         } else if (thingTypeUID.equals(DSCAlarmBindingConstants.PARTITION_THING_TYPE)) {
 287             logger.debug("createHandler(): PARTITION_THING: ThingHandler created for {}", thingTypeUID);
 288             return new PartitionThingHandler(thing);
 289         } else if (thingTypeUID.equals(DSCAlarmBindingConstants.ZONE_THING_TYPE)) {
 290             logger.debug("createHandler(): ZONE_THING: ThingHandler created for {}", thingTypeUID);
 291             return new ZoneThingHandler(thing);
 292         } else if (thingTypeUID.equals(DSCAlarmBindingConstants.KEYPAD_THING_TYPE)) {
 293             logger.debug("createHandler(): KEYPAD_THING: ThingHandler created for {}", thingTypeUID);
 294             return new KeypadThingHandler(thing);
 295         } else {
 296             logger.debug("createHandler(): ThingHandler not found for {}", thingTypeUID);
 297             return null;
 298         }
 299     }
 300
 301     @Override
 302     protected void removeHandler(ThingHandler thingHandler) {
 303         ServiceRegistration<?> discoveryServiceRegistration = discoveryServiceRegistrations
 304                 .get(thingHandler.getThing().getUID());
 305
 306         if (discoveryServiceRegistration != null) {
 307             DSCAlarmDiscoveryService discoveryService = (DSCAlarmDiscoveryService) bundleContext
 308                     .getService(discoveryServiceRegistration.getReference());
 309             discoveryService.deactivate();
 310             discoveryServiceRegistration.unregister();
 311             discoveryServiceRegistration = null;
 312             discoveryServiceRegistrations.remove(thingHandler.getThing().getUID());
 313         }
 314
 315         super.removeHandler(thingHandler);
 316     }
 317 }