return THING_TYPE_STATION.equals(thingTypeUID)
? new AirQualityStationHandler(thing, timeZoneProvider, locationProvider)
- : BRIDGE_TYPE_API.equals(thingTypeUID) ? new AirQualityBridgeHandler((Bridge) thing, locationProvider)
- : null;
+ : BRIDGE_TYPE_API.equals(thingTypeUID) ? new AirQualityBridgeHandler((Bridge) thing) : null;
}
}
import java.util.Set;
import org.eclipse.jdt.annotation.NonNullByDefault;
-import org.eclipse.jdt.annotation.Nullable;
import org.openhab.binding.airquality.internal.handler.AirQualityBridgeHandler;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
-import org.openhab.core.config.discovery.DiscoveryService;
import org.openhab.core.i18n.LocationProvider;
import org.openhab.core.library.types.PointType;
import org.openhab.core.thing.ThingTypeUID;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
import org.openhab.core.thing.binding.ThingHandlerService;
+import org.osgi.service.component.annotations.Activate;
import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.Reference;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Gaël L'hopital - Initial Contribution
*/
-@Component(service = DiscoveryService.class, configurationPid = "discovery.airquality")
+@Component(scope = ServiceScope.PROTOTYPE, service = AirQualityDiscoveryService.class, configurationPid = "discovery.airquality")
@NonNullByDefault
-public class AirQualityDiscoveryService extends AbstractDiscoveryService implements ThingHandlerService {
+public class AirQualityDiscoveryService extends AbstractThingHandlerDiscoveryService<AirQualityBridgeHandler>
+ implements ThingHandlerService {
private static final int DISCOVER_TIMEOUT_SECONDS = 2;
private static final Set<ThingTypeUID> SUPPORTED_THING_TYPES_UIDS = Set.of(THING_TYPE_STATION);
private final Logger logger = LoggerFactory.getLogger(AirQualityDiscoveryService.class);
- private @Nullable LocationProvider locationProvider;
- private @Nullable AirQualityBridgeHandler bridgeHandler;
+ private @NonNullByDefault({}) LocationProvider locationProvider;
/**
* Creates an AirQualityDiscoveryService with enabled autostart.
*/
+ @Activate
public AirQualityDiscoveryService() {
- super(SUPPORTED_THING_TYPES_UIDS, DISCOVER_TIMEOUT_SECONDS, false);
+ super(AirQualityBridgeHandler.class, SUPPORTED_THING_TYPES_UIDS, DISCOVER_TIMEOUT_SECONDS, false);
}
- @Override
- public void setThingHandler(@Nullable ThingHandler handler) {
- if (handler instanceof AirQualityBridgeHandler bridgeHandlerInstance) {
- this.bridgeHandler = bridgeHandlerInstance;
- this.locationProvider = bridgeHandler.getLocationProvider();
- }
- }
-
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return bridgeHandler;
- }
-
- @Override
- public void deactivate() {
- super.deactivate();
+ @Reference(unbind = "-")
+ public void bindLocationProvider(LocationProvider locationProvider) {
+ this.locationProvider = locationProvider;
}
@Override
LocationProvider provider = locationProvider;
if (provider != null) {
PointType location = provider.getLocation();
- AirQualityBridgeHandler bridge = this.bridgeHandler;
+ AirQualityBridgeHandler bridge = this.thingHandler;
if (location == null || bridge == null) {
logger.info("openHAB server location is not defined, will not provide any discovery results");
return;
import org.eclipse.jdt.annotation.Nullable;
import org.openhab.binding.airquality.internal.api.ApiBridge;
import org.openhab.binding.airquality.internal.discovery.AirQualityDiscoveryService;
-import org.openhab.core.i18n.LocationProvider;
import org.openhab.core.thing.Bridge;
import org.openhab.core.thing.ChannelUID;
import org.openhab.core.thing.ThingStatus;
*/
@NonNullByDefault
public class AirQualityBridgeHandler extends BaseBridgeHandler {
- private final LocationProvider locationProvider;
private @Nullable ApiBridge apiBridge;
- public AirQualityBridgeHandler(Bridge bridge, LocationProvider locationProvider) {
+ public AirQualityBridgeHandler(Bridge bridge) {
super(bridge);
- this.locationProvider = locationProvider;
}
@Override
public Collection<Class<? extends ThingHandlerService>> getServices() {
return Set.of(AirQualityDiscoveryService.class);
}
-
- public LocationProvider getLocationProvider() {
- return locationProvider;
- }
}
import org.openhab.core.thing.binding.ThingActions;
import org.openhab.core.thing.binding.ThingActionsScope;
import org.openhab.core.thing.binding.ThingHandler;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Bob Adair - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = BridgeActions.class)
@ThingActionsScope(name = "alarmdecoder")
@NonNullByDefault
public class BridgeActions implements ThingActions {
import org.openhab.core.thing.binding.ThingHandler;
import org.openhab.core.thing.binding.ThingHandlerService;
import org.openhab.core.thing.type.ChannelTypeUID;
+import org.openhab.core.thing.type.DynamicStateDescriptionProvider;
import org.openhab.core.types.StateDescription;
import org.openhab.core.types.StateOption;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
/**
* This class provides the list of valid inputs for the input channel of a source.
* @author Kai Kreuzer - Initial contribution
*
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = { DynamicStateDescriptionProvider.class,
+ InputStateOptionProvider.class })
@NonNullByDefault
public class InputStateOptionProvider extends BaseDynamicStateDescriptionProvider implements ThingHandlerService {
import org.openhab.core.thing.binding.ThingHandler;
import org.openhab.core.thing.binding.ThingHandlerService;
import org.openhab.core.thing.type.ChannelTypeUID;
+import org.openhab.core.thing.type.DynamicCommandDescriptionProvider;
import org.openhab.core.types.CommandDescription;
import org.openhab.core.types.CommandOption;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
/**
* This class provides the list of valid commands for the preset channel.
* @author Kai Kreuzer - Initial contribution
*
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = { PresetCommandOptionProvider.class,
+ DynamicCommandDescriptionProvider.class })
@NonNullByDefault
public class PresetCommandOptionProvider extends BaseDynamicCommandDescriptionProvider implements ThingHandlerService {
import org.openhab.core.library.types.PercentType;
import org.openhab.core.thing.binding.ThingHandler;
import org.openhab.core.thing.binding.ThingHandlerService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
* @author Kai Kreuzer - Initial contribution
*
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = PAAudioSink.class)
@NonNullByDefault
public class PAAudioSink extends AudioSinkSync implements ThingHandlerService {
import java.util.Set;
import org.eclipse.jdt.annotation.NonNullByDefault;
-import org.eclipse.jdt.annotation.Nullable;
import org.openhab.binding.amplipi.internal.AmpliPiBindingConstants;
import org.openhab.binding.amplipi.internal.AmpliPiHandler;
import org.openhab.binding.amplipi.internal.AmpliPiStatusChangeListener;
import org.openhab.binding.amplipi.internal.model.Group;
import org.openhab.binding.amplipi.internal.model.Status;
import org.openhab.binding.amplipi.internal.model.Zone;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResult;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
/**
* This class discoveres the available zones and groups of the AmpliPi system.
* @author Kai Kreuzer - Initial contribution
*
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = AmpliPiZoneAndGroupDiscoveryService.class)
@NonNullByDefault
-public class AmpliPiZoneAndGroupDiscoveryService extends AbstractDiscoveryService
- implements ThingHandlerService, AmpliPiStatusChangeListener {
+public class AmpliPiZoneAndGroupDiscoveryService extends AbstractThingHandlerDiscoveryService<AmpliPiHandler>
+ implements AmpliPiStatusChangeListener {
private static final int TIMEOUT = 10;
- private @Nullable AmpliPiHandler handler;
private List<Zone> zones = List.of();
private List<Group> groups = List.of();
public AmpliPiZoneAndGroupDiscoveryService() throws IllegalArgumentException {
- super(Set.of(AmpliPiBindingConstants.THING_TYPE_GROUP, AmpliPiBindingConstants.THING_TYPE_ZONE), TIMEOUT, true);
+ super(AmpliPiHandler.class,
+ Set.of(AmpliPiBindingConstants.THING_TYPE_GROUP, AmpliPiBindingConstants.THING_TYPE_ZONE), TIMEOUT,
+ true);
}
@Override
- public void setThingHandler(ThingHandler handler) {
- AmpliPiHandler ampliPiHander = (AmpliPiHandler) handler;
- ampliPiHander.addStatusChangeListener(this);
- this.handler = ampliPiHander;
- }
-
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return handler;
+ public void initialize() {
+ thingHandler.addStatusChangeListener(this);
+ super.initialize();
}
@Override
}
private void createZone(Zone z) {
- if (handler != null) {
- ThingUID bridgeUID = handler.getThing().getUID();
- ThingUID uid = new ThingUID(AmpliPiBindingConstants.THING_TYPE_ZONE, bridgeUID, z.getId().toString());
- DiscoveryResult result = DiscoveryResultBuilder.create(uid).withLabel("AmpliPi Zone '" + z.getName() + "'")
- .withProperty(AmpliPiBindingConstants.CFG_PARAM_ID, z.getId()).withBridge(bridgeUID)
- .withRepresentationProperty(AmpliPiBindingConstants.CFG_PARAM_ID).build();
- thingDiscovered(result);
- }
+ ThingUID bridgeUID = thingHandler.getThing().getUID();
+ ThingUID uid = new ThingUID(AmpliPiBindingConstants.THING_TYPE_ZONE, bridgeUID, z.getId().toString());
+ DiscoveryResult result = DiscoveryResultBuilder.create(uid).withLabel("AmpliPi Zone '" + z.getName() + "'")
+ .withProperty(AmpliPiBindingConstants.CFG_PARAM_ID, z.getId()).withBridge(bridgeUID)
+ .withRepresentationProperty(AmpliPiBindingConstants.CFG_PARAM_ID).build();
+ thingDiscovered(result);
}
private void createGroup(Group g) {
- if (handler != null) {
- ThingUID bridgeUID = handler.getThing().getUID();
- ThingUID uid = new ThingUID(AmpliPiBindingConstants.THING_TYPE_GROUP, bridgeUID, g.getId().toString());
- DiscoveryResult result = DiscoveryResultBuilder.create(uid).withLabel("AmpliPi Group '" + g.getName() + "'")
- .withProperty(AmpliPiBindingConstants.CFG_PARAM_ID, g.getId()).withBridge(bridgeUID)
- .withRepresentationProperty(AmpliPiBindingConstants.CFG_PARAM_ID).build();
- thingDiscovered(result);
- }
+ ThingUID bridgeUID = thingHandler.getThing().getUID();
+ ThingUID uid = new ThingUID(AmpliPiBindingConstants.THING_TYPE_GROUP, bridgeUID, g.getId().toString());
+ DiscoveryResult result = DiscoveryResultBuilder.create(uid).withLabel("AmpliPi Group '" + g.getName() + "'")
+ .withProperty(AmpliPiBindingConstants.CFG_PARAM_ID, g.getId()).withBridge(bridgeUID)
+ .withRepresentationProperty(AmpliPiBindingConstants.CFG_PARAM_ID).build();
+ thingDiscovered(result);
}
@Override
- public void deactivate() {
- if (handler != null) {
- handler.removeStatusChangeListener(this);
- }
- super.deactivate();
+ public void dispose() {
+ super.dispose();
+ thingHandler.removeStatusChangeListener(this);
}
@Override
import org.openhab.core.thing.binding.ThingActions;
import org.openhab.core.thing.binding.ThingActionsScope;
import org.openhab.core.thing.binding.ThingHandler;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Gaël L'hopital - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = AstroActions.class)
@ThingActionsScope(name = "astro")
@NonNullByDefault
public class AstroActions implements ThingActions {
import java.util.Map;
import org.eclipse.jdt.annotation.NonNullByDefault;
-import org.eclipse.jdt.annotation.Nullable;
import org.openhab.binding.asuswrt.internal.structures.AsuswrtClientInfo;
import org.openhab.binding.asuswrt.internal.structures.AsuswrtClientList;
import org.openhab.binding.asuswrt.internal.structures.AsuswrtInterfaceList;
import org.openhab.binding.asuswrt.internal.structures.AsuswrtIpInfo;
import org.openhab.binding.asuswrt.internal.things.AsuswrtRouter;
import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResult;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
import org.openhab.core.thing.Thing;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Christian Wild - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = AbstractDiscoveryService.class)
@NonNullByDefault
-public class AsuswrtDiscoveryService extends AbstractDiscoveryService implements ThingHandlerService {
+public class AsuswrtDiscoveryService extends AbstractThingHandlerDiscoveryService<AsuswrtRouter> {
private final Logger logger = LoggerFactory.getLogger(AsuswrtDiscoveryService.class);
private String uid = "";
- protected @NonNullByDefault({}) AsuswrtRouter router;
public AsuswrtDiscoveryService() {
- super(SUPPORTED_THING_TYPES_UIDS, DISCOVERY_TIMEOUT_S, false);
+ super(AsuswrtRouter.class, SUPPORTED_THING_TYPES_UIDS, DISCOVERY_TIMEOUT_S, false);
}
@Override
- public void activate() {
- }
-
- @Override
- public void deactivate() {
- super.deactivate();
+ public void dispose() {
+ super.dispose();
removeAllResults();
}
@Override
- public void setThingHandler(@Nullable ThingHandler handler) {
- if (handler instanceof AsuswrtRouter router) {
- router.setDiscoveryService(this);
- this.router = router;
- this.uid = router.getUID().getAsString();
- }
- }
-
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return this.router;
+ public void initialize() {
+ thingHandler.setDiscoveryService(this);
+ uid = thingHandler.getThing().getUID().getAsString();
+ super.initialize();
}
/*
@Override
public void startScan() {
logger.trace("{} starting scan", uid);
- if (router != null) {
- /* query Data */
- router.queryDeviceData(false);
- /* discover interfaces */
- AsuswrtInterfaceList ifList = router.getInterfaces();
- handleInterfaceScan(ifList);
- /* discover clients */
- AsuswrtClientList clientList = router.getClients();
- handleClientScan(clientList);
- }
+ /* query Data */
+ thingHandler.queryDeviceData(false);
+ /* discover interfaces */
+ AsuswrtInterfaceList ifList = thingHandler.getInterfaces();
+ handleInterfaceScan(ifList);
+ /* discover clients */
+ AsuswrtClientList clientList = thingHandler.getClients();
+ handleClientScan(clientList);
}
@Override
properties.put(Thing.PROPERTY_MAC_ADDRESS, macAddress);
logger.debug("{} thing discovered: '{}", uid, label);
- if (this.router != null) {
- ThingUID bridgeUID = router.getUID();
- ThingUID thingUID = new ThingUID(THING_TYPE_INTERFACE, bridgeUID, ifName);
- return DiscoveryResultBuilder.create(thingUID).withProperties(properties)
- .withRepresentationProperty(NETWORK_REPRESENTATION_PROPERTY).withBridge(bridgeUID).withLabel(label)
- .build();
- } else {
- ThingUID thingUID = new ThingUID(BINDING_ID, ifName);
- return DiscoveryResultBuilder.create(thingUID).withProperties(properties)
- .withRepresentationProperty(NETWORK_REPRESENTATION_PROPERTY).withLabel(label).build();
- }
+
+ ThingUID bridgeUID = thingHandler.getUID();
+ ThingUID thingUID = new ThingUID(THING_TYPE_INTERFACE, bridgeUID, ifName);
+ return DiscoveryResultBuilder.create(thingUID).withProperties(properties)
+ .withRepresentationProperty(NETWORK_REPRESENTATION_PROPERTY).withBridge(bridgeUID).withLabel(label)
+ .build();
}
/**
properties.put(CHANNEL_CLIENT_NICKNAME, nickName);
logger.debug("{} thing discovered: '{}", uid, label);
- if (this.router != null) {
- ThingUID bridgeUID = router.getUID();
- ThingUID thingUID = new ThingUID(THING_TYPE_CLIENT, bridgeUID, unformatedMac);
- return DiscoveryResultBuilder.create(thingUID).withProperties(properties)
- .withRepresentationProperty(CLIENT_REPRESENTATION_PROPERTY).withTTL(DISCOVERY_AUTOREMOVE_S)
- .withBridge(bridgeUID).withLabel(label).build();
- } else {
- ThingUID thingUID = new ThingUID(BINDING_ID, unformatedMac);
- return DiscoveryResultBuilder.create(thingUID).withProperties(properties)
- .withRepresentationProperty(CLIENT_REPRESENTATION_PROPERTY).withTTL(DISCOVERY_AUTOREMOVE_S)
- .withLabel(label).build();
- }
+ ThingUID bridgeUID = thingHandler.getUID();
+ ThingUID thingUID = new ThingUID(THING_TYPE_CLIENT, bridgeUID, unformatedMac);
+ return DiscoveryResultBuilder.create(thingUID).withProperties(properties)
+ .withRepresentationProperty(CLIENT_REPRESENTATION_PROPERTY).withTTL(DISCOVERY_AUTOREMOVE_S)
+ .withBridge(bridgeUID).withLabel(label).build();
}
}
import org.openhab.core.thing.binding.ThingActions;
import org.openhab.core.thing.binding.ThingActionsScope;
import org.openhab.core.thing.binding.ThingHandler;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* @author Markus Pfleger - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = AutomowerActions.class)
@ThingActionsScope(name = "automower")
@NonNullByDefault
public class AutomowerActions implements ThingActions {
import java.util.stream.Stream;
import org.eclipse.jdt.annotation.NonNullByDefault;
-import org.eclipse.jdt.annotation.Nullable;
import org.openhab.binding.avmfritz.internal.dto.AVMFritzBaseModel;
import org.openhab.binding.avmfritz.internal.dto.GroupModel;
import org.openhab.binding.avmfritz.internal.handler.AVMFritzBaseBridgeHandler;
import org.openhab.binding.avmfritz.internal.hardware.FritzAhaStatusListener;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResult;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
import org.openhab.core.config.discovery.DiscoveryService;
import org.openhab.core.thing.ThingTypeUID;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
* @author Robert Bausdorf - Initial contribution
* @author Christoph Weitkamp - Added support for groups
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = AVMFritzDiscoveryService.class)
@NonNullByDefault
-public class AVMFritzDiscoveryService extends AbstractDiscoveryService
- implements FritzAhaStatusListener, DiscoveryService, ThingHandlerService {
-
+public class AVMFritzDiscoveryService extends AbstractThingHandlerDiscoveryService<AVMFritzBaseBridgeHandler>
+ implements FritzAhaStatusListener, DiscoveryService {
private final Logger logger = LoggerFactory.getLogger(AVMFritzDiscoveryService.class);
- /**
- * Handler of the bridge of which devices have to be discovered.
- */
- private @NonNullByDefault({}) AVMFritzBaseBridgeHandler bridgeHandler;
public AVMFritzDiscoveryService() {
- super(Stream
+ super(AVMFritzBaseBridgeHandler.class, Stream
.of(SUPPORTED_LIGHTING_THING_TYPES, SUPPORTED_BUTTON_THING_TYPES_UIDS, SUPPORTED_HEATING_THING_TYPES,
SUPPORTED_DEVICE_THING_TYPES_UIDS, SUPPORTED_GROUP_THING_TYPES_UIDS)
.flatMap(Set::stream).collect(Collectors.toUnmodifiableSet()), 30);
}
@Override
- public void activate() {
- super.activate(null);
- bridgeHandler.registerStatusListener(this);
+ public void initialize() {
+ thingHandler.registerStatusListener(this);
+ super.initialize();
}
@Override
- public void deactivate() {
- bridgeHandler.unregisterStatusListener(this);
- super.deactivate();
+ public void dispose() {
+ super.dispose();
+ thingHandler.unregisterStatusListener(this);
}
@Override
public void startScan() {
- logger.debug("Start manual scan on bridge {}", bridgeHandler.getThing().getUID());
- bridgeHandler.handleRefreshCommand();
+ logger.debug("Start manual scan on bridge {}", thingHandler.getThing().getUID());
+ thingHandler.handleRefreshCommand();
}
@Override
protected synchronized void stopScan() {
- logger.debug("Stop manual scan on bridge {}", bridgeHandler.getThing().getUID());
+ logger.debug("Stop manual scan on bridge {}", thingHandler.getThing().getUID());
super.stopScan();
}
- @Override
- public void setThingHandler(@NonNullByDefault({}) ThingHandler handler) {
- if (handler instanceof AVMFritzBaseBridgeHandler baseBridgeHandler) {
- bridgeHandler = baseBridgeHandler;
- }
- }
-
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return bridgeHandler;
- }
-
@Override
public void onDeviceAdded(AVMFritzBaseModel device) {
- String id = bridgeHandler.getThingTypeId(device);
+ String id = thingHandler.getThingTypeId(device);
ThingTypeUID thingTypeUID = id.isEmpty() ? null : new ThingTypeUID(BINDING_ID, id);
if (thingTypeUID != null && getSupportedThingTypes().contains(thingTypeUID)) {
- ThingUID thingUID = new ThingUID(thingTypeUID, bridgeHandler.getThing().getUID(),
- bridgeHandler.getThingName(device));
+ ThingUID thingUID = new ThingUID(thingTypeUID, thingHandler.getThing().getUID(),
+ thingHandler.getThingName(device));
onDeviceAddedInternal(thingUID, device);
} else {
logger.debug("Discovered unsupported device: {}", device);
}
DiscoveryResult discoveryResult = DiscoveryResultBuilder.create(thingUID).withProperties(properties)
- .withRepresentationProperty(CONFIG_AIN).withBridge(bridgeHandler.getThing().getUID())
+ .withRepresentationProperty(CONFIG_AIN).withBridge(thingHandler.getThing().getUID())
.withLabel(device.getName()).build();
thingDiscovered(discoveryResult);
import org.openhab.binding.bondhome.internal.api.BondDevice;
import org.openhab.binding.bondhome.internal.api.BondHttpApi;
import org.openhab.binding.bondhome.internal.handler.BondBridgeHandler;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResult;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Sara Geleskie Damiano - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = BondDiscoveryService.class)
@NonNullByDefault
-public class BondDiscoveryService extends AbstractDiscoveryService implements ThingHandlerService {
+public class BondDiscoveryService extends AbstractThingHandlerDiscoveryService<BondBridgeHandler> {
private static final long REFRESH_INTERVAL_MINUTES = 60;
private final Logger logger = LoggerFactory.getLogger(BondDiscoveryService.class);
private @Nullable ScheduledFuture<?> discoveryJob;
- private @Nullable BondBridgeHandler bridgeHandler;
private @Nullable BondHttpApi api;
public BondDiscoveryService() {
- super(SUPPORTED_THING_TYPES, 10);
+ super(BondBridgeHandler.class, SUPPORTED_THING_TYPES, 10);
this.discoveryJob = null;
}
@Override
- public void deactivate() {
- super.deactivate();
- }
-
- @Override
- public void setThingHandler(@Nullable ThingHandler handler) {
- if (handler instanceof BondBridgeHandler localHandler) {
- bridgeHandler = localHandler;
- localHandler.setDiscoveryService(this);
- api = localHandler.getBridgeAPI();
- }
- }
-
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return bridgeHandler;
+ public void initialize() {
+ thingHandler.setDiscoveryService(this);
+ api = thingHandler.getBridgeAPI();
+ super.initialize();
}
@Override
protected synchronized void startScan() {
logger.debug("Start scan for Bond devices.");
try {
+ BondBridgeHandler bridgeHandler = thingHandler;
final ThingUID bridgeUid = bridgeHandler.getThing().getUID();
api = bridgeHandler.getBridgeAPI();
List<String> deviceList = api.getDevices();
import java.util.Set;
import org.eclipse.jdt.annotation.NonNullByDefault;
-import org.eclipse.jdt.annotation.Nullable;
import org.openhab.binding.boschindego.internal.IndegoTypeDatabase;
import org.openhab.binding.boschindego.internal.dto.response.DevicePropertiesResponse;
import org.openhab.binding.boschindego.internal.exceptions.IndegoException;
import org.openhab.binding.boschindego.internal.handler.BoschAccountHandler;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResult;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
import org.openhab.core.thing.Thing;
import org.openhab.core.thing.ThingTypeUID;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Jacob Laursen - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = IndegoDiscoveryService.class)
@NonNullByDefault
-public class IndegoDiscoveryService extends AbstractDiscoveryService implements ThingHandlerService {
-
+public class IndegoDiscoveryService extends AbstractThingHandlerDiscoveryService<BoschAccountHandler> {
private static final int TIMEOUT_SECONDS = 60;
private final Logger logger = LoggerFactory.getLogger(IndegoDiscoveryService.class);
- private @NonNullByDefault({}) BoschAccountHandler accountHandler;
-
public IndegoDiscoveryService() {
- super(Set.of(THING_TYPE_ACCOUNT), TIMEOUT_SECONDS, false);
- }
-
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return accountHandler;
- }
-
- @Override
- public void setThingHandler(ThingHandler handler) {
- if (handler instanceof BoschAccountHandler accountHandler) {
- this.accountHandler = accountHandler;
- }
+ super(BoschAccountHandler.class, Set.of(THING_TYPE_ACCOUNT), TIMEOUT_SECONDS, false);
}
@Override
@Override
public void startScan() {
try {
- Collection<DevicePropertiesResponse> devices = accountHandler.getDevices();
+ Collection<DevicePropertiesResponse> devices = thingHandler.getDevices();
- ThingUID bridgeUID = accountHandler.getThing().getUID();
+ ThingUID bridgeUID = thingHandler.getThing().getUID();
for (DevicePropertiesResponse device : devices) {
ThingUID thingUID = new ThingUID(THING_TYPE_INDEGO, bridgeUID, device.serialNumber);
DiscoveryResult discoveryResult = DiscoveryResultBuilder.create(thingUID)
}
@Override
- public void deactivate() {
+ public void dispose() {
+ super.dispose();
removeOlderResults(Instant.now().getEpochSecond());
}
}
import org.openhab.binding.boschshc.internal.devices.bridge.dto.Device;
import org.openhab.binding.boschshc.internal.devices.bridge.dto.Room;
import org.openhab.binding.boschshc.internal.devices.bridge.dto.UserDefinedState;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
import org.openhab.core.thing.ThingTypeUID;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
import org.openhab.core.thing.binding.ThingHandlerService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Gerd Zanker - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = ThingHandlerService.class)
@NonNullByDefault
-public class ThingDiscoveryService extends AbstractDiscoveryService implements ThingHandlerService {
+public class ThingDiscoveryService extends AbstractThingHandlerDiscoveryService<BridgeHandler> {
private static final int SEARCH_TIME = 1;
private final Logger logger = LoggerFactory.getLogger(ThingDiscoveryService.class);
- private @Nullable BridgeHandler shcBridgeHandler;
protected static final Set<ThingTypeUID> SUPPORTED_THING_TYPES = Set.of(
BoschSHCBindingConstants.THING_TYPE_INWALL_SWITCH, BoschSHCBindingConstants.THING_TYPE_TWINGUARD,
// @formatter:on
public ThingDiscoveryService() {
- super(SUPPORTED_THING_TYPES, SEARCH_TIME);
+ super(BridgeHandler.class, SUPPORTED_THING_TYPES, SEARCH_TIME);
}
@Override
- public void activate() {
- logger.trace("activate");
- final BridgeHandler handler = shcBridgeHandler;
- if (handler != null) {
- handler.registerDiscoveryListener(this);
- }
+ public void initialize() {
+ logger.trace("initialize");
+ thingHandler.registerDiscoveryListener(this);
+ super.initialize();
}
@Override
- public void deactivate() {
- logger.trace("deactivate");
- final BridgeHandler handler = shcBridgeHandler;
- if (handler != null) {
- removeOlderResults(new Date().getTime(), handler.getThing().getUID());
- handler.unregisterDiscoveryListener();
- }
+ public void dispose() {
+ super.dispose();
+ logger.trace("dispose");
+ removeOlderResults(new Date().getTime(), thingHandler.getThing().getUID());
+ thingHandler.unregisterDiscoveryListener();
super.deactivate();
}
@Override
protected void startScan() {
- if (shcBridgeHandler == null) {
- logger.debug("The shcBridgeHandler is empty, no manual scan is currently possible");
- return;
- }
-
try {
doScan();
} catch (InterruptedException e) {
@Override
protected synchronized void stopScan() {
- logger.debug("Stop manual scan on bridge {}",
- shcBridgeHandler != null ? shcBridgeHandler.getThing().getUID() : "?");
+ logger.debug("Stop manual scan on bridge {}", thingHandler.getThing().getUID());
super.stopScan();
- final BridgeHandler handler = shcBridgeHandler;
- if (handler != null) {
- removeOlderResults(getTimestampOfLastScan(), handler.getThing().getUID());
- }
- }
-
- @Override
- public void setThingHandler(@Nullable ThingHandler handler) {
- if (handler instanceof BridgeHandler bridgeHandler) {
- logger.trace("Set bridge handler {}", handler);
- shcBridgeHandler = bridgeHandler;
- }
- }
-
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return shcBridgeHandler;
+ removeOlderResults(getTimestampOfLastScan(), thingHandler.getThing().getUID());
}
public void doScan() throws InterruptedException {
- logger.debug("Start manual scan on bridge {}", shcBridgeHandler.getThing().getUID());
+ logger.debug("Start manual scan on bridge {}", thingHandler.getThing().getUID());
// use shcBridgeHandler to getDevices()
- List<Room> rooms = shcBridgeHandler.getRooms();
+ List<Room> rooms = thingHandler.getRooms();
logger.debug("SHC has {} rooms", rooms.size());
- List<Device> devices = shcBridgeHandler.getDevices();
+ List<Device> devices = thingHandler.getDevices();
logger.debug("SHC has {} devices", devices.size());
- List<UserDefinedState> userStates = shcBridgeHandler.getUserStates();
+ List<UserDefinedState> userStates = thingHandler.getUserStates();
logger.debug("SHC has {} user-defined states", userStates.size());
// Write found devices into openhab.log to support manual configuration
}
private void addUserState(UserDefinedState userState) {
- // see startScan for the runtime null check of shcBridgeHandler
- assert shcBridgeHandler != null;
-
logger.trace("Discovering user-defined state {}", userState.getName());
logger.trace("- details: id {}, state {}", userState.getId(), userState.isState());
logger.trace("- got thingTypeID '{}' for user-defined state '{}'", thingTypeUID.getId(), userState.getName());
- ThingUID thingUID = new ThingUID(thingTypeUID, shcBridgeHandler.getThing().getUID(),
+ ThingUID thingUID = new ThingUID(thingTypeUID, thingHandler.getThing().getUID(),
userState.getId().replace(':', '_'));
logger.trace("- got thingUID '{}' for user-defined state: '{}'", thingUID, userState);
DiscoveryResultBuilder discoveryResult = DiscoveryResultBuilder.create(thingUID).withThingType(thingTypeUID)
.withProperty("id", userState.getId()).withLabel(userState.getName());
- discoveryResult.withBridge(shcBridgeHandler.getThing().getUID());
+ discoveryResult.withBridge(thingHandler.getThing().getUID());
thingDiscovered(discoveryResult.build());
protected void addDevice(Device device, String roomName) {
// see startScan for the runtime null check of shcBridgeHandler
- assert shcBridgeHandler != null;
-
logger.trace("Discovering device {}", device.name);
logger.trace("- details: id {}, roomId {}, deviceModel {}", device.id, device.roomId, device.deviceModel);
logger.trace("- got thingTypeID '{}' for deviceModel '{}'", thingTypeUID.getId(), device.deviceModel);
- ThingUID thingUID = new ThingUID(thingTypeUID, shcBridgeHandler.getThing().getUID(),
- device.id.replace(':', '_'));
+ ThingUID thingUID = new ThingUID(thingTypeUID, thingHandler.getThing().getUID(), device.id.replace(':', '_'));
logger.trace("- got thingUID '{}' for device: '{}'", thingUID, device);
DiscoveryResultBuilder discoveryResult = DiscoveryResultBuilder.create(thingUID).withThingType(thingTypeUID)
.withProperty("id", device.id).withLabel(getNiceName(device.name, roomName));
- if (null != shcBridgeHandler) {
- discoveryResult.withBridge(shcBridgeHandler.getThing().getUID());
- }
+ discoveryResult.withBridge(thingHandler.getThing().getUID());
if (!roomName.isEmpty()) {
discoveryResult.withProperty("Location", roomName);
}
import org.openhab.binding.bticinosmarther.internal.account.SmartherAccountHandler;
import org.openhab.binding.bticinosmarther.internal.api.dto.Location;
import org.openhab.binding.bticinosmarther.internal.api.dto.Module;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResult;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
import org.openhab.core.config.discovery.DiscoveryService;
import org.openhab.core.thing.ThingTypeUID;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Fabio Possieri - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = SmartherModuleDiscoveryService.class)
@NonNullByDefault
-public class SmartherModuleDiscoveryService extends AbstractDiscoveryService
- implements DiscoveryService, ThingHandlerService {
+public class SmartherModuleDiscoveryService extends AbstractThingHandlerDiscoveryService<SmartherAccountHandler> {
// Only modules can be discovered. A bridge must be manually added.
private static final Set<ThingTypeUID> SUPPORTED_THING_TYPES_UIDS = Set.of(THING_TYPE_MODULE);
private final Logger logger = LoggerFactory.getLogger(SmartherModuleDiscoveryService.class);
- private @Nullable SmartherAccountHandler bridgeHandler;
private @Nullable ThingUID bridgeUID;
/**
* Constructs a {@code SmartherModuleDiscoveryService}.
*/
public SmartherModuleDiscoveryService() {
- super(SUPPORTED_THING_TYPES_UIDS, DISCOVERY_TIME_SECONDS);
+ super(SmartherAccountHandler.class, SUPPORTED_THING_TYPES_UIDS, DISCOVERY_TIME_SECONDS);
}
@Override
@Override
public void activate() {
- logger.debug("Bridge[{}] Activating chronothermostat discovery service", this.bridgeUID);
Map<String, Object> properties = new HashMap<>();
properties.put(DiscoveryService.CONFIG_PROPERTY_BACKGROUND_DISCOVERY, Boolean.TRUE);
super.activate(properties);
}
@Override
- public void deactivate() {
- logger.debug("Bridge[{}] Deactivating chronothermostat discovery service", this.bridgeUID);
- removeOlderResults(new Date().getTime());
- }
-
- @Override
- public void setThingHandler(@Nullable ThingHandler handler) {
- if (handler instanceof SmartherAccountHandler localBridgeHandler) {
- this.bridgeHandler = localBridgeHandler;
- this.bridgeUID = localBridgeHandler.getUID();
- }
+ public void initialize() {
+ logger.debug("Bridge[{}] Activating chronothermostat discovery service", this.bridgeUID);
+ this.bridgeUID = thingHandler.getThing().getUID();
+ super.initialize();
}
@Override
- public @Nullable ThingHandler getThingHandler() {
- return this.bridgeHandler;
+ public void dispose() {
+ super.dispose();
+ logger.debug("Bridge[{}] Deactivating chronothermostat discovery service", this.bridgeUID);
+ removeOlderResults(new Date().getTime());
}
@Override
* Discovers Chronothermostat devices for the given bridge handler.
*/
private synchronized void discoverChronothermostats() {
- final SmartherAccountHandler localBridgeHandler = this.bridgeHandler;
- if (localBridgeHandler != null) {
- // If the bridge is not online no other thing devices can be found, so no reason to scan at this moment
- if (localBridgeHandler.isOnline()) {
- localBridgeHandler.getLocations()
- .forEach(l -> localBridgeHandler.getLocationModules(l).forEach(m -> addDiscoveredDevice(l, m)));
- }
+ // If the bridge is not online no other thing devices can be found, so no reason to scan at this moment
+ if (thingHandler.isOnline()) {
+ thingHandler.getLocations()
+ .forEach(l -> thingHandler.getLocationModules(l).forEach(m -> addDiscoveredDevice(l, m)));
}
}
import org.openhab.core.thing.binding.ThingActions;
import org.openhab.core.thing.binding.ThingActionsScope;
import org.openhab.core.thing.binding.ThingHandler;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Georgios Moutsos - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = CaddxBridgeActions.class)
@ThingActionsScope(name = "caddx")
@NonNullByDefault
public class CaddxBridgeActions implements ThingActions {
import org.openhab.core.thing.binding.ThingActions;
import org.openhab.core.thing.binding.ThingActionsScope;
import org.openhab.core.thing.binding.ThingHandler;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Georgios Moutsos - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = CaddxKeypadActions.class)
@ThingActionsScope(name = "caddx")
@NonNullByDefault
public class CaddxKeypadActions implements ThingActions {
import org.openhab.core.thing.binding.ThingActions;
import org.openhab.core.thing.binding.ThingActionsScope;
import org.openhab.core.thing.binding.ThingHandler;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Georgios Moutsos - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = CaddxPanelActions.class)
@ThingActionsScope(name = "caddx")
@NonNullByDefault
public class CaddxPanelActions implements ThingActions {
import java.util.Map;
import org.eclipse.jdt.annotation.NonNullByDefault;
-import org.eclipse.jdt.annotation.Nullable;
import org.openhab.binding.caddx.internal.CaddxBindingConstants;
import org.openhab.binding.caddx.internal.CaddxEvent;
import org.openhab.binding.caddx.internal.config.CaddxKeypadConfiguration;
import org.openhab.binding.caddx.internal.config.CaddxZoneConfiguration;
import org.openhab.binding.caddx.internal.handler.CaddxBridgeHandler;
import org.openhab.binding.caddx.internal.handler.CaddxThingType;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResult;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
-import org.openhab.core.config.discovery.DiscoveryService;
import org.openhab.core.thing.Bridge;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Georgios Moutsos - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = CaddxDiscoveryService.class)
@NonNullByDefault
-public class CaddxDiscoveryService extends AbstractDiscoveryService implements ThingHandlerService, DiscoveryService {
+public class CaddxDiscoveryService extends AbstractThingHandlerDiscoveryService<CaddxBridgeHandler> {
private final Logger logger = LoggerFactory.getLogger(CaddxDiscoveryService.class);
- private @Nullable CaddxBridgeHandler caddxBridgeHandler = null;
-
public CaddxDiscoveryService() {
- super(CaddxBindingConstants.SUPPORTED_THING_TYPES_UIDS, 15, false);
+ super(CaddxBridgeHandler.class, CaddxBindingConstants.SUPPORTED_THING_TYPES_UIDS, 15, false);
}
@Override
* Activates the Discovery Service.
*/
@Override
- public void activate() {
- CaddxBridgeHandler handler = caddxBridgeHandler;
- if (handler != null) {
- handler.registerDiscoveryService(this);
- }
+ public void initialize() {
+ thingHandler.registerDiscoveryService(this);
+ super.initialize();
}
/**
* Deactivates the Discovery Service.
*/
@Override
- public void deactivate() {
- CaddxBridgeHandler handler = caddxBridgeHandler;
- if (handler != null) {
- handler.unregisterDiscoveryService();
- }
- }
-
- @Override
- public void setThingHandler(@Nullable ThingHandler handler) {
- if (handler instanceof CaddxBridgeHandler bridgeHandler) {
- caddxBridgeHandler = bridgeHandler;
- }
- }
-
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return caddxBridgeHandler;
+ public void dispose() {
+ super.dispose();
+ thingHandler.unregisterDiscoveryService();
}
}
import java.io.IOException;
import java.math.BigDecimal;
import java.util.Collection;
-import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.TooManyListenersException;
@Override
public Collection<Class<? extends ThingHandlerService>> getServices() {
- Set<Class<? extends ThingHandlerService>> set = new HashSet<Class<? extends ThingHandlerService>>(2);
- set.add(CaddxDiscoveryService.class);
- set.add(CaddxBridgeActions.class);
- return set;
+ return Set.of(CaddxBridgeActions.class, CaddxDiscoveryService.class);
}
public void restart() {
import org.openhab.core.config.core.ParameterOption;
import org.openhab.core.thing.binding.ThingHandler;
import org.openhab.core.thing.binding.ThingHandlerService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
/**
* The {@link ChatGPTModelOptionProvider} provides the available models from OpenAI as options for the channel
*
* @author Kai Kreuzer - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = { ChatGPTModelOptionProvider.class, ConfigOptionProvider.class })
@NonNullByDefault
public class ChatGPTModelOptionProvider implements ThingHandlerService, ConfigOptionProvider {
import org.openhab.core.thing.binding.ThingActions;
import org.openhab.core.thing.binding.ThingActionsScope;
import org.openhab.core.thing.binding.ThingHandler;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Scott Hanson - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = ChromecastActions.class)
@ThingActionsScope(name = "chromecast")
@NonNullByDefault
public class ChromecastActions implements ThingActions {
import org.openhab.core.thing.binding.ThingActions;
import org.openhab.core.thing.binding.ThingActionsScope;
import org.openhab.core.thing.binding.ThingHandler;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* @author Joan Pujol - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = DBQueryActions.class)
@ThingActionsScope(name = "dbquery")
@NonNullByDefault
public class DBQueryActions implements IDBQueryActions, ThingActions {
import org.openhab.core.thing.binding.ThingActions;
import org.openhab.core.thing.binding.ThingActionsScope;
import org.openhab.core.thing.binding.ThingHandler;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Jan N. Klug - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = BridgeActions.class)
@ThingActionsScope(name = "deconz")
@NonNullByDefault
public class BridgeActions implements ThingActions {
import org.openhab.core.thing.binding.ThingActions;
import org.openhab.core.thing.binding.ThingActionsScope;
import org.openhab.core.thing.binding.ThingHandler;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Jan N. Klug - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = GroupActions.class)
@ThingActionsScope(name = "deconz")
@NonNullByDefault
public class GroupActions implements ThingActions {
import org.openhab.binding.deconz.internal.handler.SensorThingHandler;
import org.openhab.binding.deconz.internal.types.GroupType;
import org.openhab.binding.deconz.internal.types.LightType;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResult;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
import org.openhab.core.config.discovery.DiscoveryService;
import org.openhab.core.thing.Thing;
import org.openhab.core.thing.ThingTypeUID;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
+import org.osgi.service.component.annotations.Activate;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author David Graeff - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = ThingDiscoveryService.class)
@NonNullByDefault
-public class ThingDiscoveryService extends AbstractDiscoveryService implements DiscoveryService, ThingHandlerService {
+public class ThingDiscoveryService extends AbstractThingHandlerDiscoveryService<DeconzBridgeHandler>
+ implements DiscoveryService {
private static final Set<ThingTypeUID> SUPPORTED_THING_TYPES_UIDS = Stream
.of(LightThingHandler.SUPPORTED_THING_TYPE_UIDS, SensorThingHandler.SUPPORTED_THING_TYPES,
SensorThermostatThingHandler.SUPPORTED_THING_TYPES)
.flatMap(Set::stream).collect(Collectors.toSet());
private final Logger logger = LoggerFactory.getLogger(ThingDiscoveryService.class);
- private @Nullable DeconzBridgeHandler handler;
private @Nullable ScheduledFuture<?> scanningJob;
private @Nullable ThingUID bridgeUID;
+ @Activate
public ThingDiscoveryService() {
- super(SUPPORTED_THING_TYPES_UIDS, 30);
+ super(DeconzBridgeHandler.class, SUPPORTED_THING_TYPES_UIDS, 30);
}
@Override
public void startScan() {
- final DeconzBridgeHandler handler = this.handler;
- if (handler != null) {
- handler.getBridgeFullState().thenAccept(fullState -> {
- stopScan();
- fullState.ifPresent(state -> {
- state.sensors.forEach(this::addSensor);
- state.lights.forEach(this::addLight);
- state.groups.forEach(this::addGroup);
- });
-
+ thingHandler.getBridgeFullState().thenAccept(fullState -> {
+ stopScan();
+ fullState.ifPresent(state -> {
+ state.sensors.forEach(this::addSensor);
+ state.lights.forEach(this::addLight);
+ state.groups.forEach(this::addGroup);
});
- }
+
+ });
}
@Override
}
@Override
- public void setThingHandler(@Nullable ThingHandler handler) {
- if (handler instanceof DeconzBridgeHandler bridgeHandler) {
- this.handler = bridgeHandler;
- this.bridgeUID = handler.getThing().getUID();
- }
- }
-
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return handler;
- }
-
- @Override
- public void activate() {
- super.activate(null);
+ public void initialize() {
+ bridgeUID = thingHandler.getThing().getUID();
+ super.initialize();
}
@Override
- public void deactivate() {
+ public void dispose() {
+ super.dispose();
removeOlderResults(new Date().getTime());
- super.deactivate();
}
}
.getBridgeFullState();
ThingDiscoveryService discoveryService = new ThingDiscoveryService();
discoveryService.setThingHandler(bridgeHandler);
+ discoveryService.initialize();
discoveryService.addDiscoveryListener(discoveryListener);
discoveryService.startScan();
Mockito.verify(discoveryListener, times(20)).thingDiscovered(any(), any());
import java.util.Set;
import org.eclipse.jdt.annotation.NonNullByDefault;
-import org.eclipse.jdt.annotation.Nullable;
import org.openhab.binding.digiplex.internal.communication.AreaLabelRequest;
import org.openhab.binding.digiplex.internal.communication.AreaLabelResponse;
import org.openhab.binding.digiplex.internal.communication.DigiplexMessageHandler;
import org.openhab.binding.digiplex.internal.communication.ZoneLabelRequest;
import org.openhab.binding.digiplex.internal.communication.ZoneLabelResponse;
import org.openhab.binding.digiplex.internal.handler.DigiplexBridgeHandler;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResult;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
-import org.openhab.core.config.discovery.DiscoveryService;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
/**
* Service for discovering things on Digiplex alarm systems
* @author Robert Michalak - Initial contribution
*
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = DigiplexDiscoveryService.class)
@NonNullByDefault
-public class DigiplexDiscoveryService extends AbstractDiscoveryService
- implements DiscoveryService, ThingHandlerService, DigiplexMessageHandler {
+public class DigiplexDiscoveryService extends AbstractThingHandlerDiscoveryService<DigiplexBridgeHandler>
+ implements DigiplexMessageHandler {
private static final int MAX_ZONE = 96;
private static final int MAX_AREA = 8;
private static final int DISCOVERY_TIMEOUT = 30;
- private @Nullable DigiplexBridgeHandler bridgeHandler;
-
public DigiplexDiscoveryService() {
- super(Set.of(THING_TYPE_ZONE), DISCOVERY_TIMEOUT, false);
+ super(DigiplexBridgeHandler.class, Set.of(THING_TYPE_ZONE), DISCOVERY_TIMEOUT, false);
}
@Override
@SuppressWarnings("null")
protected void startScan() {
- bridgeHandler.registerMessageHandler(this);
+ thingHandler.registerMessageHandler(this);
// find zones
for (int i = 1; i <= MAX_ZONE; i++) {
DigiplexRequest command = new ZoneLabelRequest(i);
- bridgeHandler.sendRequest(command);
+ thingHandler.sendRequest(command);
}
// find areas
for (int i = 1; i <= MAX_AREA; i++) {
DigiplexRequest command = new AreaLabelRequest(i);
- bridgeHandler.sendRequest(command);
+ thingHandler.sendRequest(command);
}
}
@Override
@SuppressWarnings("null")
protected synchronized void stopScan() {
- bridgeHandler.unregisterMessageHandler(this);
+ thingHandler.unregisterMessageHandler(this);
super.stopScan();
}
if (isDefaultName(response)) {
return;
}
-
- ThingUID bridgeUID = bridgeHandler.getThing().getUID();
+ ThingUID bridgeUID = thingHandler.getThing().getUID();
ThingUID thingUID = new ThingUID(THING_TYPE_ZONE, bridgeUID, String.format("zone%d", response.zoneNo));
Map<String, Object> properties = new HashMap<>(1);
return;
}
- ThingUID bridgeUID = bridgeHandler.getThing().getUID();
+ ThingUID bridgeUID = thingHandler.getThing().getUID();
ThingUID thingUID = new ThingUID(THING_TYPE_AREA, bridgeUID, String.format("area%d", response.areaNo));
Map<String, Object> properties = new HashMap<>(1);
}
@Override
- public void setThingHandler(@Nullable ThingHandler handler) {
- if (handler instanceof DigiplexBridgeHandler digiplexBridgeHandler) {
- bridgeHandler = digiplexBridgeHandler;
- bridgeHandler.registerMessageHandler(this);
- }
- }
-
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return bridgeHandler;
- }
-
- @Override
- public void activate() {
- super.activate(null);
- }
-
- @Override
- public void deactivate() {
- super.deactivate();
+ public void initialize() {
+ thingHandler.registerMessageHandler(this);
+ super.initialize();
}
}
import org.openhab.core.thing.binding.ThingActions;
import org.openhab.core.thing.binding.ThingActionsScope;
import org.openhab.core.thing.binding.ThingHandler;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Jan N. Klug - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = DmxActions.class)
@ThingActionsScope(name = "dmx")
@NonNullByDefault
public class DmxActions implements ThingActions {
import org.openhab.core.thing.binding.ThingActions;
import org.openhab.core.thing.binding.ThingActionsScope;
import org.openhab.core.thing.binding.ThingHandler;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Mark Hilbush - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = DoorbirdActions.class)
@ThingActionsScope(name = "doorbird")
@NonNullByDefault
public class DoorbirdActions implements ThingActions {
import org.openhab.binding.draytonwiser.internal.model.RoomStatDTO;
import org.openhab.binding.draytonwiser.internal.model.SmartPlugDTO;
import org.openhab.binding.draytonwiser.internal.model.SmartValveDTO;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResult;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
-import org.openhab.core.config.discovery.DiscoveryService;
import org.openhab.core.thing.ThingTypeUID;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Andrew Schofield - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = DraytonWiserDiscoveryService.class)
@NonNullByDefault
-public class DraytonWiserDiscoveryService extends AbstractDiscoveryService
- implements DiscoveryService, ThingHandlerService, DraytonWiserRefreshListener {
+public class DraytonWiserDiscoveryService extends AbstractThingHandlerDiscoveryService<HeatHubHandler>
+ implements DraytonWiserRefreshListener {
private final Logger logger = LoggerFactory.getLogger(DraytonWiserDiscoveryService.class);
- private @Nullable HeatHubHandler bridgeHandler;
private @Nullable ThingUID bridgeUID;
public DraytonWiserDiscoveryService() {
- super(SUPPORTED_THING_TYPES_UIDS, 30, false);
- }
-
- @Override
- public void activate() {
- super.activate(null);
- }
-
- @Override
- public void deactivate() {
- super.deactivate();
+ super(HeatHubHandler.class, SUPPORTED_THING_TYPES_UIDS, 30, false);
}
@Override
protected void startScan() {
- final HeatHubHandler handler = bridgeHandler;
- if (handler != null) {
- removeOlderResults(getTimestampOfLastScan());
- handler.setDiscoveryService(this);
- }
+ removeOlderResults(getTimestampOfLastScan());
+ thingHandler.setDiscoveryService(this);
}
@Override
@Override
public synchronized void stopScan() {
- final HeatHubHandler handler = bridgeHandler;
-
- if (handler != null) {
- handler.unsetDiscoveryService();
- }
+ thingHandler.unsetDiscoveryService();
super.stopScan();
}
@Override
- public void setThingHandler(@Nullable final ThingHandler handler) {
- if (handler instanceof HeatHubHandler hubHandler) {
- bridgeHandler = hubHandler;
- bridgeUID = handler.getThing().getUID();
- } else {
- bridgeHandler = null;
- bridgeUID = null;
- }
- }
-
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return bridgeHandler;
+ public void initialize() {
+ bridgeUID = thingHandler.getThing().getUID();
+ super.initialize();
}
}
}
};
service.setThingHandler(bridgeHandler);
+ service.initialize();
final DomainDTO domain = api.getDomain();
if (domain == null) {
+++ /dev/null
-/**
- * Copyright (c) 2010-2024 Contributors to the openHAB 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.openhab.binding.dsmr.internal.discovery;
-
-import org.eclipse.jdt.annotation.NonNullByDefault;
-import org.eclipse.jdt.annotation.Nullable;
-import org.openhab.core.i18n.LocaleProvider;
-import org.openhab.core.i18n.TranslationProvider;
-import org.openhab.core.thing.binding.ThingHandlerService;
-import org.osgi.service.component.annotations.Activate;
-import org.osgi.service.component.annotations.Component;
-import org.osgi.service.component.annotations.Deactivate;
-import org.osgi.service.component.annotations.Reference;
-
-/**
- * Tracks the i18n provider dependencies of the {@link DSMRMeterDiscoveryService}. The {@link DSMRMeterDiscoveryService}
- * is a {@link ThingHandlerService} so its i18n dependencies cannot be injected using service component annotations.
- *
- * @author Wouter Born - Initial contribution
- */
-@Component
-@NonNullByDefault
-public class DSMRI18nProviderTracker {
-
- static @Nullable TranslationProvider i18nProvider;
- static @Nullable LocaleProvider localeProvider;
-
- @Activate
- public DSMRI18nProviderTracker(final @Reference TranslationProvider i18nProvider,
- final @Reference LocaleProvider localeProvider) {
- DSMRI18nProviderTracker.i18nProvider = i18nProvider;
- DSMRI18nProviderTracker.localeProvider = localeProvider;
- }
-
- @Deactivate
- public void deactivate() {
- i18nProvider = null;
- localeProvider = null;
- }
-}
import org.openhab.binding.dsmr.internal.handler.DSMRMeterHandler;
import org.openhab.binding.dsmr.internal.meter.DSMRMeterDescriptor;
import org.openhab.binding.dsmr.internal.meter.DSMRMeterType;
+import org.openhab.core.i18n.LocaleProvider;
+import org.openhab.core.i18n.TranslationProvider;
import org.openhab.core.library.types.StringType;
import org.openhab.core.thing.Thing;
import org.openhab.core.thing.binding.ThingHandler;
import org.openhab.core.thing.binding.ThingHandlerService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.Reference;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
* @author M. Volaart - Initial contribution
* @author Hilbrand Bouwkamp - Refactored code to detect meters during actual discovery phase.
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = DSMRMeterDiscoveryService.class)
@NonNullByDefault
public class DSMRMeterDiscoveryService extends DSMRDiscoveryService implements P1TelegramListener, ThingHandlerService {
*/
private @NonNullByDefault({}) DSMRBridgeHandler dsmrBridgeHandler;
- /**
- * Constructs a new {@link DSMRMeterDiscoveryService} attached to the give bridge handler.
- */
- public DSMRMeterDiscoveryService() {
- super();
- this.i18nProvider = DSMRI18nProviderTracker.i18nProvider;
- this.localeProvider = DSMRI18nProviderTracker.localeProvider;
+ @Reference(unbind = "-")
+ public void bindTranslationProvider(TranslationProvider translationProvider) {
+ this.i18nProvider = translationProvider;
+ }
+
+ @Reference(unbind = "-")
+ public void bindLocaleProvider(LocaleProvider localeProvider) {
+ this.localeProvider = localeProvider;
}
@Override
import org.openhab.binding.easee.internal.command.site.GetSite;
import org.openhab.binding.easee.internal.connector.CommunicationStatus;
import org.openhab.binding.easee.internal.handler.EaseeSiteHandler;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
import org.openhab.core.thing.ThingTypeUID;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
* @author Alexander Friese - initial contribution
*
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = EaseeSiteDiscoveryService.class)
@NonNullByDefault
-public class EaseeSiteDiscoveryService extends AbstractDiscoveryService implements ThingHandlerService {
+public class EaseeSiteDiscoveryService extends AbstractThingHandlerDiscoveryService<EaseeSiteHandler> {
private final Logger logger = LoggerFactory.getLogger(EaseeSiteDiscoveryService.class);
- private @NonNullByDefault({}) EaseeSiteHandler bridgeHandler;
public EaseeSiteDiscoveryService() throws IllegalArgumentException {
- super(EaseeBindingConstants.SUPPORTED_THING_TYPES_UIDS, 300, false);
+ super(EaseeSiteHandler.class, EaseeBindingConstants.SUPPORTED_THING_TYPES_UIDS, 300, false);
}
@Override
protected void startScan() {
- bridgeHandler.enqueueCommand(new GetSite(bridgeHandler, this::processSiteDiscoveryResult));
+ thingHandler.enqueueCommand(new GetSite(thingHandler, this::processSiteDiscoveryResult));
}
@Override
- public void setThingHandler(ThingHandler handler) {
- if (handler instanceof EaseeSiteHandler siteHandler) {
- this.bridgeHandler = siteHandler;
- this.bridgeHandler.setDiscoveryService(this);
- }
- }
-
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return bridgeHandler;
- }
-
- // method is defined in both implemented interface and inherited class, thus we must define a behaviour here.
- @Override
- public void deactivate() {
- super.deactivate();
+ public void initialize() {
+ thingHandler.setDiscoveryService(this);
+ super.initialize();
}
/**
*/
private DiscoveryResultBuilder initDiscoveryResultBuilder(String deviceType, String deviceId,
@Nullable String deviceName) {
- ThingUID bridgeUID = bridgeHandler.getThing().getUID();
+ ThingUID bridgeUID = thingHandler.getThing().getUID();
ThingTypeUID typeUid = new ThingTypeUID(BINDING_ID, deviceType);
ThingUID thingUID = new ThingUID(typeUid, bridgeUID, deviceId);
import java.util.Set;
import org.eclipse.jdt.annotation.NonNullByDefault;
-import org.eclipse.jdt.annotation.Nullable;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResult;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* @author Michael Barker - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = EchonetDiscoveryService.class)
@NonNullByDefault
-public class EchonetDiscoveryService extends AbstractDiscoveryService
- implements EchonetDiscoveryListener, ThingHandlerService {
+public class EchonetDiscoveryService extends AbstractThingHandlerDiscoveryService<EchonetLiteBridgeHandler>
+ implements EchonetDiscoveryListener {
private final Logger logger = LoggerFactory.getLogger(EchonetDiscoveryService.class);
- @Nullable
- private EchonetLiteBridgeHandler bridgeHandler;
-
public EchonetDiscoveryService() {
- super(Set.of(THING_TYPE_ECHONET_DEVICE), 10);
+ super(EchonetLiteBridgeHandler.class, Set.of(THING_TYPE_ECHONET_DEVICE), 10);
}
@Override
protected void startScan() {
- final EchonetLiteBridgeHandler bridgeHandler = this.bridgeHandler;
- logger.debug("startScan: {}", bridgeHandler);
- if (null != bridgeHandler) {
- bridgeHandler.startDiscovery(this);
- }
+ logger.debug("startScan: {}", thingHandler);
+ thingHandler.startDiscovery(this);
}
@Override
protected synchronized void stopScan() {
- final EchonetLiteBridgeHandler bridgeHandler = this.bridgeHandler;
- logger.debug("stopScan: {}", bridgeHandler);
- if (null != bridgeHandler) {
- bridgeHandler.stopDiscovery();
- }
+ logger.debug("stopScan: {}", thingHandler);
+ thingHandler.stopDiscovery();
}
@Override
public void onDeviceFound(String identifier, InstanceKey instanceKey) {
- final EchonetLiteBridgeHandler bridgeHandler = this.bridgeHandler;
-
- if (null == bridgeHandler) {
- return;
- }
-
final DiscoveryResult discoveryResult = DiscoveryResultBuilder
- .create(new ThingUID(THING_TYPE_ECHONET_DEVICE, bridgeHandler.getThing().getUID(), identifier))
+ .create(new ThingUID(THING_TYPE_ECHONET_DEVICE, thingHandler.getThing().getUID(), identifier))
.withProperty(PROPERTY_NAME_INSTANCE_KEY, instanceKey.representationProperty())
.withProperty(PROPERTY_NAME_HOSTNAME, instanceKey.address.getAddress().getHostAddress())
.withProperty(PROPERTY_NAME_PORT, instanceKey.address.getPort())
.withProperty(PROPERTY_NAME_GROUP_CODE, instanceKey.klass.groupCode())
.withProperty(PROPERTY_NAME_CLASS_CODE, instanceKey.klass.classCode())
- .withProperty(PROPERTY_NAME_INSTANCE, instanceKey.instance)
- .withBridge(bridgeHandler.getThing().getUID()).withRepresentationProperty(PROPERTY_NAME_INSTANCE_KEY)
- .build();
+ .withProperty(PROPERTY_NAME_INSTANCE, instanceKey.instance).withBridge(thingHandler.getThing().getUID())
+ .withRepresentationProperty(PROPERTY_NAME_INSTANCE_KEY).build();
thingDiscovered(discoveryResult);
}
-
- @Override
- public void deactivate() {
- ThingHandlerService.super.deactivate();
- }
-
- @Override
- public void activate() {
- ThingHandlerService.super.activate();
- }
-
- @Override
- public void setThingHandler(ThingHandler thingHandler) {
- if (thingHandler instanceof EchonetLiteBridgeHandler bridgeHandler) {
- this.bridgeHandler = bridgeHandler;
- }
- }
-
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return bridgeHandler;
- }
}
import org.openhab.core.thing.binding.ThingActions;
import org.openhab.core.thing.binding.ThingActionsScope;
import org.openhab.core.thing.binding.ThingHandler;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
* @author Mark Hilbush - Adapted for OH2/3
* @author Connor Petty - Proxy method for invoking actions
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = EcobeeActions.class)
@ThingActionsScope(name = "ecobee")
@NonNullByDefault
public class EcobeeActions implements ThingActions {
import org.openhab.binding.ecobee.internal.dto.thermostat.ThermostatDTO;
import org.openhab.binding.ecobee.internal.handler.EcobeeAccountBridgeHandler;
import org.openhab.binding.ecobee.internal.handler.EcobeeThermostatBridgeHandler;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResult;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
import org.openhab.core.thing.Thing;
import org.openhab.core.thing.ThingStatus;
import org.openhab.core.thing.ThingTypeUID;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Mark Hilbush - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = EcobeeDiscoveryService.class)
@NonNullByDefault
-public class EcobeeDiscoveryService extends AbstractDiscoveryService implements ThingHandlerService {
+public class EcobeeDiscoveryService extends AbstractThingHandlerDiscoveryService<EcobeeAccountBridgeHandler> {
private final Logger logger = LoggerFactory.getLogger(EcobeeDiscoveryService.class);
- private @NonNullByDefault({}) EcobeeAccountBridgeHandler bridgeHandler;
-
private @Nullable Future<?> discoveryJob;
public EcobeeDiscoveryService() {
- super(SUPPORTED_THERMOSTAT_AND_SENSOR_THING_TYPES_UIDS, 8, true);
- }
-
- @Override
- public void setThingHandler(@Nullable ThingHandler handler) {
- if (handler instanceof EcobeeAccountBridgeHandler accountBridgeHandler) {
- this.bridgeHandler = accountBridgeHandler;
- }
- }
-
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return bridgeHandler;
- }
-
- @Override
- public void activate() {
- super.activate(null);
- }
-
- @Override
- public void deactivate() {
- super.deactivate();
+ super(EcobeeAccountBridgeHandler.class, SUPPORTED_THERMOSTAT_AND_SENSOR_THING_TYPES_UIDS, 8, true);
}
@Override
}
private void backgroundDiscover() {
- if (!bridgeHandler.isBackgroundDiscoveryEnabled()) {
+ if (!thingHandler.isBackgroundDiscoveryEnabled()) {
return;
}
discover();
}
private void discover() {
- if (bridgeHandler.getThing().getStatus() != ThingStatus.ONLINE) {
+ if (thingHandler.getThing().getStatus() != ThingStatus.ONLINE) {
logger.debug("EcobeeDiscovery: Skipping discovery because Account Bridge thing is not ONLINE");
return;
}
private synchronized void discoverThermostats() {
logger.debug("EcobeeDiscovery: Discovering thermostats");
- for (ThermostatDTO thermostat : bridgeHandler.getRegisteredThermostats()) {
+ for (ThermostatDTO thermostat : thingHandler.getRegisteredThermostats()) {
String name = thermostat.name;
String identifier = thermostat.identifier;
if (identifier != null && name != null) {
- ThingUID thingUID = new ThingUID(UID_THERMOSTAT_BRIDGE, bridgeHandler.getThing().getUID(), identifier);
+ ThingUID thingUID = new ThingUID(UID_THERMOSTAT_BRIDGE, thingHandler.getThing().getUID(), identifier);
thingDiscovered(createThermostatDiscoveryResult(thingUID, identifier, name));
logger.debug("EcobeeDiscovery: Thermostat '{}' and name '{}' added with UID '{}'", identifier, name,
thingUID);
}
private DiscoveryResult createThermostatDiscoveryResult(ThingUID thermostatUID, String identifier, String name) {
+ EcobeeAccountBridgeHandler bridgeHandler = thingHandler;
+ if (bridgeHandler == null) {
+ throw new IllegalStateException("thingHandler must not be null");
+ }
Map<String, Object> properties = new HashMap<>();
properties.put(CONFIG_THERMOSTAT_ID, identifier);
return DiscoveryResultBuilder.create(thermostatUID).withProperties(properties)
}
private synchronized void discoverSensors() {
- List<Thing> thermostatThings = bridgeHandler.getThing().getThings();
+ List<Thing> thermostatThings = thingHandler.getThing().getThings();
if (thermostatThings.isEmpty()) {
logger.debug("EcobeeDiscovery: Skipping sensor discovery because there are no thermostat things");
return;
import org.openhab.core.thing.binding.ThingActions;
import org.openhab.core.thing.binding.ThingActionsScope;
import org.openhab.core.thing.binding.ThingHandler;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* @author Danny Baumann - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = EcovacsVacuumActions.class)
@ThingActionsScope(name = "ecovacs")
@NonNullByDefault
public class EcovacsVacuumActions implements ThingActions {
import java.util.Set;
import org.eclipse.jdt.annotation.NonNullByDefault;
-import org.eclipse.jdt.annotation.Nullable;
import org.openhab.binding.ecovacs.internal.api.EcovacsApi;
import org.openhab.binding.ecovacs.internal.api.EcovacsApiException;
import org.openhab.binding.ecovacs.internal.api.EcovacsDevice;
import org.openhab.binding.ecovacs.internal.api.util.SchedulerTask;
import org.openhab.binding.ecovacs.internal.handler.EcovacsApiHandler;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResult;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
import org.openhab.core.config.discovery.DiscoveryService;
import org.openhab.core.thing.Thing;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
* @author Danny Baumann - Initial contribution
*/
@NonNullByDefault
-@Component(service = DiscoveryService.class, configurationPid = "discovery.ecovacs")
-public class EcovacsDeviceDiscoveryService extends AbstractDiscoveryService implements ThingHandlerService {
+@Component(scope = ServiceScope.PROTOTYPE, service = DiscoveryService.class, configurationPid = "discovery.ecovacs")
+public class EcovacsDeviceDiscoveryService extends AbstractThingHandlerDiscoveryService<EcovacsApiHandler> {
private final Logger logger = LoggerFactory.getLogger(EcovacsDeviceDiscoveryService.class);
private static final int DISCOVER_TIMEOUT_SECONDS = 10;
-
- private @NonNullByDefault({}) EcovacsApiHandler apiHandler;
private Optional<EcovacsApi> api = Optional.empty();
private final SchedulerTask onDemandScanTask = new SchedulerTask(scheduler, logger, "OnDemandScan",
this::scanForDevices);
this::scanForDevices);
public EcovacsDeviceDiscoveryService() {
- super(Set.of(THING_TYPE_VACUUM), DISCOVER_TIMEOUT_SECONDS, true);
- }
-
- @Override
- public void setThingHandler(@Nullable ThingHandler handler) {
- if (handler instanceof EcovacsApiHandler ecovacsApiHandler) {
- this.apiHandler = ecovacsApiHandler;
- this.apiHandler.setDiscoveryService(this);
- }
- }
-
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return apiHandler;
- }
-
- @Override
- public void activate() {
- super.activate(null);
+ super(EcovacsApiHandler.class, Set.of(THING_TYPE_VACUUM), DISCOVER_TIMEOUT_SECONDS, true);
}
@Override
- public void deactivate() {
- super.deactivate();
+ public void initialize() {
+ thingHandler.setDiscoveryService(this);
+ super.initialize();
}
@Override
for (EcovacsDevice device : devices) {
deviceDiscovered(device);
}
- for (Thing thing : apiHandler.getThing().getThings()) {
+ for (Thing thing : thingHandler.getThing().getThings()) {
String serial = thing.getUID().getId();
if (!devices.stream().anyMatch(d -> serial.equals(d.getSerialNumber()))) {
thingRemoved(thing.getUID());
}
private void deviceDiscovered(EcovacsDevice device) {
- ThingUID thingUID = new ThingUID(THING_TYPE_VACUUM, apiHandler.getThing().getUID(), device.getSerialNumber());
+ ThingUID thingUID = new ThingUID(THING_TYPE_VACUUM, thingHandler.getThing().getUID(), device.getSerialNumber());
DiscoveryResult discoveryResult = DiscoveryResultBuilder.create(thingUID)
- .withBridge(apiHandler.getThing().getUID()).withLabel(device.getModelName())
+ .withBridge(thingHandler.getThing().getUID()).withLabel(device.getModelName())
.withProperty(Thing.PROPERTY_SERIAL_NUMBER, device.getSerialNumber())
.withProperty(Thing.PROPERTY_MODEL_ID, device.getModelName())
.withRepresentationProperty(Thing.PROPERTY_SERIAL_NUMBER).build();
import static org.openhab.binding.electroluxair.internal.ElectroluxAirBindingConstants.*;
-import java.util.Map;
-
import org.eclipse.jdt.annotation.NonNullByDefault;
-import org.eclipse.jdt.annotation.Nullable;
import org.openhab.binding.electroluxair.internal.ElectroluxAirConfiguration;
import org.openhab.binding.electroluxair.internal.handler.ElectroluxAirBridgeHandler;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
-import org.openhab.core.config.discovery.DiscoveryService;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
/**
* The {@link ElectroluxAirDiscoveryService} searches for available
*
* @author Jan Gustafsson - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = ElectroluxAirDiscoveryService.class)
@NonNullByDefault
-public class ElectroluxAirDiscoveryService extends AbstractDiscoveryService
- implements ThingHandlerService, DiscoveryService {
+public class ElectroluxAirDiscoveryService extends AbstractThingHandlerDiscoveryService<ElectroluxAirBridgeHandler> {
private static final int SEARCH_TIME = 2;
- private @Nullable ElectroluxAirBridgeHandler handler;
public ElectroluxAirDiscoveryService() {
- super(SUPPORTED_THING_TYPES_UIDS, SEARCH_TIME);
- }
-
- @Override
- public void setThingHandler(@Nullable ThingHandler handler) {
- if (handler instanceof ElectroluxAirBridgeHandler bridgeHandler) {
- this.handler = bridgeHandler;
- }
- }
-
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return handler;
- }
-
- @Override
- public void activate(@Nullable Map<String, Object> configProperties) {
- super.activate(configProperties);
- }
-
- @Override
- public void deactivate() {
- super.deactivate();
+ super(ElectroluxAirBridgeHandler.class, SUPPORTED_THING_TYPES_UIDS, SEARCH_TIME);
}
@Override
protected void startScan() {
- ElectroluxAirBridgeHandler bridgeHandler = this.handler;
- if (bridgeHandler != null) {
- ThingUID bridgeUID = bridgeHandler.getThing().getUID();
- bridgeHandler.getElectroluxAirThings().entrySet().stream().forEach(thing -> {
- thingDiscovered(DiscoveryResultBuilder
- .create(new ThingUID(THING_TYPE_ELECTROLUX_PURE_A9, bridgeUID, thing.getKey()))
- .withLabel("Electrolux Pure A9").withBridge(bridgeUID)
- .withProperty(ElectroluxAirConfiguration.DEVICE_ID_LABEL, thing.getKey())
- .withRepresentationProperty(ElectroluxAirConfiguration.DEVICE_ID_LABEL).build());
- });
- }
+ ThingUID bridgeUID = thingHandler.getThing().getUID();
+ thingHandler.getElectroluxAirThings().entrySet().stream().forEach(thing -> {
+ thingDiscovered(DiscoveryResultBuilder
+ .create(new ThingUID(THING_TYPE_ELECTROLUX_PURE_A9, bridgeUID, thing.getKey()))
+ .withLabel("Electrolux Pure A9").withBridge(bridgeUID)
+ .withProperty(ElectroluxAirConfiguration.DEVICE_ID_LABEL, thing.getKey())
+ .withRepresentationProperty(ElectroluxAirConfiguration.DEVICE_ID_LABEL).build());
+ });
+
stopScan();
}
}
import org.openhab.binding.elroconnects.internal.ElroConnectsBindingConstants;
import org.openhab.binding.elroconnects.internal.devices.ElroConnectsConnector;
import org.openhab.binding.elroconnects.internal.handler.ElroConnectsAccountHandler;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
import org.openhab.core.thing.Thing;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Mark Herwege - Initial Contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = ElroConnectsBridgeDiscoveryService.class)
@NonNullByDefault
-public class ElroConnectsBridgeDiscoveryService extends AbstractDiscoveryService implements ThingHandlerService {
+public class ElroConnectsBridgeDiscoveryService
+ extends AbstractThingHandlerDiscoveryService<ElroConnectsAccountHandler> {
private final Logger logger = LoggerFactory.getLogger(ElroConnectsBridgeDiscoveryService.class);
- private @Nullable ElroConnectsAccountHandler accountHandler;
-
private volatile @Nullable ScheduledFuture<?> discoveryJob;
private static final int TIMEOUT_S = 5;
private static final int REFRESH_INTERVAL_S = 60;
public ElroConnectsBridgeDiscoveryService() {
- super(ElroConnectsBindingConstants.SUPPORTED_CONNECTOR_TYPES_UIDS, TIMEOUT_S);
+ super(ElroConnectsAccountHandler.class, ElroConnectsBindingConstants.SUPPORTED_CONNECTOR_TYPES_UIDS, TIMEOUT_S);
logger.debug("Bridge discovery service started");
}
private void discoverConnectors() {
logger.debug("Starting hub discovery scan");
- ElroConnectsAccountHandler account = accountHandler;
- if (account == null) {
- return;
- }
- ThingUID bridgeUID = account.getThing().getUID();
+ ThingUID bridgeUID = thingHandler.getThing().getUID();
- Map<String, ElroConnectsConnector> connectors = account.getDevices();
+ Map<String, ElroConnectsConnector> connectors = thingHandler.getDevices();
if (connectors == null) {
return;
}
}
@Override
- public void deactivate() {
+ public void dispose() {
+ super.dispose();
removeOlderResults(Instant.now().toEpochMilli());
- super.deactivate();
- }
-
- @Override
- public void setThingHandler(@Nullable ThingHandler handler) {
- if (handler instanceof ElroConnectsAccountHandler accountHandler) {
- this.accountHandler = accountHandler;
- accountHandler.setDiscoveryService(this);
- }
}
@Override
- public @Nullable ThingHandler getThingHandler() {
- return accountHandler;
+ public void initialize() {
+ thingHandler.setDiscoveryService(this);
+ super.initialize();
}
}
import org.openhab.binding.elroconnects.internal.ElroConnectsBindingConstants.ElroDeviceType;
import org.openhab.binding.elroconnects.internal.devices.ElroConnectsDevice;
import org.openhab.binding.elroconnects.internal.handler.ElroConnectsBridgeHandler;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
import org.openhab.core.thing.ThingTypeUID;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Mark Herwege - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = ElroConnectsDiscoveryService.class)
@NonNullByDefault
-public class ElroConnectsDiscoveryService extends AbstractDiscoveryService implements ThingHandlerService {
+public class ElroConnectsDiscoveryService extends AbstractThingHandlerDiscoveryService<ElroConnectsBridgeHandler> {
private final Logger logger = LoggerFactory.getLogger(ElroConnectsDiscoveryService.class);
- private @Nullable ElroConnectsBridgeHandler bridgeHandler;
-
private static final int TIMEOUT_S = 5;
private static final int REFRESH_INTERVAL_S = 60;
private @Nullable ScheduledFuture<?> discoveryJob;
public ElroConnectsDiscoveryService() {
- super(ElroConnectsBindingConstants.SUPPORTED_DEVICE_TYPES_UIDS, TIMEOUT_S);
+ super(ElroConnectsBridgeHandler.class, ElroConnectsBindingConstants.SUPPORTED_DEVICE_TYPES_UIDS, TIMEOUT_S);
logger.debug("Discovery service started");
}
private void discoverDevices() {
logger.debug("Starting device discovery scan");
- ElroConnectsBridgeHandler bridge = bridgeHandler;
- if (bridge != null) {
- Map<Integer, ElroConnectsDevice> devices = bridge.getDevices();
- ThingUID bridgeUID = bridge.getThing().getUID();
- devices.entrySet().forEach(e -> {
- String deviceId = e.getKey().toString();
- String deviceName = e.getValue().getDeviceName();
- String deviceType = e.getValue().getDeviceType();
- if (!deviceType.isEmpty()) {
- ElroDeviceType type = TYPE_MAP.get(deviceType);
- if (type != null) {
- ThingTypeUID thingTypeUID = THING_TYPE_MAP.get(type);
- if (thingTypeUID != null) {
- thingDiscovered(DiscoveryResultBuilder
- .create(new ThingUID(thingTypeUID, bridgeUID, deviceId)).withLabel(deviceName)
- .withBridge(bridgeUID).withProperty(CONFIG_DEVICE_ID, deviceId)
- .withRepresentationProperty(CONFIG_DEVICE_ID).build());
- }
+ Map<Integer, ElroConnectsDevice> devices = thingHandler.getDevices();
+ ThingUID bridgeUID = thingHandler.getThing().getUID();
+ devices.entrySet().forEach(e -> {
+ String deviceId = e.getKey().toString();
+ String deviceName = e.getValue().getDeviceName();
+ String deviceType = e.getValue().getDeviceType();
+ if (!deviceType.isEmpty()) {
+ ElroDeviceType type = TYPE_MAP.get(deviceType);
+ if (type != null) {
+ ThingTypeUID thingTypeUID = THING_TYPE_MAP.get(type);
+ if (thingTypeUID != null) {
+ thingDiscovered(DiscoveryResultBuilder.create(new ThingUID(thingTypeUID, bridgeUID, deviceId))
+ .withLabel(deviceName).withBridge(bridgeUID).withProperty(CONFIG_DEVICE_ID, deviceId)
+ .withRepresentationProperty(CONFIG_DEVICE_ID).build());
}
}
- });
- }
+ }
+ });
}
@Override
}
@Override
- public void deactivate() {
+ public void dispose() {
+ super.dispose();
removeOlderResults(Instant.now().toEpochMilli());
- super.deactivate();
- }
-
- @Override
- public void setThingHandler(@Nullable ThingHandler handler) {
- if (handler instanceof ElroConnectsBridgeHandler bridgeHandler) {
- this.bridgeHandler = bridgeHandler;
- bridgeHandler.setDiscoveryService(this);
- }
}
@Override
- public @Nullable ThingHandler getThingHandler() {
- return bridgeHandler;
+ public void initialize() {
+ thingHandler.setDiscoveryService(this);
+ super.initialize();
}
}
import org.openhab.core.thing.binding.ThingActions;
import org.openhab.core.thing.binding.ThingActionsScope;
import org.openhab.core.thing.binding.ThingHandler;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Jacob Laursen - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = EnergiDataServiceActions.class)
@ThingActionsScope(name = "energidataservice")
@NonNullByDefault
public class EnergiDataServiceActions implements ThingActions {
import org.openhab.core.thing.binding.ThingActions;
import org.openhab.core.thing.binding.ThingActionsScope;
import org.openhab.core.thing.binding.ThingHandler;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
/**
* This is the automation engine actions handler service for the
*
* @author Guido Dolfen - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = Enigma2Actions.class)
@ThingActionsScope(name = "enigma2")
@NonNullByDefault
public class Enigma2Actions implements ThingActions {
import org.openhab.binding.enphase.internal.dto.InventoryJsonDTO.DeviceDTO;
import org.openhab.binding.enphase.internal.dto.InverterDTO;
import org.openhab.binding.enphase.internal.handler.EnvoyBridgeHandler;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResult;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
-import org.openhab.core.config.discovery.DiscoveryService;
import org.openhab.core.thing.ThingTypeUID;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
* @author Thomas Hentschel - Initial contribution
* @author Hilbrand Bouwkamp - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = EnphaseDevicesDiscoveryService.class)
@NonNullByDefault
-public class EnphaseDevicesDiscoveryService extends AbstractDiscoveryService
- implements ThingHandlerService, DiscoveryService {
-
+public class EnphaseDevicesDiscoveryService extends AbstractThingHandlerDiscoveryService<EnvoyBridgeHandler> {
private static final int TIMEOUT_SECONDS = 20;
private final Logger logger = LoggerFactory.getLogger(EnphaseDevicesDiscoveryService.class);
- private @Nullable EnvoyBridgeHandler envoyHandler;
public EnphaseDevicesDiscoveryService() {
- super(Set.of(THING_TYPE_ENPHASE_INVERTER), TIMEOUT_SECONDS, false);
- }
-
- @Override
- public void setThingHandler(final @Nullable ThingHandler handler) {
- if (handler instanceof EnvoyBridgeHandler bridgeHandler) {
- envoyHandler = bridgeHandler;
- }
- }
-
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return envoyHandler;
- }
-
- @Override
- public void deactivate() {
- super.deactivate();
+ super(EnvoyBridgeHandler.class, Set.of(THING_TYPE_ENPHASE_INVERTER), TIMEOUT_SECONDS, false);
}
@Override
protected void startScan() {
removeOlderResults(getTimestampOfLastScan());
- final EnvoyBridgeHandler envoyHandler = this.envoyHandler;
-
- if (envoyHandler == null || !envoyHandler.isOnline()) {
- logger.debug("Envoy handler not available or online: {}", envoyHandler);
+ if (!thingHandler.isOnline()) {
+ logger.debug("Envoy handler not available or online: {}", thingHandler);
return;
}
- final ThingUID uid = envoyHandler.getThing().getUID();
+ final ThingUID uid = thingHandler.getThing().getUID();
- scanForInverterThings(envoyHandler, uid);
- scanForDeviceThings(envoyHandler, uid);
+ scanForInverterThings(thingHandler, uid);
+ scanForDeviceThings(thingHandler, uid);
}
private void scanForInverterThings(final EnvoyBridgeHandler envoyHandler, final ThingUID bridgeID) {
import java.util.Map;
import org.eclipse.jdt.annotation.NonNullByDefault;
-import org.eclipse.jdt.annotation.Nullable;
import org.openhab.binding.foobot.internal.FoobotApiException;
import org.openhab.binding.foobot.internal.FoobotBindingConstants;
import org.openhab.binding.foobot.internal.FoobotHandlerFactory;
import org.openhab.binding.foobot.internal.handler.FoobotAccountHandler;
import org.openhab.binding.foobot.internal.handler.FoobotDeviceHandler;
import org.openhab.binding.foobot.internal.json.FoobotDevice;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
-import org.openhab.core.config.discovery.DiscoveryService;
import org.openhab.core.thing.Thing;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
* @author George Katsis - Initial contribution
* @author Hilbrand Bouwkamp - Completed implementation
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = FoobotAccountDiscoveryService.class)
@NonNullByDefault
-public class FoobotAccountDiscoveryService extends AbstractDiscoveryService
- implements DiscoveryService, ThingHandlerService {
+public class FoobotAccountDiscoveryService extends AbstractThingHandlerDiscoveryService<FoobotAccountHandler> {
private static final int TIMEOUT_SECONDS = 5;
private final Logger logger = LoggerFactory.getLogger(FoobotAccountDiscoveryService.class);
- private @Nullable FoobotAccountHandler handler;
private @NonNullByDefault({}) ThingUID bridgeUID;
public FoobotAccountDiscoveryService() {
- super(FoobotHandlerFactory.DISCOVERABLE_THING_TYPE_UIDS, TIMEOUT_SECONDS, false);
+ super(FoobotAccountHandler.class, FoobotHandlerFactory.DISCOVERABLE_THING_TYPE_UIDS, TIMEOUT_SECONDS, false);
}
@Override
}
private void retrieveFoobots() {
- if (handler == null) {
- return;
- }
try {
- final List<FoobotDeviceHandler> footbotHandlers = handler.getFootbotHandlers();
+ final List<FoobotDeviceHandler> footbotHandlers = thingHandler.getFootbotHandlers();
- handler.getDeviceList().stream()
+ thingHandler.getDeviceList().stream()
.filter(d -> !footbotHandlers.stream().anyMatch(h -> h.getUuid().equals(d.getUuid())))
.forEach(this::addThing);
} catch (final FoobotApiException e) {
}
}
- @Override
- public void deactivate() {
- super.deactivate();
- }
-
private void addThing(final FoobotDevice foobot) {
logger.debug("Adding new Foobot '{}' with uuid: {}", foobot.getName(), foobot.getUuid());
thingDiscovered(DiscoveryResultBuilder.create(thingUID).withBridge(bridgeUID).withProperties(properties)
.withLabel(foobot.getName()).withRepresentationProperty(foobot.getUuid()).build());
}
-
- @Override
- public void setThingHandler(@Nullable final ThingHandler handler) {
- if (handler instanceof FoobotAccountHandler accountHandler) {
- this.handler = accountHandler;
- }
- }
-
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return handler;
- }
}
import org.openhab.binding.freebox.internal.config.FreeboxServerConfiguration;
import org.openhab.binding.freebox.internal.handler.FreeboxHandler;
import org.openhab.core.config.core.Configuration;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResult;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
import org.openhab.core.thing.Thing;
import org.openhab.core.thing.ThingStatus;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
* @author Laurent Garnier - use new internal API manager
* @author Laurent Garnier - use ThingHandlerService
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = FreeboxDiscoveryService.class)
@NonNullByDefault
-public class FreeboxDiscoveryService extends AbstractDiscoveryService
- implements FreeboxDataListener, ThingHandlerService {
+public class FreeboxDiscoveryService extends AbstractThingHandlerDiscoveryService<FreeboxHandler>
+ implements FreeboxDataListener {
private final Logger logger = LoggerFactory.getLogger(FreeboxDiscoveryService.class);
private static final int SEARCH_TIME = 10;
private static final String PHONE_ID = "wired";
-
- private @Nullable FreeboxHandler bridgeHandler;
private boolean discoverPhone;
private boolean discoverNetDevice;
private boolean discoverNetInterface;
* Creates a FreeboxDiscoveryService with background discovery disabled.
*/
public FreeboxDiscoveryService() {
- super(FreeboxBindingConstants.SUPPORTED_THING_TYPES_UIDS, SEARCH_TIME, false);
+ super(FreeboxHandler.class, FreeboxBindingConstants.SUPPORTED_THING_TYPES_UIDS, SEARCH_TIME, false);
this.discoverPhone = true;
this.discoverNetDevice = true;
this.discoverNetInterface = true;
}
@Override
- public void setThingHandler(ThingHandler handler) {
- if (handler instanceof FreeboxHandler freeboxHandler) {
- bridgeHandler = freeboxHandler;
- }
- }
-
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return bridgeHandler;
+ public void initialize() {
+ Configuration config = thingHandler.getThing().getConfiguration();
+ Object property = config.get(FreeboxServerConfiguration.DISCOVER_PHONE);
+ discoverPhone = property != null ? ((Boolean) property).booleanValue() : true;
+ property = config.get(FreeboxServerConfiguration.DISCOVER_NET_DEVICE);
+ discoverNetDevice = property != null ? ((Boolean) property).booleanValue() : true;
+ property = config.get(FreeboxServerConfiguration.DISCOVER_NET_INTERFACE);
+ discoverNetInterface = property != null ? ((Boolean) property).booleanValue() : true;
+ property = config.get(FreeboxServerConfiguration.DISCOVER_AIRPLAY_RECEIVER);
+ discoverAirPlayReceiver = property != null ? ((Boolean) property).booleanValue() : true;
+ logger.debug("Freebox discovery - discoverPhone : {}", discoverPhone);
+ logger.debug("Freebox discovery - discoverNetDevice : {}", discoverNetDevice);
+ logger.debug("Freebox discovery - discoverNetInterface : {}", discoverNetInterface);
+ logger.debug("Freebox discovery - discoverAirPlayReceiver : {}", discoverAirPlayReceiver);
+
+ thingHandler.registerDataListener(this);
+ super.initialize();
}
@Override
- public void activate() {
- super.activate(null);
- FreeboxHandler handler = bridgeHandler;
- if (handler != null) {
- Configuration config = handler.getThing().getConfiguration();
- Object property = config.get(FreeboxServerConfiguration.DISCOVER_PHONE);
- discoverPhone = property != null ? ((Boolean) property).booleanValue() : true;
- property = config.get(FreeboxServerConfiguration.DISCOVER_NET_DEVICE);
- discoverNetDevice = property != null ? ((Boolean) property).booleanValue() : true;
- property = config.get(FreeboxServerConfiguration.DISCOVER_NET_INTERFACE);
- discoverNetInterface = property != null ? ((Boolean) property).booleanValue() : true;
- property = config.get(FreeboxServerConfiguration.DISCOVER_AIRPLAY_RECEIVER);
- discoverAirPlayReceiver = property != null ? ((Boolean) property).booleanValue() : true;
- logger.debug("Freebox discovery - discoverPhone : {}", discoverPhone);
- logger.debug("Freebox discovery - discoverNetDevice : {}", discoverNetDevice);
- logger.debug("Freebox discovery - discoverNetInterface : {}", discoverNetInterface);
- logger.debug("Freebox discovery - discoverAirPlayReceiver : {}", discoverAirPlayReceiver);
-
- handler.registerDataListener(this);
- }
- }
-
- @Override
- public void deactivate() {
- FreeboxHandler handler = bridgeHandler;
- if (handler != null) {
- handler.unregisterDataListener(this);
- }
- super.deactivate();
+ public void dispose() {
+ super.dispose();
+ thingHandler.unregisterDataListener(this);
}
@Override
protected void startScan() {
logger.debug("Starting Freebox discovery scan");
- FreeboxHandler handler = bridgeHandler;
- if (handler != null && handler.getThing().getStatus() == ThingStatus.ONLINE) {
+ if (thingHandler.getThing().getStatus() == ThingStatus.ONLINE) {
try {
- List<FreeboxLanHost> lanHosts = handler.getApiManager().getLanHosts();
- List<FreeboxAirMediaReceiver> airPlayDevices = handler.getApiManager().getAirMediaReceivers();
- onDataFetched(handler.getThing().getUID(), lanHosts, airPlayDevices);
+ List<FreeboxLanHost> lanHosts = thingHandler.getApiManager().getLanHosts();
+ List<FreeboxAirMediaReceiver> airPlayDevices = thingHandler.getApiManager().getAirMediaReceivers();
+ onDataFetched(thingHandler.getThing().getUID(), lanHosts, airPlayDevices);
} catch (FreeboxException e) {
logger.warn("Error while requesting data for things discovery", e);
}
import org.openhab.core.automation.annotation.RuleAction;
import org.openhab.core.thing.binding.ThingActions;
import org.openhab.core.thing.binding.ThingActionsScope;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Gaël L'hopital - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = ActivePlayerActions.class)
@ThingActionsScope(name = "freeboxos")
@NonNullByDefault
public class ActivePlayerActions extends PlayerActions {
import org.openhab.core.thing.binding.ThingActions;
import org.openhab.core.thing.binding.ThingActionsScope;
import org.openhab.core.thing.binding.ThingHandler;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Gaël L'hopital - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = CallActions.class)
@ThingActionsScope(name = "freeboxos")
@NonNullByDefault
public class CallActions implements ThingActions {
import org.openhab.core.thing.binding.ThingActions;
import org.openhab.core.thing.binding.ThingActionsScope;
import org.openhab.core.thing.binding.ThingHandler;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Gaël L'hopital - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = FreeplugActions.class)
@ThingActionsScope(name = "freeboxos")
@NonNullByDefault
public class FreeplugActions implements ThingActions {
import org.openhab.core.thing.binding.ThingActions;
import org.openhab.core.thing.binding.ThingActionsScope;
import org.openhab.core.thing.binding.ThingHandler;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Gaël L'hopital - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = HostActions.class)
@ThingActionsScope(name = "freeboxos")
@NonNullByDefault
public class HostActions implements ThingActions {
import org.openhab.core.thing.binding.ThingActions;
import org.openhab.core.thing.binding.ThingActionsScope;
import org.openhab.core.thing.binding.ThingHandler;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Gaël L'hopital - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = PlayerActions.class)
@ThingActionsScope(name = "freeboxos")
@NonNullByDefault
public class PlayerActions implements ThingActions {
import org.openhab.core.thing.binding.ThingActions;
import org.openhab.core.thing.binding.ThingActionsScope;
import org.openhab.core.thing.binding.ThingHandler;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Gaël L'hopital - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = RepeaterActions.class)
@ThingActionsScope(name = "freeboxos")
@NonNullByDefault
public class RepeaterActions implements ThingActions {
import org.openhab.core.thing.binding.ThingActions;
import org.openhab.core.thing.binding.ThingActionsScope;
import org.openhab.core.thing.binding.ThingHandler;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Gaël L'hopital - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = ServerActions.class)
@ThingActionsScope(name = "freeboxos")
@NonNullByDefault
public class ServerActions implements ThingActions {
import java.util.stream.Stream;
import org.eclipse.jdt.annotation.NonNullByDefault;
-import org.eclipse.jdt.annotation.Nullable;
import org.openhab.binding.freeboxos.internal.api.FreeboxException;
import org.openhab.binding.freeboxos.internal.api.PermissionException;
import org.openhab.binding.freeboxos.internal.api.rest.APManager;
import org.openhab.binding.freeboxos.internal.config.NodeConfigurationBuilder;
import org.openhab.binding.freeboxos.internal.config.PhoneConfigurationBuilder;
import org.openhab.binding.freeboxos.internal.handler.FreeboxOsHandler;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResult;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
import org.openhab.core.thing.Thing;
import org.openhab.core.thing.ThingStatus;
import org.openhab.core.thing.ThingTypeUID;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Gaël L'hopital - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = FreeboxOsDiscoveryService.class)
@NonNullByDefault
-public class FreeboxOsDiscoveryService extends AbstractDiscoveryService implements ThingHandlerService {
+public class FreeboxOsDiscoveryService extends AbstractThingHandlerDiscoveryService<FreeboxOsHandler> {
private static final int DISCOVERY_TIME_SECONDS = 10;
private final Logger logger = LoggerFactory.getLogger(FreeboxOsDiscoveryService.class);
private Optional<ScheduledFuture<?>> backgroundFuture = Optional.empty();
- private @Nullable FreeboxOsHandler bridgeHandler;
public FreeboxOsDiscoveryService() {
- super(Stream.of(THINGS_TYPES_UIDS, HOME_TYPES_UIDS).flatMap(Set::stream).collect(Collectors.toSet()),
+ super(FreeboxOsHandler.class,
+ Stream.of(THINGS_TYPES_UIDS, HOME_TYPES_UIDS).flatMap(Set::stream).collect(Collectors.toSet()),
DISCOVERY_TIME_SECONDS);
}
- @Override
- public void deactivate() {
- super.deactivate();
- }
-
- @Override
- public void setThingHandler(@Nullable ThingHandler handler) {
- if (handler instanceof FreeboxOsHandler freeboxosHandler) {
- bridgeHandler = freeboxosHandler;
- activate(null);
- }
- }
-
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return bridgeHandler;
- }
-
@Override
protected void startBackgroundDiscovery() {
stopBackgroundDiscovery();
- FreeboxOsHandler handler = bridgeHandler;
- if (handler != null) {
- int interval = handler.getConfiguration().discoveryInterval;
- if (interval > 0) {
- backgroundFuture = Optional
- .of(scheduler.scheduleWithFixedDelay(this::startScan, 1, interval, TimeUnit.MINUTES));
- }
+ int interval = thingHandler.getConfiguration().discoveryInterval;
+ if (interval > 0) {
+ backgroundFuture = Optional
+ .of(scheduler.scheduleWithFixedDelay(this::startScan, 1, interval, TimeUnit.MINUTES));
}
}
@Override
protected void startScan() {
logger.debug("Starting Freebox discovery scan");
- FreeboxOsHandler handler = bridgeHandler;
- if (handler != null && handler.getThing().getStatus() == ThingStatus.ONLINE) {
+ if (thingHandler.getThing().getStatus() == ThingStatus.ONLINE) {
try {
- ThingUID bridgeUID = handler.getThing().getUID();
+ ThingUID bridgeUID = thingHandler.getThing().getUID();
- List<LanHost> lanHosts = new ArrayList<>(handler.getManager(LanBrowserManager.class).getHosts().stream()
- .filter(LanHost::reachable).toList());
+ List<LanHost> lanHosts = new ArrayList<>(thingHandler.getManager(LanBrowserManager.class).getHosts()
+ .stream().filter(LanHost::reachable).toList());
- discoverServer(handler.getManager(SystemManager.class), bridgeUID);
- discoverPhone(handler.getManager(PhoneManager.class), bridgeUID);
- discoverPlugs(handler.getManager(FreeplugManager.class), bridgeUID);
- discoverRepeater(handler.getManager(RepeaterManager.class), bridgeUID, lanHosts);
- discoverPlayer(handler.getManager(PlayerManager.class), bridgeUID, lanHosts);
- discoverVM(handler.getManager(VmManager.class), bridgeUID, lanHosts);
- discoverHome(handler.getManager(HomeManager.class), bridgeUID);
- if (handler.getConfiguration().discoverNetDevice) {
- discoverHosts(handler, bridgeUID, lanHosts);
+ discoverServer(thingHandler.getManager(SystemManager.class), bridgeUID);
+ discoverPhone(thingHandler.getManager(PhoneManager.class), bridgeUID);
+ discoverPlugs(thingHandler.getManager(FreeplugManager.class), bridgeUID);
+ discoverRepeater(thingHandler.getManager(RepeaterManager.class), bridgeUID, lanHosts);
+ discoverPlayer(thingHandler.getManager(PlayerManager.class), bridgeUID, lanHosts);
+ discoverVM(thingHandler.getManager(VmManager.class), bridgeUID, lanHosts);
+ discoverHome(thingHandler.getManager(HomeManager.class), bridgeUID);
+ if (thingHandler.getConfiguration().discoverNetDevice) {
+ discoverHosts(thingHandler, bridgeUID, lanHosts);
}
} catch (FreeboxException e) {
logger.warn("Error while requesting data for things discovery: {}", e.getMessage());
import org.openhab.binding.gardena.internal.model.dto.Device;
import org.openhab.binding.gardena.internal.util.PropertyUtils;
import org.openhab.binding.gardena.internal.util.UidUtils;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResult;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
-import org.openhab.core.config.discovery.DiscoveryService;
import org.openhab.core.thing.Thing;
import org.openhab.core.thing.ThingTypeUID;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Gerhard Riegler - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = GardenaDeviceDiscoveryService.class)
@NonNullByDefault
-public class GardenaDeviceDiscoveryService extends AbstractDiscoveryService
- implements DiscoveryService, ThingHandlerService {
+public class GardenaDeviceDiscoveryService extends AbstractThingHandlerDiscoveryService<GardenaAccountHandler> {
private final Logger logger = LoggerFactory.getLogger(GardenaDeviceDiscoveryService.class);
private static final int DISCOVER_TIMEOUT_SECONDS = 5;
-
- private @NonNullByDefault({}) GardenaAccountHandler accountHandler;
private @Nullable Future<?> scanFuture;
public GardenaDeviceDiscoveryService() {
- super(Collections.unmodifiableSet(Stream.of(new ThingTypeUID(BINDING_ID, "-")).collect(Collectors.toSet())),
+ super(GardenaAccountHandler.class,
+ Collections.unmodifiableSet(Stream.of(new ThingTypeUID(BINDING_ID, "-")).collect(Collectors.toSet())),
DISCOVER_TIMEOUT_SECONDS, false);
}
@Override
- public void setThingHandler(@Nullable ThingHandler handler) {
- if (handler instanceof GardenaAccountHandler gardenaAccountHandler) {
- this.accountHandler = gardenaAccountHandler;
- this.accountHandler.setDiscoveryService(this);
- }
- }
-
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return accountHandler;
- }
-
- /**
- * Called on component activation.
- */
- @Override
- public void activate() {
- super.activate(null);
- }
-
- @Override
- public void deactivate() {
- super.deactivate();
+ public void initialize() {
+ thingHandler.setDiscoveryService(this);
+ super.initialize();
}
@Override
private void loadDevices() {
if (scanFuture == null) {
scanFuture = scheduler.submit(() -> {
- GardenaSmart gardena = accountHandler.getGardenaSmart();
+ GardenaSmart gardena = thingHandler.getGardenaSmart();
if (gardena != null) {
for (Device device : gardena.getAllDevices()) {
deviceDiscovered(device);
}
- for (Thing thing : accountHandler.getThing().getThings()) {
+ for (Thing thing : thingHandler.getThing().getThings()) {
try {
gardena.getDevice(UidUtils.getGardenaDeviceId(thing));
} catch (GardenaException ex) {
*/
public void deviceDiscovered(Device device) {
if (device.active) {
- ThingUID accountUID = accountHandler.getThing().getUID();
- ThingUID thingUID = UidUtils.generateThingUID(device, accountHandler.getThing());
+ ThingUID accountUID = thingHandler.getThing().getUID();
+ ThingUID thingUID = UidUtils.generateThingUID(device, thingHandler.getThing());
try {
DiscoveryResult discoveryResult = DiscoveryResultBuilder.create(thingUID).withBridge(accountUID)
import org.openhab.core.thing.binding.ThingActions;
import org.openhab.core.thing.binding.ThingActionsScope;
import org.openhab.core.thing.binding.ThingHandler;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Gaël L'hopital - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = Ipx800Actions.class)
@ThingActionsScope(name = "gce")
@NonNullByDefault
public class Ipx800Actions implements ThingActions {
import org.openhab.binding.groupepsa.internal.bridge.GroupePSABridgeHandler;
import org.openhab.binding.groupepsa.internal.rest.api.dto.Vehicle;
import org.openhab.binding.groupepsa.internal.rest.exceptions.GroupePSACommunicationException;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResult;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
import org.openhab.core.thing.ThingTypeUID;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Arjan Mels - Initial contribution
*/
-@Component(service = ThingHandlerService.class)
+@Component(scope = ServiceScope.PROTOTYPE, service = GroupePSADiscoveryService.class)
@NonNullByDefault
-public class GroupePSADiscoveryService extends AbstractDiscoveryService implements ThingHandlerService {
+public class GroupePSADiscoveryService extends AbstractThingHandlerDiscoveryService<GroupePSABridgeHandler> {
private final Logger logger = LoggerFactory.getLogger(GroupePSADiscoveryService.class);
- private @Nullable GroupePSABridgeHandler bridgeHandler;
-
public GroupePSADiscoveryService() {
- super(Set.of(THING_TYPE_VEHICLE), 10, false);
- }
-
- @Override
- public void setThingHandler(@Nullable ThingHandler handler) {
- if (handler instanceof GroupePSABridgeHandler bridgeHandler) {
- this.bridgeHandler = bridgeHandler;
- }
- }
-
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return bridgeHandler;
- }
-
- @Override
- public void deactivate() {
- super.deactivate();
+ super(GroupePSABridgeHandler.class, Set.of(THING_TYPE_VEHICLE), 10, false);
}
@Override
protected void startScan() {
try {
- GroupePSABridgeHandler localBridgeHandler = bridgeHandler;
- if (localBridgeHandler == null) {
- return;
- }
- List<Vehicle> vehicles = localBridgeHandler.getVehicles();
+ List<Vehicle> vehicles = thingHandler.getVehicles();
if (vehicles == null || vehicles.isEmpty()) {
logger.warn("No vehicles found");
return;
}
for (Vehicle vehicle : vehicles) {
- ThingUID bridgeUID = localBridgeHandler.getThing().getUID();
+ ThingUID bridgeUID = thingHandler.getThing().getUID();
ThingTypeUID thingTypeUID = THING_TYPE_VEHICLE;
String id = vehicle.getId();
if (id != null) {
import org.openhab.binding.haywardomnilogic.internal.HaywardException;
import org.openhab.binding.haywardomnilogic.internal.HaywardTypeToRequest;
import org.openhab.binding.haywardomnilogic.internal.handler.HaywardBridgeHandler;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResult;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
-import org.openhab.core.config.discovery.DiscoveryService;
import org.openhab.core.thing.ThingTypeUID;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Matt Myers - Initial contribution
*/
-
+@Component(scope = ServiceScope.PROTOTYPE, service = HaywardDiscoveryService.class)
@NonNullByDefault
-public class HaywardDiscoveryService extends AbstractDiscoveryService implements DiscoveryService, ThingHandlerService {
+public class HaywardDiscoveryService extends AbstractThingHandlerDiscoveryService<HaywardBridgeHandler> {
private final Logger logger = LoggerFactory.getLogger(HaywardDiscoveryService.class);
- private @Nullable HaywardBridgeHandler discoveryBridgehandler;
public HaywardDiscoveryService() {
- super(THING_TYPES_UIDS, 0, false);
- }
-
- @Override
- public void activate() {
- super.activate(null);
- }
-
- @Override
- public void deactivate() {
- super.deactivate();
+ super(HaywardBridgeHandler.class, THING_TYPES_UIDS, 0, false);
}
@Override
protected void startScan() {
- HaywardBridgeHandler bridgehandler = discoveryBridgehandler;
try {
- if (bridgehandler != null) {
- String xmlResults = bridgehandler.getMspConfig();
- mspConfigDiscovery(xmlResults);
- }
+ String xmlResults = thingHandler.getMspConfig();
+ mspConfigDiscovery(xmlResults);
} catch (HaywardException e) {
logger.warn("Exception during discovery scan: {}", e.getMessage());
} catch (InterruptedException e) {
List<String> names = new ArrayList<>();
Map<String, Object> backyardProperties = new HashMap<>();
Map<String, Object> bowProperties = new HashMap<>();
- HaywardBridgeHandler bridgehandler = discoveryBridgehandler;
-
- if (bridgehandler == null) {
- return;
- }
// Find Backyard
- names = bridgehandler.evaluateXPath("//Backyard/Name/text()", xmlResponse);
+ names = thingHandler.evaluateXPath("//Backyard/Name/text()", xmlResponse);
for (int i = 0; i < names.size(); i++) {
backyardProperties.put(HaywardBindingConstants.PROPERTY_TYPE, HaywardTypeToRequest.BACKYARD);
- backyardProperties.put(HaywardBindingConstants.PROPERTY_SYSTEM_ID, bridgehandler.account.mspSystemID);
+ backyardProperties.put(HaywardBindingConstants.PROPERTY_SYSTEM_ID, thingHandler.account.mspSystemID);
onDeviceDiscovered(HaywardBindingConstants.THING_TYPE_BACKYARD, names.get(i), backyardProperties);
}
// Find Bodies of Water
- systemIDs = bridgehandler.evaluateXPath("//Body-of-water/System-Id/text()", xmlResponse);
- names = bridgehandler.evaluateXPath("//Body-of-water/Name/text()", xmlResponse);
+ systemIDs = thingHandler.evaluateXPath("//Body-of-water/System-Id/text()", xmlResponse);
+ names = thingHandler.evaluateXPath("//Body-of-water/Name/text()", xmlResponse);
- final List<String> bowProperty1 = bridgehandler.evaluateXPath("//Body-of-water/Type/text()", xmlResponse);
- final List<String> bowProperty2 = bridgehandler.evaluateXPath("//Body-of-water/Shared-Type/text()",
- xmlResponse);
- final List<String> bowProperty3 = bridgehandler.evaluateXPath("//Body-of-water/Shared-Priority/text()",
+ final List<String> bowProperty1 = thingHandler.evaluateXPath("//Body-of-water/Type/text()", xmlResponse);
+ final List<String> bowProperty2 = thingHandler.evaluateXPath("//Body-of-water/Shared-Type/text()", xmlResponse);
+ final List<String> bowProperty3 = thingHandler.evaluateXPath("//Body-of-water/Shared-Priority/text()",
xmlResponse);
- final List<String> bowProperty4 = bridgehandler
+ final List<String> bowProperty4 = thingHandler
.evaluateXPath("//Body-of-water/Shared-Equipment-System-ID/text()", xmlResponse);
- final List<String> bowProperty5 = bridgehandler.evaluateXPath("//Body-of-water/Supports-Spillover/text()",
+ final List<String> bowProperty5 = thingHandler.evaluateXPath("//Body-of-water/Supports-Spillover/text()",
xmlResponse);
- final List<String> bowProperty6 = bridgehandler.evaluateXPath("//Body-of-water/Size-In-Gallons/text()",
+ final List<String> bowProperty6 = thingHandler.evaluateXPath("//Body-of-water/Size-In-Gallons/text()",
xmlResponse);
for (int i = 0; i < systemIDs.size(); i++) {
}
// Find Chlorinators
- final List<String> chlorinatorProperty1 = bridgehandler
+ final List<String> chlorinatorProperty1 = thingHandler
.evaluateXPath("//Body-of-water/Chlorinator/Shared-Type/text()", xmlResponse);
- final List<String> chlorinatorProperty2 = bridgehandler.evaluateXPath("//Body-of-water/Chlorinator/Mode/text()",
+ final List<String> chlorinatorProperty2 = thingHandler.evaluateXPath("//Body-of-water/Chlorinator/Mode/text()",
xmlResponse);
- final List<String> chlorinatorProperty3 = bridgehandler
+ final List<String> chlorinatorProperty3 = thingHandler
.evaluateXPath("//Body-of-water/Chlorinator/Cell-Type/text()", xmlResponse);
- final List<String> chlorinatorProperty4 = bridgehandler
+ final List<String> chlorinatorProperty4 = thingHandler
.evaluateXPath("//Body-of-water/Chlorinator/Dispenser-Type/text()", xmlResponse);
- discoverDevices(bridgehandler, xmlResponse, "Chlorinator", HaywardTypeToRequest.CHLORINATOR,
+ discoverDevices(thingHandler, xmlResponse, "Chlorinator", HaywardTypeToRequest.CHLORINATOR,
HaywardBindingConstants.THING_TYPE_CHLORINATOR, (props, i) -> {
props.put(HaywardBindingConstants.PROPERTY_CHLORINATOR_SHAREDTYPE, chlorinatorProperty1.get(i));
props.put(HaywardBindingConstants.PROPERTY_CHLORINATOR_MODE, chlorinatorProperty2.get(i));
});
// Find ColorLogic Lights
- final List<String> colorLogicProperty1 = bridgehandler.evaluateXPath("//Backyard//ColorLogic-Light/Type/text()",
+ final List<String> colorLogicProperty1 = thingHandler.evaluateXPath("//Backyard//ColorLogic-Light/Type/text()",
xmlResponse);
- discoverDevices(bridgehandler, xmlResponse, "ColorLogic-Light", HaywardTypeToRequest.COLORLOGIC,
+ discoverDevices(thingHandler, xmlResponse, "ColorLogic-Light", HaywardTypeToRequest.COLORLOGIC,
HaywardBindingConstants.THING_TYPE_COLORLOGIC, (props, i) -> {
props.put(HaywardBindingConstants.PROPERTY_COLORLOGIC_TYPE, colorLogicProperty1.get(i));
});
// Find Filters
- final List<String> filterProperty1 = bridgehandler.evaluateXPath("//Body-of-water/Filter/Shared-Type/text()",
+ final List<String> filterProperty1 = thingHandler.evaluateXPath("//Body-of-water/Filter/Shared-Type/text()",
+ xmlResponse);
+ final List<String> filterProperty2 = thingHandler.evaluateXPath("//Body-of-water/Filter/Filter-Type/text()",
xmlResponse);
- final List<String> filterProperty2 = bridgehandler.evaluateXPath("//Body-of-water/Filter/Filter-Type/text()",
+ final List<String> filterProperty3 = thingHandler.evaluateXPath("//Body-of-water/Filter/Priming-Enabled/text()",
xmlResponse);
- final List<String> filterProperty3 = bridgehandler
- .evaluateXPath("//Body-of-water/Filter/Priming-Enabled/text()", xmlResponse);
- final List<String> filterProperty4 = bridgehandler.evaluateXPath("//Body-of-water/Filter/Min-Pump-Speed/text()",
+ final List<String> filterProperty4 = thingHandler.evaluateXPath("//Body-of-water/Filter/Min-Pump-Speed/text()",
xmlResponse);
- final List<String> filterProperty5 = bridgehandler.evaluateXPath("//Body-of-water/Filter/Max-Pump-Speed/text()",
+ final List<String> filterProperty5 = thingHandler.evaluateXPath("//Body-of-water/Filter/Max-Pump-Speed/text()",
xmlResponse);
- final List<String> filterProperty6 = bridgehandler.evaluateXPath("//Body-of-water/Filter/Min-Pump-RPM/text()",
+ final List<String> filterProperty6 = thingHandler.evaluateXPath("//Body-of-water/Filter/Min-Pump-RPM/text()",
xmlResponse);
- final List<String> filterProperty7 = bridgehandler.evaluateXPath("//Body-of-water/Filter/Max-Pump-RPM/text()",
+ final List<String> filterProperty7 = thingHandler.evaluateXPath("//Body-of-water/Filter/Max-Pump-RPM/text()",
xmlResponse);
- final List<String> filterProperty8 = bridgehandler
+ final List<String> filterProperty8 = thingHandler
.evaluateXPath("//Body-of-water/Filter/Vsp-Low-Pump-Speed/text()", xmlResponse);
- final List<String> filterProperty9 = bridgehandler
+ final List<String> filterProperty9 = thingHandler
.evaluateXPath("//Body-of-water/Filter/Vsp-Medium-Pump-Speed/text()", xmlResponse);
- final List<String> filterProperty10 = bridgehandler
+ final List<String> filterProperty10 = thingHandler
.evaluateXPath("//Body-of-water/Filter/Vsp-High-Pump-Speed/text()", xmlResponse);
- final List<String> filterProperty11 = bridgehandler
+ final List<String> filterProperty11 = thingHandler
.evaluateXPath("//Body-of-water/Filter/Vsp-Custom-Pump-Speed/text()", xmlResponse);
- final List<String> filterProperty12 = bridgehandler
+ final List<String> filterProperty12 = thingHandler
.evaluateXPath("//Body-of-water/Filter/Freeze-Protect-Override-Interval/text()", xmlResponse);
- discoverDevices(bridgehandler, xmlResponse, "Filter", HaywardTypeToRequest.FILTER,
+ discoverDevices(thingHandler, xmlResponse, "Filter", HaywardTypeToRequest.FILTER,
HaywardBindingConstants.THING_TYPE_FILTER, (props, i) -> {
props.put(HaywardBindingConstants.PROPERTY_FILTER_SHAREDTYPE, filterProperty1.get(i));
props.put(HaywardBindingConstants.PROPERTY_FILTER_FILTERTYPE, filterProperty2.get(i));
});
// Find Heaters
- final List<String> heaterProperty1 = bridgehandler
+ final List<String> heaterProperty1 = thingHandler
.evaluateXPath("//Body-of-water/Heater/Operation/Heater-Equipment/Type/text()", xmlResponse);
- final List<String> heaterProperty2 = bridgehandler
+ final List<String> heaterProperty2 = thingHandler
.evaluateXPath("//Body-of-water/Heater/Operation/Heater-Equipment/Heater-Type/text()", xmlResponse);
- final List<String> heaterProperty3 = bridgehandler.evaluateXPath(
+ final List<String> heaterProperty3 = thingHandler.evaluateXPath(
"//Body-of-water/Heater/Operation/Heater-Equipment/Shared-Equipment-System-ID/text()", xmlResponse);
- discoverDevices(bridgehandler, xmlResponse, "Heater-Equipment", HaywardTypeToRequest.HEATER,
+ discoverDevices(thingHandler, xmlResponse, "Heater-Equipment", HaywardTypeToRequest.HEATER,
HaywardBindingConstants.THING_TYPE_HEATER, (props, i) -> {
props.put(HaywardBindingConstants.PROPERTY_HEATER_TYPE, heaterProperty1.get(i));
props.put(HaywardBindingConstants.PROPERTY_HEATER_HEATERTYPE, heaterProperty2.get(i));
});
// Find Pumps
- final List<String> pumpProperty1 = bridgehandler.evaluateXPath("//Body-of-water/Pump/Type/text()", xmlResponse);
- final List<String> pumpProperty2 = bridgehandler.evaluateXPath("//Body-of-water/Pump/Function/text()",
+ final List<String> pumpProperty1 = thingHandler.evaluateXPath("//Body-of-water/Pump/Type/text()", xmlResponse);
+ final List<String> pumpProperty2 = thingHandler.evaluateXPath("//Body-of-water/Pump/Function/text()",
xmlResponse);
- final List<String> pumpProperty3 = bridgehandler.evaluateXPath("//Body-of-water/Pump/Priming-Enabled/text()",
+ final List<String> pumpProperty3 = thingHandler.evaluateXPath("//Body-of-water/Pump/Priming-Enabled/text()",
xmlResponse);
- final List<String> pumpProperty4 = bridgehandler.evaluateXPath("//Body-of-water/Pump/Min-Pump-Speed/text()",
+ final List<String> pumpProperty4 = thingHandler.evaluateXPath("//Body-of-water/Pump/Min-Pump-Speed/text()",
xmlResponse);
- final List<String> pumpProperty5 = bridgehandler.evaluateXPath("//Body-of-water/Pump/Max-Pump-Speed/text()",
+ final List<String> pumpProperty5 = thingHandler.evaluateXPath("//Body-of-water/Pump/Max-Pump-Speed/text()",
xmlResponse);
- final List<String> pumpProperty6 = bridgehandler.evaluateXPath("//Body-of-water/Pump/Min-Pump-RPM/text()",
+ final List<String> pumpProperty6 = thingHandler.evaluateXPath("//Body-of-water/Pump/Min-Pump-RPM/text()",
xmlResponse);
- final List<String> pumpProperty7 = bridgehandler.evaluateXPath("//Body-of-water/Pump/Max-Pump-RPM/text()",
+ final List<String> pumpProperty7 = thingHandler.evaluateXPath("//Body-of-water/Pump/Max-Pump-RPM/text()",
xmlResponse);
- final List<String> pumpProperty8 = bridgehandler.evaluateXPath("//Body-of-water/Pump/Vsp-Low-Pump-Speed/text()",
+ final List<String> pumpProperty8 = thingHandler.evaluateXPath("//Body-of-water/Pump/Vsp-Low-Pump-Speed/text()",
xmlResponse);
- final List<String> pumpProperty9 = bridgehandler
+ final List<String> pumpProperty9 = thingHandler
.evaluateXPath("//Body-of-water/Pump/Vsp-Medium-Pump-Speed/text()", xmlResponse);
- final List<String> pumpProperty10 = bridgehandler
+ final List<String> pumpProperty10 = thingHandler
.evaluateXPath("//Body-of-water/Pump/Vsp-High-Pump-Speed/text()", xmlResponse);
- final List<String> pumpProperty11 = bridgehandler
+ final List<String> pumpProperty11 = thingHandler
.evaluateXPath("//Body-of-water/Pump/Vsp-Custom-Pump-Speed/text()", xmlResponse);
- discoverDevices(bridgehandler, xmlResponse, "Pump", HaywardTypeToRequest.PUMP,
+ discoverDevices(thingHandler, xmlResponse, "Pump", HaywardTypeToRequest.PUMP,
HaywardBindingConstants.THING_TYPE_PUMP, (props, i) -> {
props.put(HaywardBindingConstants.PROPERTY_PUMP_TYPE, pumpProperty1.get(i));
props.put(HaywardBindingConstants.PROPERTY_PUMP_FUNCTION, pumpProperty2.get(i));
});
// Find Relays
- final List<String> relayProperty1 = bridgehandler.evaluateXPath("//Backyard//Relay/Type/text()", xmlResponse);
- final List<String> relayProperty2 = bridgehandler.evaluateXPath("//Backyard//Relay/Function/text()",
+ final List<String> relayProperty1 = thingHandler.evaluateXPath("//Backyard//Relay/Type/text()", xmlResponse);
+ final List<String> relayProperty2 = thingHandler.evaluateXPath("//Backyard//Relay/Function/text()",
xmlResponse);
- discoverDevices(bridgehandler, xmlResponse, "Relay", HaywardTypeToRequest.RELAY,
+ discoverDevices(thingHandler, xmlResponse, "Relay", HaywardTypeToRequest.RELAY,
HaywardBindingConstants.THING_TYPE_RELAY, (props, i) -> {
props.put(HaywardBindingConstants.PROPERTY_RELAY_TYPE, relayProperty1.get(i));
props.put(HaywardBindingConstants.PROPERTY_RELAY_FUNCTION, relayProperty2.get(i));
});
// Find Virtual Heaters
- final List<String> virtualHeaterProperty1 = bridgehandler
+ final List<String> virtualHeaterProperty1 = thingHandler
.evaluateXPath("//Body-of-water/Heater/Shared-Type/text()", xmlResponse);
- final List<String> virtualHeaterProperty2 = bridgehandler
+ final List<String> virtualHeaterProperty2 = thingHandler
.evaluateXPath("//Body-of-water/Heater/Min-Settable-Water-Temp/text()", xmlResponse);
- final List<String> virtualHeaterProperty3 = bridgehandler
+ final List<String> virtualHeaterProperty3 = thingHandler
.evaluateXPath("//Body-of-water/Heater/Max-Settable-Water-Temp/text()", xmlResponse);
- final List<String> virtualHeaterProperty4 = bridgehandler
+ final List<String> virtualHeaterProperty4 = thingHandler
.evaluateXPath("//Body-of-water/Heater/Max-Water-Temp/text()", xmlResponse);
- discoverDevices(bridgehandler, xmlResponse, "Heater", HaywardTypeToRequest.VIRTUALHEATER,
+ discoverDevices(thingHandler, xmlResponse, "Heater", HaywardTypeToRequest.VIRTUALHEATER,
HaywardBindingConstants.THING_TYPE_VIRTUALHEATER, (props, i) -> {
props.put(HaywardBindingConstants.PROPERTY_VIRTUALHEATER_SHAREDTYPE, virtualHeaterProperty1.get(i));
props.put(HaywardBindingConstants.PROPERTY_VIRTUALHEATER_MINSETTABLEWATERTEMP,
}
public void onDeviceDiscovered(ThingTypeUID thingType, String label, Map<String, Object> properties) {
- HaywardBridgeHandler bridgehandler = discoveryBridgehandler;
+ HaywardBridgeHandler bridgehandler = thingHandler;
String systemID = (String) properties.get(HaywardBindingConstants.PROPERTY_SYSTEM_ID);
if (bridgehandler != null) {
if (systemID != null) {
}
}
}
-
- @Override
- public void setThingHandler(@Nullable ThingHandler handler) {
- if (handler instanceof HaywardBridgeHandler bridgeHandler) {
- this.discoveryBridgehandler = bridgeHandler;
- }
- }
-
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return discoveryBridgehandler;
- }
}
import org.openhab.core.thing.binding.ThingActions;
import org.openhab.core.thing.binding.ThingActionsScope;
import org.openhab.core.thing.binding.ThingHandler;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Martin van Wingerden - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = HeosActions.class)
@ThingActionsScope(name = "heos")
@NonNullByDefault
public class HeosActions implements ThingActions {
import org.openhab.binding.homeconnect.internal.client.exception.CommunicationException;
import org.openhab.binding.homeconnect.internal.client.model.HomeAppliance;
import org.openhab.binding.homeconnect.internal.handler.HomeConnectBridgeHandler;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResult;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
-import org.openhab.core.config.discovery.DiscoveryService;
import org.openhab.core.thing.ThingTypeUID;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Jonas Brüstel - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = HomeConnectDiscoveryService.class)
@NonNullByDefault
-public class HomeConnectDiscoveryService extends AbstractDiscoveryService
- implements DiscoveryService, ThingHandlerService {
+public class HomeConnectDiscoveryService extends AbstractThingHandlerDiscoveryService<HomeConnectBridgeHandler> {
private static final int SEARCH_TIME_SEC = 20;
private final Logger logger = LoggerFactory.getLogger(HomeConnectDiscoveryService.class);
- private @Nullable HomeConnectBridgeHandler bridgeHandler;
-
/**
* Construct a {@link HomeConnectDiscoveryService}.
*
*/
public HomeConnectDiscoveryService() {
- super(DISCOVERABLE_DEVICE_THING_TYPES_UIDS, SEARCH_TIME_SEC, true);
- }
-
- @Override
- public void setThingHandler(ThingHandler handler) {
- if (handler instanceof HomeConnectBridgeHandler homeConnectBridgeHandler) {
- this.bridgeHandler = homeConnectBridgeHandler;
- }
- }
-
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return bridgeHandler;
+ super(HomeConnectBridgeHandler.class, DISCOVERABLE_DEVICE_THING_TYPES_UIDS, SEARCH_TIME_SEC, true);
}
@Override
protected void startScan() {
logger.debug("Starting device scan.");
- var bridgeHandler = this.bridgeHandler;
- if (bridgeHandler != null) {
- HomeConnectApiClient apiClient = bridgeHandler.getApiClient();
-
- try {
- List<HomeAppliance> appliances = apiClient.getHomeAppliances();
- logger.debug("Scan found {} devices.", appliances.size());
-
- // add found devices
- for (HomeAppliance appliance : appliances) {
- @Nullable
- ThingTypeUID thingTypeUID = getThingTypeUID(appliance);
-
- if (thingTypeUID != null) {
- logger.debug("Found {} ({}).", appliance.getHaId(), appliance.getType().toUpperCase());
-
- Map<String, Object> properties = Map.of(HA_ID, appliance.getHaId());
- String name = appliance.getBrand() + " " + appliance.getName() + " (" + appliance.getHaId()
- + ")";
-
- DiscoveryResult discoveryResult = DiscoveryResultBuilder
- .create(new ThingUID(BINDING_ID, appliance.getType(),
- bridgeHandler.getThing().getUID().getId(), appliance.getHaId()))
- .withThingType(thingTypeUID).withProperties(properties)
- .withRepresentationProperty(HA_ID).withBridge(bridgeHandler.getThing().getUID())
- .withLabel(name).build();
- thingDiscovered(discoveryResult);
- } else {
- logger.debug("Ignoring unsupported device {} of type {}.", appliance.getHaId(),
- appliance.getType());
- }
+ HomeConnectApiClient apiClient = thingHandler.getApiClient();
+
+ try {
+ List<HomeAppliance> appliances = apiClient.getHomeAppliances();
+ logger.debug("Scan found {} devices.", appliances.size());
+
+ // add found devices
+ for (HomeAppliance appliance : appliances) {
+ @Nullable
+ ThingTypeUID thingTypeUID = getThingTypeUID(appliance);
+
+ if (thingTypeUID != null) {
+ logger.debug("Found {} ({}).", appliance.getHaId(), appliance.getType().toUpperCase());
+
+ Map<String, Object> properties = Map.of(HA_ID, appliance.getHaId());
+ String name = appliance.getBrand() + " " + appliance.getName() + " (" + appliance.getHaId() + ")";
+
+ DiscoveryResult discoveryResult = DiscoveryResultBuilder
+ .create(new ThingUID(BINDING_ID, appliance.getType(),
+ thingHandler.getThing().getUID().getId(), appliance.getHaId()))
+ .withThingType(thingTypeUID).withProperties(properties).withRepresentationProperty(HA_ID)
+ .withBridge(thingHandler.getThing().getUID()).withLabel(name).build();
+ thingDiscovered(discoveryResult);
+ } else {
+ logger.debug("Ignoring unsupported device {} of type {}.", appliance.getHaId(),
+ appliance.getType());
}
- } catch (CommunicationException | AuthorizationException e) {
- logger.debug("Exception during scan.", e);
}
+ } catch (CommunicationException | AuthorizationException e) {
+ logger.debug("Exception during scan.", e);
}
+
logger.debug("Finished device scan.");
}
@Override
- public void deactivate() {
- super.deactivate();
- var bridgeHandler = this.bridgeHandler;
- if (bridgeHandler != null) {
- removeOlderResults(System.currentTimeMillis(), bridgeHandler.getThing().getUID());
- }
+ public void dispose() {
+ super.dispose();
+ removeOlderResults(System.currentTimeMillis(), thingHandler.getThing().getUID());
}
@Override
protected synchronized void stopScan() {
super.stopScan();
- var bridgeHandler = this.bridgeHandler;
- if (bridgeHandler != null) {
- removeOlderResults(getTimestampOfLastScan(), bridgeHandler.getThing().getUID());
- }
+ removeOlderResults(getTimestampOfLastScan(), thingHandler.getThing().getUID());
}
private @Nullable ThingTypeUID getThingTypeUID(HomeAppliance appliance) {
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
-import org.eclipse.jdt.annotation.NonNullByDefault;
-import org.eclipse.jdt.annotation.Nullable;
+import org.eclipse.jdt.annotation.NonNull;
import org.openhab.binding.homematic.internal.common.HomematicConfig;
import org.openhab.binding.homematic.internal.communicator.HomematicGateway;
import org.openhab.binding.homematic.internal.handler.HomematicBridgeHandler;
import org.openhab.binding.homematic.internal.model.HmDevice;
import org.openhab.binding.homematic.internal.type.UidUtils;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResult;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
-import org.openhab.core.config.discovery.DiscoveryService;
import org.openhab.core.thing.Thing;
import org.openhab.core.thing.ThingStatus;
import org.openhab.core.thing.ThingTypeUID;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Gerhard Riegler - Initial contribution
*/
-public class HomematicDeviceDiscoveryService extends AbstractDiscoveryService
- implements DiscoveryService, ThingHandlerService {
+@Component(scope = ServiceScope.PROTOTYPE, service = HomematicDeviceDiscoveryService.class)
+public class HomematicDeviceDiscoveryService
+ extends AbstractThingHandlerDiscoveryService<@NonNull HomematicBridgeHandler> {
private final Logger logger = LoggerFactory.getLogger(HomematicDeviceDiscoveryService.class);
private static final int DISCOVER_TIMEOUT_SECONDS = 300;
- private @NonNullByDefault({}) HomematicBridgeHandler bridgeHandler;
private Future<?> loadDevicesFuture;
private volatile boolean isInInstallMode = false;
private volatile Object installModeSync = new Object();
public HomematicDeviceDiscoveryService() {
- super(Set.of(new ThingTypeUID(BINDING_ID, "-")), DISCOVER_TIMEOUT_SECONDS, false);
+ super(HomematicBridgeHandler.class, Set.of(new ThingTypeUID(BINDING_ID, "-")), DISCOVER_TIMEOUT_SECONDS, false);
}
@Override
- public void setThingHandler(@Nullable ThingHandler handler) {
- if (handler instanceof HomematicBridgeHandler homematicBridgeHandler) {
- this.bridgeHandler = homematicBridgeHandler;
- this.bridgeHandler.setDiscoveryService(this);
- }
- }
-
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return bridgeHandler;
- }
-
- /**
- * Called on component activation.
- */
- @Override
- public void activate() {
- super.activate(null);
- }
-
- @Override
- public void deactivate() {
- super.deactivate();
+ public void initialize() {
+ thingHandler.setDiscoveryService(this);
+ super.initialize();
}
@Override
*/
private void enableInstallMode() {
try {
- HomematicGateway gateway = bridgeHandler.getGateway();
- ThingStatus bridgeStatus = null;
+ HomematicGateway gateway = thingHandler.getGateway();
+ Thing bridge = thingHandler.getThing();
+ ThingStatus bridgeStatus = bridge.getStatus();
- if (bridgeHandler != null) {
- Thing bridge = bridgeHandler.getThing();
- bridgeStatus = bridge.getStatus();
- }
if (ThingStatus.ONLINE == bridgeStatus) {
gateway.setInstallMode(true, getInstallModeDuration());
}
private int getInstallModeDuration() {
- if (bridgeHandler != null) {
- return bridgeHandler.getThing().getConfiguration().as(HomematicConfig.class).getInstallModeDuration();
- }
- return HomematicConfig.DEFAULT_INSTALL_MODE_DURATION;
+ return thingHandler.getThing().getConfiguration().as(HomematicConfig.class).getInstallModeDuration();
}
@Override
@Override
public synchronized void stopScan() {
logger.debug("Stopping Homematic discovery scan");
- if (bridgeHandler != null && bridgeHandler.getGateway() != null) {
- disableInstallMode();
- bridgeHandler.getGateway().cancelLoadAllDeviceMetadata();
- }
+ disableInstallMode();
+ thingHandler.getGateway().cancelLoadAllDeviceMetadata();
waitForScanFinishing();
super.stopScan();
}
if (isInInstallMode) {
isInInstallMode = false;
installModeSync.notify();
- bridgeHandler.getGateway().setInstallMode(false, 0);
+ thingHandler.getGateway().setInstallMode(false, 0);
}
}
} catch (Exception ex) {
logger.error("Error waiting for device discovery scan: {}", ex.getMessage(), ex);
}
+ HomematicBridgeHandler bridgeHandler = thingHandler;
String gatewayId = bridgeHandler != null && bridgeHandler.getGateway() != null
? bridgeHandler.getGateway().getId()
: "UNKNOWN";
* Starts a thread which loads all Homematic devices connected to the gateway.
*/
public void loadDevices() {
- if (loadDevicesFuture == null && bridgeHandler.getGateway() != null) {
+ if (loadDevicesFuture == null && thingHandler.getGateway() != null) {
loadDevicesFuture = scheduler.submit(() -> {
try {
- final HomematicGateway gateway = bridgeHandler.getGateway();
+ final HomematicGateway gateway = thingHandler.getGateway();
gateway.loadAllDeviceMetadata();
- bridgeHandler.getTypeGenerator().validateFirmwares();
+ thingHandler.getTypeGenerator().validateFirmwares();
} catch (Throwable ex) {
logger.error("{}", ex.getMessage(), ex);
} finally {
loadDevicesFuture = null;
- bridgeHandler.setOfflineStatus();
+ thingHandler.setOfflineStatus();
removeOlderResults(getTimestampOfLastScan());
}
});
* Removes the Homematic device.
*/
public void deviceRemoved(HmDevice device) {
- ThingUID thingUID = UidUtils.generateThingUID(device, bridgeHandler.getThing());
+ ThingUID thingUID = UidUtils.generateThingUID(device, thingHandler.getThing());
thingRemoved(thingUID);
}
* Generates the DiscoveryResult from a Homematic device.
*/
public void deviceDiscovered(HmDevice device) {
- ThingUID bridgeUID = bridgeHandler.getThing().getUID();
+ ThingUID bridgeUID = thingHandler.getThing().getUID();
ThingTypeUID typeUid = UidUtils.generateThingTypeUID(device);
ThingUID thingUID = new ThingUID(typeUid, bridgeUID, device.getAddress());
String label = device.getName() != null ? device.getName() : device.getAddress();
- long timeToLive = bridgeHandler.getThing().getConfiguration().as(HomematicConfig.class)
- .getDiscoveryTimeToLive();
+ long timeToLive = thingHandler.getThing().getConfiguration().as(HomematicConfig.class).getDiscoveryTimeToLive();
DiscoveryResult discoveryResult = DiscoveryResultBuilder.create(thingUID).withBridge(bridgeUID).withLabel(label)
.withProperty(Thing.PROPERTY_SERIAL_NUMBER, device.getAddress())
import org.openhab.core.thing.binding.ThingActionsScope;
import org.openhab.core.thing.binding.ThingHandler;
import org.openhab.core.types.Command;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Andrew Fiddian-Green - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = DynamicsActions.class)
@ThingActionsScope(name = "hue")
@NonNullByDefault
public class DynamicsActions implements ThingActions {
import org.openhab.core.thing.binding.ThingActionsScope;
import org.openhab.core.thing.binding.ThingHandler;
import org.openhab.core.types.Command;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Jochen Leopold - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = LightActions.class)
@ThingActionsScope(name = "hue")
@NonNullByDefault
public class LightActions implements ThingActions {
import org.openhab.binding.hue.internal.exceptions.ApiException;
import org.openhab.binding.hue.internal.exceptions.AssetNotLoadedException;
import org.openhab.binding.hue.internal.handler.Clip2BridgeHandler;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
import org.openhab.core.thing.Thing;
import org.openhab.core.thing.ThingStatus;
import org.openhab.core.thing.ThingTypeUID;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Andrew Fiddian-Green - Initial Contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = Clip2ThingDiscoveryService.class)
@NonNullByDefault
-public class Clip2ThingDiscoveryService extends AbstractDiscoveryService implements ThingHandlerService {
-
+public class Clip2ThingDiscoveryService extends AbstractThingHandlerDiscoveryService<Clip2BridgeHandler> {
private final Logger logger = LoggerFactory.getLogger(Clip2ThingDiscoveryService.class);
private static final int DISCOVERY_TIMEOUT_SECONDS = 20;
ResourceType.ZONE, THING_TYPE_ZONE, //
ResourceType.BRIDGE_HOME, THING_TYPE_ZONE);
- private @Nullable Clip2BridgeHandler bridgeHandler;
private @Nullable ScheduledFuture<?> discoveryTask;
public Clip2ThingDiscoveryService() {
- super(Set.of(THING_TYPE_DEVICE, THING_TYPE_ROOM, THING_TYPE_ZONE), DISCOVERY_TIMEOUT_SECONDS, true);
+ super(Clip2BridgeHandler.class, Set.of(THING_TYPE_DEVICE, THING_TYPE_ROOM, THING_TYPE_ZONE),
+ DISCOVERY_TIMEOUT_SECONDS, true);
}
@Override
- public void activate() {
- Clip2BridgeHandler bridgeHandler = this.bridgeHandler;
- if (Objects.nonNull(bridgeHandler)) {
- bridgeHandler.registerDiscoveryService(this);
- }
- super.activate(null);
+ public void initialize() {
+ thingHandler.registerDiscoveryService(this);
+ super.initialize();
}
@Override
- public void deactivate() {
- super.deactivate();
- Clip2BridgeHandler bridgeHandler = this.bridgeHandler;
- if (Objects.nonNull(bridgeHandler)) {
- bridgeHandler.unregisterDiscoveryService();
- removeOlderResults(new Date().getTime(), bridgeHandler.getThing().getBridgeUID());
- this.bridgeHandler = null;
- }
+ public void dispose() {
+ super.dispose();
+ thingHandler.unregisterDiscoveryService();
+ removeOlderResults(new Date().getTime(), thingHandler.getThing().getBridgeUID());
}
/**
* as OH things, and announce those respective things by calling the core 'thingDiscovered()' method.
*/
private synchronized void discoverThings() {
- Clip2BridgeHandler bridgeHandler = this.bridgeHandler;
- if (Objects.nonNull(bridgeHandler) && bridgeHandler.getThing().getStatus() == ThingStatus.ONLINE) {
+ if (thingHandler.getThing().getStatus() == ThingStatus.ONLINE) {
try {
- ThingUID bridgeUID = bridgeHandler.getThing().getUID();
+ ThingUID bridgeUID = thingHandler.getThing().getUID();
for (Entry<ResourceType, ThingTypeUID> entry : DISCOVERY_TYPES.entrySet()) {
- for (Resource resource : bridgeHandler.getResources(new ResourceReference().setType(entry.getKey()))
+ for (Resource resource : thingHandler.getResources(new ResourceReference().setType(entry.getKey()))
.getResources()) {
MetaData metaData = resource.getMetaData();
// special zone 'all lights'
if (resource.getType() == ResourceType.BRIDGE_HOME) {
- thingLabel = bridgeHandler.getLocalizedText(ALL_LIGHTS_KEY);
+ thingLabel = thingHandler.getLocalizedText(ALL_LIGHTS_KEY);
}
- Optional<Thing> legacyThingOptional = bridgeHandler.getLegacyThing(idv1);
+ Optional<Thing> legacyThingOptional = thingHandler.getLegacyThing(idv1);
if (legacyThingOptional.isPresent()) {
Thing legacyThing = legacyThingOptional.get();
legacyThingUID = legacyThing.getUID().getAsString();
stopScan();
}
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return bridgeHandler;
- }
-
- @Override
- public void setThingHandler(ThingHandler handler) {
- if (handler instanceof Clip2BridgeHandler) {
- bridgeHandler = (Clip2BridgeHandler) handler;
- }
- }
-
@Override
protected void startBackgroundDiscovery() {
ScheduledFuture<?> discoveryTask = this.discoveryTask;
import org.openhab.binding.hue.internal.handler.sensors.PresenceHandler;
import org.openhab.binding.hue.internal.handler.sensors.TapSwitchHandler;
import org.openhab.binding.hue.internal.handler.sensors.TemperatureHandler;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResult;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
+import org.openhab.core.i18n.LocaleProvider;
+import org.openhab.core.i18n.TranslationProvider;
import org.openhab.core.thing.Thing;
import org.openhab.core.thing.ThingTypeUID;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.Reference;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
* @author Meng Yiqi - Added support for CLIP sensor
* @author Laurent Garnier - Added support for groups
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = HueDeviceDiscoveryService.class)
@NonNullByDefault
-public class HueDeviceDiscoveryService extends AbstractDiscoveryService implements ThingHandlerService {
-
+public class HueDeviceDiscoveryService extends AbstractThingHandlerDiscoveryService<HueBridgeHandler> {
public static final Set<ThingTypeUID> SUPPORTED_THING_TYPES = Stream
.of(HueLightHandler.SUPPORTED_THING_TYPES.stream(), DimmerSwitchHandler.SUPPORTED_THING_TYPES.stream(),
TapSwitchHandler.SUPPORTED_THING_TYPES.stream(), PresenceHandler.SUPPORTED_THING_TYPES.stream(),
private final Logger logger = LoggerFactory.getLogger(HueDeviceDiscoveryService.class);
- private @Nullable HueBridgeHandler hueBridgeHandler;
private @Nullable ThingUID bridgeUID;
public HueDeviceDiscoveryService() {
- super(SUPPORTED_THING_TYPES, SEARCH_TIME);
+ super(HueBridgeHandler.class, SUPPORTED_THING_TYPES, SEARCH_TIME);
}
- @Override
- public void setThingHandler(@Nullable ThingHandler handler) {
- if (handler instanceof HueBridgeHandler) {
- HueBridgeHandler localHandler = (HueBridgeHandler) handler;
- hueBridgeHandler = localHandler;
- bridgeUID = handler.getThing().getUID();
- i18nProvider = localHandler.getI18nProvider();
- localeProvider = localHandler.getLocaleProvider();
- }
+ @Reference(unbind = "-")
+ public void bindTranslationProvider(TranslationProvider translationProvider) {
+ this.i18nProvider = translationProvider;
}
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return hueBridgeHandler;
+ @Reference(unbind = "-")
+ public void bindLocaleProvider(LocaleProvider localeProvider) {
+ this.localeProvider = localeProvider;
}
@Override
- public void activate() {
- final HueBridgeHandler handler = hueBridgeHandler;
- if (handler != null) {
- handler.registerDiscoveryListener(this);
- }
+ public void initialize() {
+ bridgeUID = thingHandler.getThing().getUID();
+ thingHandler.registerDiscoveryListener(this);
+ super.initialize();
}
@Override
- public void deactivate() {
+ public void dispose() {
+ super.dispose();
removeOlderResults(new Date().getTime(), bridgeUID);
- final HueBridgeHandler handler = hueBridgeHandler;
- if (handler != null) {
- handler.unregisterDiscoveryListener();
- }
+ thingHandler.unregisterDiscoveryListener();
}
@Override
@Override
public void startScan() {
- final HueBridgeHandler handler = hueBridgeHandler;
- if (handler != null) {
- List<FullLight> lights = handler.getFullLights();
- for (FullLight l : lights) {
- addLightDiscovery(l);
- }
- List<FullSensor> sensors = handler.getFullSensors();
- for (FullSensor s : sensors) {
- addSensorDiscovery(s);
- }
- List<FullGroup> groups = handler.getFullGroups();
- for (FullGroup g : groups) {
- addGroupDiscovery(g);
- }
- // search for unpaired lights
- handler.startSearch();
+ List<FullLight> lights = thingHandler.getFullLights();
+ for (FullLight l : lights) {
+ addLightDiscovery(l);
}
+ List<FullSensor> sensors = thingHandler.getFullSensors();
+ for (FullSensor s : sensors) {
+ addSensorDiscovery(s);
+ }
+ List<FullGroup> groups = thingHandler.getFullGroups();
+ for (FullGroup g : groups) {
+ addGroupDiscovery(g);
+ }
+ // search for unpaired lights
+ thingHandler.startSearch();
}
@Override
protected synchronized void stopScan() {
super.stopScan();
- final HueBridgeHandler handler = hueBridgeHandler;
- if (handler != null) {
- removeOlderResults(getTimestampOfLastScan(), handler.getThing().getUID());
- }
+ removeOlderResults(getTimestampOfLastScan(), thingHandler.getThing().getUID());
}
public void addLightDiscovery(FullLight light) {
itemChannelLinkRegistry);
} else if (HueBridgeHandler.SUPPORTED_THING_TYPES.contains(thingTypeUID)) {
return new HueBridgeHandler((Bridge) thing, httpClientFactory.getCommonHttpClient(),
- stateDescriptionProvider, i18nProvider, localeProvider);
+ stateDescriptionProvider);
} else if (HueLightHandler.SUPPORTED_THING_TYPES.contains(thingTypeUID)) {
return new HueLightHandler(thing, stateDescriptionProvider);
} else if (DimmerSwitchHandler.SUPPORTED_THING_TYPES.contains(thingTypeUID)) {
import org.openhab.core.config.core.status.ConfigStatusMessage;
import org.openhab.core.i18n.CommunicationException;
import org.openhab.core.i18n.ConfigurationException;
-import org.openhab.core.i18n.LocaleProvider;
-import org.openhab.core.i18n.TranslationProvider;
import org.openhab.core.io.net.http.TlsTrustManagerProvider;
import org.openhab.core.library.types.HSBType;
import org.openhab.core.library.types.OnOffType;
private @Nullable ServiceRegistration<?> serviceRegistration;
private final HttpClient httpClient;
private final HueStateDescriptionProvider stateDescriptionOptionProvider;
- private final TranslationProvider i18nProvider;
- private final LocaleProvider localeProvider;
private final Map<String, FullLight> lastLightStates = new ConcurrentHashMap<>();
private final Map<String, FullSensor> lastSensorStates = new ConcurrentHashMap<>();
private List<String> consoleScenesList = new ArrayList<>();
public HueBridgeHandler(Bridge bridge, HttpClient httpClient,
- HueStateDescriptionProvider stateDescriptionOptionProvider, TranslationProvider i18nProvider,
- LocaleProvider localeProvider) {
+ HueStateDescriptionProvider stateDescriptionOptionProvider) {
super(bridge);
this.httpClient = httpClient;
this.stateDescriptionOptionProvider = stateDescriptionOptionProvider;
- this.i18nProvider = i18nProvider;
- this.localeProvider = localeProvider;
}
@Override
return List.of();
}
}
-
- public TranslationProvider getI18nProvider() {
- return i18nProvider;
- }
-
- public LocaleProvider getLocaleProvider() {
- return localeProvider;
- }
}
import java.util.Set;
import org.eclipse.jdt.annotation.NonNullByDefault;
-import org.eclipse.jdt.annotation.Nullable;
import org.openhab.binding.hydrawise.internal.HydrawiseBindingConstants;
import org.openhab.binding.hydrawise.internal.HydrawiseControllerListener;
import org.openhab.binding.hydrawise.internal.api.graphql.dto.Controller;
import org.openhab.binding.hydrawise.internal.api.graphql.dto.Customer;
import org.openhab.binding.hydrawise.internal.handler.HydrawiseAccountHandler;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
import org.openhab.core.thing.binding.ThingHandlerService;
import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
/**
*
*/
@NonNullByDefault
-@Component(service = ThingHandlerService.class)
-public class HydrawiseCloudControllerDiscoveryService extends AbstractDiscoveryService
- implements HydrawiseControllerListener, ThingHandlerService {
-
+@Component(scope = ServiceScope.PROTOTYPE, service = ThingHandlerService.class)
+public class HydrawiseCloudControllerDiscoveryService
+ extends AbstractThingHandlerDiscoveryService<HydrawiseAccountHandler> implements HydrawiseControllerListener {
private static final int TIMEOUT = 5;
- @Nullable
- HydrawiseAccountHandler handler;
public HydrawiseCloudControllerDiscoveryService() {
- super(Set.of(HydrawiseBindingConstants.THING_TYPE_CONTROLLER), TIMEOUT, true);
+ super(HydrawiseAccountHandler.class, Set.of(HydrawiseBindingConstants.THING_TYPE_CONTROLLER), TIMEOUT, true);
}
@Override
protected void startScan() {
- HydrawiseAccountHandler localHandler = this.handler;
- if (localHandler != null) {
- Customer data = localHandler.lastData();
- if (data != null) {
- data.controllers.forEach(controller -> addDiscoveryResults(controller));
- }
+ Customer data = thingHandler.lastData();
+ if (data != null) {
+ data.controllers.forEach(controller -> addDiscoveryResults(controller));
}
}
@Override
- public void deactivate() {
- HydrawiseAccountHandler localHandler = this.handler;
- if (localHandler != null) {
- removeOlderResults(new Date().getTime(), localHandler.getThing().getUID());
- }
+ public void dispose() {
+ super.dispose();
+ removeOlderResults(new Date().getTime(), thingHandler.getThing().getUID());
}
@Override
protected synchronized void stopScan() {
super.stopScan();
- HydrawiseAccountHandler localHandler = this.handler;
- if (localHandler != null) {
- removeOlderResults(getTimestampOfLastScan(), localHandler.getThing().getUID());
- }
+ removeOlderResults(getTimestampOfLastScan(), thingHandler.getThing().getUID());
}
@Override
}
@Override
- public void setThingHandler(ThingHandler handler) {
- this.handler = (HydrawiseAccountHandler) handler;
- this.handler.addControllerListeners(this);
- }
-
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return handler;
+ public void initialize() {
+ thingHandler.addControllerListeners(this);
+ super.initialize();
}
private void addDiscoveryResults(Controller controller) {
- HydrawiseAccountHandler localHandler = this.handler;
- if (localHandler != null) {
- String label = String.format("Hydrawise Controller %s", controller.name);
- int id = controller.id;
- ThingUID bridgeUID = localHandler.getThing().getUID();
- ThingUID thingUID = new ThingUID(HydrawiseBindingConstants.THING_TYPE_CONTROLLER, bridgeUID,
- String.valueOf(id));
- thingDiscovered(DiscoveryResultBuilder.create(thingUID).withLabel(label).withBridge(bridgeUID)
- .withProperty(HydrawiseBindingConstants.CONFIG_CONTROLLER_ID, id)
- .withRepresentationProperty(HydrawiseBindingConstants.CONFIG_CONTROLLER_ID).build());
- }
+ String label = String.format("Hydrawise Controller %s", controller.name);
+ int id = controller.id;
+ ThingUID bridgeUID = thingHandler.getThing().getUID();
+ ThingUID thingUID = new ThingUID(HydrawiseBindingConstants.THING_TYPE_CONTROLLER, bridgeUID,
+ String.valueOf(id));
+ thingDiscovered(DiscoveryResultBuilder.create(thingUID).withLabel(label).withBridge(bridgeUID)
+ .withProperty(HydrawiseBindingConstants.CONFIG_CONTROLLER_ID, id)
+ .withRepresentationProperty(HydrawiseBindingConstants.CONFIG_CONTROLLER_ID).build());
}
}
import org.openhab.core.thing.binding.ThingActions;
import org.openhab.core.thing.binding.ThingActionsScope;
import org.openhab.core.thing.binding.ThingHandler;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Matthew Skinner - Initial contribution
*/
-
+@Component(scope = ServiceScope.PROTOTYPE, service = IpCameraActions.class)
@ThingActionsScope(name = "ipcamera")
@NonNullByDefault
public class IpCameraActions implements ThingActions {
import org.eclipse.jdt.annotation.Nullable;
import org.openhab.binding.jablotron.internal.handler.JablotronBridgeHandler;
import org.openhab.binding.jablotron.internal.model.JablotronDiscoveredService;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
-import org.openhab.core.config.discovery.DiscoveryService;
import org.openhab.core.thing.ThingStatus;
import org.openhab.core.thing.ThingTypeUID;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Ondrej Pecta - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = JablotronDiscoveryService.class)
@NonNullByDefault
-public class JablotronDiscoveryService extends AbstractDiscoveryService
- implements DiscoveryService, ThingHandlerService {
+public class JablotronDiscoveryService extends AbstractThingHandlerDiscoveryService<JablotronBridgeHandler> {
private final Logger logger = LoggerFactory.getLogger(JablotronDiscoveryService.class);
- private @Nullable JablotronBridgeHandler bridgeHandler;
-
private @Nullable ScheduledFuture<?> discoveryJob = null;
public JablotronDiscoveryService() {
- super(DISCOVERY_TIMEOUT_SEC);
+ super(JablotronBridgeHandler.class, DISCOVERY_TIMEOUT_SEC);
logger.debug("Creating discovery service");
}
private void startDiscovery() {
- JablotronBridgeHandler localBridgeHandler = bridgeHandler;
+ JablotronBridgeHandler localBridgeHandler = thingHandler;
if (localBridgeHandler != null && ThingStatus.ONLINE == localBridgeHandler.getThing().getStatus()) {
discoverServices();
}
}
- @Override
- public void setThingHandler(@Nullable ThingHandler thingHandler) {
- if (thingHandler instanceof JablotronBridgeHandler bridgeHandler) {
- this.bridgeHandler = bridgeHandler;
- }
- }
-
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return bridgeHandler;
- }
-
@Override
protected void stopBackgroundDiscovery() {
super.stopBackgroundDiscovery();
}
}
- @Override
- public void activate() {
- super.activate(null);
- }
-
- @Override
- public void deactivate() {
- super.deactivate();
- }
-
@Override
public Set<ThingTypeUID> getSupportedThingTypes() {
return SUPPORTED_THING_TYPES_UIDS;
}
public void oasisDiscovered(String label, String serviceId) {
- JablotronBridgeHandler localBridgeHandler = bridgeHandler;
+ JablotronBridgeHandler localBridgeHandler = thingHandler;
if (localBridgeHandler != null) {
ThingUID thingUID = new ThingUID(THING_TYPE_OASIS, localBridgeHandler.getThing().getUID(), serviceId);
}
public void ja100Discovered(String label, String serviceId) {
- JablotronBridgeHandler localBridgeHandler = bridgeHandler;
+ JablotronBridgeHandler localBridgeHandler = thingHandler;
if (localBridgeHandler != null) {
ThingUID thingUID = new ThingUID(THING_TYPE_JA100, localBridgeHandler.getThing().getUID(), serviceId);
Map<String, Object> properties = new HashMap<>();
}
public void ja100fDiscovered(String label, String serviceId) {
- JablotronBridgeHandler localBridgeHandler = bridgeHandler;
+ JablotronBridgeHandler localBridgeHandler = thingHandler;
if (localBridgeHandler != null) {
ThingUID thingUID = new ThingUID(THING_TYPE_JA100F, localBridgeHandler.getThing().getUID(), serviceId);
Map<String, Object> properties = new HashMap<>();
}
private synchronized void discoverServices() {
- JablotronBridgeHandler localBridgeHandler = bridgeHandler;
+ JablotronBridgeHandler localBridgeHandler = thingHandler;
if (localBridgeHandler != null) {
List<JablotronDiscoveredService> services = localBridgeHandler.discoverServices();
import java.util.Set;
import org.eclipse.jdt.annotation.NonNullByDefault;
-import org.eclipse.jdt.annotation.Nullable;
import org.jellyfin.sdk.api.client.exception.ApiClientException;
import org.jellyfin.sdk.api.client.exception.InvalidStatusException;
import org.jellyfin.sdk.model.api.SessionInfo;
import org.openhab.binding.jellyfin.internal.handler.JellyfinServerHandler;
import org.openhab.binding.jellyfin.internal.util.SyncCallback;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
import org.openhab.core.thing.Thing;
import org.openhab.core.thing.ThingStatus;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Miguel Alvarez - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = JellyfinClientDiscoveryService.class)
@NonNullByDefault
-public class JellyfinClientDiscoveryService extends AbstractDiscoveryService implements ThingHandlerService {
+public class JellyfinClientDiscoveryService extends AbstractThingHandlerDiscoveryService<JellyfinServerHandler> {
private final Logger logger = LoggerFactory.getLogger(JellyfinClientDiscoveryService.class);
- private @Nullable JellyfinServerHandler bridgeHandler;
public JellyfinClientDiscoveryService() throws IllegalArgumentException {
- super(Set.of(THING_TYPE_SERVER), 60);
+ super(JellyfinServerHandler.class, Set.of(THING_TYPE_SERVER), 60);
}
@Override
protected void startScan() {
- var bridgeHandler = this.bridgeHandler;
- if (bridgeHandler == null) {
- logger.warn("missing bridge aborting");
+ if (!thingHandler.getThing().getStatus().equals(ThingStatus.ONLINE)) {
+ logger.warn("Server handler {} is not online.", thingHandler.getThing().getLabel());
return;
}
- if (!bridgeHandler.getThing().getStatus().equals(ThingStatus.ONLINE)) {
- logger.warn("Server handler {} is not online.", bridgeHandler.getThing().getLabel());
- return;
- }
- logger.debug("Searching devices for server {}", bridgeHandler.getThing().getLabel());
+ logger.debug("Searching devices for server {}", thingHandler.getThing().getLabel());
try {
- bridgeHandler.getControllableSessions().forEach(this::discoverDevice);
+ thingHandler.getControllableSessions().forEach(this::discoverDevice);
} catch (SyncCallback.SyncCallbackError syncCallbackError) {
logger.error("Unexpected error: {}", syncCallbackError.getMessage());
} catch (InvalidStatusException e) {
logger.warn("missing device id aborting");
return;
}
- var bridgeHandler = this.bridgeHandler;
- if (bridgeHandler == null) {
- logger.warn("missing bridge aborting");
- return;
- }
logger.debug("Client discovered: [{}] {}", id, info.getDeviceName());
- var bridgeUID = bridgeHandler.getThing().getUID();
+ var bridgeUID = thingHandler.getThing().getUID();
Map<String, Object> properties = new HashMap<>();
properties.put(Thing.PROPERTY_SERIAL_NUMBER, id);
var appVersion = info.getApplicationVersion();
.withTTL(DISCOVERY_RESULT_TTL_SEC).withRepresentationProperty(Thing.PROPERTY_SERIAL_NUMBER)
.withProperties(properties).withLabel(info.getDeviceName()).build());
}
-
- @Override
- public void setThingHandler(ThingHandler thingHandler) {
- if (thingHandler instanceof JellyfinServerHandler bridgeHandler) {
- this.bridgeHandler = bridgeHandler;
- }
- }
-
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return null;
- }
-
- @Override
- public void activate() {
- activate(new HashMap<>());
- }
-
- @Override
- public void deactivate() {
- super.deactivate();
- }
}
import static org.openhab.binding.juicenet.internal.JuiceNetBindingConstants.*;
-import java.util.Objects;
import java.util.Set;
import org.eclipse.jdt.annotation.NonNullByDefault;
-import org.eclipse.jdt.annotation.Nullable;
import org.openhab.binding.juicenet.internal.handler.JuiceNetBridgeHandler;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResult;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
-import org.openhab.core.config.discovery.DiscoveryService;
import org.openhab.core.thing.ThingTypeUID;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Jeff James - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = JuiceNetDiscoveryService.class)
@NonNullByDefault
-public class JuiceNetDiscoveryService extends AbstractDiscoveryService
- implements DiscoveryService, ThingHandlerService {
+public class JuiceNetDiscoveryService extends AbstractThingHandlerDiscoveryService<JuiceNetBridgeHandler> {
private final Logger logger = LoggerFactory.getLogger(JuiceNetDiscoveryService.class);
- private @Nullable JuiceNetBridgeHandler bridgeHandler;
-
private static final Set<ThingTypeUID> DISCOVERABLE_THING_TYPES_UIDS = Set.of(DEVICE_THING_TYPE);
public JuiceNetDiscoveryService() {
- super(DISCOVERABLE_THING_TYPES_UIDS, 0, false);
- }
-
- @Override
- public void activate() {
- super.activate(null);
- }
-
- @Override
- public void deactivate() {
- super.deactivate();
+ super(JuiceNetBridgeHandler.class, DISCOVERABLE_THING_TYPES_UIDS, 0, false);
}
@Override
protected synchronized void startScan() {
- Objects.requireNonNull(bridgeHandler).iterateApiDevices();
- }
-
- @Override
- public void setThingHandler(@Nullable ThingHandler handler) {
- if (handler instanceof JuiceNetBridgeHandler bridgeHandler) {
- bridgeHandler.setDiscoveryService(this);
- this.bridgeHandler = bridgeHandler;
- } else {
- this.bridgeHandler = null;
- }
- }
-
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return this.bridgeHandler;
+ thingHandler.iterateApiDevices();
}
public void notifyDiscoveryDevice(String id, String name) {
- JuiceNetBridgeHandler bridgeHandler = this.bridgeHandler;
- Objects.requireNonNull(bridgeHandler, "Discovery with null bridgehandler.");
- ThingUID bridgeUID = bridgeHandler.getThing().getUID();
+ ThingUID bridgeUID = thingHandler.getThing().getUID();
ThingUID uid = new ThingUID(DEVICE_THING_TYPE, bridgeUID, id);
import org.openhab.core.thing.binding.ThingActions;
import org.openhab.core.thing.binding.ThingActionsScope;
import org.openhab.core.thing.binding.ThingHandler;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Michael Lobstein - initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = KaleidescapeThingActions.class)
@ThingActionsScope(name = "kaleidescape")
@NonNullByDefault
public class KaleidescapeThingActions implements ThingActions {
import org.openhab.core.thing.binding.ThingActions;
import org.openhab.core.thing.binding.ThingActionsScope;
import org.openhab.core.thing.binding.ThingHandler;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Fabian Wolter - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = LcnModuleActions.class)
@ThingActionsScope(name = "lcn")
@NonNullByDefault
public class LcnModuleActions implements ThingActions {
import org.openhab.binding.lcn.internal.connection.Connection;
import org.openhab.binding.lcn.internal.subhandler.LcnModuleMetaAckSubHandler;
import org.openhab.binding.lcn.internal.subhandler.LcnModuleMetaFirmwareSubHandler;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
-import org.openhab.core.config.discovery.DiscoveryService;
import org.openhab.core.thing.Thing;
import org.openhab.core.thing.ThingTypeUID;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Fabian Wolter - Initial Contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = LcnModuleDiscoveryService.class)
@NonNullByDefault
-public class LcnModuleDiscoveryService extends AbstractDiscoveryService
- implements DiscoveryService, ThingHandlerService {
+public class LcnModuleDiscoveryService extends AbstractThingHandlerDiscoveryService<PckGatewayHandler> {
private final Logger logger = LoggerFactory.getLogger(LcnModuleDiscoveryService.class);
private static final Pattern NAME_PATTERN = Pattern
.compile("=M(?<segId>\\d{3})(?<modId>\\d{3}).N(?<part>[1-2]{1})(?<name>.*)");
private static final int DISCOVERY_TIMEOUT_SEC = 90;
private static final int ACK_TIMEOUT_MS = 1000;
private static final Set<ThingTypeUID> SUPPORTED_THING_TYPES_UIDS = Set.of(LcnBindingConstants.THING_TYPE_MODULE);
- private @Nullable PckGatewayHandler bridgeHandler;
private final Map<LcnAddrMod, @Nullable Map<Integer, String>> moduleNames = new HashMap<>();
private final Map<LcnAddrMod, DiscoveryResultBuilder> discoveryResultBuilders = new ConcurrentHashMap<>();
private final List<LcnAddrMod> successfullyDiscovered = new LinkedList<>();
private @Nullable ScheduledFuture<?> builderTask;
public LcnModuleDiscoveryService() {
- super(SUPPORTED_THING_TYPES_UIDS, DISCOVERY_TIMEOUT_SEC, false);
+ super(PckGatewayHandler.class, SUPPORTED_THING_TYPES_UIDS, DISCOVERY_TIMEOUT_SEC, false);
}
@Override
- public void setThingHandler(@Nullable ThingHandler handler) {
- if (handler instanceof PckGatewayHandler gatewayHandler) {
- this.bridgeHandler = gatewayHandler;
- }
- }
-
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return bridgeHandler;
- }
-
- @Override
- public void deactivate() {
+ public void dispose() {
+ super.dispose();
stopScan();
- super.deactivate();
}
@Override
@SuppressWarnings("PMD.CompareObjectsWithEquals")
protected void startScan() {
synchronized (this) {
- PckGatewayHandler localBridgeHandler = bridgeHandler;
- if (localBridgeHandler == null) {
- logger.warn("Bridge handler not set");
- return;
- }
-
ScheduledFuture<?> localBuilderTask = builderTask;
- if (localBridgeHandler.getConnection() == null && localBuilderTask != null) {
+ if (thingHandler.getConnection() == null && localBuilderTask != null) {
localBuilderTask.cancel(true);
}
- localBridgeHandler.registerPckListener(data -> {
+ thingHandler.registerPckListener(data -> {
Matcher matcher;
if ((matcher = LcnModuleMetaAckSubHandler.PATTERN_POS.matcher(data)).matches()
|| (matcher = LcnModuleMetaFirmwareSubHandler.PATTERN.matcher(data)).matches()
|| (matcher = NAME_PATTERN.matcher(data)).matches()) {
synchronized (LcnModuleDiscoveryService.this) {
- Connection connection = localBridgeHandler.getConnection();
+ Connection connection = thingHandler.getConnection();
if (connection == null) {
return;
}
LcnAddrMod addr = new LcnAddrMod(
- localBridgeHandler.toLogicalSegmentId(Integer.parseInt(matcher.group("segId"))),
+ thingHandler.toLogicalSegmentId(Integer.parseInt(matcher.group("segId"))),
Integer.parseInt(matcher.group("modId")));
if (matcher.pattern() == LcnModuleMetaAckSubHandler.PATTERN_POS) {
} else if (matcher.pattern() == LcnModuleMetaFirmwareSubHandler.PATTERN) {
// Received a firmware version info frame
- ThingUID bridgeUid = localBridgeHandler.getThing().getUID();
+ ThingUID bridgeUid = thingHandler.getThing().getUID();
String serialNumber = matcher.group("sn");
String thingID = String.format("S%03dM%03d", addr.getSegmentId(), addr.getModuleId());
}
}, 500, 500, TimeUnit.MILLISECONDS);
- localBridgeHandler.sendModuleDiscoveryCommand();
+ thingHandler.sendModuleDiscoveryCommand();
}
}
localQueueProcessor.cancel(true);
}
queueProcessor = scheduler.scheduleWithFixedDelay(() -> {
- PckGatewayHandler localBridgeHandler = bridgeHandler;
- if (localBridgeHandler != null) {
- LcnAddrMod serial = serialNumberRequestQueue.poll();
- if (serial != null) {
- localBridgeHandler.sendSerialNumberRequest(serial);
- }
+ LcnAddrMod serial = serialNumberRequestQueue.poll();
+ if (serial != null) {
+ thingHandler.sendSerialNumberRequest(serial);
+ }
- LcnAddrMod name = moduleNameRequestQueue.poll();
- if (name != null) {
- localBridgeHandler.sendModuleNameRequest(name);
- }
+ LcnAddrMod name = moduleNameRequestQueue.poll();
+ if (name != null) {
+ thingHandler.sendModuleNameRequest(name);
+ }
- // stop scan when all LCN modules have been requested
- if (serial == null && name == null) {
- scheduler.schedule(this::stopScan, ACK_TIMEOUT_MS, TimeUnit.MILLISECONDS);
- }
+ // stop scan when all LCN modules have been requested
+ if (serial == null && name == null) {
+ scheduler.schedule(this::stopScan, ACK_TIMEOUT_MS, TimeUnit.MILLISECONDS);
}
}, ACK_TIMEOUT_MS, ACK_TIMEOUT_MS, TimeUnit.MILLISECONDS);
}
if (localQueueProcessor != null) {
localQueueProcessor.cancel(true);
}
- PckGatewayHandler localBridgeHandler = bridgeHandler;
- if (localBridgeHandler != null) {
- localBridgeHandler.removeAllPckListeners();
- }
+ thingHandler.removeAllPckListeners();
successfullyDiscovered.clear();
moduleNames.clear();
import org.openhab.core.thing.binding.ThingActions;
import org.openhab.core.thing.binding.ThingActionsScope;
import org.openhab.core.thing.binding.ThingHandler;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
* @author Sebastian Prehn - Initial contribution
* @author Laurent Garnier - new method invokeMethodOf + interface ILGWebOSActions
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = LGWebOSActions.class)
@ThingActionsScope(name = "lgwebos")
@NonNullByDefault
public class LGWebOSActions implements ThingActions {
import java.util.Set;
import org.eclipse.jdt.annotation.NonNullByDefault;
-import org.eclipse.jdt.annotation.Nullable;
import org.openhab.binding.livisismarthome.internal.LivisiBindingConstants;
import org.openhab.binding.livisismarthome.internal.client.api.entity.device.DeviceDTO;
import org.openhab.binding.livisismarthome.internal.handler.LivisiBridgeHandler;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResult;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
-import org.openhab.core.config.discovery.DiscoveryService;
import org.openhab.core.thing.ThingTypeUID;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
* @author Oliver Kuhl - Initial contribution
* @author Sven Strohschein - Renamed from Innogy to Livisi
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = LivisiDeviceDiscoveryService.class)
@NonNullByDefault
-public class LivisiDeviceDiscoveryService extends AbstractDiscoveryService
- implements DiscoveryService, ThingHandlerService {
+public class LivisiDeviceDiscoveryService extends AbstractThingHandlerDiscoveryService<LivisiBridgeHandler> {
private static final int SEARCH_TIME_SECONDS = 60;
private final Logger logger = LoggerFactory.getLogger(LivisiDeviceDiscoveryService.class);
- private @Nullable LivisiBridgeHandler bridgeHandler;
-
/**
* Construct a {@link LivisiDeviceDiscoveryService}.
*/
public LivisiDeviceDiscoveryService() {
- super(SEARCH_TIME_SECONDS);
+ super(LivisiBridgeHandler.class, SEARCH_TIME_SECONDS);
}
/**
* @see org.openhab.core.config.discovery.AbstractDiscoveryService#deactivate()
*/
@Override
- public void deactivate() {
+ public void dispose() {
+ super.dispose();
removeOlderResults(new Date().getTime());
}
@Override
protected void startScan() {
logger.debug("SCAN for new LIVISI SmartHome devices started...");
- final LivisiBridgeHandler bridgeHandlerNonNullable = bridgeHandler;
- if (bridgeHandlerNonNullable != null) {
- for (final DeviceDTO d : bridgeHandlerNonNullable.loadDevices()) {
- onDeviceAdded(d);
- }
+ for (final DeviceDTO d : thingHandler.loadDevices()) {
+ onDeviceAdded(d);
}
}
}
public void onDeviceAdded(DeviceDTO device) {
- final LivisiBridgeHandler bridgeHandlerNonNullable = bridgeHandler;
- if (bridgeHandlerNonNullable != null) {
- final ThingUID bridgeUID = bridgeHandlerNonNullable.getThing().getUID();
- final Optional<ThingUID> thingUID = getThingUID(bridgeUID, device);
- final Optional<ThingTypeUID> thingTypeUID = getThingTypeUID(device);
-
- if (thingUID.isPresent() && thingTypeUID.isPresent()) {
- String name = device.getConfig().getName();
- if (name.isEmpty()) {
- name = device.getSerialNumber();
- }
-
- final Map<String, Object> properties = new HashMap<>();
- properties.put(PROPERTY_ID, device.getId());
-
- final String label;
- if (device.hasLocation()) {
- label = device.getType() + ": " + name + " (" + device.getLocation().getName() + ")";
- } else {
- label = device.getType() + ": " + name;
- }
-
- final DiscoveryResult discoveryResult = DiscoveryResultBuilder.create(thingUID.get())
- .withThingType(thingTypeUID.get()).withProperties(properties).withBridge(bridgeUID)
- .withRepresentationProperty(PROPERTY_ID).withLabel(label).build();
-
- thingDiscovered(discoveryResult);
+ final ThingUID bridgeUID = thingHandler.getThing().getUID();
+ final Optional<ThingUID> thingUID = getThingUID(bridgeUID, device);
+ final Optional<ThingTypeUID> thingTypeUID = getThingTypeUID(device);
+
+ if (thingUID.isPresent() && thingTypeUID.isPresent()) {
+ String name = device.getConfig().getName();
+ if (name.isEmpty()) {
+ name = device.getSerialNumber();
+ }
+
+ final Map<String, Object> properties = new HashMap<>();
+ properties.put(PROPERTY_ID, device.getId());
+
+ final String label;
+ if (device.hasLocation()) {
+ label = device.getType() + ": " + name + " (" + device.getLocation().getName() + ")";
} else {
- logger.debug("Discovered unsupported device of type '{}' and name '{}' with id {}", device.getType(),
- device.getConfig().getName(), device.getId());
+ label = device.getType() + ": " + name;
}
+
+ final DiscoveryResult discoveryResult = DiscoveryResultBuilder.create(thingUID.get())
+ .withThingType(thingTypeUID.get()).withProperties(properties).withBridge(bridgeUID)
+ .withRepresentationProperty(PROPERTY_ID).withLabel(label).build();
+
+ thingDiscovered(discoveryResult);
+ } else {
+ logger.debug("Discovered unsupported device of type '{}' and name '{}' with id {}", device.getType(),
+ device.getConfig().getName(), device.getId());
}
}
}
return Optional.empty();
}
-
- @Override
- public void setThingHandler(@Nullable ThingHandler handler) {
- if (handler instanceof LivisiBridgeHandler livisiBridgeHandler) {
- bridgeHandler = livisiBridgeHandler;
- }
- }
-
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return bridgeHandler;
- }
}
import org.openhab.core.thing.binding.ThingActions;
import org.openhab.core.thing.binding.ThingActionsScope;
import org.openhab.core.thing.binding.ThingHandler;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Bob Adair - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = DimmerActions.class)
@ThingActionsScope(name = "lutron")
@NonNullByDefault
public class DimmerActions implements ThingActions {
import org.openhab.binding.lutron.internal.protocol.leap.dto.Area;
import org.openhab.binding.lutron.internal.protocol.leap.dto.Device;
import org.openhab.binding.lutron.internal.protocol.leap.dto.OccupancyGroup;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResult;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
-import org.openhab.core.config.discovery.DiscoveryService;
import org.openhab.core.thing.ThingTypeUID;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Bob Adair - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = LeapDeviceDiscoveryService.class)
@NonNullByDefault
-public class LeapDeviceDiscoveryService extends AbstractDiscoveryService
- implements DiscoveryService, ThingHandlerService {
+public class LeapDeviceDiscoveryService extends AbstractThingHandlerDiscoveryService<LeapBridgeHandler> {
private static final int DISCOVERY_SERVICE_TIMEOUT = 0; // seconds
private @Nullable Map<Integer, String> areaMap;
private @Nullable List<OccupancyGroup> oGroupList;
- private @NonNullByDefault({}) LeapBridgeHandler bridgeHandler;
-
public LeapDeviceDiscoveryService() {
- super(LutronHandlerFactory.DISCOVERABLE_DEVICE_TYPES_UIDS, DISCOVERY_SERVICE_TIMEOUT);
- }
-
- @Override
- public void setThingHandler(ThingHandler handler) {
- if (handler instanceof LeapBridgeHandler leapBridgeHandler) {
- bridgeHandler = leapBridgeHandler;
- bridgeHandler.setDiscoveryService(this);
- }
+ super(LeapBridgeHandler.class, LutronHandlerFactory.DISCOVERABLE_DEVICE_TYPES_UIDS, DISCOVERY_SERVICE_TIMEOUT);
}
@Override
- public @Nullable ThingHandler getThingHandler() {
- return bridgeHandler;
+ public void initialize() {
+ thingHandler.setDiscoveryService(this);
+ super.initialize();
}
@Override
protected void startScan() {
logger.debug("Active discovery scan started");
- bridgeHandler.queryDiscoveryData();
+ thingHandler.queryDiscoveryData();
}
public void processDeviceDefinitions(List<Device> deviceList) {
private void notifyDiscovery(ThingTypeUID thingTypeUID, @Nullable Integer integrationId, String label,
@Nullable String propName, @Nullable Object propValue) {
if (integrationId == null) {
- logger.debug("Discovered {} with no integration ID", label);
+ logger.debug("Discovered {} with no integration ID or thinghandler", label);
return;
}
- ThingUID bridgeUID = this.bridgeHandler.getThing().getUID();
+ ThingUID bridgeUID = thingHandler.getThing().getUID();
ThingUID uid = new ThingUID(thingTypeUID, bridgeUID, integrationId.toString());
Map<String, Object> properties = new HashMap<>();
private void notifyDiscovery(ThingTypeUID thingTypeUID, Integer integrationId, String label) {
notifyDiscovery(thingTypeUID, integrationId, label, null, null);
}
-
- @Override
- public void deactivate() {
- super.deactivate();
- }
}
*/
@NonNullByDefault
public class LutronDeviceDiscoveryService extends AbstractDiscoveryService {
-
private static final int DECLARATION_MAX_LEN = 80;
private static final long HTTP_REQUEST_TIMEOUT = 60; // seconds
private static final int DISCOVERY_SERVICE_TIMEOUT = 90; // seconds
import java.util.Map;
import java.util.concurrent.atomic.AtomicBoolean;
-import org.eclipse.jdt.annotation.NonNullByDefault;
-import org.eclipse.jdt.annotation.Nullable;
+import org.eclipse.jdt.annotation.NonNull;
import org.openhab.binding.lutron.internal.LutronHandlerFactory;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResult;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
-import org.openhab.core.config.discovery.DiscoveryService;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Andrew Shilliday - Initial contribution
*/
-public class HwDiscoveryService extends AbstractDiscoveryService implements DiscoveryService, ThingHandlerService {
+public class HwDiscoveryService extends AbstractThingHandlerDiscoveryService<@NonNull HwSerialBridgeHandler> {
private Logger logger = LoggerFactory.getLogger(HwDiscoveryService.class);
private final AtomicBoolean isScanning = new AtomicBoolean(false);
- private @NonNullByDefault({}) HwSerialBridgeHandler handler;
-
public HwDiscoveryService() {
- super(LutronHandlerFactory.HW_DISCOVERABLE_DEVICE_TYPES_UIDS, 10);
- }
-
- @Override
- public void setThingHandler(@Nullable ThingHandler handler) {
- if (handler instanceof HwSerialBridgeHandler bridgeHandler) {
- this.handler = bridgeHandler;
- this.handler.setDiscoveryService(this);
- }
- }
-
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return handler;
- }
-
- @Override
- public void activate() {
- super.activate(null);
+ super(HwSerialBridgeHandler.class, LutronHandlerFactory.HW_DISCOVERABLE_DEVICE_TYPES_UIDS, 10);
}
@Override
- public void deactivate() {
- super.deactivate();
+ public void initialize() {
+ thingHandler.setDiscoveryService(this);
+ super.initialize();
}
@Override
for (int m = 1; m <= 8; m++) { // Modules
for (int o = 1; o <= 4; o++) { // Outputs
String address = String.format("[01:01:00:%02d:%02d]", m, o);
- handler.sendCommand("RDL, " + address);
+ thingHandler.sendCommand("RDL, " + address);
Thread.sleep(5);
}
}
*/
public void declareUnknownDimmer(String address) {
if (address == null) {
- logger.info("Discovered HomeWorks dimmer with no address");
+ logger.info("Discovered HomeWorks dimmer with no address or thing handler");
return;
}
String addressUid = address.replaceAll("[\\[\\]]", "").replace(":", "-");
- ThingUID bridgeUID = this.handler.getThing().getUID();
+ ThingUID bridgeUID = thingHandler.getThing().getUID();
ThingUID uid = new ThingUID(HwConstants.THING_TYPE_HWDIMMER, bridgeUID, addressUid);
Map<String, Object> props = new HashMap<>();
import org.openhab.core.thing.binding.ThingActions;
import org.openhab.core.thing.binding.ThingActionsScope;
import org.openhab.core.thing.binding.ThingHandler;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Jan N. Klug - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = SendMailActions.class)
@ThingActionsScope(name = "mail")
@NonNullByDefault
public class SendMailActions implements ThingActions {
import org.openhab.core.thing.binding.ThingActions;
import org.openhab.core.thing.binding.ThingActionsScope;
import org.openhab.core.thing.binding.ThingHandler;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Christoph Weitkamp - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = MaxCubeActions.class)
@ThingActionsScope(name = "max-cube")
@NonNullByDefault
public class MaxCubeActions implements ThingActions {
import org.openhab.core.thing.binding.ThingActions;
import org.openhab.core.thing.binding.ThingActionsScope;
import org.openhab.core.thing.binding.ThingHandler;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Christoph Weitkamp - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = MaxDevicesActions.class)
@ThingActionsScope(name = "max-devices")
@NonNullByDefault
public class MaxDevicesActions implements ThingActions {
import java.util.Set;
import org.eclipse.jdt.annotation.NonNullByDefault;
-import org.eclipse.jdt.annotation.Nullable;
import org.openhab.binding.max.internal.MaxBindingConstants;
import org.openhab.binding.max.internal.device.Device;
import org.openhab.binding.max.internal.handler.DeviceStatusListener;
import org.openhab.binding.max.internal.handler.MaxCubeBridgeHandler;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResult;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
-import org.openhab.core.config.discovery.DiscoveryService;
import org.openhab.core.thing.Bridge;
import org.openhab.core.thing.Thing;
import org.openhab.core.thing.ThingTypeUID;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Marcel Verpaalen - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = MaxDeviceDiscoveryService.class)
@NonNullByDefault
-public class MaxDeviceDiscoveryService extends AbstractDiscoveryService
- implements DeviceStatusListener, DiscoveryService, ThingHandlerService {
+public class MaxDeviceDiscoveryService extends AbstractThingHandlerDiscoveryService<MaxCubeBridgeHandler>
+ implements DeviceStatusListener {
private static final int SEARCH_TIME = 60;
private final Logger logger = LoggerFactory.getLogger(MaxDeviceDiscoveryService.class);
- private @Nullable MaxCubeBridgeHandler maxCubeBridgeHandler;
-
public MaxDeviceDiscoveryService() {
- super(MaxBindingConstants.SUPPORTED_DEVICE_THING_TYPES_UIDS, SEARCH_TIME, true);
- }
-
- @Override
- public void setThingHandler(@NonNullByDefault({}) ThingHandler handler) {
- if (handler instanceof MaxCubeBridgeHandler maxCubeBridgeHandler) {
- this.maxCubeBridgeHandler = maxCubeBridgeHandler;
- }
+ super(MaxCubeBridgeHandler.class, MaxBindingConstants.SUPPORTED_DEVICE_THING_TYPES_UIDS, SEARCH_TIME, true);
}
@Override
- public @Nullable ThingHandler getThingHandler() {
- return maxCubeBridgeHandler;
+ public void initialize() {
+ thingHandler.registerDeviceStatusListener(this);
+ super.initialize();
}
@Override
- public void activate() {
- MaxCubeBridgeHandler localMaxCubeBridgeHandler = maxCubeBridgeHandler;
- if (localMaxCubeBridgeHandler != null) {
- localMaxCubeBridgeHandler.registerDeviceStatusListener(this);
- }
- }
-
- @Override
- public void deactivate() {
- MaxCubeBridgeHandler localMaxCubeBridgeHandler = maxCubeBridgeHandler;
- if (localMaxCubeBridgeHandler != null) {
- localMaxCubeBridgeHandler.unregisterDeviceStatusListener(this);
- removeOlderResults(new Date().getTime(), localMaxCubeBridgeHandler.getThing().getUID());
- }
+ public void dispose() {
+ super.dispose();
+ thingHandler.unregisterDeviceStatusListener(this);
+ removeOlderResults(new Date().getTime(), thingHandler.getThing().getUID());
}
@Override
@Override
protected void startScan() {
- MaxCubeBridgeHandler localMaxCubeBridgeHandler = maxCubeBridgeHandler;
- if (localMaxCubeBridgeHandler != null) {
- localMaxCubeBridgeHandler.clearDeviceList();
- localMaxCubeBridgeHandler.deviceInclusion();
- }
+ thingHandler.clearDeviceList();
+ thingHandler.deviceInclusion();
}
@Override
import static org.openhab.binding.meater.internal.MeaterBindingConstants.*;
-import java.util.Map;
-
import org.eclipse.jdt.annotation.NonNullByDefault;
-import org.eclipse.jdt.annotation.Nullable;
import org.openhab.binding.meater.internal.MeaterConfiguration;
import org.openhab.binding.meater.internal.handler.MeaterBridgeHandler;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
+import org.openhab.core.i18n.LocaleProvider;
+import org.openhab.core.i18n.TranslationProvider;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.Reference;
+import org.osgi.service.component.annotations.ServiceScope;
/**
* The {@link MeaterDiscoveryService} searches for available
*
* @author Jan Gustafsson - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = MeaterDiscoveryService.class)
@NonNullByDefault
-public class MeaterDiscoveryService extends AbstractDiscoveryService implements ThingHandlerService {
+public class MeaterDiscoveryService extends AbstractThingHandlerDiscoveryService<MeaterBridgeHandler> {
private static final int SEARCH_TIME = 2;
- private @Nullable MeaterBridgeHandler handler;
public MeaterDiscoveryService() {
- super(SUPPORTED_THING_TYPES_UIDS, SEARCH_TIME);
+ super(MeaterBridgeHandler.class, SUPPORTED_THING_TYPES_UIDS, SEARCH_TIME);
}
- @Override
- public void setThingHandler(@Nullable ThingHandler handler) {
- if (handler instanceof MeaterBridgeHandler bridgeHandler) {
- this.handler = bridgeHandler;
- i18nProvider = bridgeHandler.getI18nProvider();
- localeProvider = bridgeHandler.getLocaleProvider();
- }
- }
-
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return handler;
+ @Reference(unbind = "-")
+ public void bindTranslationProvider(TranslationProvider translationProvider) {
+ this.i18nProvider = translationProvider;
}
- @Override
- public void activate(@Nullable Map<String, Object> configProperties) {
- super.activate(configProperties);
- }
-
- @Override
- public void deactivate() {
- super.deactivate();
+ @Reference(unbind = "-")
+ public void bindLocaleProvider(LocaleProvider localeProvider) {
+ this.localeProvider = localeProvider;
}
@Override
protected void startScan() {
- MeaterBridgeHandler bridgeHandler = this.handler;
- if (bridgeHandler != null) {
- ThingUID bridgeUID = bridgeHandler.getThing().getUID();
- bridgeHandler.getMeaterThings().entrySet().stream().forEach(thing -> {
- thingDiscovered(
- DiscoveryResultBuilder.create(new ThingUID(THING_TYPE_MEATER_PROBE, bridgeUID, thing.getKey()))
- .withLabel("@text/discovery.probe.label").withBridge(bridgeUID)
- .withProperty(MeaterConfiguration.DEVICE_ID_LABEL, thing.getKey())
- .withRepresentationProperty(MeaterConfiguration.DEVICE_ID_LABEL).build());
- });
- }
+ ThingUID bridgeUID = thingHandler.getThing().getUID();
+ thingHandler.getMeaterThings().entrySet().stream().forEach(thing -> {
+ thingDiscovered(
+ DiscoveryResultBuilder.create(new ThingUID(THING_TYPE_MEATER_PROBE, bridgeUID, thing.getKey()))
+ .withLabel("@text/discovery.probe.label").withBridge(bridgeUID)
+ .withProperty(MeaterConfiguration.DEVICE_ID_LABEL, thing.getKey())
+ .withRepresentationProperty(MeaterConfiguration.DEVICE_ID_LABEL).build());
+ });
}
}
import org.openhab.binding.meater.internal.discovery.MeaterDiscoveryService;
import org.openhab.binding.meater.internal.dto.MeaterProbeDTO;
import org.openhab.core.i18n.LocaleProvider;
-import org.openhab.core.i18n.TranslationProvider;
import org.openhab.core.thing.Bridge;
import org.openhab.core.thing.ChannelUID;
import org.openhab.core.thing.ThingStatus;
private final Gson gson;
private final HttpClient httpClient;
- private final TranslationProvider i18nProvider;
private final LocaleProvider localeProvider;
private final Map<String, MeaterProbeDTO.Device> meaterProbeThings = new ConcurrentHashMap<>();
private @Nullable MeaterRestAPI api;
private @Nullable ScheduledFuture<?> refreshJob;
- public MeaterBridgeHandler(Bridge bridge, HttpClient httpClient, Gson gson, TranslationProvider i18nProvider,
- LocaleProvider localeProvider) {
+ public MeaterBridgeHandler(Bridge bridge, HttpClient httpClient, Gson gson, LocaleProvider localeProvider) {
super(bridge);
this.httpClient = httpClient;
this.gson = gson;
- this.i18nProvider = i18nProvider;
this.localeProvider = localeProvider;
}
}
}
}
-
- public TranslationProvider getI18nProvider() {
- return i18nProvider;
- }
-
- public LocaleProvider getLocaleProvider() {
- return localeProvider;
- }
}
import org.eclipse.jetty.client.HttpClient;
import org.openhab.core.i18n.LocaleProvider;
import org.openhab.core.i18n.TimeZoneProvider;
-import org.openhab.core.i18n.TranslationProvider;
import org.openhab.core.io.net.http.HttpClientFactory;
import org.openhab.core.thing.Bridge;
import org.openhab.core.thing.Thing;
private final Gson gson;
private final HttpClient httpClient;
private final TimeZoneProvider timeZoneProvider;
- private final TranslationProvider i18nProvider;
private final LocaleProvider localeProvider;
@Activate
- public MeaterHandlerFactory(@Reference TimeZoneProvider timeZoneProvider,
- final @Reference TranslationProvider i18nProvider, @Reference LocaleProvider localeProvider,
+ public MeaterHandlerFactory(@Reference TimeZoneProvider timeZoneProvider, @Reference LocaleProvider localeProvider,
@Reference HttpClientFactory httpClientFactory) {
this.timeZoneProvider = timeZoneProvider;
- this.i18nProvider = i18nProvider;
this.localeProvider = localeProvider;
this.httpClient = httpClientFactory.getCommonHttpClient();
this.gson = new Gson();
if (THING_TYPE_MEATER_PROBE.equals(thingTypeUID)) {
return new MeaterHandler(thing, timeZoneProvider);
} else if (THING_TYPE_BRIDGE.equals(thingTypeUID)) {
- return new MeaterBridgeHandler((Bridge) thing, httpClient, gson, i18nProvider, localeProvider);
+ return new MeaterBridgeHandler((Bridge) thing, httpClient, gson, localeProvider);
}
return null;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;
-import org.eclipse.jdt.annotation.Nullable;
+import org.eclipse.jdt.annotation.NonNull;
import org.openhab.binding.melcloud.internal.MelCloudBindingConstants;
import org.openhab.binding.melcloud.internal.api.json.Device;
import org.openhab.binding.melcloud.internal.exceptions.MelCloudCommException;
import org.openhab.binding.melcloud.internal.exceptions.MelCloudLoginException;
import org.openhab.binding.melcloud.internal.handler.MelCloudAccountHandler;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
-import org.openhab.core.config.discovery.DiscoveryService;
import org.openhab.core.thing.Thing;
import org.openhab.core.thing.ThingTypeUID;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
-import org.osgi.service.component.annotations.Modified;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
* @author Pauli Anttila - Refactoring
* @author Wietse van Buitenen - Check device type, added heatpump device
*/
-public class MelCloudDiscoveryService extends AbstractDiscoveryService
- implements DiscoveryService, ThingHandlerService {
-
+@Component(scope = ServiceScope.PROTOTYPE, service = MelCloudDiscoveryService.class)
+public class MelCloudDiscoveryService extends AbstractThingHandlerDiscoveryService<@NonNull MelCloudAccountHandler> {
private final Logger logger = LoggerFactory.getLogger(MelCloudDiscoveryService.class);
private static final String PROPERTY_DEVICE_ID = "deviceID";
private static final int DISCOVER_TIMEOUT_SECONDS = 10;
- private MelCloudAccountHandler melCloudHandler;
private ScheduledFuture<?> scanTask;
/**
* Creates a MelCloudDiscoveryService with enabled autostart.
*/
public MelCloudDiscoveryService() {
- super(MelCloudBindingConstants.DISCOVERABLE_THING_TYPE_UIDS, DISCOVER_TIMEOUT_SECONDS, true);
- }
-
- @Override
- protected void activate(Map<String, Object> configProperties) {
- super.activate(configProperties);
- }
-
- @Override
- public void deactivate() {
- super.deactivate();
- }
-
- @Override
- @Modified
- protected void modified(Map<String, Object> configProperties) {
- super.modified(configProperties);
+ super(MelCloudAccountHandler.class, MelCloudBindingConstants.DISCOVERABLE_THING_TYPE_UIDS,
+ DISCOVER_TIMEOUT_SECONDS, true);
}
@Override
private void discoverDevices() {
logger.debug("Discover devices");
-
- if (melCloudHandler != null) {
- try {
- List<Device> deviceList = melCloudHandler.getDeviceList();
-
- if (deviceList == null) {
- logger.debug("No devices found");
- } else {
- ThingUID bridgeUID = melCloudHandler.getThing().getUID();
-
- deviceList.forEach(device -> {
- ThingTypeUID thingTypeUid = null;
- if (device.getType() == 0) {
- thingTypeUid = THING_TYPE_ACDEVICE;
- } else if (device.getType() == 1) {
- thingTypeUid = THING_TYPE_HEATPUMPDEVICE;
- } else {
- logger.debug("Unsupported device found: name {} : type: {}", device.getDeviceName(),
- device.getType());
- return;
- }
- ThingUID deviceThing = new ThingUID(thingTypeUid, melCloudHandler.getThing().getUID(),
- device.getDeviceID().toString());
-
- Map<String, Object> deviceProperties = new HashMap<>();
- deviceProperties.put(PROPERTY_DEVICE_ID, device.getDeviceID().toString());
- deviceProperties.put(Thing.PROPERTY_SERIAL_NUMBER, device.getSerialNumber());
- deviceProperties.put(Thing.PROPERTY_MAC_ADDRESS, device.getMacAddress());
- deviceProperties.put("deviceName", device.getDeviceName());
- deviceProperties.put("buildingID", device.getBuildingID().toString());
-
- String label = createLabel(device);
- logger.debug("Found device: {} : {}", label, deviceProperties);
-
- thingDiscovered(DiscoveryResultBuilder.create(deviceThing).withLabel(label)
- .withProperties(deviceProperties).withRepresentationProperty(PROPERTY_DEVICE_ID)
- .withBridge(bridgeUID).build());
- });
- }
- } catch (MelCloudLoginException e) {
- logger.debug("Login error occurred during device list fetch, reason {}. ", e.getMessage(), e);
- } catch (MelCloudCommException e) {
- logger.debug("Error occurred during device list fetch, reason {}. ", e.getMessage(), e);
+ try {
+ List<Device> deviceList = thingHandler.getDeviceList();
+
+ if (deviceList == null) {
+ logger.debug("No devices found");
+ } else {
+ ThingUID bridgeUID = thingHandler.getThing().getUID();
+
+ deviceList.forEach(device -> {
+ ThingTypeUID thingTypeUid = null;
+ if (device.getType() == 0) {
+ thingTypeUid = THING_TYPE_ACDEVICE;
+ } else if (device.getType() == 1) {
+ thingTypeUid = THING_TYPE_HEATPUMPDEVICE;
+ } else {
+ logger.debug("Unsupported device found: name {} : type: {}", device.getDeviceName(),
+ device.getType());
+ return;
+ }
+ ThingUID deviceThing = new ThingUID(thingTypeUid, thingHandler.getThing().getUID(),
+ device.getDeviceID().toString());
+
+ Map<String, Object> deviceProperties = new HashMap<>();
+ deviceProperties.put(PROPERTY_DEVICE_ID, device.getDeviceID().toString());
+ deviceProperties.put(Thing.PROPERTY_SERIAL_NUMBER, device.getSerialNumber());
+ deviceProperties.put(Thing.PROPERTY_MAC_ADDRESS, device.getMacAddress());
+ deviceProperties.put("deviceName", device.getDeviceName());
+ deviceProperties.put("buildingID", device.getBuildingID().toString());
+
+ String label = createLabel(device);
+ logger.debug("Found device: {} : {}", label, deviceProperties);
+
+ thingDiscovered(
+ DiscoveryResultBuilder.create(deviceThing).withLabel(label).withProperties(deviceProperties)
+ .withRepresentationProperty(PROPERTY_DEVICE_ID).withBridge(bridgeUID).build());
+ });
}
+ } catch (MelCloudLoginException e) {
+ logger.debug("Login error occurred during device list fetch, reason {}. ", e.getMessage(), e);
+ } catch (MelCloudCommException e) {
+ logger.debug("Error occurred during device list fetch, reason {}. ", e.getMessage(), e);
}
}
sb.append(device.getDeviceName());
return sb.toString();
}
-
- @Override
- public void setThingHandler(@Nullable ThingHandler handler) {
- if (handler instanceof MelCloudAccountHandler accountHandler) {
- melCloudHandler = accountHandler;
- }
- }
-
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return melCloudHandler;
- }
}
import static org.openhab.binding.mielecloud.internal.MieleCloudBindingConstants.*;
import static org.openhab.binding.mielecloud.internal.handler.MieleHandlerFactory.SUPPORTED_THING_TYPES;
+import java.util.Map;
import java.util.Optional;
import org.eclipse.jdt.annotation.NonNullByDefault;
import org.openhab.binding.mielecloud.internal.handler.MieleBridgeHandler;
import org.openhab.binding.mielecloud.internal.webservice.api.DeviceState;
import org.openhab.binding.mielecloud.internal.webservice.api.json.DeviceType;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResult;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
import org.openhab.core.config.discovery.DiscoveryService;
import org.openhab.core.thing.Thing;
import org.openhab.core.thing.ThingTypeUID;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
* @author Roland Edelhoff - Initial contribution
* @author Björn Lange - Do not directly listen to webservice events
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = ThingDiscoveryService.class)
@NonNullByDefault
-public class ThingDiscoveryService extends AbstractDiscoveryService implements DiscoveryService, ThingHandlerService {
+public class ThingDiscoveryService extends AbstractThingHandlerDiscoveryService<MieleBridgeHandler> {
private static final int BACKGROUND_DISCOVERY_TIMEOUT_IN_SECONDS = 5;
- @Nullable
- private MieleBridgeHandler bridgeHandler;
-
private final Logger logger = LoggerFactory.getLogger(this.getClass());
private boolean discoveringDevices = false;
* Creates a new {@link ThingDiscoveryService}.
*/
public ThingDiscoveryService() {
- super(SUPPORTED_THING_TYPES, BACKGROUND_DISCOVERY_TIMEOUT_IN_SECONDS);
+ super(MieleBridgeHandler.class, SUPPORTED_THING_TYPES, BACKGROUND_DISCOVERY_TIMEOUT_IN_SECONDS);
}
@Nullable
private ThingUID getBridgeUid() {
- var bridgeHandler = this.bridgeHandler;
+ var bridgeHandler = this.thingHandler;
if (bridgeHandler == null) {
return null;
} else {
@Override
public void activate() {
- startBackgroundDiscovery();
+ super.activate(Map.of(DiscoveryService.CONFIG_PROPERTY_BACKGROUND_DISCOVERY, true));
}
@Override
- public void deactivate() {
- stopBackgroundDiscovery();
+ public void dispose() {
+ super.dispose();
removeOlderResults(System.currentTimeMillis(), getBridgeUid());
}
}
private void createDiscoveryResult(DeviceState deviceState, ThingTypeUID thingTypeUid) {
- MieleBridgeHandler bridgeHandler = this.bridgeHandler;
- if (bridgeHandler == null) {
- return;
- }
-
- ThingUID thingUid = new ThingUID(thingTypeUid, bridgeHandler.getThing().getUID(),
+ ThingUID thingUid = new ThingUID(thingTypeUid, thingHandler.getThing().getUID(),
deviceState.getDeviceIdentifier());
DiscoveryResultBuilder discoveryResultBuilder = DiscoveryResultBuilder.create(thingUid)
- .withBridge(bridgeHandler.getThing().getUID()).withRepresentationProperty(Thing.PROPERTY_SERIAL_NUMBER)
+ .withBridge(thingHandler.getThing().getUID()).withRepresentationProperty(Thing.PROPERTY_SERIAL_NUMBER)
.withLabel(getLabel(deviceState));
ThingInformationExtractor.extractProperties(thingTypeUid, deviceState).entrySet()
}
@Override
- public void setThingHandler(ThingHandler handler) {
- if (handler instanceof MieleBridgeHandler bridgeHandler) {
- bridgeHandler.setDiscoveryService(this);
- this.bridgeHandler = bridgeHandler;
- }
- }
-
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return bridgeHandler;
+ public void initialize() {
+ thingHandler.setDiscoveryService(this);
+ super.initialize();
}
}
import org.openhab.core.thing.binding.ThingActions;
import org.openhab.core.thing.binding.ThingActionsScope;
import org.openhab.core.thing.binding.ThingHandler;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Bernhard Bauer - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = HeliosEasyControlsActions.class)
@ThingActionsScope(name = "modbus.helioseasycontrols")
@NonNullByDefault
public class HeliosEasyControlsActions implements ThingActions {
import org.openhab.binding.modbus.handler.ModbusEndpointThingHandler;
import org.openhab.core.config.discovery.DiscoveryResult;
import org.openhab.core.thing.binding.ThingHandler;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
* @author Nagy Attila Gabor - initial contribution
*
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = ModbusEndpointDiscoveryService.class)
@NonNullByDefault
public class ModbusEndpointDiscoveryService implements ModbusThingHandlerDiscoveryService {
import org.openhab.core.thing.binding.ThingActions;
import org.openhab.core.thing.binding.ThingActionsScope;
import org.openhab.core.thing.binding.ThingHandler;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Stefan Röllin - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = MPDActions.class)
@ThingActionsScope(name = "mpd")
@NonNullByDefault
public class MPDActions implements ThingActions {
import org.openhab.core.thing.binding.ThingActions;
import org.openhab.core.thing.binding.ThingActionsScope;
import org.openhab.core.thing.binding.ThingHandler;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author David Graeff - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = MQTTActions.class)
@ThingActionsScope(name = "mqtt")
@NonNullByDefault
public class MQTTActions implements ThingActions {
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.NonNullByDefault;
-import org.eclipse.jdt.annotation.Nullable;
import org.openhab.binding.mybmw.internal.MyBMWConstants;
import org.openhab.binding.mybmw.internal.dto.vehicle.Vehicle;
import org.openhab.binding.mybmw.internal.dto.vehicle.VehicleAttributes;
import org.openhab.binding.mybmw.internal.utils.Constants;
import org.openhab.binding.mybmw.internal.utils.VehicleStatusUtils;
import org.openhab.core.config.core.Configuration;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
import org.openhab.core.thing.Thing;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
* @author Bernd Weymann - Initial contribution
* @author Martin Grassl - refactoring
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = VehicleDiscovery.class)
@NonNullByDefault
-public class VehicleDiscovery extends AbstractDiscoveryService implements ThingHandlerService {
+public class VehicleDiscovery extends AbstractThingHandlerDiscoveryService<MyBMWBridgeHandler> {
private final Logger logger = LoggerFactory.getLogger(VehicleDiscovery.class);
private static final int DISCOVERY_TIMEOUT = 10;
- private Optional<MyBMWBridgeHandler> bridgeHandler = Optional.empty();
private Optional<MyBMWProxy> myBMWProxy = Optional.empty();
- private Optional<ThingUID> bridgeUid = Optional.empty();
+ private @NonNullByDefault({}) ThingUID bridgeUid;
public VehicleDiscovery() {
- super(MyBMWConstants.SUPPORTED_THING_SET, DISCOVERY_TIMEOUT, false);
+ super(MyBMWBridgeHandler.class, MyBMWConstants.SUPPORTED_THING_SET, DISCOVERY_TIMEOUT, false);
}
@Override
- public void setThingHandler(ThingHandler handler) {
- if (handler instanceof MyBMWBridgeHandler bmwBridgeHandler) {
- logger.trace("VehicleDiscovery.setThingHandler for MybmwBridge");
- bridgeHandler = Optional.of(bmwBridgeHandler);
- bridgeHandler.get().setVehicleDiscovery(this);
- bridgeUid = Optional.of(bridgeHandler.get().getThing().getUID());
- }
- }
-
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return bridgeHandler.orElse(null);
+ public void initialize() {
+ thingHandler.setVehicleDiscovery(this);
+ bridgeUid = thingHandler.getThing().getUID();
+ super.initialize();
}
@Override
discoverVehicles();
}
- @Override
- public void deactivate() {
- logger.trace("VehicleDiscovery.deactivate");
-
- super.deactivate();
- }
-
public void discoverVehicles() {
logger.trace("VehicleDiscovery.discoverVehicles");
- myBMWProxy = bridgeHandler.get().getMyBmwProxy();
+ myBMWProxy = thingHandler.getMyBmwProxy();
try {
Optional<List<@NonNull Vehicle>> vehicleList = myBMWProxy.map(prox -> {
}
});
vehicleList.ifPresentOrElse(vehicles -> {
- bridgeHandler.ifPresent(bridge -> bridge.vehicleDiscoverySuccess());
+ thingHandler.vehicleDiscoverySuccess();
processVehicles(vehicles);
- }, () -> bridgeHandler.ifPresent(bridge -> bridge.vehicleDiscoveryError()));
+ }, () -> thingHandler.vehicleDiscoveryError());
} catch (IllegalStateException ex) {
- bridgeHandler.ifPresent(bridge -> bridge.vehicleDiscoveryError());
+ thingHandler.vehicleDiscoveryError();
}
}
.toString();
MyBMWConstants.SUPPORTED_THING_SET.forEach(entry -> {
if (entry.getId().equals(vehicleType)) {
- ThingUID uid = new ThingUID(entry, vehicle.getVehicleBase().getVin(), bridgeUid.get().getId());
+ ThingUID uid = new ThingUID(entry, vehicle.getVehicleBase().getVin(), bridgeUid.getId());
Map<String, String> properties = generateProperties(vehicle);
boolean thingFound = false;
// Update Properties for already created Things
- List<Thing> vehicleThings = bridgeHandler.get().getThing().getThings();
+ List<Thing> vehicleThings = thingHandler.getThing().getThings();
for (Thing vehicleThing : vehicleThings) {
Configuration configuration = vehicleThing.getConfiguration();
Integer.toString(MyBMWConstants.DEFAULT_REFRESH_INTERVAL_MINUTES));
String vehicleLabel = vehicleAttributes.getBrand() + " " + vehicleAttributes.getModel();
- thingDiscovered(DiscoveryResultBuilder.create(uid).withBridge(bridgeUid.get())
+ thingDiscovered(DiscoveryResultBuilder.create(uid).withBridge(bridgeUid)
.withRepresentationProperty(MyBMWConstants.VIN).withLabel(vehicleLabel)
.withProperties(convertedProperties).build());
}
when(bridgeHandler.getMyBmwProxy()).thenReturn(Optional.of(myBMWProxy));
vehicleDiscovery.setThingHandler(bridgeHandler);
+ vehicleDiscovery.initialize();
assertNotNull(vehicleDiscovery.getThingHandler());
DiscoveryListener listener = mock(DiscoveryListener.class);
import static org.openhab.binding.mynice.internal.MyNiceBindingConstants.*;
import java.util.List;
-import java.util.Optional;
import java.util.Set;
import org.eclipse.jdt.annotation.NonNullByDefault;
-import org.eclipse.jdt.annotation.Nullable;
import org.openhab.binding.mynice.internal.handler.It4WifiHandler;
import org.openhab.binding.mynice.internal.handler.MyNiceDataListener;
import org.openhab.binding.mynice.internal.xml.dto.CommandType;
import org.openhab.binding.mynice.internal.xml.dto.Device;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResult;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Gaël L'hopital - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = MyNiceDiscoveryService.class)
@NonNullByDefault
-public class MyNiceDiscoveryService extends AbstractDiscoveryService
- implements MyNiceDataListener, ThingHandlerService {
+public class MyNiceDiscoveryService extends AbstractThingHandlerDiscoveryService<It4WifiHandler>
+ implements MyNiceDataListener {
private static final int SEARCH_TIME = 5;
private final Logger logger = LoggerFactory.getLogger(MyNiceDiscoveryService.class);
- private Optional<It4WifiHandler> bridgeHandler = Optional.empty();
-
/**
* Creates a MyNiceDiscoveryService with background discovery disabled.
*/
public MyNiceDiscoveryService() {
- super(Set.of(THING_TYPE_SWING, THING_TYPE_SLIDING), SEARCH_TIME, false);
- }
-
- @Override
- public void setThingHandler(ThingHandler handler) {
- if (handler instanceof It4WifiHandler it4Handler) {
- bridgeHandler = Optional.of(it4Handler);
- }
- }
-
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return bridgeHandler.orElse(null);
+ super(It4WifiHandler.class, Set.of(THING_TYPE_SWING, THING_TYPE_SLIDING), SEARCH_TIME, false);
}
@Override
- public void activate() {
- super.activate(null);
- bridgeHandler.ifPresent(h -> h.registerDataListener(this));
+ public void initialize() {
+ thingHandler.registerDataListener(this);
+ super.initialize();
}
@Override
- public void deactivate() {
- bridgeHandler.ifPresent(h -> h.unregisterDataListener(this));
- bridgeHandler = Optional.empty();
- super.deactivate();
+ public void dispose() {
+ super.dispose();
+ thingHandler.unregisterDataListener(this);
}
@Override
public void onDataFetched(List<Device> devices) {
- bridgeHandler.ifPresent(handler -> {
- ThingUID bridgeUID = handler.getThing().getUID();
- devices.stream().filter(device -> device.type != null).forEach(device -> {
- ThingUID thingUID = switch (device.type) {
- case SWING -> new ThingUID(THING_TYPE_SWING, bridgeUID, device.id);
- case SLIDING -> new ThingUID(THING_TYPE_SLIDING, bridgeUID, device.id);
- default -> null;
- };
+ ThingUID bridgeUID = thingHandler.getThing().getUID();
+ devices.stream().filter(device -> device.type != null).forEach(device -> {
+ ThingUID thingUID = switch (device.type) {
+ case SWING -> new ThingUID(THING_TYPE_SWING, bridgeUID, device.id);
+ case SLIDING -> new ThingUID(THING_TYPE_SLIDING, bridgeUID, device.id);
+ default -> null;
+ };
- if (thingUID != null) {
- DiscoveryResult discoveryResult = DiscoveryResultBuilder.create(thingUID).withBridge(bridgeUID)
- .withLabel(String.format("%s %s", device.manuf, device.prod))
- .withRepresentationProperty(DEVICE_ID).withProperty(DEVICE_ID, device.id).build();
- thingDiscovered(discoveryResult);
- } else {
- logger.info("`{}` type of device is not yet supported", device.type);
- }
- });
+ if (thingUID != null) {
+ DiscoveryResult discoveryResult = DiscoveryResultBuilder.create(thingUID).withBridge(bridgeUID)
+ .withLabel(String.format("%s %s", device.manuf, device.prod))
+ .withRepresentationProperty(DEVICE_ID).withProperty(DEVICE_ID, device.id).build();
+ thingDiscovered(discoveryResult);
+ } else {
+ logger.info("`{}` type of device is not yet supported", device.type);
+ }
});
}
@Override
protected void startScan() {
- bridgeHandler.ifPresent(h -> h.sendCommand(CommandType.INFO));
+ thingHandler.sendCommand(CommandType.INFO);
}
}
import org.openhab.core.thing.type.DynamicCommandDescriptionProvider;
import org.openhab.core.types.CommandOption;
import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
/**
* This class provides the available effects as dynamic options as they are read from the Nanoleaf controller.
*
*/
@NonNullByDefault
-@Component(service = { DynamicCommandDescriptionProvider.class })
+@Component(scope = ServiceScope.PROTOTYPE, service = { NanoleafCommandDescriptionProvider.class,
+ DynamicCommandDescriptionProvider.class })
public class NanoleafCommandDescriptionProvider extends BaseDynamicCommandDescriptionProvider
implements NanoleafControllerListener, ThingHandlerService {
}
@Override
- public void deactivate() {
+ public void dispose() {
NanoleafControllerHandler localHandler = this.bridgeHandler;
if (localHandler != null) {
localHandler.unregisterControllerListener(this);
}
- super.deactivate();
}
@Override
import org.openhab.binding.nanoleaf.internal.model.Layout;
import org.openhab.binding.nanoleaf.internal.model.PanelLayout;
import org.openhab.binding.nanoleaf.internal.model.PositionDatum;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResult;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
import org.openhab.core.thing.ThingUID;
import org.openhab.core.thing.binding.BridgeHandler;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
* @author Martin Raepple - Initial contribution
* @author Kai Kreuzer - Made it a ThingHandlerService
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = NanoleafPanelsDiscoveryService.class)
@NonNullByDefault
-public class NanoleafPanelsDiscoveryService extends AbstractDiscoveryService
- implements NanoleafControllerListener, ThingHandlerService {
+public class NanoleafPanelsDiscoveryService extends AbstractThingHandlerDiscoveryService<NanoleafControllerHandler>
+ implements NanoleafControllerListener {
private static final int SEARCH_TIMEOUT_SECONDS = 60;
private final Logger logger = LoggerFactory.getLogger(NanoleafPanelsDiscoveryService.class);
- private @Nullable NanoleafControllerHandler bridgeHandler;
private @Nullable ControllerInfo controllerInfo;
/**
* Constructs a new {@link NanoleafPanelsDiscoveryService}.
*/
public NanoleafPanelsDiscoveryService() {
- super(NanoleafHandlerFactory.SUPPORTED_THING_TYPES_UIDS, SEARCH_TIMEOUT_SECONDS, false);
+ super(NanoleafControllerHandler.class, NanoleafHandlerFactory.SUPPORTED_THING_TYPES_UIDS,
+ SEARCH_TIMEOUT_SECONDS, false);
}
@Override
- public void deactivate() {
- NanoleafControllerHandler localBridgeHandler = bridgeHandler;
- if (localBridgeHandler != null) {
- Boolean result = localBridgeHandler.unregisterControllerListener(this);
- logger.debug("unregistration of controller was {}", result ? "successful" : "unsuccessful");
- }
- super.deactivate();
+ public void dispose() {
+ super.dispose();
+ boolean result = thingHandler.unregisterControllerListener(this);
+ logger.debug("unregistration of controller was {}", result ? "successful" : "unsuccessful");
}
@Override
private void createResultsFromControllerInfo() {
ThingUID bridgeUID;
- BridgeHandler localBridgeHandler = bridgeHandler;
+ BridgeHandler localBridgeHandler = thingHandler;
if (localBridgeHandler != null) {
bridgeUID = localBridgeHandler.getThing().getUID();
} else {
}
@Override
- public void setThingHandler(ThingHandler handler) {
- this.bridgeHandler = (NanoleafControllerHandler) handler;
- NanoleafControllerHandler localBridgeHandler = (NanoleafControllerHandler) handler;
-
- localBridgeHandler.registerControllerListener(this);
- }
-
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return bridgeHandler;
+ public void initialize() {
+ thingHandler.registerControllerListener(this);
+ super.initialize();
}
}
import org.openhab.binding.nest.internal.sdm.exception.InvalidSDMAccessTokenException;
import org.openhab.binding.nest.internal.sdm.handler.SDMAccountHandler;
import org.openhab.binding.nest.internal.sdm.handler.SDMBaseHandler;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
import org.openhab.core.thing.ThingTypeUID;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
-import org.osgi.service.component.ComponentContext;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
* @see <a href="https://developers.google.com/nest/device-access/reference/rest/v1/enterprises.devices/list">
* https://developers.google.com/nest/device-access/reference/rest/v1/enterprises.devices/list</a>
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = SDMDiscoveryService.class)
@NonNullByDefault
-public class SDMDiscoveryService extends AbstractDiscoveryService implements ThingHandlerService {
-
+public class SDMDiscoveryService extends AbstractThingHandlerDiscoveryService<SDMAccountHandler> {
private final Logger logger = LoggerFactory.getLogger(SDMDiscoveryService.class);
- private @NonNullByDefault({}) SDMAccountHandler accountHandler;
private @Nullable Future<?> discoveryJob;
public SDMDiscoveryService() {
- super(SUPPORTED_THING_TYPES_UIDS, 30, false);
- }
-
- protected void activate(ComponentContext context) {
+ super(SDMAccountHandler.class, SUPPORTED_THING_TYPES_UIDS, 30, false);
}
@Override
- public void deactivate() {
+ public void dispose() {
+ super.dispose();
cancelDiscoveryJob();
- super.deactivate();
- }
-
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return accountHandler;
- }
-
- @Override
- public void setThingHandler(ThingHandler handler) {
- if (handler instanceof SDMAccountHandler sdmAccountHandler) {
- accountHandler = sdmAccountHandler;
- }
}
@Override
}
private void discoverDevices() {
- ThingUID bridgeUID = accountHandler.getThing().getUID();
+ ThingUID bridgeUID = thingHandler.getThing().getUID();
logger.debug("Starting discovery scan for {}", bridgeUID);
try {
- accountHandler.getAPI().listDevices().forEach(device -> addDeviceDiscoveryResult(bridgeUID, device));
+ thingHandler.getAPI().listDevices().forEach(device -> addDeviceDiscoveryResult(bridgeUID, device));
} catch (FailedSendingSDMDataException | InvalidSDMAccessTokenException e) {
logger.debug("Exception during discovery scan for {}", bridgeUID, e);
}
import org.openhab.core.thing.binding.ThingActions;
import org.openhab.core.thing.binding.ThingActionsScope;
import org.openhab.core.thing.binding.ThingHandler;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Markus Dillmann - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = RoomActions.class)
@ThingActionsScope(name = "netatmo")
@NonNullByDefault
public class RoomActions implements ThingActions {
import java.util.stream.Collectors;
import org.eclipse.jdt.annotation.NonNullByDefault;
-import org.eclipse.jdt.annotation.Nullable;
import org.openhab.binding.netatmo.internal.api.data.ModuleType;
import org.openhab.binding.netatmo.internal.api.dto.NAModule;
import org.openhab.binding.netatmo.internal.config.NAThingConfiguration;
import org.openhab.binding.netatmo.internal.handler.ApiBridgeHandler;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
-import org.openhab.core.config.discovery.DiscoveryService;
import org.openhab.core.thing.ThingTypeUID;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
* @author Gaël L'hopital - Initial contribution
*
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = NetatmoDiscoveryService.class)
@NonNullByDefault
-public class NetatmoDiscoveryService extends AbstractDiscoveryService implements ThingHandlerService, DiscoveryService {
+public class NetatmoDiscoveryService extends AbstractThingHandlerDiscoveryService<ApiBridgeHandler> {
private static final int DISCOVER_TIMEOUT_SECONDS = 3;
private final Logger logger = LoggerFactory.getLogger(NetatmoDiscoveryService.class);
- private @Nullable ApiBridgeHandler handler;
-
public NetatmoDiscoveryService() {
- super(ModuleType.AS_SET.stream().filter(mt -> !mt.apiName.isBlank()).map(mt -> mt.thingTypeUID)
- .collect(Collectors.toSet()), DISCOVER_TIMEOUT_SECONDS);
+ super(ApiBridgeHandler.class, ModuleType.AS_SET.stream().filter(mt -> !mt.apiName.isBlank())
+ .map(mt -> mt.thingTypeUID).collect(Collectors.toSet()), DISCOVER_TIMEOUT_SECONDS);
}
@Override
public void startScan() {
- ApiBridgeHandler localHandler = handler;
- if (localHandler != null) {
- localHandler.identifyAllModulesAndApplyAction(this::createThing);
- }
+ thingHandler.identifyAllModulesAndApplyAction(this::createThing);
}
private Optional<ThingUID> findThingUID(ModuleType moduleType, String thingId, ThingUID bridgeUID) {
}
return moduleUID;
}
-
- @Override
- public void setThingHandler(ThingHandler handler) {
- if (handler instanceof ApiBridgeHandler bridgeHandler) {
- this.handler = bridgeHandler;
- }
- }
-
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return handler;
- }
-
- @Override
- public void deactivate() {
- super.deactivate();
- }
}
import org.openhab.core.thing.binding.ThingActions;
import org.openhab.core.thing.binding.ThingActionsScope;
import org.openhab.core.thing.binding.ThingHandler;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Wouter Born - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = NetworkActions.class)
@ThingActionsScope(name = "network")
@NonNullByDefault
public class NetworkActions implements ThingActions {
import org.openhab.core.thing.type.ChannelType;
import org.openhab.core.thing.type.ChannelTypeProvider;
import org.openhab.core.thing.type.ChannelTypeUID;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
/**
* Provider class to provide channel types for user configured channels.
*
* @author Hilbrand Bouwkamp - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = { NUTChannelTypeProvider.class, ChannelTypeProvider.class })
@NonNullByDefault
public class NUTChannelTypeProvider implements ChannelTypeProvider, ThingHandlerService {
import java.util.Set;
import org.eclipse.jdt.annotation.NonNullByDefault;
-import org.eclipse.jdt.annotation.Nullable;
import org.openhab.binding.nikobus.internal.handler.NikobusPcLinkHandler;
import org.openhab.binding.nikobus.internal.utils.Utils;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Boris Krivonog - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = NikobusDiscoveryService.class)
@NonNullByDefault
-public class NikobusDiscoveryService extends AbstractDiscoveryService implements ThingHandlerService {
-
+public class NikobusDiscoveryService extends AbstractThingHandlerDiscoveryService<NikobusPcLinkHandler> {
private final Logger logger = LoggerFactory.getLogger(NikobusDiscoveryService.class);
- private @Nullable NikobusPcLinkHandler bridgeHandler;
public NikobusDiscoveryService() throws IllegalArgumentException {
- super(Set.of(THING_TYPE_PUSH_BUTTON), 0);
+ super(NikobusPcLinkHandler.class, Set.of(THING_TYPE_PUSH_BUTTON), 0);
}
@Override
@Override
protected void stopBackgroundDiscovery() {
- NikobusPcLinkHandler handler = bridgeHandler;
- if (handler != null) {
- handler.resetUnhandledCommandProcessor();
- }
+ thingHandler.resetUnhandledCommandProcessor();
}
@Override
protected void startBackgroundDiscovery() {
- NikobusPcLinkHandler handler = bridgeHandler;
- if (handler != null) {
- handler.setUnhandledCommandProcessor(this::process);
- }
+ thingHandler.setUnhandledCommandProcessor(this::process);
}
private void process(String command) {
String address = command.substring(2);
logger.debug("Received address = '{}'", address);
- NikobusPcLinkHandler handler = bridgeHandler;
- if (handler != null) {
- ThingUID thingUID = new ThingUID(THING_TYPE_PUSH_BUTTON, handler.getThing().getUID(), address);
+ ThingUID thingUID = new ThingUID(THING_TYPE_PUSH_BUTTON, thingHandler.getThing().getUID(), address);
- Map<String, Object> properties = new HashMap<>();
- properties.put(CONFIG_ADDRESS, address);
+ Map<String, Object> properties = new HashMap<>();
+ properties.put(CONFIG_ADDRESS, address);
- String humanReadableNikobusAddress = Utils.convertToHumanReadableNikobusAddress(address).toUpperCase();
- logger.debug("Detected Nikobus Push Button: '{}'", humanReadableNikobusAddress);
- thingDiscovered(DiscoveryResultBuilder.create(thingUID).withThingType(THING_TYPE_PUSH_BUTTON)
- .withLabel("Nikobus Push Button " + humanReadableNikobusAddress).withProperties(properties)
- .withRepresentationProperty(CONFIG_ADDRESS).withBridge(handler.getThing().getUID()).build());
- }
- }
-
- @Override
- public void setThingHandler(ThingHandler handler) {
- if (handler instanceof NikobusPcLinkHandler pcLinkHandler) {
- bridgeHandler = pcLinkHandler;
- }
- }
-
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return bridgeHandler;
- }
-
- @Override
- public void activate() {
- super.activate(null);
- }
-
- @Override
- public void deactivate() {
- super.deactivate();
+ String humanReadableNikobusAddress = Utils.convertToHumanReadableNikobusAddress(address).toUpperCase();
+ logger.debug("Detected Nikobus Push Button: '{}'", humanReadableNikobusAddress);
+ thingDiscovered(DiscoveryResultBuilder.create(thingUID).withThingType(THING_TYPE_PUSH_BUTTON)
+ .withLabel("Nikobus Push Button " + humanReadableNikobusAddress).withProperties(properties)
+ .withRepresentationProperty(CONFIG_ADDRESS).withBridge(thingHandler.getThing().getUID()).build());
}
}
import org.openhab.binding.nikohomecontrol.internal.protocol.NhcEnergyMeter;
import org.openhab.binding.nikohomecontrol.internal.protocol.NhcThermostat;
import org.openhab.binding.nikohomecontrol.internal.protocol.NikoHomeControlCommunication;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Mark Herwege - Initial Contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = NikoHomeControlDiscoveryService.class)
@NonNullByDefault
-public class NikoHomeControlDiscoveryService extends AbstractDiscoveryService implements ThingHandlerService {
-
+public class NikoHomeControlDiscoveryService
+ extends AbstractThingHandlerDiscoveryService<NikoHomeControlBridgeHandler> {
private final Logger logger = LoggerFactory.getLogger(NikoHomeControlDiscoveryService.class);
private volatile @Nullable ScheduledFuture<?> nhcDiscoveryJob;
private static final int REFRESH_INTERVAL_S = 60;
private @Nullable ThingUID bridgeUID;
- private @Nullable NikoHomeControlBridgeHandler handler;
public NikoHomeControlDiscoveryService() {
- super(SUPPORTED_THING_TYPES_UIDS, TIMEOUT_S, true);
+ super(NikoHomeControlBridgeHandler.class, SUPPORTED_THING_TYPES_UIDS, TIMEOUT_S, true);
logger.debug("device discovery service started");
}
@Override
- public void activate() {
- startBackgroundDiscovery();
- }
-
- @Override
- public void deactivate() {
+ public void dispose() {
+ super.dispose();
removeOlderResults(Instant.now().toEpochMilli());
- super.deactivate();
}
/**
* Discovers devices connected to a Niko Home Control controller
*/
public void discoverDevices() {
- NikoHomeControlBridgeHandler bridgeHandler = handler;
- if (bridgeHandler == null) {
- return;
- }
-
- NikoHomeControlCommunication nhcComm = bridgeHandler.getCommunication();
+ NikoHomeControlCommunication nhcComm = thingHandler.getCommunication();
if ((nhcComm == null) || !nhcComm.communicationActive()) {
logger.warn("not connected");
return;
}
- logger.debug("getting devices on {}", bridgeHandler.getThing().getUID().getId());
+ logger.debug("getting devices on {}", thingHandler.getThing().getUID().getId());
Map<String, NhcAction> actions = nhcComm.getActions();
switch (nhcAction.getType()) {
case TRIGGER:
- addActionDevice(new ThingUID(THING_TYPE_PUSHBUTTON, bridgeHandler.getThing().getUID(), actionId),
+ addActionDevice(new ThingUID(THING_TYPE_PUSHBUTTON, thingHandler.getThing().getUID(), actionId),
actionId, thingName, thingLocation);
break;
case RELAY:
- addActionDevice(new ThingUID(THING_TYPE_ON_OFF_LIGHT, bridgeHandler.getThing().getUID(), actionId),
+ addActionDevice(new ThingUID(THING_TYPE_ON_OFF_LIGHT, thingHandler.getThing().getUID(), actionId),
actionId, thingName, thingLocation);
break;
case DIMMER:
- addActionDevice(
- new ThingUID(THING_TYPE_DIMMABLE_LIGHT, bridgeHandler.getThing().getUID(), actionId),
+ addActionDevice(new ThingUID(THING_TYPE_DIMMABLE_LIGHT, thingHandler.getThing().getUID(), actionId),
actionId, thingName, thingLocation);
break;
case ROLLERSHUTTER:
- addActionDevice(new ThingUID(THING_TYPE_BLIND, bridgeHandler.getThing().getUID(), actionId),
+ addActionDevice(new ThingUID(THING_TYPE_BLIND, thingHandler.getThing().getUID(), actionId),
actionId, thingName, thingLocation);
break;
default:
thermostats.forEach((thermostatId, nhcThermostat) -> {
String thingName = nhcThermostat.getName();
String thingLocation = nhcThermostat.getLocation();
- addThermostatDevice(new ThingUID(THING_TYPE_THERMOSTAT, bridgeHandler.getThing().getUID(), thermostatId),
+ addThermostatDevice(new ThingUID(THING_TYPE_THERMOSTAT, thingHandler.getThing().getUID(), thermostatId),
thermostatId, thingName, thingLocation);
});
energyMeters.forEach((energyMeterId, nhcEnergyMeter) -> {
String thingName = nhcEnergyMeter.getName();
String thingLocation = nhcEnergyMeter.getLocation();
- addEnergyMeterDevice(new ThingUID(THING_TYPE_ENERGYMETER, bridgeHandler.getThing().getUID(), energyMeterId),
+ addEnergyMeterDevice(new ThingUID(THING_TYPE_ENERGYMETER, thingHandler.getThing().getUID(), energyMeterId),
energyMeterId, thingName, thingLocation);
});
}
}
@Override
- public void setThingHandler(@Nullable ThingHandler handler) {
- if (handler instanceof NikoHomeControlBridgeHandler homeControlBridgeHandler) {
- this.handler = homeControlBridgeHandler;
- bridgeUID = handler.getThing().getUID();
- }
- }
-
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return handler;
+ public void initialize() {
+ bridgeUID = thingHandler.getThing().getUID();
+ super.initialize();
}
}
import java.time.Duration;
import java.util.Collection;
import java.util.Map;
+import java.util.Set;
import org.eclipse.jdt.annotation.NonNullByDefault;
import org.eclipse.jdt.annotation.Nullable;
import org.openhab.binding.nobohub.internal.connection.HubCommunicationThread;
import org.openhab.binding.nobohub.internal.connection.HubConnection;
+import org.openhab.binding.nobohub.internal.discovery.NoboHubDiscoveryService;
import org.openhab.binding.nobohub.internal.discovery.NoboThingDiscoveryService;
import org.openhab.binding.nobohub.internal.model.Component;
import org.openhab.binding.nobohub.internal.model.ComponentRegister;
import org.openhab.core.thing.ThingStatusDetail;
import org.openhab.core.thing.binding.BaseBridgeHandler;
import org.openhab.core.thing.binding.ThingHandler;
+import org.openhab.core.thing.binding.ThingHandlerService;
import org.openhab.core.types.Command;
import org.openhab.core.types.RefreshType;
import org.slf4j.Logger;
public void setStatusInfo(ThingStatus status, ThingStatusDetail statusDetail, @Nullable String description) {
updateStatus(status, statusDetail, description);
}
+
+ @Override
+ public Collection<Class<? extends ThingHandlerService>> getServices() {
+ return Set.of(NoboHubDiscoveryService.class);
+ }
}
import java.util.Map;
import org.eclipse.jdt.annotation.NonNullByDefault;
-import org.eclipse.jdt.annotation.Nullable;
import org.openhab.binding.nobohub.internal.NoboHubBridgeHandler;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResult;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
-import org.openhab.core.config.discovery.DiscoveryService;
import org.openhab.core.thing.Thing;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
* @author Espen Fossen - Initial contribution
*/
@NonNullByDefault
-@Component(service = DiscoveryService.class, immediate = true, configurationPid = "discovery.nobohub")
-public class NoboHubDiscoveryService extends AbstractDiscoveryService implements DiscoveryService, ThingHandlerService {
+@Component(scope = ServiceScope.PROTOTYPE, service = NoboHubDiscoveryService.class, configurationPid = "discovery.nobohub")
+public class NoboHubDiscoveryService extends AbstractThingHandlerDiscoveryService<NoboHubBridgeHandler> {
private final Logger logger = LoggerFactory.getLogger(NoboHubDiscoveryService.class);
- private @NonNullByDefault({}) NoboHubBridgeHandler hubBridgeHandler;
-
public NoboHubDiscoveryService() {
- super(DISCOVERABLE_DEVICE_TYPES_UIDS, 10, true);
+ super(NoboHubBridgeHandler.class, DISCOVERABLE_DEVICE_TYPES_UIDS, 10, true);
}
@Override
}
@Override
- public void deactivate() {
+ public void dispose() {
+ super.dispose();
removeOlderResults(new Date().getTime());
}
- @Override
- public void setThingHandler(ThingHandler thingHandler) {
- if (thingHandler instanceof NoboHubBridgeHandler bridgeHandler) {
- this.hubBridgeHandler = bridgeHandler;
- }
- }
-
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return hubBridgeHandler;
- }
-
private final Runnable scanner = new Runnable() {
@Override
public void run() {
import org.openhab.binding.nuki.internal.dataexchange.BridgeListResponse;
import org.openhab.binding.nuki.internal.dto.BridgeApiListDeviceDto;
import org.openhab.binding.nuki.internal.handler.NukiBridgeHandler;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResult;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Jan Vybíral - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = NukiDeviceDiscoveryService.class)
@NonNullByDefault
-public class NukiDeviceDiscoveryService extends AbstractDiscoveryService implements ThingHandlerService {
+public class NukiDeviceDiscoveryService extends AbstractThingHandlerDiscoveryService<NukiBridgeHandler> {
private final Logger logger = LoggerFactory.getLogger(NukiDeviceDiscoveryService.class);
- @Nullable
- private NukiBridgeHandler bridge;
public NukiDeviceDiscoveryService() {
- super(Set.of(NukiBindingConstants.THING_TYPE_SMARTLOCK), 5, false);
+ super(NukiBridgeHandler.class, Set.of(NukiBindingConstants.THING_TYPE_SMARTLOCK), 5, false);
}
@Override
protected void startScan() {
- NukiBridgeHandler bridgeHandler = bridge;
+ NukiBridgeHandler bridgeHandler = thingHandler;
if (bridgeHandler == null) {
logger.warn("Cannot start Nuki discovery - no bridge available");
return;
super.stopScan();
removeOlderResults(getTimestampOfLastScan());
}
-
- @Override
- public void setThingHandler(@Nullable ThingHandler handler) {
- if (handler instanceof NukiBridgeHandler bridgeHandler) {
- bridge = bridgeHandler;
- }
- }
-
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return bridge;
- }
-
- @Override
- public void deactivate() {
- }
}
import org.openhab.core.thing.binding.ThingActions;
import org.openhab.core.thing.binding.ThingActionsScope;
import org.openhab.core.thing.binding.ThingHandler;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Michael Lobstein - initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = NuvoThingActions.class)
@ThingActionsScope(name = "nuvo")
@NonNullByDefault
public class NuvoThingActions implements ThingActions {
import org.eclipse.jdt.annotation.Nullable;
import org.openhab.binding.ojelectronics.internal.OJCloudHandler;
import org.openhab.binding.ojelectronics.internal.models.groups.GroupContentModel;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
-import org.openhab.core.config.discovery.DiscoveryService;
import org.openhab.core.thing.ThingTypeUID;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
/**
* DiscoveryService for OJ Components
* @author Christian Kittel - Initial Contribution
*/
@NonNullByDefault
-@Component(service = DiscoveryService.class, immediate = true, configurationPid = "discovery.ojelectronics")
-public final class OJDiscoveryService extends AbstractDiscoveryService implements ThingHandlerService {
-
+@Component(scope = ServiceScope.PROTOTYPE, service = OJDiscoveryService.class, configurationPid = "discovery.ojelectronics")
+public final class OJDiscoveryService extends AbstractThingHandlerDiscoveryService<OJCloudHandler> {
private static final Set<ThingTypeUID> SUPPORTED_THING_TYPES_UIDS = Set.of(THING_TYPE_OJCLOUD);
- private @Nullable OJCloudHandler bridgeHandler;
private @Nullable Collection<GroupContentModel> groupContents;
/**
*
*/
public OJDiscoveryService() throws IllegalArgumentException {
- super(SUPPORTED_THING_TYPES_UIDS, 10);
+ super(OJCloudHandler.class, SUPPORTED_THING_TYPES_UIDS, 10);
}
/**
@Override
protected void startScan() {
- final OJCloudHandler bridgeHandler = this.bridgeHandler;
final Collection<GroupContentModel> groupContents = this.groupContents;
- if (groupContents != null && bridgeHandler != null) {
+ if (groupContents != null) {
groupContents.stream().flatMap(content -> content.thermostats.stream())
- .forEach(thermostat -> thingDiscovered(bridgeHandler.getThing().getUID(), thermostat.serialNumber));
- }
- }
-
- @Override
- public void setThingHandler(@Nullable ThingHandler handler) {
- if (handler instanceof OJCloudHandler bridgeHandler) {
- this.bridgeHandler = bridgeHandler;
- bridgeHandler.setDiscoveryService(this);
+ .forEach(thermostat -> thingDiscovered(thingHandler.getThing().getUID(), thermostat.serialNumber));
}
}
@Override
- public @Nullable ThingHandler getThingHandler() {
- return bridgeHandler;
- }
-
- @Override
- public void deactivate() {
- super.deactivate();
+ public void initialize() {
+ thingHandler.setDiscoveryService(this);
+ super.initialize();
}
private void thingDiscovered(ThingUID bridgeUID, String serialNumber) {
import org.openhab.core.thing.binding.ThingActions;
import org.openhab.core.thing.binding.ThingActionsScope;
import org.openhab.core.thing.binding.ThingHandler;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Ethan Dye - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = OmnilinkActions.class)
@ThingActionsScope(name = "omnilink")
@NonNullByDefault
public class OmnilinkActions implements ThingActions {
import org.openhab.binding.omnilink.internal.SystemType;
import org.openhab.binding.omnilink.internal.exceptions.BridgeOfflineException;
import org.openhab.binding.omnilink.internal.handler.OmnilinkBridgeHandler;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResult;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
-import org.openhab.core.config.discovery.DiscoveryService;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
* @author Craig Hamilton - Initial contribution
* @author Ethan Dye - openHAB3 rewrite
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = OmnilinkDiscoveryService.class)
@NonNullByDefault
-public class OmnilinkDiscoveryService extends AbstractDiscoveryService
- implements DiscoveryService, ThingHandlerService {
+public class OmnilinkDiscoveryService extends AbstractThingHandlerDiscoveryService<OmnilinkBridgeHandler> {
private final Logger logger = LoggerFactory.getLogger(OmnilinkDiscoveryService.class);
private static final int DISCOVER_TIMEOUT_SECONDS = 30;
- private @Nullable OmnilinkBridgeHandler bridgeHandler;
private Optional<SystemType> systemType = Optional.empty();
private @Nullable List<AreaProperties> areas;
* Creates an OmnilinkDiscoveryService.
*/
public OmnilinkDiscoveryService() {
- super(SUPPORTED_THING_TYPES_UIDS, DISCOVER_TIMEOUT_SECONDS, false);
- }
-
- @Override
- public void setThingHandler(@Nullable ThingHandler handler) {
- if (handler instanceof OmnilinkBridgeHandler omnilinkBridgeHandler) {
- bridgeHandler = omnilinkBridgeHandler;
- }
- }
-
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return bridgeHandler;
- }
-
- @Override
- public void activate() {
- }
-
- @Override
- public void deactivate() {
+ super(OmnilinkBridgeHandler.class, SUPPORTED_THING_TYPES_UIDS, DISCOVER_TIMEOUT_SECONDS, false);
}
@Override
protected synchronized void startScan() {
- final OmnilinkBridgeHandler handler = bridgeHandler;
- if (handler != null) {
- logger.debug("Starting scan");
- try {
- SystemInformation systemInformation = handler.reqSystemInformation();
- this.systemType = SystemType.getType(systemInformation.getModel());
- this.areas = discoverAreas();
- discoverUnits();
- discoverZones();
- discoverButtons();
- discoverThermostats();
- discoverAudioZones();
- discoverAudioSources();
- discoverTempSensors();
- discoverHumiditySensors();
- discoverLocks();
- } catch (OmniInvalidResponseException | OmniUnknownMessageTypeException | BridgeOfflineException e) {
- logger.debug("Received error during discovery: {}", e.getMessage());
- }
+ logger.debug("Starting scan");
+ try {
+ SystemInformation systemInformation = thingHandler.reqSystemInformation();
+ this.systemType = SystemType.getType(systemInformation.getModel());
+ this.areas = discoverAreas();
+ discoverUnits();
+ discoverZones();
+ discoverButtons();
+ discoverThermostats();
+ discoverAudioZones();
+ discoverAudioSources();
+ discoverTempSensors();
+ discoverHumiditySensors();
+ discoverLocks();
+ } catch (OmniInvalidResponseException | OmniUnknownMessageTypeException | BridgeOfflineException e) {
+ logger.debug("Received error during discovery: {}", e.getMessage());
}
}
* Discovers OmniLink buttons
*/
private void discoverButtons() {
- final OmnilinkBridgeHandler handler = bridgeHandler;
- if (handler != null) {
- final ThingUID bridgeUID = handler.getThing().getUID();
- final List<AreaProperties> areas = this.areas;
+ final ThingUID bridgeUID = thingHandler.getThing().getUID();
+ final List<AreaProperties> areas = this.areas;
- if (areas != null) {
- for (AreaProperties areaProperties : areas) {
- int areaFilter = bitFilterForArea(areaProperties);
+ if (areas != null) {
+ for (AreaProperties areaProperties : areas) {
+ int areaFilter = bitFilterForArea(areaProperties);
- ObjectPropertyRequest<ButtonProperties> objectPropertyRequest = ObjectPropertyRequest
- .builder(handler, ObjectPropertyRequests.BUTTONS, 0, 1).selectNamed().areaFilter(areaFilter)
- .build();
+ ObjectPropertyRequest<ButtonProperties> objectPropertyRequest = ObjectPropertyRequest
+ .builder(thingHandler, ObjectPropertyRequests.BUTTONS, 0, 1).selectNamed()
+ .areaFilter(areaFilter).build();
- for (ButtonProperties buttonProperties : objectPropertyRequest) {
- String thingName = buttonProperties.getName();
- String thingID = Integer.toString(buttonProperties.getNumber());
+ for (ButtonProperties buttonProperties : objectPropertyRequest) {
+ String thingName = buttonProperties.getName();
+ String thingID = Integer.toString(buttonProperties.getNumber());
- Map<String, Object> properties = new HashMap<>();
- properties.put(THING_PROPERTIES_NAME, thingName);
- properties.put(THING_PROPERTIES_AREA, areaProperties.getNumber());
+ Map<String, Object> properties = new HashMap<>();
+ properties.put(THING_PROPERTIES_NAME, thingName);
+ properties.put(THING_PROPERTIES_AREA, areaProperties.getNumber());
- ThingUID thingUID = new ThingUID(THING_TYPE_BUTTON, bridgeUID, thingID);
+ ThingUID thingUID = new ThingUID(THING_TYPE_BUTTON, bridgeUID, thingID);
- DiscoveryResult discoveryResult = DiscoveryResultBuilder.create(thingUID)
- .withProperties(properties).withProperty(THING_PROPERTIES_NUMBER, thingID)
- .withRepresentationProperty(THING_PROPERTIES_NUMBER).withBridge(bridgeUID)
- .withLabel(thingName).build();
- thingDiscovered(discoveryResult);
- }
+ DiscoveryResult discoveryResult = DiscoveryResultBuilder.create(thingUID).withProperties(properties)
+ .withProperty(THING_PROPERTIES_NUMBER, thingID)
+ .withRepresentationProperty(THING_PROPERTIES_NUMBER).withBridge(bridgeUID)
+ .withLabel(thingName).build();
+ thingDiscovered(discoveryResult);
}
}
}
* Discovers OmniLink locks
*/
private void discoverLocks() {
- final OmnilinkBridgeHandler handler = bridgeHandler;
- if (handler != null) {
- final ThingUID bridgeUID = handler.getThing().getUID();
+ final ThingUID bridgeUID = thingHandler.getThing().getUID();
-
ObjectPropertyRequest<AccessControlReaderProperties> objectPropertyRequest = ObjectPropertyRequest
- .builder(handler, ObjectPropertyRequests.LOCK, 0, 1).selectNamed().build();
+ ObjectPropertyRequest<AccessControlReaderProperties> objectPropertyRequest = ObjectPropertyRequest
+ .builder(thingHandler, ObjectPropertyRequests.LOCK, 0, 1).selectNamed().build();
- for (AccessControlReaderProperties lockProperties : objectPropertyRequest) {
- String thingName = lockProperties.getName();
- String thingID = Integer.toString(lockProperties.getNumber());
+ for (AccessControlReaderProperties lockProperties : objectPropertyRequest) {
+ String thingName = lockProperties.getName();
+ String thingID = Integer.toString(lockProperties.getNumber());
- Map<String, Object> properties = Map.of(THING_PROPERTIES_NAME, thingName);
+ Map<String, Object> properties = Map.of(THING_PROPERTIES_NAME, thingName);
- ThingUID thingUID = new ThingUID(THING_TYPE_LOCK, bridgeUID, thingID);
+ ThingUID thingUID = new ThingUID(THING_TYPE_LOCK, bridgeUID, thingID);
- DiscoveryResult discoveryResult = DiscoveryResultBuilder.create(thingUID).withProperties(properties)
- .withProperty(THING_PROPERTIES_NUMBER, thingID)
- .withRepresentationProperty(THING_PROPERTIES_NUMBER).withBridge(bridgeUID).withLabel(thingName)
- .build();
- thingDiscovered(discoveryResult);
- }
+ DiscoveryResult discoveryResult = DiscoveryResultBuilder.create(thingUID).withProperties(properties)
+ .withProperty(THING_PROPERTIES_NUMBER, thingID).withRepresentationProperty(THING_PROPERTIES_NUMBER)
+ .withBridge(bridgeUID).withLabel(thingName).build();
+ thingDiscovered(discoveryResult);
}
}
* Discovers OmniLink audio zones
*/
private void discoverAudioZones() {
- final OmnilinkBridgeHandler handler = bridgeHandler;
- if (handler != null) {
- final ThingUID bridgeUID = handler.getThing().getUID();
+ final ThingUID bridgeUID = thingHandler.getThing().getUID();
-
ObjectPropertyRequest<AudioZoneProperties> objectPropertyRequest = ObjectPropertyRequest
- .builder(handler, ObjectPropertyRequests.AUDIO_ZONE, 0, 1).selectNamed().build();
+ ObjectPropertyRequest<AudioZoneProperties> objectPropertyRequest = ObjectPropertyRequest
+ .builder(thingHandler, ObjectPropertyRequests.AUDIO_ZONE, 0, 1).selectNamed().build();
- for (AudioZoneProperties audioZoneProperties : objectPropertyRequest) {
- String thingName = audioZoneProperties.getName();
- String thingID = Integer.toString(audioZoneProperties.getNumber());
+ for (AudioZoneProperties audioZoneProperties : objectPropertyRequest) {
+ String thingName = audioZoneProperties.getName();
+ String thingID = Integer.toString(audioZoneProperties.getNumber());
- Map<String, Object> properties = Map.of(THING_PROPERTIES_NAME, thingName);
+ Map<String, Object> properties = Map.of(THING_PROPERTIES_NAME, thingName);
- ThingUID thingUID = new ThingUID(THING_TYPE_AUDIO_ZONE, bridgeUID, thingID);
+ ThingUID thingUID = new ThingUID(THING_TYPE_AUDIO_ZONE, bridgeUID, thingID);
- DiscoveryResult discoveryResult = DiscoveryResultBuilder.create(thingUID).withProperties(properties)
- .withProperty(THING_PROPERTIES_NUMBER, thingID)
- .withRepresentationProperty(THING_PROPERTIES_NUMBER).withBridge(bridgeUID).withLabel(thingName)
- .build();
- thingDiscovered(discoveryResult);
- }
+ DiscoveryResult discoveryResult = DiscoveryResultBuilder.create(thingUID).withProperties(properties)
+ .withProperty(THING_PROPERTIES_NUMBER, thingID).withRepresentationProperty(THING_PROPERTIES_NUMBER)
+ .withBridge(bridgeUID).withLabel(thingName).build();
+ thingDiscovered(discoveryResult);
}
}
* Discovers OmniLink audio sources
*/
private void discoverAudioSources() {
- final OmnilinkBridgeHandler handler = bridgeHandler;
- if (handler != null) {
- final ThingUID bridgeUID = handler.getThing().getUID();
+ final ThingUID bridgeUID = thingHandler.getThing().getUID();
-
ObjectPropertyRequest<AudioSourceProperties> objectPropertyRequest = ObjectPropertyRequest
- .builder(handler, ObjectPropertyRequests.AUDIO_SOURCE, 0, 1).selectNamed().build();
+ ObjectPropertyRequest<AudioSourceProperties> objectPropertyRequest = ObjectPropertyRequest
+ .builder(thingHandler, ObjectPropertyRequests.AUDIO_SOURCE, 0, 1).selectNamed().build();
- for (AudioSourceProperties audioSourceProperties : objectPropertyRequest) {
- String thingName = audioSourceProperties.getName();
- String thingID = Integer.toString(audioSourceProperties.getNumber());
+ for (AudioSourceProperties audioSourceProperties : objectPropertyRequest) {
+ String thingName = audioSourceProperties.getName();
+ String thingID = Integer.toString(audioSourceProperties.getNumber());
- Map<String, Object> properties = Map.of(THING_PROPERTIES_NAME, thingName);
+ Map<String, Object> properties = Map.of(THING_PROPERTIES_NAME, thingName);
- ThingUID thingUID = new ThingUID(THING_TYPE_AUDIO_SOURCE, bridgeUID, thingID);
+ ThingUID thingUID = new ThingUID(THING_TYPE_AUDIO_SOURCE, bridgeUID, thingID);
- DiscoveryResult discoveryResult = DiscoveryResultBuilder.create(thingUID).withProperties(properties)
- .withProperty(THING_PROPERTIES_NUMBER, thingID)
- .withRepresentationProperty(THING_PROPERTIES_NUMBER).withBridge(bridgeUID).withLabel(thingName)
- .build();
- thingDiscovered(discoveryResult);
- }
+ DiscoveryResult discoveryResult = DiscoveryResultBuilder.create(thingUID).withProperties(properties)
+ .withProperty(THING_PROPERTIES_NUMBER, thingID).withRepresentationProperty(THING_PROPERTIES_NUMBER)
+ .withBridge(bridgeUID).withLabel(thingName).build();
+ thingDiscovered(discoveryResult);
}
}
* Discovers OmniLink temperature sensors
*/
private void discoverTempSensors() {
- final OmnilinkBridgeHandler handler = bridgeHandler;
- if (handler != null) {
- final ThingUID bridgeUID = handler.getThing().getUID();
- final List<AreaProperties> areas = this.areas;
-
- if (areas != null) {
- for (AreaProperties areaProperties : areas) {
- int areaFilter = bitFilterForArea(areaProperties);
-
- ObjectPropertyRequest<AuxSensorProperties> objectPropertyRequest = ObjectPropertyRequest
- .builder(handler, ObjectPropertyRequests.AUX_SENSORS, 0, 1).selectNamed()
- .areaFilter(areaFilter).build();
-
- for (AuxSensorProperties auxSensorProperties : objectPropertyRequest) {
- if (auxSensorProperties.getSensorType() != SENSOR_TYPE_PROGRAMMABLE_ENERGY_SAVER_MODULE
- && auxSensorProperties.getSensorType() != SENSOR_TYPE_HUMIDITY) {
- String thingName = auxSensorProperties.getName();
- String thingID = Integer.toString(auxSensorProperties.getNumber());
-
- Map<String, Object> properties = new HashMap<>();
- properties.put(THING_PROPERTIES_NAME, thingName);
- properties.put(THING_PROPERTIES_AREA, areaProperties.getNumber());
-
- ThingUID thingUID = new ThingUID(THING_TYPE_TEMP_SENSOR, bridgeUID, thingID);
-
- DiscoveryResult discoveryResult = DiscoveryResultBuilder.create(thingUID)
- .withProperties(properties).withProperty(THING_PROPERTIES_NUMBER, thingID)
- .withRepresentationProperty(THING_PROPERTIES_NUMBER).withBridge(bridgeUID)
- .withLabel(thingName).build();
- thingDiscovered(discoveryResult);
- }
+ final ThingUID bridgeUID = thingHandler.getThing().getUID();
+ final List<AreaProperties> areas = this.areas;
+
+ if (areas != null) {
+ for (AreaProperties areaProperties : areas) {
+ int areaFilter = bitFilterForArea(areaProperties);
+
+ ObjectPropertyRequest<AuxSensorProperties> objectPropertyRequest = ObjectPropertyRequest
+ .builder(thingHandler, ObjectPropertyRequests.AUX_SENSORS, 0, 1).selectNamed()
+ .areaFilter(areaFilter).build();
+
+ for (AuxSensorProperties auxSensorProperties : objectPropertyRequest) {
+ if (auxSensorProperties.getSensorType() != SENSOR_TYPE_PROGRAMMABLE_ENERGY_SAVER_MODULE
+ && auxSensorProperties.getSensorType() != SENSOR_TYPE_HUMIDITY) {
+ String thingName = auxSensorProperties.getName();
+ String thingID = Integer.toString(auxSensorProperties.getNumber());
+
+ Map<String, Object> properties = new HashMap<>();
+ properties.put(THING_PROPERTIES_NAME, thingName);
+ properties.put(THING_PROPERTIES_AREA, areaProperties.getNumber());
+
+ ThingUID thingUID = new ThingUID(THING_TYPE_TEMP_SENSOR, bridgeUID, thingID);
+
+ DiscoveryResult discoveryResult = DiscoveryResultBuilder.create(thingUID)
+ .withProperties(properties).withProperty(THING_PROPERTIES_NUMBER, thingID)
+ .withRepresentationProperty(THING_PROPERTIES_NUMBER).withBridge(bridgeUID)
+ .withLabel(thingName).build();
+ thingDiscovered(discoveryResult);
}
}
}
* Discovers OmniLink humidity sensors
*/
private void discoverHumiditySensors() {
- final OmnilinkBridgeHandler handler = bridgeHandler;
- if (handler != null) {
- final ThingUID bridgeUID = handler.getThing().getUID();
- final List<AreaProperties> areas = this.areas;
-
- if (areas != null) {
- for (AreaProperties areaProperties : areas) {
- int areaFilter = bitFilterForArea(areaProperties);
-
- ObjectPropertyRequest<AuxSensorProperties> objectPropertyRequest = ObjectPropertyRequest
- .builder(handler, ObjectPropertyRequests.AUX_SENSORS, 0, 1).selectNamed()
- .areaFilter(areaFilter).build();
-
- for (AuxSensorProperties auxSensorProperties : objectPropertyRequest) {
- if (auxSensorProperties.getSensorType() == SENSOR_TYPE_HUMIDITY) {
- String thingName = auxSensorProperties.getName();
- String thingID = Integer.toString(auxSensorProperties.getNumber());
-
- Map<String, Object> properties = new HashMap<>();
- properties.put(THING_PROPERTIES_NAME, thingName);
- properties.put(THING_PROPERTIES_AREA, areaProperties.getNumber());
-
- ThingUID thingUID = new ThingUID(THING_TYPE_HUMIDITY_SENSOR, bridgeUID, thingID);
-
- DiscoveryResult discoveryResult = DiscoveryResultBuilder.create(thingUID)
- .withProperties(properties).withProperty(THING_PROPERTIES_NUMBER, thingID)
- .withRepresentationProperty(THING_PROPERTIES_NUMBER).withBridge(bridgeUID)
- .withLabel(thingName).build();
- thingDiscovered(discoveryResult);
- }
+ final ThingUID bridgeUID = thingHandler.getThing().getUID();
+ final List<AreaProperties> areas = this.areas;
+
+ if (areas != null) {
+ for (AreaProperties areaProperties : areas) {
+ int areaFilter = bitFilterForArea(areaProperties);
+
+ ObjectPropertyRequest<AuxSensorProperties> objectPropertyRequest = ObjectPropertyRequest
+ .builder(thingHandler, ObjectPropertyRequests.AUX_SENSORS, 0, 1).selectNamed()
+ .areaFilter(areaFilter).build();
+
+ for (AuxSensorProperties auxSensorProperties : objectPropertyRequest) {
+ if (auxSensorProperties.getSensorType() == SENSOR_TYPE_HUMIDITY) {
+ String thingName = auxSensorProperties.getName();
+ String thingID = Integer.toString(auxSensorProperties.getNumber());
+
+ Map<String, Object> properties = new HashMap<>();
+ properties.put(THING_PROPERTIES_NAME, thingName);
+ properties.put(THING_PROPERTIES_AREA, areaProperties.getNumber());
+
+ ThingUID thingUID = new ThingUID(THING_TYPE_HUMIDITY_SENSOR, bridgeUID, thingID);
+
+ DiscoveryResult discoveryResult = DiscoveryResultBuilder.create(thingUID)
+ .withProperties(properties).withProperty(THING_PROPERTIES_NUMBER, thingID)
+ .withRepresentationProperty(THING_PROPERTIES_NUMBER).withBridge(bridgeUID)
+ .withLabel(thingName).build();
+ thingDiscovered(discoveryResult);
}
}
}
* Discovers OmniLink thermostats
*/
private void discoverThermostats() {
- final OmnilinkBridgeHandler handler = bridgeHandler;
- if (handler != null) {
- final ThingUID bridgeUID = handler.getThing().getUID();
- final List<AreaProperties> areas = this.areas;
+ final ThingUID bridgeUID = thingHandler.getThing().getUID();
+ final List<AreaProperties> areas = this.areas;
- if (areas != null) {
- for (AreaProperties areaProperties : areas) {
- int areaFilter = bitFilterForArea(areaProperties);
+ if (areas != null) {
+ for (AreaProperties areaProperties : areas) {
+ int areaFilter = bitFilterForArea(areaProperties);
- ObjectPropertyRequest<ThermostatProperties> objectPropertyRequest = ObjectPropertyRequest
- .builder(handler, ObjectPropertyRequests.THERMOSTAT, 0, 1).selectNamed()
- .areaFilter(areaFilter).build();
+ ObjectPropertyRequest<ThermostatProperties> objectPropertyRequest = ObjectPropertyRequest
+ .builder(thingHandler, ObjectPropertyRequests.THERMOSTAT, 0, 1).selectNamed()
+ .areaFilter(areaFilter).build();
- for (ThermostatProperties thermostatProperties : objectPropertyRequest) {
- String thingName = thermostatProperties.getName();
- String thingID = Integer.toString(thermostatProperties.getNumber());
+ for (ThermostatProperties thermostatProperties : objectPropertyRequest) {
+ String thingName = thermostatProperties.getName();
+ String thingID = Integer.toString(thermostatProperties.getNumber());
- ThingUID thingUID = new ThingUID(THING_TYPE_THERMOSTAT, bridgeUID, thingID);
+ ThingUID thingUID = new ThingUID(THING_TYPE_THERMOSTAT, bridgeUID, thingID);
- Map<String, Object> properties = new HashMap<>();
- properties.put(THING_PROPERTIES_NAME, thingName);
- properties.put(THING_PROPERTIES_AREA, areaProperties.getNumber());
+ Map<String, Object> properties = new HashMap<>();
+ properties.put(THING_PROPERTIES_NAME, thingName);
+ properties.put(THING_PROPERTIES_AREA, areaProperties.getNumber());
- DiscoveryResult discoveryResult = DiscoveryResultBuilder.create(thingUID)
- .withProperties(properties).withProperty(THING_PROPERTIES_NUMBER, thingID)
- .withRepresentationProperty(THING_PROPERTIES_NUMBER).withBridge(bridgeUID)
- .withLabel(thingName).build();
- thingDiscovered(discoveryResult);
- }
+ DiscoveryResult discoveryResult = DiscoveryResultBuilder.create(thingUID).withProperties(properties)
+ .withProperty(THING_PROPERTIES_NUMBER, thingID)
+ .withRepresentationProperty(THING_PROPERTIES_NUMBER).withBridge(bridgeUID)
+ .withLabel(thingName).build();
+ thingDiscovered(discoveryResult);
}
}
}
* Discovers OmniLink areas
*/
private @Nullable List<AreaProperties> discoverAreas() {
- final OmnilinkBridgeHandler handler = bridgeHandler;
- if (handler != null) {
- final ThingUID bridgeUID = handler.getThing().getUID();
- List<AreaProperties> areas = new LinkedList<>();
-
- ObjectPropertyRequest<AreaProperties> objectPropertyRequest = ObjectPropertyRequest
- .builder(handler, ObjectPropertyRequests.AREA, 0, 1).build();
-
- for (AreaProperties areaProperties : objectPropertyRequest) {
- int thingNumber = areaProperties.getNumber();
- String thingName = areaProperties.getName();
- String thingID = Integer.toString(thingNumber);
-
- /*
- * It seems that for simple OmniLink Controller configurations there
- * is only 1 area, without a name. So if there is no name for the
- * first area, we will call that Main Area. If other area's name is
- * blank, we will not create a thing.
- */
- if (thingNumber == 1 && "".equals(thingName)) {
- thingName = "Main Area";
- } else if ("".equals(thingName)) {
- break;
+ final ThingUID bridgeUID = thingHandler.getThing().getUID();
+ List<AreaProperties> areas = new LinkedList<>();
+
+ ObjectPropertyRequest<AreaProperties> objectPropertyRequest = ObjectPropertyRequest
+ .builder(thingHandler, ObjectPropertyRequests.AREA, 0, 1).build();
+
+ for (AreaProperties areaProperties : objectPropertyRequest) {
+ int thingNumber = areaProperties.getNumber();
+ String thingName = areaProperties.getName();
+ String thingID = Integer.toString(thingNumber);
+
+ /*
+ * It seems that for simple OmniLink Controller configurations there
+ * is only 1 area, without a name. So if there is no name for the
+ * first area, we will call that Main Area. If other area's name is
+ * blank, we will not create a thing.
+ */
+ if (thingNumber == 1 && "".equals(thingName)) {
+ thingName = "Main Area";
+ } else if ("".equals(thingName)) {
+ break;
+ }
+
+ Map<String, Object> properties = Map.of(THING_PROPERTIES_NAME, thingName);
+
+ final String name = thingName;
+ systemType.ifPresentOrElse(t -> {
+ ThingUID thingUID = null;
+ switch (t) {
+ case LUMINA:
+ thingUID = new ThingUID(THING_TYPE_LUMINA_AREA, bridgeUID, thingID);
+ break;
+ default:
+ thingUID = new ThingUID(THING_TYPE_OMNI_AREA, bridgeUID, thingID);
}
+ DiscoveryResult discoveryResult = DiscoveryResultBuilder.create(thingUID).withProperties(properties)
+ .withProperty(THING_PROPERTIES_NUMBER, thingID)
+ .withRepresentationProperty(THING_PROPERTIES_NUMBER).withBridge(bridgeUID).withLabel(name)
+ .build();
+ thingDiscovered(discoveryResult);
+ }, () -> {
+ logger.warn("Unknown System Type");
+ });
+
+ areas.add(areaProperties);
+ }
+ return areas;
+ }
+
+ /**
+ * Discovers OmniLink supported units
+ */
+ private void discoverUnits() {
+ final ThingUID bridgeUID = thingHandler.getThing().getUID();
+ final List<AreaProperties> areas = this.areas;
- Map<String, Object> properties = Map.of(THING_PROPERTIES_NAME, thingName);
+ if (areas != null) {
+ for (AreaProperties areaProperties : areas) {
+ int areaFilter = bitFilterForArea(areaProperties);
- final String name = thingName;
- systemType.ifPresentOrElse(t -> {
+ ObjectPropertyRequest<UnitProperties> objectPropertyRequest = ObjectPropertyRequest
+ .builder(thingHandler, ObjectPropertyRequests.UNIT, 0, 1).selectNamed().areaFilter(areaFilter)
+ .selectAnyLoad().build();
+
+ for (UnitProperties unitProperties : objectPropertyRequest) {
+ int thingType = unitProperties.getUnitType();
+ String thingName = unitProperties.getName();
+ String thingID = Integer.toString(unitProperties.getNumber());
ThingUID thingUID = null;
- switch (t) {
- case LUMINA:
- thingUID = new ThingUID(THING_TYPE_LUMINA_AREA, bridgeUID, thingID);
+
+ Map<String, Object> properties = new HashMap<>();
+ properties.put(THING_PROPERTIES_NAME, thingName);
+ properties.put(THING_PROPERTIES_AREA, areaProperties.getNumber());
+
+ switch (thingType) {
+ case UNIT_TYPE_HLC_ROOM:
+ case UNIT_TYPE_VIZIARF_ROOM:
+ thingUID = new ThingUID(THING_TYPE_ROOM, bridgeUID, thingID);
+ break;
+ case UNIT_TYPE_FLAG:
+ thingUID = new ThingUID(THING_TYPE_FLAG, bridgeUID, thingID);
+ break;
+ case UNIT_TYPE_OUTPUT:
+ thingUID = new ThingUID(THING_TYPE_OUTPUT, bridgeUID, thingID);
+ break;
+ case UNIT_TYPE_UPB:
+ case UNIT_TYPE_HLC_LOAD:
+ thingUID = new ThingUID(THING_TYPE_UNIT_UPB, bridgeUID, thingID);
+ break;
+ case UNIT_TYPE_CENTRALITE:
+ case UNIT_TYPE_RADIORA:
+ case UNIT_TYPE_VIZIARF_LOAD:
+ case UNIT_TYPE_COMPOSE:
+ thingUID = new ThingUID(THING_TYPE_DIMMABLE, bridgeUID, thingID);
break;
default:
- thingUID = new ThingUID(THING_TYPE_OMNI_AREA, bridgeUID, thingID);
+ thingUID = new ThingUID(THING_TYPE_UNIT, bridgeUID, thingID);
+ logger.debug("Generic unit type: {}", thingType);
+ break;
}
+
DiscoveryResult discoveryResult = DiscoveryResultBuilder.create(thingUID).withProperties(properties)
.withProperty(THING_PROPERTIES_NUMBER, thingID)
- .withRepresentationProperty(THING_PROPERTIES_NUMBER).withBridge(bridgeUID).withLabel(name)
- .build();
+ .withRepresentationProperty(THING_PROPERTIES_NUMBER).withBridge(bridgeUID)
+ .withLabel(thingName).build();
thingDiscovered(discoveryResult);
- }, () -> {
- logger.warn("Unknown System Type");
- });
-
- areas.add(areaProperties);
+ }
}
- return areas;
- } else {
- return null;
}
}
/**
- * Discovers OmniLink supported units
+ * Generates zone items
*/
- private void discoverUnits() {
- final OmnilinkBridgeHandler handler = bridgeHandler;
- if (handler != null) {
- final ThingUID bridgeUID = handler.getThing().getUID();
- final List<AreaProperties> areas = this.areas;
+ private void discoverZones() {
+ final ThingUID bridgeUID = thingHandler.getThing().getUID();
+ final List<AreaProperties> areas = this.areas;
- if (areas != null) {
- for (AreaProperties areaProperties : areas) {
- int areaFilter = bitFilterForArea(areaProperties);
+ if (areas != null) {
+ for (AreaProperties areaProperties : areas) {
+ int areaFilter = bitFilterForArea(areaProperties);
- ObjectPropertyRequest<UnitProperties> objectPropertyRequest = ObjectPropertyRequest
- .builder(handler, ObjectPropertyRequests.UNIT, 0, 1).selectNamed().areaFilter(areaFilter)
- .selectAnyLoad().build();
+ ObjectPropertyRequest<ZoneProperties> objectPropertyRequest = ObjectPropertyRequest
+ .builder(thingHandler, ObjectPropertyRequests.ZONE, 0, 1).selectNamed().areaFilter(areaFilter)
+ .build();
- for (UnitProperties unitProperties : objectPropertyRequest) {
- int thingType = unitProperties.getUnitType();
- String thingName = unitProperties.getName();
- String thingID = Integer.toString(unitProperties.getNumber());
- ThingUID thingUID = null;
+ for (ZoneProperties zoneProperties : objectPropertyRequest) {
+ if (zoneProperties.getZoneType() <= SENSOR_TYPE_PROGRAMMABLE_ENERGY_SAVER_MODULE) {
+ String thingName = zoneProperties.getName();
+ String thingID = Integer.toString(zoneProperties.getNumber());
Map<String, Object> properties = new HashMap<>();
properties.put(THING_PROPERTIES_NAME, thingName);
properties.put(THING_PROPERTIES_AREA, areaProperties.getNumber());
- switch (thingType) {
- case UNIT_TYPE_HLC_ROOM:
- case UNIT_TYPE_VIZIARF_ROOM:
- thingUID = new ThingUID(THING_TYPE_ROOM, bridgeUID, thingID);
- break;
- case UNIT_TYPE_FLAG:
- thingUID = new ThingUID(THING_TYPE_FLAG, bridgeUID, thingID);
- break;
- case UNIT_TYPE_OUTPUT:
- thingUID = new ThingUID(THING_TYPE_OUTPUT, bridgeUID, thingID);
- break;
- case UNIT_TYPE_UPB:
- case UNIT_TYPE_HLC_LOAD:
- thingUID = new ThingUID(THING_TYPE_UNIT_UPB, bridgeUID, thingID);
- break;
- case UNIT_TYPE_CENTRALITE:
- case UNIT_TYPE_RADIORA:
- case UNIT_TYPE_VIZIARF_LOAD:
- case UNIT_TYPE_COMPOSE:
- thingUID = new ThingUID(THING_TYPE_DIMMABLE, bridgeUID, thingID);
- break;
- default:
- thingUID = new ThingUID(THING_TYPE_UNIT, bridgeUID, thingID);
- logger.debug("Generic unit type: {}", thingType);
- break;
- }
+ ThingUID thingUID = new ThingUID(THING_TYPE_ZONE, bridgeUID, thingID);
DiscoveryResult discoveryResult = DiscoveryResultBuilder.create(thingUID)
.withProperties(properties).withProperty(THING_PROPERTIES_NUMBER, thingID)
}
}
}
-
- /**
- * Generates zone items
- */
- private void discoverZones() {
- final OmnilinkBridgeHandler handler = bridgeHandler;
- if (handler != null) {
- final ThingUID bridgeUID = handler.getThing().getUID();
- final List<AreaProperties> areas = this.areas;
-
- if (areas != null) {
- for (AreaProperties areaProperties : areas) {
- int areaFilter = bitFilterForArea(areaProperties);
-
- ObjectPropertyRequest<ZoneProperties> objectPropertyRequest = ObjectPropertyRequest
- .builder(handler, ObjectPropertyRequests.ZONE, 0, 1).selectNamed().areaFilter(areaFilter)
- .build();
-
- for (ZoneProperties zoneProperties : objectPropertyRequest) {
- if (zoneProperties.getZoneType() <= SENSOR_TYPE_PROGRAMMABLE_ENERGY_SAVER_MODULE) {
- String thingName = zoneProperties.getName();
- String thingID = Integer.toString(zoneProperties.getNumber());
-
- Map<String, Object> properties = new HashMap<>();
- properties.put(THING_PROPERTIES_NAME, thingName);
- properties.put(THING_PROPERTIES_AREA, areaProperties.getNumber());
-
- ThingUID thingUID = new ThingUID(THING_TYPE_ZONE, bridgeUID, thingID);
-
- DiscoveryResult discoveryResult = DiscoveryResultBuilder.create(thingUID)
- .withProperties(properties).withProperty(THING_PROPERTIES_NUMBER, thingID)
- .withRepresentationProperty(THING_PROPERTIES_NUMBER).withBridge(bridgeUID)
- .withLabel(thingName).build();
- thingDiscovered(discoveryResult);
- }
- }
- }
- }
- }
- }
}
import java.util.Set;
import org.eclipse.jdt.annotation.NonNullByDefault;
-import org.eclipse.jdt.annotation.Nullable;
import org.openhab.binding.onewire.internal.OwException;
import org.openhab.binding.onewire.internal.SensorId;
import org.openhab.binding.onewire.internal.device.OwSensorType;
import org.openhab.binding.onewire.internal.handler.OwserverBridgeHandler;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResult;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
import org.openhab.core.thing.ThingTypeUID;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Jan N. Klug - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = OwDiscoveryService.class)
@NonNullByDefault
-public class OwDiscoveryService extends AbstractDiscoveryService implements ThingHandlerService {
+public class OwDiscoveryService extends AbstractThingHandlerDiscoveryService<OwserverBridgeHandler> {
private final Logger logger = LoggerFactory.getLogger(OwDiscoveryService.class);
- private @Nullable OwserverBridgeHandler bridgeHandler;
-
Map<SensorId, OwDiscoveryItem> owDiscoveryItems = new HashMap<>();
Set<SensorId> associatedSensors = new HashSet<>();
public OwDiscoveryService() {
- super(SUPPORTED_THING_TYPES, 60, false);
- logger.debug("registering discovery service for {}", bridgeHandler);
+ super(OwserverBridgeHandler.class, SUPPORTED_THING_TYPES, 60, false);
}
private void scanDirectory(OwserverBridgeHandler bridgeHandler, String baseDirectory) {
@Override
public void startScan() {
- OwserverBridgeHandler bridgeHandler = this.bridgeHandler;
- if (bridgeHandler == null) {
- logger.warn("bridgeHandler not found");
- return;
- }
+ ThingUID bridgeUID = thingHandler.getThing().getUID();
- ThingUID bridgeUID = bridgeHandler.getThing().getUID();
-
- scanDirectory(bridgeHandler, "/");
+ scanDirectory(thingHandler, "/");
// remove duplicates
owDiscoveryItems.entrySet().removeIf(s -> associatedSensors.contains(s.getKey()));
}
@Override
- public void setThingHandler(ThingHandler thingHandler) {
- if (thingHandler instanceof OwserverBridgeHandler serverBridgeHandler) {
- this.bridgeHandler = serverBridgeHandler;
- }
- }
-
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return bridgeHandler;
- }
-
- @Override
- public void deactivate() {
+ public void dispose() {
+ super.dispose();
removeOlderResults(new Date().getTime());
}
}
import org.openhab.core.thing.binding.ThingActions;
import org.openhab.core.thing.binding.ThingActionsScope;
import org.openhab.core.thing.binding.ThingHandler;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author David Masshardt - initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = OnkyoThingActions.class)
@ThingActionsScope(name = "onkyo")
@NonNullByDefault
public class OnkyoThingActions implements ThingActions {
import org.eclipse.jdt.annotation.Nullable;
import org.openhab.binding.openuv.internal.handler.OpenUVBridgeHandler;
import org.openhab.binding.openuv.internal.handler.OpenUVReportHandler;
-import org.openhab.core.i18n.LocaleProvider;
-import org.openhab.core.i18n.LocationProvider;
import org.openhab.core.i18n.TimeZoneProvider;
-import org.openhab.core.i18n.TranslationProvider;
import org.openhab.core.thing.Bridge;
import org.openhab.core.thing.Thing;
import org.openhab.core.thing.ThingTypeUID;
@NonNullByDefault
@Component(service = ThingHandlerFactory.class, configurationPid = "binding.openuv")
public class OpenUVHandlerFactory extends BaseThingHandlerFactory {
-
- private final LocationProvider locationProvider;
- private final TranslationProvider i18nProvider;
- private final LocaleProvider localeProvider;
private final Gson gson;
@Activate
- public OpenUVHandlerFactory(@Reference TimeZoneProvider timeZoneProvider,
- @Reference LocationProvider locationProvider, @Reference TranslationProvider i18nProvider,
- @Reference LocaleProvider localeProvider) {
- this.locationProvider = locationProvider;
- this.i18nProvider = i18nProvider;
- this.localeProvider = localeProvider;
+ public OpenUVHandlerFactory(@Reference TimeZoneProvider timeZoneProvider) {
this.gson = new GsonBuilder()
.registerTypeAdapter(ZonedDateTime.class,
(JsonDeserializer<ZonedDateTime>) (json, type, jsonDeserializationContext) -> ZonedDateTime
protected @Nullable ThingHandler createHandler(Thing thing) {
ThingTypeUID thingTypeUID = thing.getThingTypeUID();
- return APIBRIDGE_THING_TYPE.equals(thingTypeUID)
- ? new OpenUVBridgeHandler((Bridge) thing, locationProvider, i18nProvider, localeProvider, gson)
+ return APIBRIDGE_THING_TYPE.equals(thingTypeUID) ? new OpenUVBridgeHandler((Bridge) thing, gson)
: LOCATION_REPORT_THING_TYPE.equals(thingTypeUID) ? new OpenUVReportHandler(thing) : null;
}
}
import static org.openhab.binding.openuv.internal.config.ReportConfiguration.LOCATION;
import org.eclipse.jdt.annotation.NonNullByDefault;
-import org.eclipse.jdt.annotation.Nullable;
import org.openhab.binding.openuv.internal.handler.OpenUVBridgeHandler;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
+import org.openhab.core.i18n.LocaleProvider;
+import org.openhab.core.i18n.LocationProvider;
+import org.openhab.core.i18n.TranslationProvider;
import org.openhab.core.library.types.PointType;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.Reference;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Gaël L'hopital - Initial Contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = OpenUVDiscoveryService.class)
@NonNullByDefault
-public class OpenUVDiscoveryService extends AbstractDiscoveryService implements ThingHandlerService {
+public class OpenUVDiscoveryService extends AbstractThingHandlerDiscoveryService<OpenUVBridgeHandler> {
private static final int DISCOVER_TIMEOUT_SECONDS = 2;
+ private @NonNullByDefault({}) LocationProvider locationProvider;
private final Logger logger = LoggerFactory.getLogger(OpenUVDiscoveryService.class);
- private @Nullable OpenUVBridgeHandler bridgeHandler;
-
public OpenUVDiscoveryService() {
- super(SUPPORTED_THING_TYPES_UIDS, DISCOVER_TIMEOUT_SECONDS);
+ super(OpenUVBridgeHandler.class, SUPPORTED_THING_TYPES_UIDS, DISCOVER_TIMEOUT_SECONDS);
}
- @Override
- public void setThingHandler(ThingHandler handler) {
- if (handler instanceof OpenUVBridgeHandler bridgeHandler) {
- this.bridgeHandler = bridgeHandler;
- this.i18nProvider = bridgeHandler.getI18nProvider();
- this.localeProvider = bridgeHandler.getLocaleProvider();
- }
+ @Reference(unbind = "-")
+ public void bindTranslationProvider(TranslationProvider translationProvider) {
+ this.i18nProvider = translationProvider;
}
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return bridgeHandler;
+ @Reference(unbind = "-")
+ public void bindLocaleProvider(LocaleProvider localeProvider) {
+ this.localeProvider = localeProvider;
}
- @Override
- public void deactivate() {
- super.deactivate();
+ @Reference(unbind = "-")
+ public void bindLocationProvider(LocationProvider locationProvider) {
+ this.locationProvider = locationProvider;
}
@Override
protected void startScan() {
logger.debug("Starting OpenUV discovery scan");
- OpenUVBridgeHandler bridge = bridgeHandler;
- if (bridge != null) {
- PointType location = bridge.getLocation();
- if (location != null) {
- ThingUID bridgeUID = bridge.getThing().getUID();
- thingDiscovered(
- DiscoveryResultBuilder.create(new ThingUID(LOCATION_REPORT_THING_TYPE, bridgeUID, LOCAL))
- .withLabel("@text/discovery.openuv.uvreport.local.label")
- .withProperty(LOCATION, location.toString()).withRepresentationProperty(LOCATION)
- .withBridge(bridgeUID).build());
- } else {
- logger.debug("LocationProvider.getLocation() is not set -> Will not provide any discovery results");
- }
+ PointType location = locationProvider.getLocation();
+ if (location != null) {
+ ThingUID bridgeUID = thingHandler.getThing().getUID();
+ thingDiscovered(DiscoveryResultBuilder.create(new ThingUID(LOCATION_REPORT_THING_TYPE, bridgeUID, LOCAL))
+ .withLabel("@text/discovery.openuv.uvreport.local.label")
+ .withProperty(LOCATION, location.toString()).withRepresentationProperty(LOCATION)
+ .withBridge(bridgeUID).build());
} else {
- logger.debug("OpenUV Bridge Handler is not set -> Will not provide any discovery results");
+ logger.debug("LocationProvider.getLocation() is not set -> Will not provide any discovery results");
}
}
}
import org.openhab.binding.openuv.internal.discovery.OpenUVDiscoveryService;
import org.openhab.binding.openuv.internal.json.OpenUVResponse;
import org.openhab.binding.openuv.internal.json.OpenUVResult;
-import org.openhab.core.i18n.LocaleProvider;
-import org.openhab.core.i18n.LocationProvider;
-import org.openhab.core.i18n.TranslationProvider;
import org.openhab.core.io.net.http.HttpUtil;
-import org.openhab.core.library.types.PointType;
import org.openhab.core.thing.Bridge;
import org.openhab.core.thing.ChannelUID;
import org.openhab.core.thing.ThingStatus;
private final Logger logger = LoggerFactory.getLogger(OpenUVBridgeHandler.class);
private final Properties header = new Properties();
private final Gson gson;
- private final LocationProvider locationProvider;
- private final TranslationProvider i18nProvider;
- private final LocaleProvider localeProvider;
private Optional<ScheduledFuture<?>> reconnectJob = Optional.empty();
private boolean keyVerified;
- public OpenUVBridgeHandler(Bridge bridge, LocationProvider locationProvider, TranslationProvider i18nProvider,
- LocaleProvider localeProvider, Gson gson) {
+ public OpenUVBridgeHandler(Bridge bridge, Gson gson) {
super(bridge);
this.gson = gson;
- this.locationProvider = locationProvider;
- this.i18nProvider = i18nProvider;
- this.localeProvider = localeProvider;
}
@Override
public Collection<Class<? extends ThingHandlerService>> getServices() {
return Set.of(OpenUVDiscoveryService.class);
}
-
- public @Nullable PointType getLocation() {
- return locationProvider.getLocation();
- }
-
- public TranslationProvider getI18nProvider() {
- return i18nProvider;
- }
-
- public LocaleProvider getLocaleProvider() {
- return localeProvider;
- }
}
import org.openwebnet4j.communication.OWNException;
import org.openwebnet4j.communication.Response;
import org.openwebnet4j.message.CEN;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
* @author Massimo Valla - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = OpenWebNetCENActions.class)
@ThingActionsScope(name = "openwebnet")
@NonNullByDefault
public class OpenWebNetCENActions implements ThingActions {
import org.eclipse.jdt.annotation.Nullable;
import org.openhab.binding.openwebnet.internal.OpenWebNetBindingConstants;
import org.openhab.binding.openwebnet.internal.handler.OpenWebNetBridgeHandler;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResult;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
-import org.openhab.core.config.discovery.DiscoveryService;
import org.openhab.core.thing.ThingTypeUID;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
import org.openwebnet4j.OpenDeviceType;
import org.openwebnet4j.message.BaseOpenMessage;
import org.openwebnet4j.message.Where;
import org.openwebnet4j.message.WhereThermo;
import org.openwebnet4j.message.WhereZigBee;
import org.openwebnet4j.message.Who;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
* @author Gilberto Cocchi - Thermoregulation
* @author Giovanni Fabiani - Aux support
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = OpenWebNetDeviceDiscoveryService.class)
@NonNullByDefault
-public class OpenWebNetDeviceDiscoveryService extends AbstractDiscoveryService
- implements DiscoveryService, ThingHandlerService {
-
+public class OpenWebNetDeviceDiscoveryService extends AbstractThingHandlerDiscoveryService<OpenWebNetBridgeHandler> {
private final Logger logger = LoggerFactory.getLogger(OpenWebNetDeviceDiscoveryService.class);
private static final Set<ThingTypeUID> SUPPORTED_THING_TYPES = OpenWebNetBindingConstants.DEVICE_SUPPORTED_THING_TYPES;
private static final int SEARCH_TIME_SEC = 60;
- private @NonNullByDefault({}) OpenWebNetBridgeHandler bridgeHandler;
private @NonNullByDefault({}) ThingUID bridgeUID;
private boolean cuFound = false;
public OpenWebNetDeviceDiscoveryService() {
- super(SUPPORTED_THING_TYPES, SEARCH_TIME_SEC);
+ super(OpenWebNetBridgeHandler.class, SUPPORTED_THING_TYPES, SEARCH_TIME_SEC);
}
@Override
@Override
protected void startScan() {
- logger.info("------ SEARCHING for DEVICES on bridge '{}' ({}) ...", bridgeHandler.getThing().getLabel(),
+ logger.info("------ SEARCHING for DEVICES on bridge '{}' ({}) ...", thingHandler.getThing().getLabel(),
bridgeUID);
cuFound = false;
- bridgeHandler.searchDevices();
+ thingHandler.searchDevices();
}
@Override
protected void stopScan() {
logger.debug("------ stopScan() on bridge '{}'", bridgeUID);
- bridgeHandler.scanStopped();
+ thingHandler.scanStopped();
}
@Override
public void abortScan() {
logger.debug("------ abortScan() on bridge '{}'", bridgeUID);
- bridgeHandler.scanStopped();
+ thingHandler.scanStopped();
}
/**
return;
}
- String ownId = bridgeHandler.ownIdFromWhoWhere(deviceWho, w);
+ String ownId = thingHandler.ownIdFromWhoWhere(deviceWho, w);
if (OpenWebNetBindingConstants.THING_TYPE_BUS_ON_OFF_SWITCH.equals(thingTypeUID)) {
- if (bridgeHandler.getRegisteredDevice(ownId) != null) {
+ if (thingHandler.getRegisteredDevice(ownId) != null) {
logger.debug("dimmer/switch with WHERE={} already registered, skipping this discovery result", w);
return;
}
}
- String tId = bridgeHandler.thingIdFromWhere(w);
+ String tId = thingHandler.thingIdFromWhere(w);
ThingUID thingUID = new ThingUID(thingTypeUID, bridgeUID, tId);
DiscoveryResult discoveryResult = null;
}
@Override
- public void deactivate() {
- super.deactivate();
- }
-
- @Override
- public void setThingHandler(@Nullable ThingHandler handler) {
- if (handler instanceof OpenWebNetBridgeHandler openWebNetBridgeHandler) {
- logger.debug("attaching {} to handler {} ", this, handler);
- bridgeHandler = openWebNetBridgeHandler;
- bridgeHandler.deviceDiscoveryService = this;
- bridgeUID = bridgeHandler.getThing().getUID();
- }
- }
-
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return bridgeHandler;
+ public void initialize() {
+ thingHandler.deviceDiscoveryService = this;
+ bridgeUID = thingHandler.getThing().getUID();
+ super.initialize();
}
}
import org.eclipse.jdt.annotation.Nullable;
import org.openhab.binding.orbitbhyve.internal.handler.OrbitBhyveBridgeHandler;
import org.openhab.binding.orbitbhyve.internal.model.OrbitBhyveDevice;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
-import org.openhab.core.config.discovery.DiscoveryService;
import org.openhab.core.thing.Thing;
import org.openhab.core.thing.ThingStatus;
import org.openhab.core.thing.ThingTypeUID;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Ondrej Pecta - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = OrbitBhyveDiscoveryService.class)
@NonNullByDefault
-public class OrbitBhyveDiscoveryService extends AbstractDiscoveryService
- implements DiscoveryService, ThingHandlerService {
-
+public class OrbitBhyveDiscoveryService extends AbstractThingHandlerDiscoveryService<OrbitBhyveBridgeHandler> {
private final Logger logger = LoggerFactory.getLogger(OrbitBhyveDiscoveryService.class);
- private @Nullable OrbitBhyveBridgeHandler bridgeHandler;
-
private @Nullable ScheduledFuture<?> discoveryJob;
private static final int DISCOVERY_TIMEOUT_SEC = 10;
private static final int DISCOVERY_REFRESH_SEC = 1800;
public OrbitBhyveDiscoveryService() {
- super(DISCOVERY_TIMEOUT_SEC);
+ super(OrbitBhyveBridgeHandler.class, DISCOVERY_TIMEOUT_SEC);
logger.debug("Creating discovery service");
}
runDiscovery();
}
- @Override
- public void activate() {
- super.activate(null);
- }
-
- @Override
- public void deactivate() {
- super.deactivate();
- }
-
- @Override
- public void setThingHandler(@Nullable ThingHandler thingHandler) {
- if (thingHandler instanceof OrbitBhyveBridgeHandler bridgeHandler) {
- this.bridgeHandler = bridgeHandler;
- }
- }
-
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return bridgeHandler;
- }
-
@Override
protected void startBackgroundDiscovery() {
logger.debug("Starting Orbit B-Hyve background discovery");
}
private synchronized void runDiscovery() {
- OrbitBhyveBridgeHandler localBridgeHandler = bridgeHandler;
- if (localBridgeHandler != null && ThingStatus.ONLINE == localBridgeHandler.getThing().getStatus()) {
- List<OrbitBhyveDevice> devices = localBridgeHandler.getDevices();
+ if (ThingStatus.ONLINE == thingHandler.getThing().getStatus()) {
+ List<OrbitBhyveDevice> devices = thingHandler.getDevices();
logger.debug("Discovered total of {} devices", devices.size());
for (OrbitBhyveDevice device : devices) {
sprinklerDiscovered(device);
}
private void sprinklerDiscovered(OrbitBhyveDevice device) {
- OrbitBhyveBridgeHandler localBridgeHandler = bridgeHandler;
- if (localBridgeHandler != null) {
- Map<String, Object> properties = new HashMap<>();
- properties.put("id", device.getId());
- properties.put(Thing.PROPERTY_FIRMWARE_VERSION, device.getFwVersion());
- properties.put(Thing.PROPERTY_HARDWARE_VERSION, device.getHwVersion());
- properties.put(Thing.PROPERTY_MAC_ADDRESS, device.getMacAddress());
- properties.put(Thing.PROPERTY_MODEL_ID, device.getType());
- properties.put("Zones", device.getNumStations());
- properties.put("Active zones", device.getZones().size());
-
- ThingUID thingUID = new ThingUID(THING_TYPE_SPRINKLER, localBridgeHandler.getThing().getUID(),
- device.getId());
-
- logger.debug("Detected a/an {} - label: {} id: {}", THING_TYPE_SPRINKLER.getId(), device.getName(),
- device.getId());
- thingDiscovered(DiscoveryResultBuilder.create(thingUID).withThingType(THING_TYPE_SPRINKLER)
- .withProperties(properties).withRepresentationProperty("id").withLabel(device.getName())
- .withBridge(localBridgeHandler.getThing().getUID()).build());
- }
+ Map<String, Object> properties = new HashMap<>();
+ properties.put("id", device.getId());
+ properties.put(Thing.PROPERTY_FIRMWARE_VERSION, device.getFwVersion());
+ properties.put(Thing.PROPERTY_HARDWARE_VERSION, device.getHwVersion());
+ properties.put(Thing.PROPERTY_MAC_ADDRESS, device.getMacAddress());
+ properties.put(Thing.PROPERTY_MODEL_ID, device.getType());
+ properties.put("Zones", device.getNumStations());
+ properties.put("Active zones", device.getZones().size());
+
+ ThingUID thingUID = new ThingUID(THING_TYPE_SPRINKLER, thingHandler.getThing().getUID(), device.getId());
+
+ logger.debug("Detected a/an {} - label: {} id: {}", THING_TYPE_SPRINKLER.getId(), device.getName(),
+ device.getId());
+ thingDiscovered(DiscoveryResultBuilder.create(thingUID).withThingType(THING_TYPE_SPRINKLER)
+ .withProperties(properties).withRepresentationProperty("id").withLabel(device.getName())
+ .withBridge(thingHandler.getThing().getUID()).build());
}
@Override
import org.openhab.binding.pilight.internal.dto.DeviceType;
import org.openhab.binding.pilight.internal.dto.Status;
import org.openhab.binding.pilight.internal.handler.PilightBridgeHandler;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResult;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
import org.openhab.core.config.discovery.DiscoveryService;
import org.openhab.core.thing.ThingTypeUID;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Niklas Dörfler - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = PilightDeviceDiscoveryService.class)
@NonNullByDefault
-public class PilightDeviceDiscoveryService extends AbstractDiscoveryService implements ThingHandlerService {
-
+public class PilightDeviceDiscoveryService extends AbstractThingHandlerDiscoveryService<PilightBridgeHandler> {
private static final Set<ThingTypeUID> SUPPORTED_THING_TYPES_UIDS = PilightHandlerFactory.SUPPORTED_THING_TYPES_UIDS;
private static final int AUTODISCOVERY_SEARCH_TIME_SEC = 10;
private final Logger logger = LoggerFactory.getLogger(PilightDeviceDiscoveryService.class);
- private @Nullable PilightBridgeHandler pilightBridgeHandler;
- private @Nullable ThingUID bridgeUID;
+ private @NonNullByDefault({}) ThingUID bridgeUID;
private @Nullable ScheduledFuture<?> backgroundDiscoveryJob;
private CompletableFuture<Config> configFuture;
private CompletableFuture<List<Status>> statusFuture;
public PilightDeviceDiscoveryService() {
- super(SUPPORTED_THING_TYPES_UIDS, AUTODISCOVERY_SEARCH_TIME_SEC);
+ super(PilightBridgeHandler.class, SUPPORTED_THING_TYPES_UIDS, AUTODISCOVERY_SEARCH_TIME_SEC);
configFuture = new CompletableFuture<>();
statusFuture = new CompletableFuture<>();
}
@Override
protected void startScan() {
- if (pilightBridgeHandler != null) {
- configFuture = new CompletableFuture<>();
- statusFuture = new CompletableFuture<>();
-
- configFuture.thenAcceptBoth(statusFuture, (config, allStatus) -> {
- removeOlderResults(getTimestampOfLastScan(), bridgeUID);
- config.getDevices().forEach((deviceId, device) -> {
- if (this.pilightBridgeHandler != null) {
- final Optional<Status> status = allStatus.stream()
- .filter(s -> s.getDevices().contains(deviceId)).findFirst();
-
- final ThingTypeUID thingTypeUID;
- final String typeString;
-
- if (status.isPresent()) {
- if (status.get().getType().equals(DeviceType.SWITCH)) {
- thingTypeUID = new ThingTypeUID(BINDING_ID, THING_TYPE_SWITCH.getId());
- typeString = "Switch";
- } else if (status.get().getType().equals(DeviceType.DIMMER)) {
- thingTypeUID = new ThingTypeUID(BINDING_ID, THING_TYPE_DIMMER.getId());
- typeString = "Dimmer";
- } else if (status.get().getType().equals(DeviceType.VALUE)) {
- thingTypeUID = new ThingTypeUID(BINDING_ID, THING_TYPE_GENERIC.getId());
- typeString = "Generic";
- } else if (status.get().getType().equals(DeviceType.CONTACT)) {
- thingTypeUID = new ThingTypeUID(BINDING_ID, THING_TYPE_CONTACT.getId());
- typeString = "Contact";
- } else {
- thingTypeUID = new ThingTypeUID(BINDING_ID, THING_TYPE_GENERIC.getId());
- typeString = "Generic";
- }
- } else {
- thingTypeUID = new ThingTypeUID(BINDING_ID, THING_TYPE_GENERIC.getId());
- typeString = "Generic";
- }
-
- final @Nullable PilightBridgeHandler pilightBridgeHandler = this.pilightBridgeHandler;
- if (pilightBridgeHandler != null) {
- final ThingUID thingUID = new ThingUID(thingTypeUID,
- pilightBridgeHandler.getThing().getUID(), deviceId);
-
- final Map<String, Object> properties = new HashMap<>();
- properties.put(PROPERTY_NAME, deviceId);
-
- DiscoveryResult discoveryResult = DiscoveryResultBuilder.create(thingUID)
- .withThingType(thingTypeUID).withProperties(properties).withBridge(bridgeUID)
- .withRepresentationProperty(PROPERTY_NAME)
- .withLabel("Pilight " + typeString + " Device '" + deviceId + "'").build();
-
- thingDiscovered(discoveryResult);
- }
+ configFuture = new CompletableFuture<>();
+ statusFuture = new CompletableFuture<>();
+
+ configFuture.thenAcceptBoth(statusFuture, (config, allStatus) -> {
+ removeOlderResults(getTimestampOfLastScan(), bridgeUID);
+ config.getDevices().forEach((deviceId, device) -> {
+ final Optional<Status> status = allStatus.stream().filter(s -> s.getDevices().contains(deviceId))
+ .findFirst();
+
+ final ThingTypeUID thingTypeUID;
+ final String typeString;
+
+ if (status.isPresent()) {
+ if (status.get().getType().equals(DeviceType.SWITCH)) {
+ thingTypeUID = new ThingTypeUID(BINDING_ID, THING_TYPE_SWITCH.getId());
+ typeString = "Switch";
+ } else if (status.get().getType().equals(DeviceType.DIMMER)) {
+ thingTypeUID = new ThingTypeUID(BINDING_ID, THING_TYPE_DIMMER.getId());
+ typeString = "Dimmer";
+ } else if (status.get().getType().equals(DeviceType.VALUE)) {
+ thingTypeUID = new ThingTypeUID(BINDING_ID, THING_TYPE_GENERIC.getId());
+ typeString = "Generic";
+ } else if (status.get().getType().equals(DeviceType.CONTACT)) {
+ thingTypeUID = new ThingTypeUID(BINDING_ID, THING_TYPE_CONTACT.getId());
+ typeString = "Contact";
+ } else {
+ thingTypeUID = new ThingTypeUID(BINDING_ID, THING_TYPE_GENERIC.getId());
+ typeString = "Generic";
}
- });
+ } else {
+ thingTypeUID = new ThingTypeUID(BINDING_ID, THING_TYPE_GENERIC.getId());
+ typeString = "Generic";
+ }
+
+ final ThingUID thingUID = new ThingUID(thingTypeUID, thingHandler.getThing().getUID(), deviceId);
+
+ final Map<String, Object> properties = new HashMap<>();
+ properties.put(PROPERTY_NAME, deviceId);
+
+ DiscoveryResult discoveryResult = DiscoveryResultBuilder.create(thingUID).withThingType(thingTypeUID)
+ .withProperties(properties).withBridge(bridgeUID).withRepresentationProperty(PROPERTY_NAME)
+ .withLabel("Pilight " + typeString + " Device '" + deviceId + "'").build();
+
+ thingDiscovered(discoveryResult);
});
+ });
- final @Nullable PilightBridgeHandler pilightBridgeHandler = this.pilightBridgeHandler;
- if (pilightBridgeHandler != null) {
- pilightBridgeHandler.refreshConfigAndStatus();
- }
- }
+ thingHandler.refreshConfigAndStatus();
}
@Override
super.stopScan();
configFuture.cancel(true);
statusFuture.cancel(true);
- if (bridgeUID != null) {
- removeOlderResults(getTimestampOfLastScan(), bridgeUID);
- }
+ removeOlderResults(getTimestampOfLastScan(), bridgeUID);
}
@Override
}
@Override
- public void setThingHandler(final ThingHandler handler) {
- if (handler instanceof PilightBridgeHandler pilightBridgeHandler) {
- this.pilightBridgeHandler = pilightBridgeHandler;
- bridgeUID = pilightBridgeHandler.getThing().getUID();
- }
- }
-
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return pilightBridgeHandler;
- }
-
- @Override
- public void activate() {
- final @Nullable PilightBridgeHandler pilightBridgeHandler = this.pilightBridgeHandler;
+ public void initialize() {
+ bridgeUID = thingHandler.getThing().getUID();
boolean discoveryEnabled = false;
- if (pilightBridgeHandler != null) {
- removeOlderResults(new Date().getTime(), pilightBridgeHandler.getThing().getUID());
- discoveryEnabled = pilightBridgeHandler.isBackgroundDiscoveryEnabled();
- pilightBridgeHandler.registerDiscoveryListener(this);
- }
- super.activate(Map.of(DiscoveryService.CONFIG_PROPERTY_BACKGROUND_DISCOVERY, discoveryEnabled));
+ removeOlderResults(new Date().getTime(), thingHandler.getThing().getUID());
+ discoveryEnabled = thingHandler.isBackgroundDiscoveryEnabled();
+ thingHandler.registerDiscoveryListener(this);
+
+ super.initialize();
+ super.modified(Map.of(DiscoveryService.CONFIG_PROPERTY_BACKGROUND_DISCOVERY, discoveryEnabled));
}
@Override
- public void deactivate() {
- if (bridgeUID != null) {
- removeOlderResults(getTimestampOfLastScan(), bridgeUID);
- }
-
- final @Nullable PilightBridgeHandler pilightBridgeHandler = this.pilightBridgeHandler;
- if (pilightBridgeHandler != null) {
- pilightBridgeHandler.unregisterDiscoveryListener();
- }
-
- super.deactivate();
+ public void dispose() {
+ super.dispose();
+ removeOlderResults(getTimestampOfLastScan(), bridgeUID);
+ thingHandler.unregisterDiscoveryListener();
}
/**
import org.openhab.binding.plugwise.internal.protocol.RoleCallResponseMessage;
import org.openhab.binding.plugwise.internal.protocol.field.DeviceType;
import org.openhab.binding.plugwise.internal.protocol.field.MACAddress;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
import org.openhab.core.thing.Thing;
import org.openhab.core.thing.ThingStatus;
import org.openhab.core.thing.ThingTypeUID;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Wouter Born, Karel Goderis - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = PlugwiseThingDiscoveryService.class)
@NonNullByDefault
-public class PlugwiseThingDiscoveryService extends AbstractDiscoveryService
- implements PlugwiseMessageListener, PlugwiseStickStatusListener, ThingHandlerService {
+public class PlugwiseThingDiscoveryService extends AbstractThingHandlerDiscoveryService<PlugwiseStickHandler>
+ implements PlugwiseMessageListener, PlugwiseStickStatusListener {
private static class CurrentRoleCall {
private boolean isRoleCalling;
private final Logger logger = LoggerFactory.getLogger(PlugwiseThingDiscoveryService.class);
- private @NonNullByDefault({}) PlugwiseStickHandler stickHandler;
-
private @Nullable ScheduledFuture<?> discoveryJob;
private @Nullable ScheduledFuture<?> watchJob;
private CurrentRoleCall currentRoleCall = new CurrentRoleCall();
private final Map<MACAddress, DiscoveredNode> discoveredNodes = new ConcurrentHashMap<>();
public PlugwiseThingDiscoveryService() throws IllegalArgumentException {
- super(DISCOVERED_THING_TYPES_UIDS, 1, true);
+ super(PlugwiseStickHandler.class, DISCOVERED_THING_TYPES_UIDS, 1, true);
}
@Override
stopDiscoveryWatchJob();
}
- @Override
- public void activate() {
- super.activate(new HashMap<>());
- }
-
private void createDiscoveryResult(DiscoveredNode node) {
String mac = node.macAddress.toString();
- ThingUID bridgeUID = stickHandler.getThing().getUID();
+ ThingUID bridgeUID = thingHandler.getThing().getUID();
ThingTypeUID thingTypeUID = PlugwiseUtils.getThingTypeUID(node.deviceType);
if (thingTypeUID != null) {
ThingUID thingUID = new ThingUID(thingTypeUID, bridgeUID, mac);
}
@Override
- public void deactivate() {
- super.deactivate();
- stickHandler.removeMessageListener(this);
- stickHandler.removeStickStatusListener(this);
+ public void dispose() {
+ super.dispose();
+ thingHandler.removeMessageListener(this);
+ thingHandler.removeStickStatusListener(this);
}
private void discoverNewNodeDetails(MACAddress macAddress) {
} else if (currentRoleCall.isRoleCalling) {
logger.debug("Discovery with role call not possible (already role calling)");
} else {
- stickHandler.addMessageListener(this);
+ thingHandler.addMessageListener(this);
discoveredNodes.clear();
currentRoleCall.isRoleCalling = true;
currentRoleCall.currentNodeID = Integer.MIN_VALUE;
}
private @Nullable MACAddress getCirclePlusMAC() {
- return stickHandler.getCirclePlusMAC();
+ return thingHandler.getCirclePlusMAC();
}
private ThingStatus getStickStatus() {
- return stickHandler.getThing().getStatus();
- }
-
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return stickHandler;
+ return thingHandler.getThing().getStatus();
}
private void handleAnnounceAwakeRequest(AnnounceAwakeRequestMessage message) {
}
private boolean isAlreadyDiscovered(MACAddress macAddress) {
- Thing thing = stickHandler.getThingByMAC(macAddress);
+ Thing thing = thingHandler.getThingByMAC(macAddress);
if (thing != null) {
logger.debug("Node ({}) has existing thing: {}", macAddress, thing.getUID());
}
}
private void sendMessage(Message message) {
- stickHandler.sendMessage(message, PlugwiseMessagePriority.UPDATE_AND_DISCOVERY);
+ thingHandler.sendMessage(message, PlugwiseMessagePriority.UPDATE_AND_DISCOVERY);
}
@Override
- public void setThingHandler(ThingHandler handler) {
- if (handler instanceof PlugwiseStickHandler plugwiseStickHandler) {
- stickHandler = plugwiseStickHandler;
- stickHandler.addStickStatusListener(this);
- }
+ public void initialize() {
+ thingHandler.addStickStatusListener(this);
+ super.initialize();
}
@Override
import org.openhab.binding.plugwiseha.internal.api.model.dto.DomainObjects;
import org.openhab.binding.plugwiseha.internal.api.model.dto.Location;
import org.openhab.binding.plugwiseha.internal.handler.PlugwiseHABridgeHandler;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResult;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
* @author Bas van Wetten - Initial contribution
* @author Leo Siepel - finish initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = PlugwiseHADiscoveryService.class)
@NonNullByDefault
-public class PlugwiseHADiscoveryService extends AbstractDiscoveryService implements ThingHandlerService {
+public class PlugwiseHADiscoveryService extends AbstractThingHandlerDiscoveryService<PlugwiseHABridgeHandler> {
private final Logger logger = LoggerFactory.getLogger(PlugwiseHADiscoveryService.class);
private static final int TIMEOUT_SECONDS = 5;
private static final int REFRESH_SECONDS = 600;
- private @Nullable PlugwiseHABridgeHandler bridgeHandler;
private @Nullable ScheduledFuture<?> discoveryFuture;
public PlugwiseHADiscoveryService() {
- super(SUPPORTED_THING_TYPES_UIDS, TIMEOUT_SECONDS, true);
+ super(PlugwiseHABridgeHandler.class, SUPPORTED_THING_TYPES_UIDS, TIMEOUT_SECONDS, true);
}
@Override
if (localDiscoveryFuture != null) {
if (!localDiscoveryFuture.isCancelled()) {
localDiscoveryFuture.cancel(true);
- localDiscoveryFuture = null;
+ discoveryFuture = null;
}
}
}
- @Override
- public void deactivate() {
- super.deactivate();
- }
-
- @Override
- public void setThingHandler(@Nullable ThingHandler handler) {
- if (handler instanceof PlugwiseHABridgeHandler bridgeHandler) {
- this.bridgeHandler = bridgeHandler;
- }
- }
-
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return bridgeHandler;
- }
-
private void discoverDomainObjects() throws PlugwiseHAException {
- PlugwiseHAController controller = null;
- PlugwiseHABridgeHandler localBridgeHandler = this.bridgeHandler;
- if (localBridgeHandler != null) {
- controller = localBridgeHandler.getController();
- }
+ PlugwiseHAController controller = thingHandler.getController();
if (controller != null) {
DomainObjects domainObjects = controller.getDomainObjects();
String applianceName = appliance.getName();
String applianceType = appliance.getType();
- PlugwiseHABridgeHandler localBridgeHandler = this.bridgeHandler;
- if (localBridgeHandler != null) {
- ThingUID bridgeUID = localBridgeHandler.getThing().getUID();
-
- ThingUID uid;
-
- Map<String, Object> configProperties = new HashMap<>();
-
- configProperties.put(APPLIANCE_CONFIG_ID, applianceId);
-
- switch (applianceType) {
- case "thermostatic_radiator_valve":
- uid = new ThingUID(PlugwiseHABindingConstants.THING_TYPE_APPLIANCE_VALVE, bridgeUID, applianceId);
- configProperties.put(APPLIANCE_CONFIG_LOWBATTERY, 15);
- break;
- case "central_heating_pump":
- uid = new ThingUID(PlugwiseHABindingConstants.THING_TYPE_APPLIANCE_PUMP, bridgeUID, applianceId);
- break;
- case "heater_central":
- uid = new ThingUID(PlugwiseHABindingConstants.THING_TYPE_APPLIANCE_BOILER, bridgeUID, applianceId);
- break;
- case "zone_thermostat":
- uid = new ThingUID(PlugwiseHABindingConstants.THING_TYPE_APPLIANCE_THERMOSTAT, bridgeUID,
- applianceId);
- configProperties.put(APPLIANCE_CONFIG_LOWBATTERY, 15);
- break;
- default:
- return;
- }
+ ThingUID bridgeUID = thingHandler.getThing().getUID();
+
+ ThingUID uid;
+
+ Map<String, Object> configProperties = new HashMap<>();
+
+ configProperties.put(APPLIANCE_CONFIG_ID, applianceId);
+
+ switch (applianceType) {
+ case "thermostatic_radiator_valve":
+ uid = new ThingUID(PlugwiseHABindingConstants.THING_TYPE_APPLIANCE_VALVE, bridgeUID, applianceId);
+ configProperties.put(APPLIANCE_CONFIG_LOWBATTERY, 15);
+ break;
+ case "central_heating_pump":
+ uid = new ThingUID(PlugwiseHABindingConstants.THING_TYPE_APPLIANCE_PUMP, bridgeUID, applianceId);
+ break;
+ case "heater_central":
+ uid = new ThingUID(PlugwiseHABindingConstants.THING_TYPE_APPLIANCE_BOILER, bridgeUID, applianceId);
+ break;
+ case "zone_thermostat":
+ uid = new ThingUID(PlugwiseHABindingConstants.THING_TYPE_APPLIANCE_THERMOSTAT, bridgeUID, applianceId);
+ configProperties.put(APPLIANCE_CONFIG_LOWBATTERY, 15);
+ break;
+ default:
+ return;
+ }
- DiscoveryResult discoveryResult = DiscoveryResultBuilder.create(uid).withBridge(bridgeUID)
- .withLabel(applianceName).withProperties(configProperties)
- .withRepresentationProperty(APPLIANCE_CONFIG_ID).build();
+ DiscoveryResult discoveryResult = DiscoveryResultBuilder.create(uid).withBridge(bridgeUID)
+ .withLabel(applianceName).withProperties(configProperties)
+ .withRepresentationProperty(APPLIANCE_CONFIG_ID).build();
- thingDiscovered(discoveryResult);
+ thingDiscovered(discoveryResult);
- logger.debug("Discovered plugwise appliance type '{}' with name '{}' with id {} ({})", applianceType,
- applianceName, applianceId, uid);
- }
+ logger.debug("Discovered plugwise appliance type '{}' with name '{}' with id {} ({})", applianceType,
+ applianceName, applianceId, uid);
}
private void locationDiscovery(Location location) {
String locationId = location.getId();
String locationName = location.getName();
- PlugwiseHABridgeHandler localBridgeHandler = this.bridgeHandler;
- if (localBridgeHandler != null) {
- ThingUID bridgeUID = localBridgeHandler.getThing().getUID();
- ThingUID uid = new ThingUID(PlugwiseHABindingConstants.THING_TYPE_ZONE, bridgeUID, locationId);
+ ThingUID bridgeUID = thingHandler.getThing().getUID();
+ ThingUID uid = new ThingUID(PlugwiseHABindingConstants.THING_TYPE_ZONE, bridgeUID, locationId);
- Map<String, Object> configProperties = new HashMap<>();
+ Map<String, Object> configProperties = new HashMap<>();
- configProperties.put(ZONE_CONFIG_ID, locationId);
+ configProperties.put(ZONE_CONFIG_ID, locationId);
- DiscoveryResult discoveryResult = DiscoveryResultBuilder.create(uid).withBridge(bridgeUID)
- .withLabel(locationName).withRepresentationProperty(ZONE_CONFIG_ID).withProperties(configProperties)
- .build();
+ DiscoveryResult discoveryResult = DiscoveryResultBuilder.create(uid).withBridge(bridgeUID)
+ .withLabel(locationName).withRepresentationProperty(ZONE_CONFIG_ID).withProperties(configProperties)
+ .build();
- thingDiscovered(discoveryResult);
+ thingDiscovered(discoveryResult);
- logger.debug("Discovered plugwise zone '{}' with id {} ({})", locationName, locationId, uid);
- }
+ logger.debug("Discovered plugwise zone '{}' with id {} ({})", locationName, locationId, uid);
}
}
import org.openhab.binding.powermax.internal.state.PowermaxPanelSettingsListener;
import org.openhab.binding.powermax.internal.state.PowermaxX10Settings;
import org.openhab.binding.powermax.internal.state.PowermaxZoneSettings;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResult;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
import org.openhab.core.thing.Thing;
import org.openhab.core.thing.ThingUID;
import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
* @author Laurent Garnier - Initial contribution
* @author Laurent Garnier - Use ThingHandlerService
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = PowermaxDiscoveryService.class)
@NonNullByDefault
-public class PowermaxDiscoveryService extends AbstractDiscoveryService
- implements PowermaxPanelSettingsListener, ThingHandlerService {
+public class PowermaxDiscoveryService extends AbstractThingHandlerDiscoveryService<PowermaxBridgeHandler>
+ implements PowermaxPanelSettingsListener {
private static final int SEARCH_TIME = 5;
private final Logger logger = LoggerFactory.getLogger(PowermaxDiscoveryService.class);
- private @Nullable PowermaxBridgeHandler bridgeHandler;
-
/**
* Creates a PowermaxDiscoveryService with background discovery disabled.
*/
public PowermaxDiscoveryService() {
- super(PowermaxBindingConstants.SUPPORTED_THING_TYPES_UIDS, SEARCH_TIME, true);
- }
-
- @Override
- public void setThingHandler(ThingHandler handler) {
- if (handler instanceof PowermaxBridgeHandler powermaxBridgeHandler) {
- bridgeHandler = powermaxBridgeHandler;
- }
- }
-
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return bridgeHandler;
+ super(PowermaxBridgeHandler.class, PowermaxBindingConstants.SUPPORTED_THING_TYPES_UIDS, SEARCH_TIME, true);
}
/**
* Activates the Discovery Service.
*/
@Override
- public void activate() {
- super.activate(null);
- PowermaxBridgeHandler handler = bridgeHandler;
- if (handler != null) {
- handler.registerPanelSettingsListener(this);
- }
+ public void initialize() {
+ thingHandler.registerPanelSettingsListener(this);
+ super.initialize();
}
/**
* Deactivates the Discovery Service.
*/
@Override
- public void deactivate() {
- PowermaxBridgeHandler handler = bridgeHandler;
- if (handler != null) {
- handler.unregisterPanelSettingsListener(this);
- }
- super.deactivate();
+ public void dispose() {
+ super.dispose();
+ thingHandler.unregisterPanelSettingsListener(this);
}
@Override
protected void startScan() {
logger.debug("Updating discovered things (new scan)");
- PowermaxBridgeHandler handler = bridgeHandler;
- if (handler != null) {
- updateFromSettings(handler.getPanelSettings());
- }
+ updateFromSettings(thingHandler.getPanelSettings());
}
@Override
}
private void updateFromSettings(@Nullable PowermaxPanelSettings settings) {
- PowermaxBridgeHandler handler = bridgeHandler;
- if (handler != null && settings != null) {
+ if (settings != null) {
long beforeUpdate = new Date().getTime();
for (int i = 1; i <= settings.getNbZones(); i++) {
}
// Remove not updated discovered things
- removeOlderResults(beforeUpdate, handler.getThing().getUID());
+ removeOlderResults(beforeUpdate, thingHandler.getThing().getUID());
}
}
private void updateFromZoneSettings(int zoneNumber, @Nullable PowermaxZoneSettings zoneSettings) {
- PowermaxBridgeHandler handler = bridgeHandler;
- if (handler != null && zoneSettings != null) {
+ if (zoneSettings != null) {
// Prevent for adding already known zone
- for (Thing thing : handler.getThing().getThings()) {
+ for (Thing thing : thingHandler.getThing().getThings()) {
ThingHandler thingHandler = thing.getHandler();
if (thing.getThingTypeUID().equals(PowermaxBindingConstants.THING_TYPE_ZONE)
&& thingHandler instanceof PowermaxThingHandler powermaxThingHandler) {
}
}
- ThingUID bridgeUID = handler.getThing().getUID();
+ ThingUID bridgeUID = thingHandler.getThing().getUID();
ThingUID thingUID = new ThingUID(PowermaxBindingConstants.THING_TYPE_ZONE, bridgeUID,
String.valueOf(zoneNumber));
String sensorType = zoneSettings.getSensorType();
}
private void updateFromDeviceSettings(int deviceNumber, @Nullable PowermaxX10Settings deviceSettings) {
- PowermaxBridgeHandler handler = bridgeHandler;
- if (handler != null && deviceSettings != null && deviceSettings.isEnabled()) {
+ if (deviceSettings != null && deviceSettings.isEnabled()) {
// Prevent for adding already known X10 device
- for (Thing thing : handler.getThing().getThings()) {
+ for (Thing thing : thingHandler.getThing().getThings()) {
ThingHandler thingHandler = thing.getHandler();
if (thing.getThingTypeUID().equals(PowermaxBindingConstants.THING_TYPE_X10)
&& thingHandler instanceof PowermaxThingHandler powermaxThingHandler) {
}
}
- ThingUID bridgeUID = handler.getThing().getUID();
+ ThingUID bridgeUID = thingHandler.getThing().getUID();
ThingUID thingUID = new ThingUID(PowermaxBindingConstants.THING_TYPE_X10, bridgeUID,
String.valueOf(deviceNumber));
String name = (deviceSettings.getName() != null) ? deviceSettings.getName()
import org.openhab.core.thing.binding.ThingActions;
import org.openhab.core.thing.binding.ThingActionsScope;
import org.openhab.core.thing.binding.ThingHandler;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Ondrej Pecta - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = ProwlActions.class)
@ThingActionsScope(name = "prowl")
@NonNullByDefault
public class ProwlActions implements ThingActions {
import org.openhab.core.thing.binding.ThingActions;
import org.openhab.core.thing.binding.ThingActionsScope;
import org.openhab.core.thing.binding.ThingHandler;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Hakan Tandogan - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = PushbulletActions.class)
@ThingActionsScope(name = "pushbullet")
@NonNullByDefault
public class PushbulletActions implements ThingActions {
import org.openhab.core.thing.binding.ThingActions;
import org.openhab.core.thing.binding.ThingActionsScope;
import org.openhab.core.thing.binding.ThingHandler;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
* @author Christoph Weitkamp - Initial contribution
* @author Jacob Laursen - Added support for Expiring Messages
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = PushoverActions.class)
@ThingActionsScope(name = "pushover")
@NonNullByDefault
public class PushoverActions implements ThingActions {
import org.openhab.core.thing.binding.ThingHandler;
import org.openhab.core.thing.binding.ThingHandlerService;
import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
/**
* The {@link PushoverConfigOptionProvider} class contains fields mapping thing configuration parameters.
* @author Christoph Weitkamp - Initial contribution
*/
@NonNullByDefault
-@Component(service = ConfigOptionProvider.class)
+@Component(scope = ServiceScope.PROTOTYPE, service = { PushoverConfigOptionProvider.class, ConfigOptionProvider.class })
public class PushoverConfigOptionProvider implements ConfigOptionProvider, ThingHandlerService {
private @Nullable PushoverAccountHandler accountHandler;
import org.openhab.core.thing.binding.ThingActions;
import org.openhab.core.thing.binding.ThingActionsScope;
import org.openhab.core.thing.binding.ThingHandler;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Kevin Siml - Initial contribution, forked from Christoph Weitkamp
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = PushsaferActions.class)
@ThingActionsScope(name = "pushsafer")
@NonNullByDefault
public class PushsaferActions implements ThingActions {
import org.openhab.core.thing.binding.ThingHandler;
import org.openhab.core.thing.binding.ThingHandlerService;
import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
/**
* The {@link PushsaferConfigOptionProvider} class contains fields mapping thing configuration parameters.
*
* @author Kevin Siml - Initial contribution, forked from Christoph Weitkamp
*/
-@Component(service = ConfigOptionProvider.class)
+@Component(scope = ServiceScope.PROTOTYPE, service = { PushsaferConfigOptionProvider.class,
+ ConfigOptionProvider.class })
@NonNullByDefault
public class PushsaferConfigOptionProvider implements ConfigOptionProvider, ThingHandlerService {
import java.util.Set;
import org.eclipse.jdt.annotation.NonNullByDefault;
-import org.eclipse.jdt.annotation.Nullable;
import org.openhab.binding.qolsysiq.internal.QolsysIQBindingConstants;
import org.openhab.binding.qolsysiq.internal.handler.QolsysIQChildDiscoveryHandler;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResult;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
-import org.openhab.core.config.discovery.DiscoveryService;
import org.openhab.core.thing.ThingTypeUID;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
*/
@NonNullByDefault
-public class QolsysIQChildDiscoveryService extends AbstractDiscoveryService
- implements DiscoveryService, ThingHandlerService {
+public class QolsysIQChildDiscoveryService extends AbstractThingHandlerDiscoveryService<QolsysIQChildDiscoveryHandler> {
private final Logger logger = LoggerFactory.getLogger(QolsysIQChildDiscoveryService.class);
private static final Set<ThingTypeUID> SUPPORTED_DISCOVERY_THING_TYPES_UIDS = Set
.of(QolsysIQBindingConstants.THING_TYPE_PARTITION, QolsysIQBindingConstants.THING_TYPE_ZONE);
- private @Nullable ThingHandler thingHandler;
-
public QolsysIQChildDiscoveryService() throws IllegalArgumentException {
- super(SUPPORTED_DISCOVERY_THING_TYPES_UIDS, 5, false);
+ super(QolsysIQChildDiscoveryHandler.class, SUPPORTED_DISCOVERY_THING_TYPES_UIDS, 5, false);
}
@Override
- public void setThingHandler(ThingHandler handler) {
- if (handler instanceof QolsysIQChildDiscoveryHandler childDiscoveryHandler) {
- childDiscoveryHandler.setDiscoveryService(this);
- this.thingHandler = handler;
- }
- }
-
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return thingHandler;
+ public void initialize() {
+ thingHandler.setDiscoveryService(this);
+ super.initialize();
}
@Override
protected void startScan() {
- ThingHandler handler = this.thingHandler;
- if (handler != null) {
- ((QolsysIQChildDiscoveryHandler) handler).startDiscovery();
- }
- }
-
- @Override
- public void activate() {
- super.activate(null);
- }
-
- @Override
- public void deactivate() {
- super.deactivate();
+ thingHandler.startDiscovery();
}
public void discoverQolsysIQChildThing(ThingUID thingUID, ThingUID bridgeUID, Integer id, String label) {
import org.eclipse.jdt.annotation.NonNullByDefault;
import org.openhab.binding.qolsysiq.internal.discovery.QolsysIQChildDiscoveryService;
+import org.openhab.core.thing.binding.ThingHandler;
/**
* Callback for our custom discovery service
*
*/
@NonNullByDefault
-public interface QolsysIQChildDiscoveryHandler {
+public interface QolsysIQChildDiscoveryHandler extends ThingHandler {
/**
* Sets a {@link QolsysIQChildDiscoveryService} to call when device information is received
*
import org.openhab.core.thing.binding.ThingActions;
import org.openhab.core.thing.binding.ThingActionsScope;
import org.openhab.core.thing.binding.ThingHandler;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Michael Lobstein - initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = RadioThermostatThingActions.class)
@ThingActionsScope(name = "radiothermostat")
@NonNullByDefault
public class RadioThermostatThingActions implements ThingActions {
import org.openhab.binding.remoteopenhab.internal.handler.RemoteopenhabBridgeHandler;
import org.openhab.binding.remoteopenhab.internal.listener.RemoteopenhabThingsDataListener;
import org.openhab.binding.remoteopenhab.internal.rest.RemoteopenhabRestClient;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResult;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
import org.openhab.core.thing.ThingStatus;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Laurent Garnier - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = RemoteopenhabDiscoveryService.class)
@NonNullByDefault
-public class RemoteopenhabDiscoveryService extends AbstractDiscoveryService
- implements ThingHandlerService, RemoteopenhabThingsDataListener {
+public class RemoteopenhabDiscoveryService extends AbstractThingHandlerDiscoveryService<RemoteopenhabBridgeHandler>
+ implements RemoteopenhabThingsDataListener {
private final Logger logger = LoggerFactory.getLogger(RemoteopenhabDiscoveryService.class);
private static final int SEARCH_TIME = 10;
- private @NonNullByDefault({}) RemoteopenhabBridgeHandler bridgeHandler;
private @NonNullByDefault({}) RemoteopenhabRestClient restClient;
public RemoteopenhabDiscoveryService() {
- super(RemoteopenhabBindingConstants.SUPPORTED_THING_TYPES_UIDS, SEARCH_TIME, false);
+ super(RemoteopenhabBridgeHandler.class, RemoteopenhabBindingConstants.SUPPORTED_THING_TYPES_UIDS, SEARCH_TIME,
+ false);
}
@Override
- public void setThingHandler(ThingHandler handler) {
- if (handler instanceof RemoteopenhabBridgeHandler remoteopenhabBridgeHandler) {
- this.bridgeHandler = remoteopenhabBridgeHandler;
- this.restClient = bridgeHandler.gestRestClient();
- }
- }
-
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return bridgeHandler;
- }
-
- @Override
- public void activate() {
- ThingHandlerService.super.activate();
+ public void initialize() {
+ restClient = thingHandler.gestRestClient();
restClient.addThingsDataListener(this);
+ super.initialize();
}
@Override
- public void deactivate() {
+ public void dispose() {
+ super.dispose();
restClient.removeThingsDataListener(this);
- super.deactivate();
}
@Override
protected void startScan() {
logger.debug("Starting discovery scan for remote things");
- if (bridgeHandler.getThing().getStatus() == ThingStatus.ONLINE) {
+ if (thingHandler.getThing().getStatus() == ThingStatus.ONLINE) {
try {
List<RemoteopenhabThing> things = restClient.getRemoteThings();
- ThingUID bridgeUID = bridgeHandler.getThing().getUID();
+ ThingUID bridgeUID = thingHandler.getThing().getUID();
for (RemoteopenhabThing thing : things) {
createDiscoveryResult(thing, bridgeUID);
}
@Override
protected synchronized void stopScan() {
super.stopScan();
- removeOlderResults(getTimestampOfLastScan(), bridgeHandler.getThing().getUID());
+ removeOlderResults(getTimestampOfLastScan(), thingHandler.getThing().getUID());
}
@Override
@Override
public void onThingAdded(RemoteopenhabThing thing) {
- createDiscoveryResult(thing, bridgeHandler.getThing().getUID());
+ createDiscoveryResult(thing, thingHandler.getThing().getUID());
}
@Override
public void onThingRemoved(RemoteopenhabThing thing) {
- removeDiscoveryResult(thing, bridgeHandler.getThing().getUID());
+ removeDiscoveryResult(thing, thingHandler.getThing().getUID());
}
@Override
import java.util.Set;
import org.eclipse.jdt.annotation.NonNullByDefault;
-import org.eclipse.jdt.annotation.Nullable;
import org.openhab.binding.resol.handler.ResolBridgeHandler;
import org.openhab.binding.resol.internal.ResolBindingConstants;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResult;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
-import org.openhab.core.config.discovery.DiscoveryService;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Raphael Mack - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = ResolDeviceDiscoveryService.class)
@NonNullByDefault
-public class ResolDeviceDiscoveryService extends AbstractDiscoveryService
- implements DiscoveryService, ThingHandlerService {
+public class ResolDeviceDiscoveryService extends AbstractThingHandlerDiscoveryService<ResolBridgeHandler> {
private static final String THING_PROPERTY_TYPE = "type";
private final Logger logger = LoggerFactory.getLogger(ResolDeviceDiscoveryService.class);
- private @Nullable ResolBridgeHandler resolBridgeHandler;
-
public ResolDeviceDiscoveryService() throws IllegalArgumentException {
- super(Set.of(ResolBindingConstants.THING_TYPE_UID_DEVICE), 15, false);
+ super(ResolBridgeHandler.class, Set.of(ResolBindingConstants.THING_TYPE_UID_DEVICE), 15, false);
}
public void addThing(ThingUID bridgeUID, String thingType, String type, String name) {
}
@Override
- public void activate() {
- ResolBridgeHandler resolBridgeHandler = this.resolBridgeHandler;
- if (resolBridgeHandler != null) {
- resolBridgeHandler.registerDiscoveryService(this);
- }
+ public void initialize() {
+ thingHandler.registerDiscoveryService(this);
+ super.initialize();
}
@Override
- public void deactivate() {
- ResolBridgeHandler resolBridgeHandler = this.resolBridgeHandler;
- if (resolBridgeHandler != null) {
- resolBridgeHandler.unregisterDiscoveryService();
- }
+ public void dispose() {
+ super.dispose();
+ thingHandler.unregisterDiscoveryService();
}
@Override
protected void startScan() {
- ResolBridgeHandler resolBridgeHandler = this.resolBridgeHandler;
- if (resolBridgeHandler != null) {
- resolBridgeHandler.startScan();
- }
+ thingHandler.startScan();
}
@Override
protected void stopScan() {
- ResolBridgeHandler resolBridgeHandler = this.resolBridgeHandler;
- if (resolBridgeHandler != null) {
- resolBridgeHandler.stopScan();
- }
+ thingHandler.stopScan();
super.stopScan();
}
-
- @Override
- public void setThingHandler(ThingHandler handler) {
- if (handler instanceof ResolBridgeHandler resolBridgeHandler) {
- this.resolBridgeHandler = resolBridgeHandler;
- }
- }
-
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return resolBridgeHandler;
- }
}
import java.util.Set;
import org.eclipse.jdt.annotation.NonNullByDefault;
-import org.eclipse.jdt.annotation.Nullable;
import org.openhab.binding.rfxcom.internal.DeviceMessageListener;
import org.openhab.binding.rfxcom.internal.RFXComBindingConstants;
import org.openhab.binding.rfxcom.internal.exceptions.RFXComException;
import org.openhab.binding.rfxcom.internal.handler.RFXComBridgeHandler;
import org.openhab.binding.rfxcom.internal.messages.RFXComDeviceMessage;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
import org.openhab.core.thing.ThingTypeUID;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
* @author Pauli Anttila - Initial contribution
* @author Laurent Garnier - use ThingHandlerService
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = RFXComDeviceDiscoveryService.class)
@NonNullByDefault
-public class RFXComDeviceDiscoveryService extends AbstractDiscoveryService
- implements DeviceMessageListener, ThingHandlerService {
+public class RFXComDeviceDiscoveryService extends AbstractThingHandlerDiscoveryService<RFXComBridgeHandler>
+ implements DeviceMessageListener {
private final Logger logger = LoggerFactory.getLogger(RFXComDeviceDiscoveryService.class);
private final int DISCOVERY_TTL = 3600;
- private @Nullable RFXComBridgeHandler bridgeHandler;
-
public RFXComDeviceDiscoveryService() {
- super(null, 1, false);
- }
-
- @Override
- public void setThingHandler(ThingHandler handler) {
- if (handler instanceof RFXComBridgeHandler rfxComBridgeHandler) {
- bridgeHandler = rfxComBridgeHandler;
- }
+ super(RFXComBridgeHandler.class, null, 1, false);
}
@Override
- public @Nullable ThingHandler getThingHandler() {
- return bridgeHandler;
+ public void initialize() {
+ thingHandler.registerDeviceStatusListener(this);
+ super.initialize();
}
@Override
- public void activate() {
- super.activate(null);
- RFXComBridgeHandler handler = bridgeHandler;
- if (handler != null) {
- handler.registerDeviceStatusListener(this);
- }
- }
-
- @Override
- public void deactivate() {
- RFXComBridgeHandler handler = bridgeHandler;
- if (handler != null) {
- handler.unregisterDeviceStatusListener(this);
- }
- super.deactivate();
+ public void dispose() {
+ super.dispose();
+ thingHandler.unregisterDeviceStatusListener(this);
}
@Override
}
ThingUID thingUID = new ThingUID(uid, bridge, id.replace(ID_DELIMITER, "_"));
- RFXComBridgeHandler handler = bridgeHandler;
- if (handler == null) {
- logger.trace("Ignoring RFXCOM {} with id '{}' - bridge handler is null", thingUID, id);
- } else if (!handler.getConfiguration().disableDiscovery) {
+ if (!thingHandler.getConfiguration().disableDiscovery) {
logger.trace("Adding new RFXCOM {} with id '{}' to inbox", thingUID, id);
DiscoveryResultBuilder discoveryResultBuilder = DiscoveryResultBuilder.create(thingUID).withBridge(bridge)
.withTTL(DISCOVERY_TTL);
import org.openhab.core.thing.binding.ThingActions;
import org.openhab.core.thing.binding.ThingActionsScope;
import org.openhab.core.thing.binding.ThingHandler;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
* @author Krzysztof Goworek - Initial contribution
* @see SatelEventLogHandler
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = SatelEventLogActions.class)
@ThingActionsScope(name = "satel")
@NonNullByDefault
public class SatelEventLogActions implements ThingActions {
import org.openhab.core.thing.type.ChannelType;
import org.openhab.core.thing.type.ChannelTypeProvider;
import org.openhab.core.thing.type.ChannelTypeUID;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
/**
* Channel Type Provider that does a callback the SensiboSkyHandler that initiated it.
*
* @author Arne Seime - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = { CallbackChannelsTypeProvider.class, ChannelTypeProvider.class,
+ ChannelGroupTypeProvider.class })
@NonNullByDefault
public class CallbackChannelsTypeProvider
implements ChannelTypeProvider, ChannelGroupTypeProvider, ThingHandlerService {
import java.util.Set;
import org.eclipse.jdt.annotation.NonNullByDefault;
-import org.eclipse.jdt.annotation.Nullable;
import org.openhab.binding.smsmodem.internal.handler.SMSConversationHandler;
import org.openhab.binding.smsmodem.internal.handler.SMSModemBridgeHandler;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResult;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
-import org.openhab.core.config.discovery.DiscoveryService;
import org.openhab.core.thing.ThingTypeUID;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
/**
* This class implements a discovery service for SMSConversation
*
* @author Gwendal ROULLEAU - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = SMSConversationDiscoveryService.class)
@NonNullByDefault
-public class SMSConversationDiscoveryService extends AbstractDiscoveryService
- implements DiscoveryService, ThingHandlerService {
+public class SMSConversationDiscoveryService extends AbstractThingHandlerDiscoveryService<SMSModemBridgeHandler> {
- private @NonNullByDefault({}) SMSModemBridgeHandler bridgeHandler;
private @NonNullByDefault({}) ThingUID bridgeUid;
public SMSConversationDiscoveryService() {
- super(0);
+ this(0);
}
public SMSConversationDiscoveryService(int timeout) throws IllegalArgumentException {
- super(timeout);
+ super(SMSModemBridgeHandler.class, timeout);
}
@Override
protected void startScan() {
- for (String msisdn : bridgeHandler.getAllSender()) {
+ for (String msisdn : thingHandler.getAllSender()) {
buildDiscovery(msisdn);
}
}
}
@Override
- public void setThingHandler(ThingHandler handler) {
- this.bridgeHandler = (SMSModemBridgeHandler) handler;
- this.bridgeUid = handler.getThing().getUID();
- this.bridgeHandler.setDiscoveryService(this);
- }
-
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return bridgeHandler;
- }
-
- @Override
- public void deactivate() {
- super.deactivate();
+ public void initialize() {
+ bridgeUid = thingHandler.getThing().getUID();
+ thingHandler.setDiscoveryService(this);
+ super.initialize();
}
}
import org.openhab.core.thing.binding.ThingActions;
import org.openhab.core.thing.binding.ThingActionsScope;
import org.openhab.core.thing.binding.ThingHandler;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.smslib.message.AbstractMessage.Encoding;
*
* @author Gwendal ROULLEAU - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = SMSModemActions.class)
@ThingActionsScope(name = "smsmodem")
@NonNullByDefault
public class SMSModemActions implements ThingActions {
protected @Nullable ThingHandler createHandler(Thing thing) {
ThingTypeUID thingTypeUID = thing.getThingTypeUID();
if (APIBRIDGE_THING_TYPE.equals(thingTypeUID)) {
- return new SncfBridgeHandler((Bridge) thing, gson, locationProvider, httpClient);
+ return new SncfBridgeHandler((Bridge) thing, gson, httpClient);
} else if (STATION_THING_TYPE.equals(thingTypeUID)) {
return new StationHandler(thing, locationProvider);
}
import java.util.List;
import org.eclipse.jdt.annotation.NonNullByDefault;
-import org.eclipse.jdt.annotation.Nullable;
import org.openhab.binding.sncf.internal.SncfException;
import org.openhab.binding.sncf.internal.dto.PlaceNearby;
import org.openhab.binding.sncf.internal.handler.SncfBridgeHandler;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
import org.openhab.core.i18n.LocationProvider;
import org.openhab.core.library.types.PointType;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
import org.osgi.service.component.annotations.Activate;
import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.Reference;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Gaël L'hopital - Initial contribution
*/
-@Component(service = ThingHandlerService.class)
+@Component(scope = ServiceScope.PROTOTYPE, service = SncfDiscoveryService.class)
@NonNullByDefault
-public class SncfDiscoveryService extends AbstractDiscoveryService implements ThingHandlerService {
+public class SncfDiscoveryService extends AbstractThingHandlerDiscoveryService<SncfBridgeHandler> {
private static final int SEARCH_TIME = 7;
private final Logger logger = LoggerFactory.getLogger(SncfDiscoveryService.class);
- private @Nullable LocationProvider locationProvider;
- private @Nullable SncfBridgeHandler bridgeHandler;
+ private @NonNullByDefault({}) LocationProvider locationProvider;
private int searchRange = 1500;
@Activate
public SncfDiscoveryService() {
- super(SUPPORTED_THING_TYPES_UIDS, SEARCH_TIME, false);
+ super(SncfBridgeHandler.class, SUPPORTED_THING_TYPES_UIDS, SEARCH_TIME, false);
}
- @Override
- public void deactivate() {
- super.deactivate();
+ @Reference(unbind = "-")
+ public void setLocationProvider(LocationProvider locationProvider) {
+ this.locationProvider = locationProvider;
}
@Override
public void startScan() {
- SncfBridgeHandler handler = bridgeHandler;
- LocationProvider provider = locationProvider;
- if (provider != null && handler != null) {
- PointType location = provider.getLocation();
- if (location != null) {
- ThingUID bridgeUID = handler.getThing().getUID();
- searchRange += 500;
- try {
- List<PlaceNearby> places = handler.discoverNearby(location, searchRange);
- if (places != null && !places.isEmpty()) {
- places.forEach(place -> {
- // stop_point:SNCF:87386573:Bus
- List<String> idElts = new LinkedList<String>(Arrays.asList(place.id.split(":")));
- idElts.remove(0);
- idElts.remove(0);
- thingDiscovered(DiscoveryResultBuilder
- .create(new ThingUID(STATION_THING_TYPE, bridgeUID, String.join("_", idElts)))
- .withLabel(String.format("%s (%s)", place.stopPoint.name, idElts.get(1))
- .replace("-", "_"))
- .withBridge(bridgeUID).withRepresentationProperty(STOP_POINT_ID)
- .withProperty(STOP_POINT_ID, place.id).build());
- });
- } else {
- logger.info("No station found in a perimeter of {} m, extending search", searchRange);
- startScan();
- }
- } catch (SncfException e) {
- logger.warn("Error calling SNCF Api : {}", e.getMessage());
+ PointType location = locationProvider.getLocation();
+ if (location != null) {
+ ThingUID bridgeUID = thingHandler.getThing().getUID();
+ searchRange += 500;
+ try {
+ List<PlaceNearby> places = thingHandler.discoverNearby(location, searchRange);
+ if (places != null && !places.isEmpty()) {
+ places.forEach(place -> {
+ // stop_point:SNCF:87386573:Bus
+ List<String> idElts = new LinkedList<String>(Arrays.asList(place.id.split(":")));
+ idElts.remove(0);
+ idElts.remove(0);
+ thingDiscovered(DiscoveryResultBuilder
+ .create(new ThingUID(STATION_THING_TYPE, bridgeUID, String.join("_", idElts)))
+ .withLabel(
+ String.format("%s (%s)", place.stopPoint.name, idElts.get(1)).replace("-", "_"))
+ .withBridge(bridgeUID).withRepresentationProperty(STOP_POINT_ID)
+ .withProperty(STOP_POINT_ID, place.id).build());
+ });
+ } else {
+ logger.info("No station found in a perimeter of {} m, extending search", searchRange);
+ startScan();
}
- } else {
- logger.info("Please set a system location to enable station discovery");
+ } catch (SncfException e) {
+ logger.warn("Error calling SNCF Api : {}", e.getMessage());
}
+ } else {
+ logger.info("Please set a system location to enable station discovery");
}
}
-
- @Override
- public void setThingHandler(ThingHandler handler) {
- if (handler instanceof SncfBridgeHandler sncfBridgeHandler) {
- this.bridgeHandler = sncfBridgeHandler;
- this.locationProvider = sncfBridgeHandler.getLocationProvider();
- }
- }
-
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return bridgeHandler;
- }
}
import org.openhab.binding.sncf.internal.dto.StopPoint;
import org.openhab.binding.sncf.internal.dto.StopPoints;
import org.openhab.core.cache.ExpiringCacheMap;
-import org.openhab.core.i18n.LocationProvider;
import org.openhab.core.library.types.PointType;
import org.openhab.core.thing.Bridge;
import org.openhab.core.thing.ChannelUID;
public static final String SERVICE_URL = "https://api.sncf.com/v1/coverage/sncf/";
private final Logger logger = LoggerFactory.getLogger(SncfBridgeHandler.class);
- private final LocationProvider locationProvider;
private final ExpiringCacheMap<String, @Nullable String> cache = new ExpiringCacheMap<>(Duration.ofMinutes(1));
private final HttpClient httpClient;
private final Gson gson;
private @NonNullByDefault({}) String apiId;
- public SncfBridgeHandler(Bridge bridge, Gson gson, LocationProvider locationProvider, HttpClient httpClient) {
+ public SncfBridgeHandler(Bridge bridge, Gson gson, HttpClient httpClient) {
super(bridge);
- this.locationProvider = locationProvider;
this.httpClient = httpClient;
this.gson = gson;
}
return passages != null && !passages.isEmpty() ? Optional.ofNullable(passages.get(0)) : Optional.empty();
}
- public LocationProvider getLocationProvider() {
- return locationProvider;
- }
-
@Override
public Collection<Class<? extends ThingHandlerService>> getServices() {
return Set.of(SncfDiscoveryService.class);
import org.openhab.binding.solarwatt.internal.domain.model.PowerMeter;
import org.openhab.binding.solarwatt.internal.domain.model.SmartHeater;
import org.openhab.binding.solarwatt.internal.handler.EnergyManagerHandler;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResult;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
-import org.openhab.core.config.discovery.DiscoveryService;
import org.openhab.core.thing.ThingStatus;
import org.openhab.core.thing.ThingTypeUID;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Sven Carstens - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = SolarwattDevicesDiscoveryService.class)
@NonNullByDefault
-public class SolarwattDevicesDiscoveryService extends AbstractDiscoveryService
- implements ThingHandlerService, DiscoveryService {
+public class SolarwattDevicesDiscoveryService extends AbstractThingHandlerDiscoveryService<EnergyManagerHandler> {
private static final int TIMEOUT_SECONDS = 20;
private final Logger logger = LoggerFactory.getLogger(SolarwattDevicesDiscoveryService.class);
- private @Nullable EnergyManagerHandler energyManagerHandler;
/**
* Job which will do the background scanning
private @Nullable ScheduledFuture<?> scanningJob;
public SolarwattDevicesDiscoveryService() {
- super(TIMEOUT_SECONDS);
+ super(EnergyManagerHandler.class, TIMEOUT_SECONDS);
this.scanningRunnable = new EnergymanagerScan();
this.activate(null);
}
- @Override
- public void setThingHandler(final @Nullable ThingHandler handler) {
- if (handler instanceof EnergyManagerHandler energyManagerHandler) {
- this.energyManagerHandler = energyManagerHandler;
- }
- }
-
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return this.energyManagerHandler;
- }
-
- @Override
- public void deactivate() {
- this.stopBackgroundDiscovery();
- }
-
@Override
protected void startBackgroundDiscovery() {
ScheduledFuture<?> localScanningJob = this.scanningJob;
@Override
protected synchronized void startScan() {
this.removeOlderResults(this.getTimestampOfLastScan());
- final EnergyManagerHandler localEnergyManagerHandler = this.energyManagerHandler;
- if (localEnergyManagerHandler == null
- || localEnergyManagerHandler.getThing().getStatus() != ThingStatus.ONLINE) {
- this.logger.warn("Energymanager handler not available: {}", localEnergyManagerHandler);
+ if (thingHandler.getThing().getStatus() != ThingStatus.ONLINE) {
+ this.logger.warn("Energymanager handler not available: {}", thingHandler.getThing().getUID());
return;
}
this.scanForDeviceThings();
* Walks through the list of devices and adds discovery results for the supported devices.
*/
private void scanForDeviceThings() {
- EnergyManagerHandler localEnergyManagerHandler = this.energyManagerHandler;
- if (localEnergyManagerHandler != null) {
- final Map<String, Device> devices = localEnergyManagerHandler.getDevices();
-
- final ThingUID bridgeUID = localEnergyManagerHandler.getThing().getUID();
-
- if (devices == null) {
- this.logger.warn("No device data for solarwatt devices in discovery for energy manager {}.", bridgeUID);
- } else {
- devices.forEach((key, entry) -> {
- this.logger.debug("scanForDeviceThings: {}-{}", entry.getClass(), entry.getGuid());
- if (entry instanceof BatteryConverter) {
- this.discover(bridgeUID, entry, THING_TYPE_BATTERYCONVERTER);
- } else if (entry instanceof Inverter) {
- this.discover(bridgeUID, entry, THING_TYPE_INVERTER);
- } else if (entry instanceof PowerMeter) {
- this.discover(bridgeUID, entry, THING_TYPE_POWERMETER);
- } else if (entry instanceof EVStation) {
- this.discover(bridgeUID, entry, THING_TYPE_EVSTATION);
- } else if (entry instanceof Location) {
- this.discover(bridgeUID, entry, THING_TYPE_LOCATION);
- } else if (entry instanceof PVPlant) {
- this.discover(bridgeUID, entry, THING_TYPE_PVPLANT);
- } else if (entry instanceof GridFlow) {
- this.discover(bridgeUID, entry, THING_TYPE_GRIDFLOW);
- } else if (entry instanceof SmartHeater) {
- this.discover(bridgeUID, entry, THING_TYPE_SMARTHEATER);
- } else {
- this.logger.debug("Found unhandled device");
- }
- });
- }
+ final Map<String, Device> devices = thingHandler.getDevices();
+
+ final ThingUID bridgeUID = thingHandler.getThing().getUID();
+
+ if (devices == null) {
+ this.logger.warn("No device data for solarwatt devices in discovery for energy manager {}.", bridgeUID);
+ } else {
+ devices.forEach((key, entry) -> {
+ this.logger.debug("scanForDeviceThings: {}-{}", entry.getClass(), entry.getGuid());
+ if (entry instanceof BatteryConverter) {
+ this.discover(bridgeUID, entry, THING_TYPE_BATTERYCONVERTER);
+ } else if (entry instanceof Inverter) {
+ this.discover(bridgeUID, entry, THING_TYPE_INVERTER);
+ } else if (entry instanceof PowerMeter) {
+ this.discover(bridgeUID, entry, THING_TYPE_POWERMETER);
+ } else if (entry instanceof EVStation) {
+ this.discover(bridgeUID, entry, THING_TYPE_EVSTATION);
+ } else if (entry instanceof Location) {
+ this.discover(bridgeUID, entry, THING_TYPE_LOCATION);
+ } else if (entry instanceof PVPlant) {
+ this.discover(bridgeUID, entry, THING_TYPE_PVPLANT);
+ } else if (entry instanceof GridFlow) {
+ this.discover(bridgeUID, entry, THING_TYPE_GRIDFLOW);
+ } else if (entry instanceof SmartHeater) {
+ this.discover(bridgeUID, entry, THING_TYPE_SMARTHEATER);
+ } else {
+ this.logger.debug("Found unhandled device");
+ }
+ });
}
}
import org.openhab.binding.somfymylink.internal.handler.SomfyMyLinkException;
import org.openhab.binding.somfymylink.internal.model.SomfyMyLinkScene;
import org.openhab.binding.somfymylink.internal.model.SomfyMyLinkShade;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResult;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
-import org.openhab.core.config.discovery.DiscoveryService;
import org.openhab.core.config.discovery.ScanListener;
import org.openhab.core.thing.ThingStatus;
import org.openhab.core.thing.ThingTypeUID;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
-import org.osgi.service.component.annotations.Activate;
-import org.osgi.service.component.annotations.Deactivate;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Chris Johnson - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = SomfyMyLinkDeviceDiscoveryService.class)
@NonNullByDefault
-public class SomfyMyLinkDeviceDiscoveryService extends AbstractDiscoveryService
- implements DiscoveryService, ThingHandlerService {
+public class SomfyMyLinkDeviceDiscoveryService extends AbstractThingHandlerDiscoveryService<SomfyMyLinkBridgeHandler> {
private static final int DISCOVERY_REFRESH_SEC = 900;
private final Logger logger = LoggerFactory.getLogger(SomfyMyLinkDeviceDiscoveryService.class);
- private @NonNullByDefault({}) SomfyMyLinkBridgeHandler mylinkHandler;
private @Nullable Future<?> scanTask;
private @Nullable ScheduledFuture<?> discoveryJob;
public SomfyMyLinkDeviceDiscoveryService() {
- super(SomfyMyLinkHandlerFactory.DISCOVERABLE_DEVICE_TYPES_UIDS, 10);
- }
-
- @Override
- public void setThingHandler(@Nullable ThingHandler handler) {
- if (handler instanceof SomfyMyLinkBridgeHandler bridgeHandler) {
- this.mylinkHandler = bridgeHandler;
- }
- }
-
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return mylinkHandler;
- }
-
- @Override
- @Activate
- public void activate() {
- super.activate(null);
- }
-
- @Override
- @Deactivate
- public void deactivate() {
- super.deactivate();
+ super(SomfyMyLinkBridgeHandler.class, SomfyMyLinkHandlerFactory.DISCOVERABLE_DEVICE_TYPES_UIDS, 10);
}
@Override
private synchronized void discoverDevices() {
logger.info("Scanning for things...");
- if (this.mylinkHandler.getThing().getStatus() != ThingStatus.ONLINE) {
- logger.info("Skipping device discover as bridge is {}", this.mylinkHandler.getThing().getStatus());
+ if (thingHandler.getThing().getStatus() != ThingStatus.ONLINE) {
+ logger.info("Skipping device discover as bridge is {}", thingHandler.getThing().getStatus());
return;
}
try {
// get the shade list
- SomfyMyLinkShade[] shades = this.mylinkHandler.getShadeList();
+ SomfyMyLinkShade[] shades = thingHandler.getShadeList();
for (SomfyMyLinkShade shade : shades) {
String id = shade.getTargetID();
}
}
- SomfyMyLinkScene[] scenes = this.mylinkHandler.getSceneList();
+ SomfyMyLinkScene[] scenes = thingHandler.getSceneList();
for (SomfyMyLinkScene scene : scenes) {
String id = scene.getTargetID();
return;
}
- ThingUID bridgeUID = this.mylinkHandler.getThing().getUID();
+ ThingUID bridgeUID = thingHandler.getThing().getUID();
ThingUID uid = new ThingUID(thingTypeUID, bridgeUID, id);
Map<String, Object> properties = new HashMap<>();
import org.openhab.binding.somfytahoma.internal.model.SomfyTahomaSetup;
import org.openhab.binding.somfytahoma.internal.model.SomfyTahomaState;
import org.openhab.binding.somfytahoma.internal.model.SomfyTahomaSubPlace;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
-import org.openhab.core.config.discovery.DiscoveryService;
import org.openhab.core.thing.ThingStatus;
import org.openhab.core.thing.ThingTypeUID;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
* @author Ondrej Pecta - Initial contribution
* @author Laurent Garnier - Include the place into the inbox label (when defined for the device)
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = SomfyTahomaItemDiscoveryService.class)
@NonNullByDefault
-public class SomfyTahomaItemDiscoveryService extends AbstractDiscoveryService
- implements DiscoveryService, ThingHandlerService {
+public class SomfyTahomaItemDiscoveryService extends AbstractThingHandlerDiscoveryService<SomfyTahomaBridgeHandler> {
private static final int DISCOVERY_TIMEOUT_SEC = 10;
private static final int DISCOVERY_REFRESH_SEC = 3600;
private final Logger logger = LoggerFactory.getLogger(SomfyTahomaItemDiscoveryService.class);
- private @Nullable SomfyTahomaBridgeHandler bridgeHandler;
-
private @Nullable ScheduledFuture<?> discoveryJob;
public SomfyTahomaItemDiscoveryService() {
- super(DISCOVERY_TIMEOUT_SEC);
+ super(SomfyTahomaBridgeHandler.class, DISCOVERY_TIMEOUT_SEC);
logger.debug("Creating discovery service");
}
- @Override
- public void activate() {
- super.activate(null);
- }
-
- @Override
- public void deactivate() {
- super.deactivate();
- }
-
- @Override
- public void setThingHandler(@NonNullByDefault({}) ThingHandler handler) {
- if (handler instanceof SomfyTahomaBridgeHandler tahomaBridgeHandler) {
- bridgeHandler = tahomaBridgeHandler;
- }
- }
-
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return bridgeHandler;
- }
-
@Override
protected void startBackgroundDiscovery() {
logger.debug("Starting SomfyTahoma background discovery");
private synchronized void runDiscovery() {
logger.debug("Starting scanning for things...");
- SomfyTahomaBridgeHandler localBridgeHandler = bridgeHandler;
- if (localBridgeHandler != null && ThingStatus.ONLINE == localBridgeHandler.getThing().getStatus()) {
- SomfyTahomaSetup setup = localBridgeHandler.getSetup();
+ if (ThingStatus.ONLINE == thingHandler.getThing().getStatus()) {
+ SomfyTahomaSetup setup = thingHandler.getSetup();
if (setup == null) {
return;
}
// local mode does not have action groups
- if (!localBridgeHandler.isDevModeReady()) {
- List<SomfyTahomaActionGroup> actions = localBridgeHandler.listActionGroups();
+ if (!thingHandler.isDevModeReady()) {
+ List<SomfyTahomaActionGroup> actions = thingHandler.listActionGroups();
for (SomfyTahomaActionGroup group : actions) {
String oid = group.getOid();
properties.put(RSSI_LEVEL_STATE, "-1");
}
- SomfyTahomaBridgeHandler localBridgeHandler = bridgeHandler;
- if (localBridgeHandler != null) {
- ThingUID thingUID = new ThingUID(thingTypeUID, localBridgeHandler.getThing().getUID(),
- deviceURL.replaceAll("[^a-zA-Z0-9_]", ""));
+ ThingUID thingUID = new ThingUID(thingTypeUID, thingHandler.getThing().getUID(),
+ deviceURL.replaceAll("[^a-zA-Z0-9_]", ""));
- logger.debug("Detected a/an {} - label: {} device URL: {}", thingTypeUID.getId(), label, deviceURL);
- thingDiscovered(DiscoveryResultBuilder.create(thingUID).withThingType(thingTypeUID)
- .withProperties(properties).withRepresentationProperty("url").withLabel(label)
- .withBridge(localBridgeHandler.getThing().getUID()).build());
- }
+ logger.debug("Detected a/an {} - label: {} device URL: {}", thingTypeUID.getId(), label, deviceURL);
+ thingDiscovered(DiscoveryResultBuilder.create(thingUID).withThingType(thingTypeUID).withProperties(properties)
+ .withRepresentationProperty("url").withLabel(label).withBridge(thingHandler.getThing().getUID())
+ .build());
}
private void actionGroupDiscovered(String label, String deviceURL) {
properties.put("id", id);
properties.put("type", type);
- SomfyTahomaBridgeHandler localBridgeHandler = bridgeHandler;
- if (localBridgeHandler != null) {
- ThingUID thingUID = new ThingUID(THING_TYPE_GATEWAY, localBridgeHandler.getThing().getUID(), id);
+ ThingUID thingUID = new ThingUID(THING_TYPE_GATEWAY, thingHandler.getThing().getUID(), id);
- logger.debug("Detected a gateway with id: {} and type: {}", id, type);
- thingDiscovered(
- DiscoveryResultBuilder.create(thingUID).withThingType(THING_TYPE_GATEWAY).withProperties(properties)
- .withRepresentationProperty("id").withLabel("Somfy Gateway (" + type + ")")
- .withBridge(localBridgeHandler.getThing().getUID()).build());
- }
+ logger.debug("Detected a gateway with id: {} and type: {}", id, type);
+ thingDiscovered(DiscoveryResultBuilder.create(thingUID).withThingType(THING_TYPE_GATEWAY)
+ .withProperties(properties).withRepresentationProperty("id").withLabel("Somfy Gateway (" + type + ")")
+ .withBridge(thingHandler.getThing().getUID()).build());
}
}
import org.openhab.binding.souliss.internal.SoulissBindingConstants;
import org.openhab.binding.souliss.internal.SoulissProtocolConstants;
import org.openhab.binding.souliss.internal.handler.SoulissGatewayHandler;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResult;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
-import org.openhab.core.config.discovery.DiscoveryService;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
* @author Tonino Fazio - Initial contribution
* @author Luca Calcaterra - Refactor for OH3
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = SoulissGatewayDiscovery.class)
@NonNullByDefault
-public class SoulissGatewayDiscovery extends AbstractDiscoveryService
- implements DiscoverResult, DiscoveryService, ThingHandlerService {
+public class SoulissGatewayDiscovery extends AbstractThingHandlerDiscoveryService<SoulissGatewayHandler>
+ implements DiscoverResult {
private @Nullable ScheduledFuture<?> discoveryJob = null;
private final Logger logger = LoggerFactory.getLogger(SoulissGatewayDiscovery.class);
private @Nullable SoulissDiscoverJob soulissDiscoverRunnableClass;
- private @Nullable SoulissGatewayHandler soulissGwHandler;
public SoulissGatewayDiscovery() {
- super(SoulissBindingConstants.SUPPORTED_THING_TYPES_UIDS, SoulissBindingConstants.DISCOVERY_TIMEOUT_IN_SECONDS,
- false);
- }
-
- @Override
- public void deactivate() {
- super.deactivate();
+ super(SoulissGatewayHandler.class, SoulissBindingConstants.SUPPORTED_THING_TYPES_UIDS,
+ SoulissBindingConstants.DISCOVERY_TIMEOUT_IN_SECONDS, false);
}
/**
- * The {@link gatewayDetected} callback used to create the Gateway
+ * This callback used to create the Gateway
*/
@Override
public void gatewayDetected(InetAddress addr, String id) {
// create discovery class
if (soulissDiscoverRunnableClass == null) {
- soulissDiscoverRunnableClass = new SoulissDiscoverJob(this.soulissGwHandler);
+ soulissDiscoverRunnableClass = new SoulissDiscoverJob(thingHandler);
// send command for gw struct (typicals).. must be not soo much quick..
discoveryJob = scheduler.scheduleWithFixedDelay(soulissDiscoverRunnableClass, 2,
DiscoveryResult discoveryResult;
String sNodeID = topicNumber + SoulissBindingConstants.UUID_NODE_SLOT_SEPARATOR + sTopicVariant;
- var localGwHandler = this.soulissGwHandler;
- if (localGwHandler != null) {
- var gatewayUID = localGwHandler.getThing().getUID();
- thingUID = new ThingUID(SoulissBindingConstants.TOPICS_THING_TYPE, gatewayUID, sNodeID);
- label = "Topic. Number: " + topicNumber + ", Variant: " + sTopicVariant;
+ var gatewayUID = thingHandler.getThing().getUID();
+ thingUID = new ThingUID(SoulissBindingConstants.TOPICS_THING_TYPE, gatewayUID, sNodeID);
+ label = "Topic. Number: " + topicNumber + ", Variant: " + sTopicVariant;
- discoveryResult = DiscoveryResultBuilder.create(thingUID).withLabel(label)
- .withProperty("number", topicNumber).withProperty("variant", sTopicVariant)
- .withRepresentationProperty("number").withBridge(gatewayUID).build();
- thingDiscovered(discoveryResult);
- }
+ discoveryResult = DiscoveryResultBuilder.create(thingUID).withLabel(label).withProperty("number", topicNumber)
+ .withProperty("variant", sTopicVariant).withRepresentationProperty("number").withBridge(gatewayUID)
+ .build();
+ thingDiscovered(discoveryResult);
}
@Override
ThingUID thingUID = null;
var label = "";
DiscoveryResult discoveryResult;
- var gwHandler = this.soulissGwHandler;
- if ((gwHandler != null) && (lastByteGatewayIP == (byte) Integer
- .parseInt(gwHandler.getGwConfig().gatewayLanAddress.split("\\.")[3]))) {
+ if (lastByteGatewayIP == (byte) Integer
+ .parseInt(thingHandler.getGwConfig().gatewayLanAddress.split("\\.")[3])) {
String sNodeId = node + SoulissBindingConstants.UUID_NODE_SLOT_SEPARATOR + slot;
- ThingUID gatewayUID = gwHandler.getThing().getUID();
+ ThingUID gatewayUID = thingHandler.getThing().getUID();
var nodeLabel = "node";
var slotLabel = "slot";
}
}
if (thingUID != null) {
- label = "[" + gwHandler.getThing().getUID().getAsString() + "] " + label;
+ label = "[" + thingHandler.getThing().getUID().getAsString() + "] " + label;
var uniqueId = "N" + Byte.toString(node) + "S" + Byte.toString(slot);
discoveryResult = DiscoveryResultBuilder.create(thingUID).withLabel(label)
.withProperty(SoulissBindingConstants.PROPERTY_NODE, node)
.withProperty(SoulissBindingConstants.PROPERTY_SLOT, slot)
.withProperty(SoulissBindingConstants.PROPERTY_UNIQUEID, uniqueId)
.withRepresentationProperty(SoulissBindingConstants.PROPERTY_UNIQUEID)
- .withBridge(gwHandler.getThing().getUID()).build();
+ .withBridge(thingHandler.getThing().getUID()).build();
thingDiscovered(discoveryResult);
- gwHandler.setThereIsAThingDetection();
+ thingHandler.setThereIsAThingDetection();
}
}
}
@Override
- public void setThingHandler(ThingHandler handler) {
- if (handler instanceof SoulissGatewayHandler localGwHandler) {
- this.soulissGwHandler = localGwHandler;
- localGwHandler.discoverResult = this;
- }
- }
-
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return soulissGwHandler;
+ public void initialize() {
+ thingHandler.discoverResult = this;
+ super.initialize();
}
}
import org.openhab.core.thing.binding.ThingActionsScope;
import org.openhab.core.thing.binding.ThingHandler;
import org.openhab.core.thing.binding.ThingHandlerService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
/**
* Spotify Rule Actions.
*
* @author Hilbrand Bouwkamp - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = SpotifyActions.class)
@ThingActionsScope(name = "spotify")
@NonNullByDefault
public class SpotifyActions implements ThingActions, ThingHandlerService {
import org.openhab.binding.spotify.internal.SpotifyAccountHandler;
import org.openhab.binding.spotify.internal.SpotifyBindingConstants;
import org.openhab.binding.spotify.internal.api.model.Device;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResult;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
import org.openhab.core.config.discovery.DiscoveryService;
import org.openhab.core.thing.ThingTypeUID;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
* @author Andreas Stenlund - Initial contribution
* @author Hilbrand Bouwkamp - Simplfied code to make call to shared code
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = SpotifyDeviceDiscoveryService.class)
@NonNullByDefault
-public class SpotifyDeviceDiscoveryService extends AbstractDiscoveryService
- implements DiscoveryService, ThingHandlerService {
+public class SpotifyDeviceDiscoveryService extends AbstractThingHandlerDiscoveryService<SpotifyAccountHandler> {
// id for device is derived by stripping id of device with this length
private static final int PLAYER_ID_LENGTH = 4;
private static final long TTL_SECONDS = Duration.ofHours(1).toSeconds();
private final Logger logger = LoggerFactory.getLogger(SpotifyDeviceDiscoveryService.class);
-
- private @NonNullByDefault({}) SpotifyAccountHandler bridgeHandler;
private @NonNullByDefault({}) ThingUID bridgeUID;
private @Nullable ScheduledFuture<?> backgroundFuture;
public SpotifyDeviceDiscoveryService() {
- super(SUPPORTED_THING_TYPES_UIDS, DISCOVERY_TIME_SECONDS);
+ super(SpotifyAccountHandler.class, SUPPORTED_THING_TYPES_UIDS, DISCOVERY_TIME_SECONDS);
}
@Override
}
@Override
- public void deactivate() {
- super.deactivate();
- }
-
- @Override
- public void setThingHandler(@Nullable ThingHandler handler) {
- if (handler instanceof SpotifyAccountHandler accountHandler) {
- bridgeHandler = accountHandler;
- bridgeUID = bridgeHandler.getUID();
- }
- }
-
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return bridgeHandler;
+ public void initialize() {
+ bridgeUID = thingHandler.getUID();
+ super.initialize();
}
@Override
protected void startScan() {
// If the bridge is not online no other thing devices can be found, so no reason to scan at this moment.
removeOlderResults(getTimestampOfLastScan());
- if (bridgeHandler.isOnline()) {
+ if (thingHandler.isOnline()) {
logger.debug("Starting Spotify Device discovery for bridge {}", bridgeUID);
try {
- bridgeHandler.listDevices().forEach(this::thingDiscovered);
+ thingHandler.listDevices().forEach(this::thingDiscovered);
} catch (final RuntimeException e) {
logger.debug("Finding devices failed with message: {}", e.getMessage(), e);
}
import org.openhab.binding.surepetcare.internal.dto.SurePetcareHousehold;
import org.openhab.binding.surepetcare.internal.dto.SurePetcarePet;
import org.openhab.binding.surepetcare.internal.handler.SurePetcareBridgeHandler;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
import org.openhab.core.config.discovery.DiscoveryService;
import org.openhab.core.thing.ThingStatus;
import org.openhab.core.thing.ThingTypeUID;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Rene Scherer - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = SurePetcareDiscoveryService.class)
@NonNullByDefault
-public class SurePetcareDiscoveryService extends AbstractDiscoveryService
- implements DiscoveryService, ThingHandlerService {
+public class SurePetcareDiscoveryService extends AbstractThingHandlerDiscoveryService<SurePetcareBridgeHandler> {
private final Logger logger = LoggerFactory.getLogger(SurePetcareDiscoveryService.class);
private @Nullable ScheduledFuture<?> discoveryJob;
- private @NonNullByDefault({}) SurePetcareBridgeHandler bridgeHandler;
private @NonNullByDefault({}) ThingUID bridgeUID;
/**
* Creates a SurePetcareDiscoveryService with enabled autostart.
*/
public SurePetcareDiscoveryService() {
- super(SUPPORTED_THING_TYPES, DISCOVER_TIMEOUT_SECONDS);
+ super(SurePetcareBridgeHandler.class, SUPPORTED_THING_TYPES, DISCOVER_TIMEOUT_SECONDS);
}
@Override
super.activate(properties);
}
- /* We override this method to allow a call from the thing handler factory */
@Override
- public void deactivate() {
- super.deactivate();
- }
-
- @Override
- public void setThingHandler(@Nullable ThingHandler handler) {
- if (handler instanceof SurePetcareBridgeHandler bridgeHandler) {
- this.bridgeHandler = bridgeHandler;
- bridgeUID = bridgeHandler.getUID();
- }
- }
-
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return bridgeHandler;
+ public void initialize() {
+ bridgeUID = thingHandler.getUID();
+ super.initialize();
}
@Override
logger.debug("Starting Sure Petcare discovery scan");
// If the bridge is not online no other thing devices can be found, so no reason to scan at this moment.
removeOlderResults(getTimestampOfLastScan());
- if (bridgeHandler.getThing().getStatus() == ThingStatus.ONLINE) {
+ if (thingHandler.getThing().getStatus() == ThingStatus.ONLINE) {
logger.debug("Starting device discovery for bridge {}", bridgeUID);
- bridgeHandler.listHouseholds().forEach(this::householdDiscovered);
- bridgeHandler.listPets().forEach(this::petDiscovered);
- bridgeHandler.listDevices().forEach(this::deviceDiscovered);
+ thingHandler.listHouseholds().forEach(this::householdDiscovered);
+ thingHandler.listPets().forEach(this::petDiscovered);
+ thingHandler.listDevices().forEach(this::deviceDiscovered);
}
}
import java.util.Map;
import org.eclipse.jdt.annotation.NonNullByDefault;
-import org.eclipse.jdt.annotation.Nullable;
import org.openhab.binding.tapocontrol.internal.device.TapoBridgeHandler;
import org.openhab.binding.tapocontrol.internal.structures.TapoBridgeConfiguration;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResult;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
+import org.openhab.core.config.discovery.DiscoveryService;
import org.openhab.core.thing.Thing;
import org.openhab.core.thing.ThingTypeUID;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Christian Wild - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = TapoDiscoveryService.class)
@NonNullByDefault
-public class TapoDiscoveryService extends AbstractDiscoveryService implements ThingHandlerService {
+public class TapoDiscoveryService extends AbstractThingHandlerDiscoveryService<TapoBridgeHandler> {
private final Logger logger = LoggerFactory.getLogger(TapoDiscoveryService.class);
- protected @NonNullByDefault({}) TapoBridgeHandler bridge;
/***********************************
*
* INIT CLASS
*/
public TapoDiscoveryService() {
- super(SUPPORTED_THING_TYPES_UIDS, TAPO_DISCOVERY_TIMEOUT_S, false);
+ super(TapoBridgeHandler.class, SUPPORTED_THING_TYPES_UIDS, TAPO_DISCOVERY_TIMEOUT_S, false);
}
- /**
- * activate
- */
@Override
- public void activate() {
- TapoBridgeConfiguration config = bridge.getBridgeConfig();
- if (config.cloudDiscovery) {
- startBackgroundDiscovery();
- }
- }
-
- /**
- * deactivate
- */
- @Override
- public void deactivate() {
- super.deactivate();
- }
-
- @Override
- public void setThingHandler(@Nullable ThingHandler handler) {
- if (handler instanceof TapoBridgeHandler tapoBridge) {
- tapoBridge.setDiscoveryService(this);
- this.bridge = tapoBridge;
- }
- }
-
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return this.bridge;
+ public void initialize() {
+ thingHandler.setDiscoveryService(this);
+ TapoBridgeConfiguration config = thingHandler.getBridgeConfig();
+ modified(Map.of(DiscoveryService.CONFIG_PROPERTY_BACKGROUND_DISCOVERY, config.cloudDiscovery));
+ super.initialize();
}
/***********************************
@Override
public void startScan() {
removeOlderResults(getTimestampOfLastScan());
- if (bridge != null) {
- JsonArray jsonArray = bridge.getDeviceList();
- handleCloudDevices(jsonArray);
- }
+ JsonArray jsonArray = thingHandler.getDeviceList();
+ handleCloudDevices(jsonArray);
}
/***********************************
* @return DiscoveryResult-Object
*/
public DiscoveryResult createResult(JsonObject device) {
- TapoBridgeHandler tapoBridge = this.bridge;
String deviceModel = getDeviceModel(device);
String label = getDeviceLabel(device);
String deviceMAC = device.get(CLOUD_JSON_KEY_MAC).getAsString();
properties.put(Thing.PROPERTY_SERIAL_NUMBER, device.get(CLOUD_JSON_KEY_ID).getAsString());
logger.debug("device {} discovered", deviceModel);
- if (tapoBridge != null) {
- ThingUID bridgeUID = tapoBridge.getUID();
- ThingUID thingUID = new ThingUID(thingTypeUID, bridgeUID, deviceMAC);
- return DiscoveryResultBuilder.create(thingUID).withProperties(properties)
- .withRepresentationProperty(DEVICE_REPRESENTATION_PROPERTY).withBridge(bridgeUID).withLabel(label)
- .build();
- } else {
- ThingUID thingUID = new ThingUID(BINDING_ID, deviceMAC);
- return DiscoveryResultBuilder.create(thingUID).withProperties(properties)
- .withRepresentationProperty(DEVICE_REPRESENTATION_PROPERTY).withLabel(label).build();
- }
+ ThingUID bridgeUID = thingHandler.getUID();
+ ThingUID thingUID = new ThingUID(thingTypeUID, bridgeUID, deviceMAC);
+ return DiscoveryResultBuilder.create(thingUID).withProperties(properties)
+ .withRepresentationProperty(DEVICE_REPRESENTATION_PROPERTY).withBridge(bridgeUID).withLabel(label)
+ .build();
}
/**
import org.openhab.core.thing.binding.ThingActions;
import org.openhab.core.thing.binding.ThingActionsScope;
import org.openhab.core.thing.binding.ThingHandler;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Alexander Krasnogolowy - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = TelegramActions.class)
@ThingActionsScope(name = "telegram")
@NonNullByDefault
public class TelegramActions implements ThingActions {
import java.util.Set;
import org.eclipse.jdt.annotation.NonNullByDefault;
-import org.eclipse.jdt.annotation.Nullable;
import org.openhab.binding.teleinfo.internal.data.Frame;
import org.openhab.binding.teleinfo.internal.handler.TeleinfoAbstractControllerHandler;
import org.openhab.binding.teleinfo.internal.handler.TeleinfoControllerHandlerListener;
import org.openhab.binding.teleinfo.internal.reader.io.serialport.InvalidFrameException;
import org.openhab.binding.teleinfo.internal.reader.io.serialport.Label;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResult;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
-import org.openhab.core.config.discovery.DiscoveryService;
import org.openhab.core.thing.ThingTypeUID;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Nicolas SIBERIL - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = TeleinfoDiscoveryService.class)
@NonNullByDefault
-public class TeleinfoDiscoveryService extends AbstractDiscoveryService
- implements TeleinfoControllerHandlerListener, ThingHandlerService, DiscoveryService {
+public class TeleinfoDiscoveryService extends AbstractThingHandlerDiscoveryService<TeleinfoAbstractControllerHandler>
+ implements TeleinfoControllerHandlerListener {
private static final Set<ThingTypeUID> SUPPORTED_THING_TYPES = Set.of(THING_HC_CBEMM_ELECTRICITY_METER_TYPE_UID,
THING_BASE_CBEMM_ELECTRICITY_METER_TYPE_UID, THING_TEMPO_CBEMM_ELECTRICITY_METER_TYPE_UID,
private static final int SCAN_DURATION_IN_S = 60;
private final Logger logger = LoggerFactory.getLogger(TeleinfoDiscoveryService.class);
- private @Nullable TeleinfoAbstractControllerHandler controllerHandler;
public TeleinfoDiscoveryService() {
- super(SCAN_DURATION_IN_S);
+ super(TeleinfoAbstractControllerHandler.class, SCAN_DURATION_IN_S);
}
public TeleinfoDiscoveryService(TeleinfoAbstractControllerHandler controllerHandler) {
- super(SCAN_DURATION_IN_S);
- this.controllerHandler = controllerHandler;
+ this();
+ setThingHandler(controllerHandler);
}
@Override
return SUPPORTED_THING_TYPES;
}
- @Override
- public void activate() {
- TeleinfoAbstractControllerHandler controllerHandlerRef = controllerHandler;
- if (controllerHandlerRef != null) {
- logger.debug("Teleinfo discovery: Activate {}", controllerHandlerRef.getThing().getUID());
- } else {
- logNullControllerHandler();
- }
- }
-
- @Override
- public void deactivate() {
- TeleinfoAbstractControllerHandler controllerHandlerRef = controllerHandler;
- if (controllerHandlerRef != null) {
- logger.debug("Teleinfo discovery: Deactivate {}", controllerHandlerRef.getThing().getUID());
- } else {
- logNullControllerHandler();
- }
- }
-
@Override
protected void startScan() {
- TeleinfoAbstractControllerHandler controllerHandlerRef = controllerHandler;
- if (controllerHandlerRef != null) {
- logger.debug("Teleinfo discovery: Start {}", controllerHandlerRef.getThing().getUID());
+ logger.debug("Teleinfo discovery: Start {}", thingHandler.getThing().getUID());
- // Start the search for new devices
- controllerHandlerRef.addListener(this);
- } else {
- logNullControllerHandler();
- }
+ // Start the search for new devices
+ thingHandler.addListener(this);
}
@Override
public synchronized void abortScan() {
- TeleinfoAbstractControllerHandler controllerHandlerRef = controllerHandler;
- if (controllerHandlerRef != null) {
- logger.debug("Teleinfo discovery: Abort {}", controllerHandlerRef.getThing().getUID());
- controllerHandlerRef.removeListener(this);
- super.abortScan();
- } else {
- logNullControllerHandler();
- }
+ logger.debug("Teleinfo discovery: Abort {}", thingHandler.getThing().getUID());
+ thingHandler.removeListener(this);
+ super.abortScan();
}
@Override
protected synchronized void stopScan() {
- TeleinfoAbstractControllerHandler controllerHandlerRef = controllerHandler;
- if (controllerHandlerRef != null) {
- logger.debug("Teleinfo discovery: Stop {}", controllerHandlerRef.getThing().getUID());
- controllerHandlerRef.removeListener(this);
- super.stopScan();
- } else {
- logNullControllerHandler();
- }
+ logger.debug("Teleinfo discovery: Stop {}", thingHandler.getThing().getUID());
+ thingHandler.removeListener(this);
+ super.stopScan();
}
@Override
}
private void detectNewElectricityMeterFromReceivedFrame(final Frame frameSample) {
- TeleinfoAbstractControllerHandler controllerHandlerRef = controllerHandler;
- if (controllerHandlerRef != null) {
- logger.debug("New eletricity meter detection from frame {}", frameSample);
- if (frameSample.get(Label.ADCO) == null && frameSample.get(Label.ADSC) == null) {
- throw new IllegalStateException("Missing ADCO or ADSC key");
- }
-
- String adco = frameSample.get(Label.ADCO) != null ? frameSample.get(Label.ADCO)
- : frameSample.get(Label.ADSC);
- if (adco != null) {
- ThingUID thingUID = new ThingUID(getThingTypeUID(frameSample), adco,
- controllerHandlerRef.getThing().getUID().getId());
-
- final Map<String, Object> properties = getThingProperties(adco);
- final String representationProperty = THING_ELECTRICITY_METER_PROPERTY_ADCO;
- DiscoveryResult discoveryResult = DiscoveryResultBuilder.create(thingUID).withProperties(properties)
- .withLabel("Teleinfo ADCO/ADSC " + adco).withThingType(getThingTypeUID(frameSample))
- .withBridge(controllerHandlerRef.getThing().getUID())
- .withRepresentationProperty(representationProperty).build();
-
- thingDiscovered(discoveryResult);
- }
- } else {
- logNullControllerHandler();
+ logger.debug("New eletricity meter detection from frame {}", frameSample);
+ if (frameSample.get(Label.ADCO) == null && frameSample.get(Label.ADSC) == null) {
+ throw new IllegalStateException("Missing ADCO or ADSC key");
+ }
+
+ String adco = frameSample.get(Label.ADCO) != null ? frameSample.get(Label.ADCO) : frameSample.get(Label.ADSC);
+ if (adco != null) {
+ ThingUID thingUID = new ThingUID(getThingTypeUID(frameSample), adco,
+ thingHandler.getThing().getUID().getId());
+
+ final Map<String, Object> properties = getThingProperties(adco);
+ final String representationProperty = THING_ELECTRICITY_METER_PROPERTY_ADCO;
+ DiscoveryResult discoveryResult = DiscoveryResultBuilder.create(thingUID).withProperties(properties)
+ .withLabel("Teleinfo ADCO/ADSC " + adco).withThingType(getThingTypeUID(frameSample))
+ .withBridge(thingHandler.getThing().getUID()).withRepresentationProperty(representationProperty)
+ .build();
+
+ thingDiscovered(discoveryResult);
}
}
return properties;
}
-
- @Override
- public void setThingHandler(@Nullable ThingHandler handler) {
- if (handler instanceof TeleinfoAbstractControllerHandler teleinfoAbstractControllerHandler) {
- controllerHandler = teleinfoAbstractControllerHandler;
- }
- }
-
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return controllerHandler;
- }
-
- private void logNullControllerHandler() {
- logger.warn("Null controller handler");
- }
}
*/
package org.openhab.binding.tesla.internal.discovery;
-import java.util.Map;
-
+import org.eclipse.jdt.annotation.NonNull;
import org.openhab.binding.tesla.internal.TeslaBindingConstants;
import org.openhab.binding.tesla.internal.TeslaHandlerFactory;
import org.openhab.binding.tesla.internal.handler.TeslaAccountHandler;
import org.openhab.binding.tesla.internal.handler.VehicleListener;
import org.openhab.binding.tesla.internal.protocol.Vehicle;
import org.openhab.binding.tesla.internal.protocol.VehicleConfig;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResult;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
-import org.openhab.core.config.discovery.DiscoveryService;
import org.openhab.core.thing.ThingTypeUID;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
* @author Kai Kreuzer - Initial contribution
*
*/
-@Component(service = ThingHandlerService.class)
-public class TeslaVehicleDiscoveryService extends AbstractDiscoveryService
- implements DiscoveryService, VehicleListener, ThingHandlerService {
+@Component(scope = ServiceScope.PROTOTYPE, service = TeslaVehicleDiscoveryService.class)
+public class TeslaVehicleDiscoveryService extends AbstractThingHandlerDiscoveryService<@NonNull TeslaAccountHandler>
+ implements VehicleListener {
private final Logger logger = LoggerFactory.getLogger(TeslaVehicleDiscoveryService.class);
public TeslaVehicleDiscoveryService() throws IllegalArgumentException {
- super(TeslaHandlerFactory.SUPPORTED_THING_TYPES_UIDS, 10, true);
- }
-
- private TeslaAccountHandler handler;
-
- @Override
- public void setThingHandler(ThingHandler handler) {
- this.handler = (TeslaAccountHandler) handler;
- this.handler.addVehicleListener(this);
+ super(TeslaAccountHandler.class, TeslaHandlerFactory.SUPPORTED_THING_TYPES_UIDS, 10, true);
}
@Override
- public ThingHandler getThingHandler() {
- return handler;
+ public void initialize() {
+ thingHandler.addVehicleListener(this);
+ super.initialize();
}
@Override
protected void startScan() {
- handler.scanForVehicles();
+ thingHandler.scanForVehicles();
}
@Override
- public void activate(Map<String, Object> configProperties) {
- super.activate(configProperties);
- }
-
- @Override
- public void deactivate() {
- super.deactivate();
- if (handler != null) {
- handler.removeVehicleListener(this);
- }
+ public void dispose() {
+ super.dispose();
+ thingHandler.removeVehicleListener(this);
}
@Override
: vehicleConfig.identifyModel();
if (type != null) {
logger.debug("Found a {} vehicle", type.getId());
- ThingUID thingUID = new ThingUID(type, handler.getThing().getUID(), vehicle.vin);
+ ThingUID thingUID = new ThingUID(type, thingHandler.getThing().getUID(), vehicle.vin);
DiscoveryResult discoveryResult = DiscoveryResultBuilder.create(thingUID).withLabel(vehicle.display_name)
- .withBridge(handler.getThing().getUID()).withProperty(TeslaBindingConstants.VIN, vehicle.vin)
+ .withBridge(thingHandler.getThing().getUID()).withProperty(TeslaBindingConstants.VIN, vehicle.vin)
.build();
thingDiscovered(discoveryResult);
}
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;
-import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.NonNullByDefault;
import org.eclipse.jdt.annotation.Nullable;
import org.openhab.binding.touchwand.internal.TouchWandBridgeHandler;
import org.openhab.binding.touchwand.internal.dto.TouchWandUnitData;
import org.openhab.binding.touchwand.internal.dto.TouchWandUnitFromJson;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
import org.openhab.core.thing.ThingStatus;
import org.openhab.core.thing.ThingTypeUID;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Roie Geron - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = TouchWandUnitDiscoveryService.class)
@NonNullByDefault
-public class TouchWandUnitDiscoveryService extends AbstractDiscoveryService implements ThingHandlerService {
+public class TouchWandUnitDiscoveryService extends AbstractThingHandlerDiscoveryService<TouchWandBridgeHandler> {
private static final int SEARCH_TIME_SEC = 10;
private static final int SCAN_INTERVAL_SEC = 60;
private static final int LINK_DISCOVERY_SERVICE_INITIAL_DELAY_SEC = 5;
private static final String[] CONNECTIVITY_OPTIONS = { CONNECTIVITY_KNX, CONNECTIVITY_ZWAVE, CONNECTIVITY_RISCO,
CONNECTIVITY_PIMA, CONNECTIVITY_ACWAND };
- private @NonNullByDefault({}) TouchWandBridgeHandler touchWandBridgeHandler;
private final Logger logger = LoggerFactory.getLogger(TouchWandUnitDiscoveryService.class);
private @Nullable ScheduledFuture<?> scanningJob;
public TouchWandUnitDiscoveryService() {
- super(SUPPORTED_THING_TYPES_UIDS, SEARCH_TIME_SEC, true);
+ super(TouchWandBridgeHandler.class, SUPPORTED_THING_TYPES_UIDS, SEARCH_TIME_SEC, true);
}
@Override
protected void startScan() {
- if (touchWandBridgeHandler.getThing().getStatus() != ThingStatus.ONLINE) {
+ if (thingHandler.getThing().getStatus() != ThingStatus.ONLINE) {
logger.debug("Could not scan units while bridge offline");
return;
}
- logger.debug("Starting TouchWand discovery on bridge {}", touchWandBridgeHandler.getThing().getUID());
- String response = touchWandBridgeHandler.touchWandClient.cmdListUnits();
+ logger.debug("Starting TouchWand discovery on bridge {}", thingHandler.getThing().getUID());
+ String response = thingHandler.touchWandClient.cmdListUnits();
if (response.isEmpty()) {
return;
}
TouchWandUnitData touchWandUnit;
touchWandUnit = TouchWandUnitFromJson.parseResponse(unit.getAsJsonObject());
- if (!touchWandBridgeHandler.isAddSecondaryControllerUnits()) {
+ if (!thingHandler.isAddSecondaryControllerUnits()) {
if (!Arrays.asList(CONNECTIVITY_OPTIONS).contains(touchWandUnit.getConnectivity())) {
continue;
}
}
@Override
- public void activate() {
- super.activate(null);
- removeOlderResults(new Date().getTime(), touchWandBridgeHandler.getThing().getUID());
+ public void initialize() {
+ removeOlderResults(new Date().getTime(), thingHandler.getThing().getUID());
+ super.initialize();
}
@Override
- public void deactivate() {
- removeOlderResults(new Date().getTime(), touchWandBridgeHandler.getThing().getUID());
- super.deactivate();
+ public void dispose() {
+ super.dispose();
+ removeOlderResults(new Date().getTime(), thingHandler.getThing().getUID());
}
@Override
}
private void addDeviceDiscoveryResult(TouchWandUnitData unit, ThingTypeUID typeUID) {
- ThingUID bridgeUID = touchWandBridgeHandler.getThing().getUID();
+ ThingUID bridgeUID = thingHandler.getThing().getUID();
ThingUID thingUID = new ThingUID(typeUID, bridgeUID, unit.getId().toString());
Map<String, Object> properties = new HashMap<>();
properties.put(HANDLER_PROPERTIES_ID, unit.getId().toString());
);
// @formatter:on
}
-
- @Override
- public void setThingHandler(@NonNullByDefault({}) ThingHandler handler) {
- if (handler instanceof TouchWandBridgeHandler touchWandBridgeHandler) {
- this.touchWandBridgeHandler = touchWandBridgeHandler;
- }
- }
-
- @Override
- public @NonNull ThingHandler getThingHandler() {
- return touchWandBridgeHandler;
- }
}
import org.openhab.core.thing.binding.ThingActionsScope;
import org.openhab.core.thing.binding.ThingHandler;
import org.openhab.core.thing.binding.ThingHandlerService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Hilbrand Bouwkamp - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = TPLinkSmartHomeActions.class)
@ThingActionsScope(name = "tplinksmarthome")
@NonNullByDefault
public class TPLinkSmartHomeActions implements ThingActions, ThingHandlerService {
import org.openhab.core.thing.binding.ThingActions;
import org.openhab.core.thing.binding.ThingActionsScope;
import org.openhab.core.thing.binding.ThingHandler;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Jan N. Klug - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = FritzboxActions.class)
@ThingActionsScope(name = "tr064")
@NonNullByDefault
public class FritzboxActions implements ThingActions {
import java.util.Set;
import org.eclipse.jdt.annotation.NonNullByDefault;
-import org.eclipse.jdt.annotation.Nullable;
import org.openhab.binding.tr064.internal.dto.scpd.root.SCPDDeviceType;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResult;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
import org.openhab.core.thing.ThingTypeUID;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.BridgeHandler;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
import org.openhab.core.util.UIDUtils;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Jan N. Klug - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = Tr064DiscoveryService.class)
@NonNullByDefault
-public class Tr064DiscoveryService extends AbstractDiscoveryService implements ThingHandlerService {
+public class Tr064DiscoveryService extends AbstractThingHandlerDiscoveryService<Tr064RootHandler> {
private static final int SEARCH_TIME = 5;
public static final Set<ThingTypeUID> SUPPORTED_THING_TYPES = Set.of(THING_TYPE_SUBDEVICE);
private final Logger logger = LoggerFactory.getLogger(Tr064DiscoveryService.class);
- private @Nullable Tr064RootHandler bridgeHandler;
public Tr064DiscoveryService() {
- super(SEARCH_TIME);
+ super(Tr064RootHandler.class, SEARCH_TIME);
}
@Override
- public void setThingHandler(ThingHandler thingHandler) {
- if (thingHandler instanceof Tr064RootHandler tr064RootHandler) {
- this.bridgeHandler = tr064RootHandler;
- }
- }
-
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return bridgeHandler;
- }
-
- @Override
- public void deactivate() {
- BridgeHandler bridgeHandler = this.bridgeHandler;
- if (bridgeHandler == null) {
- logger.warn("Bridgehandler not found, could not cleanup discovery results.");
- return;
- }
- removeOlderResults(new Date().getTime(), bridgeHandler.getThing().getUID());
+ public void dispose() {
+ super.dispose();
+ removeOlderResults(new Date().getTime(), thingHandler.getThing().getUID());
}
@Override
@Override
public void startScan() {
- Tr064RootHandler bridgeHandler = this.bridgeHandler;
- if (bridgeHandler == null) {
- logger.warn("Could not start discovery, bridge handler not set");
- return;
- }
- List<SCPDDeviceType> devices = bridgeHandler.getAllSubDevices();
- ThingUID bridgeUID = bridgeHandler.getThing().getUID();
+ List<SCPDDeviceType> devices = thingHandler.getAllSubDevices();
+ ThingUID bridgeUID = thingHandler.getThing().getUID();
devices.forEach(device -> {
logger.trace("Trying to add {} to discovery results on {}", device, bridgeUID);
String udn = device.getUDN();
import org.eclipse.jdt.annotation.Nullable;
import org.openhab.binding.tradfri.internal.DeviceUpdateListener;
import org.openhab.binding.tradfri.internal.handler.TradfriGatewayHandler;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResult;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
-import org.openhab.core.config.discovery.DiscoveryService;
import org.openhab.core.thing.ThingTypeUID;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
* @author Manuel Raffel - Added support for blinds
* @author Vivien Boistuaud - Added support for Air Purifiers
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = TradfriDiscoveryService.class)
@NonNullByDefault
-public class TradfriDiscoveryService extends AbstractDiscoveryService
- implements DeviceUpdateListener, DiscoveryService, ThingHandlerService {
+public class TradfriDiscoveryService extends AbstractThingHandlerDiscoveryService<TradfriGatewayHandler>
+ implements DeviceUpdateListener {
private final Logger logger = LoggerFactory.getLogger(TradfriDiscoveryService.class);
- private @Nullable TradfriGatewayHandler handler;
-
private static final String REMOTE_CONTROLLER_MODEL = "TRADFRI remote control";
private static final Set<String> COLOR_TEMP_MODELS = Collections
private static final String[] COLOR_MODEL_IDENTIFIER_HINTS = new String[] { "CWS", " C/WS " };
public TradfriDiscoveryService() {
- super(SUPPORTED_DEVICE_TYPES_UIDS, 10, true);
+ super(TradfriGatewayHandler.class, SUPPORTED_DEVICE_TYPES_UIDS, 10, true);
}
@Override
protected void startScan() {
- handler.startScan();
+ thingHandler.startScan();
}
@Override
}
@Override
- public void setThingHandler(@Nullable ThingHandler handler) {
- if (handler instanceof TradfriGatewayHandler gatewayHandler) {
- this.handler = gatewayHandler;
- }
- }
-
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return handler;
- }
-
- @Override
- public void activate() {
- handler.registerDeviceUpdateListener(this);
+ public void initialize() {
+ thingHandler.registerDeviceUpdateListener(this);
+ super.initialize();
}
@Override
- public void deactivate() {
+ public void dispose() {
+ super.dispose();
removeOlderResults(new Date().getTime());
- handler.unregisterDeviceUpdateListener(this);
+ thingHandler.unregisterDeviceUpdateListener(this);
}
@Override
public void onUpdate(@Nullable String instanceId, @Nullable JsonObject data) {
- ThingUID bridge = handler.getThing().getUID();
+ ThingUID bridge = thingHandler.getThing().getUID();
try {
if (data != null && data.has(INSTANCE_ID)) {
int id = data.get(INSTANCE_ID).getAsInt();
import org.openhab.core.thing.binding.ThingActions;
import org.openhab.core.thing.binding.ThingActionsScope;
import org.openhab.core.thing.binding.ThingHandler;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Mark Herwege - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = UniFiSiteActions.class)
@ThingActionsScope(name = "unifi")
@NonNullByDefault
public class UniFiSiteActions implements ThingActions {
import org.openhab.binding.unifi.internal.api.dto.UniFiSite;
import org.openhab.binding.unifi.internal.api.dto.UniFiSwitchPorts;
import org.openhab.binding.unifi.internal.api.dto.UniFiWlan;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
-import org.openhab.core.config.discovery.DiscoveryService;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Hilbrand Bouwkamp - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = UniFiThingDiscoveryService.class)
@NonNullByDefault
-public class UniFiThingDiscoveryService extends AbstractDiscoveryService
- implements ThingHandlerService, DiscoveryService {
+public class UniFiThingDiscoveryService extends AbstractThingHandlerDiscoveryService<UniFiControllerThingHandler> {
/**
* Timeout for discovery time.
private final Logger logger = LoggerFactory.getLogger(UniFiThingDiscoveryService.class);
- private @Nullable UniFiControllerThingHandler bridgeHandler;
-
public UniFiThingDiscoveryService() {
- super(UniFiBindingConstants.THING_TYPE_SUPPORTED, UNIFI_DISCOVERY_TIMEOUT_SECONDS, false);
- }
-
- @Override
- public void deactivate() {
- super.deactivate();
- }
-
- @Override
- public void setThingHandler(final ThingHandler handler) {
- if (handler instanceof UniFiControllerThingHandler controllerThingHandler) {
- bridgeHandler = controllerThingHandler;
- }
- }
-
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return bridgeHandler;
+ super(UniFiControllerThingHandler.class, UniFiBindingConstants.THING_TYPE_SUPPORTED,
+ UNIFI_DISCOVERY_TIMEOUT_SECONDS, false);
}
@Override
protected void startScan() {
removeOlderResults(getTimestampOfLastScan());
- final UniFiControllerThingHandler bh = bridgeHandler;
- if (bh == null) {
- return;
- }
- final UniFiController controller = bh.getController();
+ final UniFiController controller = thingHandler.getController();
if (controller == null) {
return;
}
try {
controller.refresh();
final UniFiControllerCache cache = controller.getCache();
- final ThingUID bridgeUID = bh.getThing().getUID();
+ final ThingUID bridgeUID = thingHandler.getThing().getUID();
discoverSites(cache, bridgeUID);
discoverWlans(cache, bridgeUID);
import java.util.Map;
import org.eclipse.jdt.annotation.NonNullByDefault;
-import org.eclipse.jdt.annotation.Nullable;
import org.openhab.binding.velbus.internal.VelbusChannelIdentifier;
import org.openhab.binding.velbus.internal.VelbusFirstGenerationDeviceModuleAddress;
import org.openhab.binding.velbus.internal.VelbusModule;
import org.openhab.binding.velbus.internal.handler.VelbusBridgeHandler;
import org.openhab.binding.velbus.internal.packets.VelbusPacket;
import org.openhab.binding.velbus.internal.packets.VelbusScanPacket;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResult;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Cedric Boon - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = VelbusThingDiscoveryService.class)
@NonNullByDefault
-public class VelbusThingDiscoveryService extends AbstractDiscoveryService
- implements ThingHandlerService, VelbusPacketListener {
+public class VelbusThingDiscoveryService extends AbstractThingHandlerDiscoveryService<VelbusBridgeHandler>
+ implements VelbusPacketListener {
private static final int SEARCH_TIME = 60;
private final Logger logger = LoggerFactory.getLogger(VelbusThingDiscoveryService.class);
private Map<Byte, VelbusModule> velbusModules = new HashMap<>();
- private @Nullable VelbusBridgeHandler velbusBridgeHandler;
-
public VelbusThingDiscoveryService() {
- super(SUPPORTED_THING_TYPES_UIDS, SEARCH_TIME);
+ super(VelbusBridgeHandler.class, SUPPORTED_THING_TYPES_UIDS, SEARCH_TIME);
}
@Override
- public void deactivate() {
+ public void dispose() {
+ super.dispose();
removeOlderResults(new Date().getTime());
-
- final VelbusBridgeHandler velbusBridgeHandler = this.velbusBridgeHandler;
- if (velbusBridgeHandler != null) {
- velbusBridgeHandler.clearDefaultPacketListener();
- }
+ thingHandler.clearDefaultPacketListener();
}
@Override
VelbusScanPacket packet = new VelbusScanPacket((byte) i);
byte[] packetBytes = packet.getBytes();
- final VelbusBridgeHandler velbusBridgeHandler = this.velbusBridgeHandler;
- if (velbusBridgeHandler != null) {
- velbusBridgeHandler.sendPacket(packetBytes);
- }
+ thingHandler.sendPacket(packetBytes);
}
}
protected void registerVelbusModule(byte address, VelbusModule velbusModule) {
velbusModules.put(address, velbusModule);
notifyDiscoveredVelbusModule(velbusModule);
- velbusModule.sendChannelNameRequests(velbusBridgeHandler);
+ velbusModule.sendChannelNameRequests(thingHandler);
}
private void handleChannelNameCommand(byte[] packet, byte address, byte length, int namePartNumber) {
}
private void notifyDiscoveredVelbusModule(VelbusModule velbusModule) {
- final VelbusBridgeHandler velbusBridgeHandler = this.velbusBridgeHandler;
- if (velbusBridgeHandler != null) {
- ThingUID bridgeUID = velbusBridgeHandler.getThing().getUID();
+ ThingUID bridgeUID = thingHandler.getThing().getUID();
- DiscoveryResult discoveryResult = DiscoveryResultBuilder.create(velbusModule.getThingUID(bridgeUID))
- .withThingType(velbusModule.getThingTypeUID()).withProperties(velbusModule.getProperties())
- .withRepresentationProperty(ADDRESS).withBridge(bridgeUID).withLabel(velbusModule.getLabel())
- .build();
+ DiscoveryResult discoveryResult = DiscoveryResultBuilder.create(velbusModule.getThingUID(bridgeUID))
+ .withThingType(velbusModule.getThingTypeUID()).withProperties(velbusModule.getProperties())
+ .withRepresentationProperty(ADDRESS).withBridge(bridgeUID).withLabel(velbusModule.getLabel()).build();
- thingDiscovered(discoveryResult);
- }
- }
-
- @Override
- public void setThingHandler(@Nullable ThingHandler handler) {
- if (handler instanceof VelbusBridgeHandler velbusBridgeHandler) {
- this.velbusBridgeHandler = velbusBridgeHandler;
- velbusBridgeHandler.setDefaultPacketListener(this);
- }
+ thingDiscovered(discoveryResult);
}
@Override
- public @Nullable ThingHandler getThingHandler() {
- return this.velbusBridgeHandler;
+ public void initialize() {
+ thingHandler.setDefaultPacketListener(this);
+ super.initialize();
}
}
import org.openhab.core.thing.binding.ThingActions;
import org.openhab.core.thing.binding.ThingActionsScope;
import org.openhab.core.thing.binding.ThingHandler;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Andrew Fiddian-Green - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = VeluxActions.class)
@ThingActionsScope(name = "velux")
@NonNullByDefault
public class VeluxActions implements ThingActions {
import org.openhab.binding.verisure.internal.VerisureThingConfiguration;
import org.openhab.binding.verisure.internal.dto.VerisureThingDTO;
import org.openhab.binding.verisure.internal.handler.VerisureBridgeHandler;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResult;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
import org.openhab.core.config.discovery.DiscoveryService;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
* @author Jan Gustafsson - Further development
*
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = VerisureThingDiscoveryService.class)
@NonNullByDefault
-public class VerisureThingDiscoveryService extends AbstractDiscoveryService
- implements DiscoveryService, ThingHandlerService {
+public class VerisureThingDiscoveryService extends AbstractThingHandlerDiscoveryService<VerisureBridgeHandler> {
private static final int SEARCH_TIME_SECONDS = 60;
private final Logger logger = LoggerFactory.getLogger(VerisureThingDiscoveryService.class);
-
- private @NonNullByDefault({}) VerisureBridgeHandler verisureBridgeHandler;
private @NonNullByDefault({}) ThingUID bridgeUID;
public VerisureThingDiscoveryService() {
- super(VerisureHandlerFactory.SUPPORTED_THING_TYPES, SEARCH_TIME_SECONDS);
+ super(VerisureBridgeHandler.class, VerisureHandlerFactory.SUPPORTED_THING_TYPES, SEARCH_TIME_SECONDS);
}
@Override
public void startScan() {
logger.debug("VerisureThingDiscoveryService:startScan");
removeOlderResults(getTimestampOfLastScan());
- if (verisureBridgeHandler != null) {
- VerisureSession session = verisureBridgeHandler.getSession();
- if (session != null) {
- Collection<VerisureThingDTO> verisureThings = session.getVerisureThings();
- verisureThings.stream().forEach(thing -> {
- logger.debug("Discovered thing: {}", thing);
- onThingAddedInternal(thing);
- });
- }
+ VerisureSession session = thingHandler.getSession();
+ if (session != null) {
+ Collection<VerisureThingDTO> verisureThings = session.getVerisureThings();
+ verisureThings.stream().forEach(thing -> {
+ logger.debug("Discovered thing: {}", thing);
+ onThingAddedInternal(thing);
+ });
}
}
ThingUID thingUID = getThingUID(thing);
String deviceId = thing.getDeviceId();
if (thingUID != null) {
- if (verisureBridgeHandler != null) {
- String className = thing.getClass().getSimpleName();
- String label = "Type: " + className + " Device Id: " + deviceId;
- if (thing.getLocation() != null) {
- label += ", Location: " + thing.getLocation();
- }
- if (thing.getSiteName() != null) {
- label += ", Site name: " + thing.getSiteName();
- }
- DiscoveryResult discoveryResult = DiscoveryResultBuilder.create(thingUID).withBridge(bridgeUID)
- .withLabel(label).withProperty(VerisureThingConfiguration.DEVICE_ID_LABEL, deviceId)
- .withRepresentationProperty(VerisureThingConfiguration.DEVICE_ID_LABEL).build();
- logger.debug("thinguid: {}, bridge {}, label {}", thingUID, bridgeUID, deviceId);
- thingDiscovered(discoveryResult);
+ String className = thing.getClass().getSimpleName();
+ String label = "Type: " + className + " Device Id: " + deviceId;
+ if (thing.getLocation() != null) {
+ label += ", Location: " + thing.getLocation();
+ }
+ if (thing.getSiteName() != null) {
+ label += ", Site name: " + thing.getSiteName();
}
+ DiscoveryResult discoveryResult = DiscoveryResultBuilder.create(thingUID).withBridge(bridgeUID)
+ .withLabel(label).withProperty(VerisureThingConfiguration.DEVICE_ID_LABEL, deviceId)
+ .withRepresentationProperty(VerisureThingConfiguration.DEVICE_ID_LABEL).build();
+ logger.debug("thinguid: {}, bridge {}, label {}", thingUID, bridgeUID, deviceId);
+ thingDiscovered(discoveryResult);
} else {
logger.debug("Discovered unsupported thing of type '{}' with deviceId {}", thing.getClass(), deviceId);
}
private @Nullable ThingUID getThingUID(VerisureThingDTO thing) {
ThingUID thingUID = null;
- if (verisureBridgeHandler != null) {
- String deviceId = thing.getDeviceId();
- // Make sure device id is normalized, i.e. replace all non character/digits with empty string
- deviceId = VerisureThingConfiguration.normalizeDeviceId(deviceId);
- thingUID = new ThingUID(thing.getThingTypeUID(), bridgeUID, deviceId);
- }
+ String deviceId = thing.getDeviceId();
+ // Make sure device id is normalized, i.e. replace all non character/digits with empty string
+ deviceId = VerisureThingConfiguration.normalizeDeviceId(deviceId);
+ thingUID = new ThingUID(thing.getThingTypeUID(), bridgeUID, deviceId);
return thingUID;
}
}
@Override
- public void deactivate() {
- super.deactivate();
- }
-
- @Override
- public void setThingHandler(@Nullable ThingHandler handler) {
- if (handler instanceof VerisureBridgeHandler verisureBridgeHandler) {
- this.verisureBridgeHandler = verisureBridgeHandler;
- bridgeUID = verisureBridgeHandler.getUID();
- }
- }
-
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return verisureBridgeHandler;
+ public void initialize() {
+ bridgeUID = thingHandler.getUID();
+ super.initialize();
}
}
import java.util.Set;
import org.eclipse.jdt.annotation.NonNullByDefault;
-import org.eclipse.jdt.annotation.Nullable;
import org.openhab.binding.vesync.internal.handlers.VeSyncBaseDeviceHandler;
import org.openhab.binding.vesync.internal.handlers.VeSyncBridgeHandler;
import org.openhab.binding.vesync.internal.handlers.VeSyncDeviceAirHumidifierHandler;
import org.openhab.binding.vesync.internal.handlers.VeSyncDeviceAirPurifierHandler;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
import org.openhab.core.config.discovery.DiscoveryService;
import org.openhab.core.thing.ThingStatus;
import org.openhab.core.thing.ThingTypeUID;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
/**
* The {@link VeSyncDiscoveryService} is an implementation of a discovery service for VeSync devices. The meta-data is
* @author David Godyear - Initial contribution
*/
@NonNullByDefault
-@Component(service = DiscoveryService.class, immediate = true, configurationPid = "discovery.vesync")
-public class VeSyncDiscoveryService extends AbstractDiscoveryService
- implements DiscoveryService, ThingHandlerService, DeviceMetaDataUpdatedHandler {
-
+@Component(scope = ServiceScope.PROTOTYPE, service = VeSyncDiscoveryService.class, configurationPid = "discovery.vesync")
+public class VeSyncDiscoveryService extends AbstractThingHandlerDiscoveryService<VeSyncBridgeHandler>
+ implements DeviceMetaDataUpdatedHandler {
private static final Set<ThingTypeUID> SUPPORTED_THING_TYPES = Set.of(THING_TYPE_BRIDGE);
private static final int DISCOVER_TIMEOUT_SECONDS = 5;
- private @NonNullByDefault({}) VeSyncBridgeHandler bridgeHandler;
private @NonNullByDefault({}) ThingUID bridgeUID;
/**
* Creates a VeSyncDiscoveryService with enabled autostart.
*/
public VeSyncDiscoveryService() {
- super(SUPPORTED_THING_TYPES, DISCOVER_TIMEOUT_SECONDS);
+ super(VeSyncBridgeHandler.class, SUPPORTED_THING_TYPES, DISCOVER_TIMEOUT_SECONDS);
}
@Override
}
@Override
- public void deactivate() {
- super.deactivate();
- }
-
- @Override
- public void setThingHandler(@Nullable ThingHandler handler) {
- if (handler instanceof VeSyncBridgeHandler veSyncBridgeHandler) {
- bridgeHandler = veSyncBridgeHandler;
- bridgeUID = bridgeHandler.getUID();
- }
- }
-
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return bridgeHandler;
+ public void initialize() {
+ bridgeUID = thingHandler.getUID();
+ super.initialize();
}
@Override
protected void startBackgroundDiscovery() {
- if (bridgeHandler != null) {
- bridgeHandler.registerMetaDataUpdatedHandler(this);
- }
+ thingHandler.registerMetaDataUpdatedHandler(this);
}
@Override
protected void stopBackgroundDiscovery() {
- if (bridgeHandler != null) {
- bridgeHandler.unregisterMetaDataUpdatedHandler(this);
- }
+ thingHandler.unregisterMetaDataUpdatedHandler(this);
}
@Override
protected void startScan() {
// If the bridge is not online no other thing devices can be found, so no reason to scan at this moment.
removeOlderResults(getTimestampOfLastScan());
- if (ThingStatus.ONLINE.equals(bridgeHandler.getThing().getStatus())) {
- bridgeHandler.runDeviceScanSequenceNoAuthErrors();
+ if (ThingStatus.ONLINE.equals(thingHandler.getThing().getStatus())) {
+ thingHandler.runDeviceScanSequenceNoAuthErrors();
}
}
@Override
public void handleMetadataRetrieved(VeSyncBridgeHandler handler) {
- bridgeHandler.getAirPurifiersMetadata().map(apMeta -> {
+ thingHandler.getAirPurifiersMetadata().map(apMeta -> {
final Map<String, Object> properties = new HashMap<>(6);
final String deviceUUID = apMeta.getUuid();
properties.put(DEVICE_PROP_DEVICE_NAME, apMeta.getDeviceName());
.withRepresentationProperty(DEVICE_PROP_DEVICE_MAC_ID).build();
}).forEach(this::thingDiscovered);
- bridgeHandler.getAirHumidifiersMetadata().map(apMeta -> {
+ thingHandler.getAirHumidifiersMetadata().map(apMeta -> {
final Map<String, Object> properties = new HashMap<>(6);
final String deviceUUID = apMeta.getUuid();
properties.put(DEVICE_PROP_DEVICE_NAME, apMeta.getDeviceName());
import org.openhab.core.thing.binding.ThingActions;
import org.openhab.core.thing.binding.ThingActionsScope;
import org.openhab.core.thing.binding.ThingHandler;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Gaël L'hopital - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = VolvoOnCallActions.class)
@ThingActionsScope(name = "volvooncall")
@NonNullByDefault
public class VolvoOnCallActions implements ThingActions {
import org.openhab.binding.volvooncall.internal.dto.CustomerAccounts;
import org.openhab.binding.volvooncall.internal.dto.Vehicles;
import org.openhab.binding.volvooncall.internal.handler.VolvoOnCallBridgeHandler;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Gaël L'hopital - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = VolvoVehicleDiscoveryService.class)
@NonNullByDefault
-public class VolvoVehicleDiscoveryService extends AbstractDiscoveryService implements ThingHandlerService {
+public class VolvoVehicleDiscoveryService extends AbstractThingHandlerDiscoveryService<VolvoOnCallBridgeHandler> {
private static final int SEARCH_TIME = 2;
private final Logger logger = LoggerFactory.getLogger(VolvoVehicleDiscoveryService.class);
- private @Nullable VolvoOnCallBridgeHandler handler;
public VolvoVehicleDiscoveryService() {
- super(SUPPORTED_THING_TYPES_UIDS, SEARCH_TIME);
- }
-
- @Override
- public void setThingHandler(@Nullable ThingHandler handler) {
- if (handler instanceof VolvoOnCallBridgeHandler volvoOnCallBridgeHandler) {
- this.handler = volvoOnCallBridgeHandler;
- }
- }
-
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return handler;
+ super(VolvoOnCallBridgeHandler.class, SUPPORTED_THING_TYPES_UIDS, SEARCH_TIME);
}
@Override
@Override
protected void startScan() {
- VolvoOnCallBridgeHandler bridgeHandler = this.handler;
- if (bridgeHandler != null) {
- ThingUID bridgeUID = bridgeHandler.getThing().getUID();
- VocHttpApi api = bridgeHandler.getApi();
- if (api != null) {
- try {
- CustomerAccounts account = api.getURL("customeraccounts/", CustomerAccounts.class);
- account.accountVehicleRelationsURL.forEach(relationURL -> {
- try {
- AccountVehicleRelation accountVehicle = api.getURL(relationURL,
- AccountVehicleRelation.class);
- logger.debug("Found vehicle : {}", accountVehicle.vehicleId);
+ ThingUID bridgeUID = thingHandler.getThing().getUID();
+ VocHttpApi api = thingHandler.getApi();
+ if (api != null) {
+ try {
+ CustomerAccounts account = api.getURL("customeraccounts/", CustomerAccounts.class);
+ account.accountVehicleRelationsURL.forEach(relationURL -> {
+ try {
+ AccountVehicleRelation accountVehicle = api.getURL(relationURL, AccountVehicleRelation.class);
+ logger.debug("Found vehicle : {}", accountVehicle.vehicleId);
- Vehicles vehicle = api.getURL(accountVehicle.vehicleURL, Vehicles.class);
- Attributes attributes = api.getURL(Attributes.class, vehicle.vehicleId);
+ Vehicles vehicle = api.getURL(accountVehicle.vehicleURL, Vehicles.class);
+ Attributes attributes = api.getURL(Attributes.class, vehicle.vehicleId);
- thingDiscovered(DiscoveryResultBuilder
- .create(new ThingUID(VEHICLE_THING_TYPE, bridgeUID, accountVehicle.vehicleId))
- .withLabel(attributes.vehicleType + " " + attributes.registrationNumber)
- .withBridge(bridgeUID).withProperty(VehicleConfiguration.VIN, attributes.vin)
- .withRepresentationProperty(VehicleConfiguration.VIN).build());
+ thingDiscovered(DiscoveryResultBuilder
+ .create(new ThingUID(VEHICLE_THING_TYPE, bridgeUID, accountVehicle.vehicleId))
+ .withLabel(attributes.vehicleType + " " + attributes.registrationNumber)
+ .withBridge(bridgeUID).withProperty(VehicleConfiguration.VIN, attributes.vin)
+ .withRepresentationProperty(VehicleConfiguration.VIN).build());
- } catch (VolvoOnCallException e) {
- logger.warn("Error while getting vehicle informations : {}", e.getMessage());
- }
- });
- } catch (VolvoOnCallException e) {
- logger.warn("Error while discovering vehicle: {}", e.getMessage());
- }
+ } catch (VolvoOnCallException e) {
+ logger.warn("Error while getting vehicle informations : {}", e.getMessage());
+ }
+ });
+ } catch (VolvoOnCallException e) {
+ logger.warn("Error while discovering vehicle: {}", e.getMessage());
}
}
+
stopScan();
}
}
import org.openhab.binding.warmup.internal.model.query.LocationDTO;
import org.openhab.binding.warmup.internal.model.query.QueryResponseDTO;
import org.openhab.binding.warmup.internal.model.query.RoomDTO;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
-import org.openhab.core.config.discovery.DiscoveryService;
import org.openhab.core.thing.Thing;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
/**
* The {@link WarmupDiscoveryService} is used to discover devices that are connected to a My Warmup account.
*
* @author James Melville - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = WarmupDiscoveryService.class)
@NonNullByDefault
-public class WarmupDiscoveryService extends AbstractDiscoveryService
- implements DiscoveryService, ThingHandlerService, WarmupRefreshListener {
+public class WarmupDiscoveryService extends AbstractThingHandlerDiscoveryService<MyWarmupAccountHandler>
+ implements WarmupRefreshListener {
- private @Nullable MyWarmupAccountHandler bridgeHandler;
private @Nullable ThingUID bridgeUID;
public WarmupDiscoveryService() {
- super(DISCOVERABLE_THING_TYPES_UIDS, 5, false);
+ super(MyWarmupAccountHandler.class, DISCOVERABLE_THING_TYPES_UIDS, 5, false);
}
@Override
@Override
public void startScan() {
- final MyWarmupAccountHandler handler = bridgeHandler;
- if (handler != null) {
- removeOlderResults(getTimestampOfLastScan());
- handler.setDiscoveryService(this);
- }
+ removeOlderResults(getTimestampOfLastScan());
+ thingHandler.setDiscoveryService(this);
}
/**
}
}
}
-
- @Override
- public void setThingHandler(@Nullable final ThingHandler handler) {
- if (handler instanceof MyWarmupAccountHandler accountHandler) {
- bridgeHandler = accountHandler;
- bridgeUID = handler.getThing().getUID();
- } else {
- bridgeHandler = null;
- bridgeUID = null;
- }
- }
-
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return bridgeHandler;
- }
}
import org.openhab.core.thing.binding.ThingActions;
import org.openhab.core.thing.binding.ThingActionsScope;
import org.openhab.core.thing.binding.ThingHandler;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Tom Deckers - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = WebexTeamsActions.class)
@ThingActionsScope(name = "webexteams")
@NonNullByDefault
public class WebexTeamsActions implements ThingActions {
import org.openhab.binding.windcentrale.internal.handler.WindcentraleAccountHandler;
import org.openhab.binding.windcentrale.internal.handler.WindcentraleWindmillHandler;
import org.openhab.binding.windcentrale.internal.listener.ThingStatusListener;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
import org.openhab.core.thing.Thing;
import org.openhab.core.thing.ThingStatus;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
-import org.osgi.service.component.ComponentContext;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Wouter Born - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = WindcentraleDiscoveryService.class)
@NonNullByDefault
-public class WindcentraleDiscoveryService extends AbstractDiscoveryService
- implements ThingHandlerService, ThingStatusListener {
-
+public class WindcentraleDiscoveryService extends AbstractThingHandlerDiscoveryService<WindcentraleAccountHandler>
+ implements ThingStatusListener {
private final Logger logger = LoggerFactory.getLogger(WindcentraleDiscoveryService.class);
- private @NonNullByDefault({}) WindcentraleAccountHandler accountHandler;
private @Nullable Future<?> discoveryJob;
public WindcentraleDiscoveryService() {
- super(Set.of(THING_TYPE_WINDMILL), 10, false);
- }
-
- protected void activate(ComponentContext context) {
+ super(WindcentraleAccountHandler.class, Set.of(THING_TYPE_WINDMILL), 10, false);
}
@Override
- public void deactivate() {
+ public void dispose() {
+ super.dispose();
cancelDiscoveryJob();
- super.deactivate();
- accountHandler.removeThingStatusListener(this);
+ thingHandler.removeThingStatusListener(this);
}
@Override
- public @Nullable ThingHandler getThingHandler() {
- return accountHandler;
- }
-
- @Override
- public void setThingHandler(ThingHandler handler) {
- if (handler instanceof WindcentraleAccountHandler accountHandler) {
- accountHandler.addThingStatusListener(this);
- this.accountHandler = accountHandler;
- }
+ public void initialize() {
+ thingHandler.addThingStatusListener(this);
+ super.initialize();
}
@Override
}
private void discoverWindmills() {
- ThingUID bridgeUID = accountHandler.getThing().getUID();
- WindcentraleAPI api = accountHandler.getAPI();
+ ThingUID bridgeUID = thingHandler.getThing().getUID();
+ WindcentraleAPI api = thingHandler.getAPI();
if (api == null) {
logger.debug("Cannot discover windmills because API is null for {}", bridgeUID);
import org.openhab.core.thing.binding.ThingActions;
import org.openhab.core.thing.binding.ThingActionsScope;
import org.openhab.core.thing.binding.ThingHandler;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
* @author Matthew Skinner - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = WLedActions.class)
@ThingActionsScope(name = "wled")
@NonNullByDefault
public class WLedActions implements ThingActions {
import org.eclipse.jdt.annotation.Nullable;
import org.openhab.binding.wled.internal.api.WledApi;
import org.openhab.binding.wled.internal.handlers.WLedBridgeHandler;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResult;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
import org.openhab.core.config.discovery.DiscoveryService;
import org.openhab.core.thing.Thing;
import org.openhab.core.thing.ThingTypeUID;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
import org.openhab.core.thing.binding.ThingHandlerService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
/**
* The {@link WLedSegmentDiscoveryService} Discovers and adds any Wled segments found by the bridge device.
*
* @author Matthew Skinner - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = WLedSegmentDiscoveryService.class)
@NonNullByDefault
-public class WLedSegmentDiscoveryService extends AbstractDiscoveryService
+public class WLedSegmentDiscoveryService extends AbstractThingHandlerDiscoveryService<WLedBridgeHandler>
implements DiscoveryService, ThingHandlerService {
- private @Nullable WLedBridgeHandler bridgeHandler;
private @Nullable ThingUID bridgeUID;
private static final int SEARCH_TIME = 10;
public WLedSegmentDiscoveryService() {
- super(SUPPORTED_THING_TYPES, SEARCH_TIME);
+ super(WLedBridgeHandler.class, SUPPORTED_THING_TYPES, SEARCH_TIME);
}
public WLedSegmentDiscoveryService(Set<ThingTypeUID> supportedThingTypes, int timeout)
throws IllegalArgumentException {
- super(supportedThingTypes, timeout);
+ super(WLedBridgeHandler.class, supportedThingTypes, timeout);
}
private void buildThing(int segmentIndex, String segmentName) {
@Override
protected void startScan() {
- WLedBridgeHandler localBridgeHandler = bridgeHandler;
- if (localBridgeHandler != null) {
- WledApi localAPI = localBridgeHandler.api;
- if (localAPI != null) {
- List<String> names = localAPI.getSegmentNames();
- for (int count = 0; count < names.size(); count++) {
- buildThing(count, names.get(count));
- }
+ WledApi localAPI = thingHandler.api;
+ if (localAPI != null) {
+ List<String> names = localAPI.getSegmentNames();
+ for (int count = 0; count < names.size(); count++) {
+ buildThing(count, names.get(count));
}
}
}
@Override
- public void setThingHandler(@Nullable ThingHandler handler) {
- if (handler instanceof WLedBridgeHandler wLedBridgeHandler) {
- bridgeHandler = wLedBridgeHandler;
- bridgeUID = bridgeHandler.getThing().getUID();
- }
- }
-
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return bridgeHandler;
- }
-
- @Override
- public void deactivate() {
+ public void initialize() {
+ bridgeUID = thingHandler.getThing().getUID();
+ super.initialize();
}
}
import org.eclipse.jdt.annotation.Nullable;
import org.openhab.binding.wolfsmartset.internal.dto.GetSystemListDTO;
import org.openhab.binding.wolfsmartset.internal.handler.WolfSmartsetAccountBridgeHandler;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResult;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
import org.openhab.core.thing.ThingStatus;
import org.openhab.core.thing.ThingTypeUID;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Bo Biene - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = WolfSmartsetAccountDiscoveryService.class)
@NonNullByDefault
-public class WolfSmartsetAccountDiscoveryService extends AbstractDiscoveryService implements ThingHandlerService {
+public class WolfSmartsetAccountDiscoveryService
+ extends AbstractThingHandlerDiscoveryService<WolfSmartsetAccountBridgeHandler> {
private final Logger logger = LoggerFactory.getLogger(WolfSmartsetAccountDiscoveryService.class);
- private @NonNullByDefault({}) WolfSmartsetAccountBridgeHandler bridgeHandler;
-
private @Nullable Future<?> discoveryJob;
public WolfSmartsetAccountDiscoveryService() {
- super(SUPPORTED_SYSTEM_AND_UNIT_THING_TYPES_UIDS, 8, true);
- }
-
- @Override
- public void setThingHandler(@Nullable ThingHandler handler) {
- if (handler instanceof WolfSmartsetAccountBridgeHandler accountBridgeHandler) {
- this.bridgeHandler = accountBridgeHandler;
- }
- }
-
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return bridgeHandler;
- }
-
- @Override
- public void activate() {
- super.activate(null);
- }
-
- @Override
- public void deactivate() {
- super.deactivate();
+ super(WolfSmartsetAccountBridgeHandler.class, SUPPORTED_SYSTEM_AND_UNIT_THING_TYPES_UIDS, 8, true);
}
@Override
}
private void backgroundDiscover() {
- if (!bridgeHandler.isBackgroundDiscoveryEnabled()) {
+ if (!thingHandler.isBackgroundDiscoveryEnabled()) {
return;
}
discover();
}
private void discover() {
- if (bridgeHandler.getThing().getStatus() != ThingStatus.ONLINE) {
+ if (thingHandler.getThing().getStatus() != ThingStatus.ONLINE) {
logger.debug("WolfSmartsetDiscovery: Skipping discovery because Account Bridge thing is not ONLINE");
return;
}
private synchronized void discoverSystems() {
logger.debug("WolfSmartsetDiscovery: Discovering systems");
- var registeredSytems = bridgeHandler.getRegisteredSystems();
+ var registeredSytems = thingHandler.getRegisteredSystems();
if (registeredSytems != null) {
for (GetSystemListDTO system : registeredSytems) {
String name = system.getName();
identifier = system.getId().toString();
}
if (identifier != null && name != null) {
- ThingUID thingUID = new ThingUID(UID_SYSTEM_BRIDGE, bridgeHandler.getThing().getUID(), identifier);
+ ThingUID thingUID = new ThingUID(UID_SYSTEM_BRIDGE, thingHandler.getThing().getUID(), identifier);
thingDiscovered(createSystemDiscoveryResult(thingUID, identifier, name));
logger.debug("WolfSmartsetDiscovery: System '{}' and name '{}' added with UID '{}'", identifier,
name, thingUID);
Map<String, Object> properties = new HashMap<>();
properties.put(CONFIG_SYSTEM_ID, identifier);
return DiscoveryResultBuilder.create(systemUID).withProperties(properties)
- .withRepresentationProperty(CONFIG_SYSTEM_ID).withBridge(bridgeHandler.getThing().getUID())
+ .withRepresentationProperty(CONFIG_SYSTEM_ID).withBridge(thingHandler.getThing().getUID())
.withLabel(String.format("WolfSmartset System %s", name)).build();
}
}
import org.openhab.binding.wolfsmartset.internal.dto.GetSystemListDTO;
import org.openhab.binding.wolfsmartset.internal.dto.SubMenuEntryWithMenuItemTabView;
import org.openhab.binding.wolfsmartset.internal.handler.WolfSmartsetSystemBridgeHandler;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResult;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
import org.openhab.core.thing.ThingStatus;
import org.openhab.core.thing.ThingTypeUID;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Bo Biene - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = WolfSmartsetSystemDiscoveryService.class)
@NonNullByDefault
-public class WolfSmartsetSystemDiscoveryService extends AbstractDiscoveryService implements ThingHandlerService {
+public class WolfSmartsetSystemDiscoveryService
+ extends AbstractThingHandlerDiscoveryService<WolfSmartsetSystemBridgeHandler> {
private final Logger logger = LoggerFactory.getLogger(WolfSmartsetSystemDiscoveryService.class);
- private @NonNullByDefault({}) WolfSmartsetSystemBridgeHandler bridgeHandler;
-
private @Nullable Future<?> discoveryJob;
public WolfSmartsetSystemDiscoveryService() {
- super(SUPPORTED_SYSTEM_AND_UNIT_THING_TYPES_UIDS, 8, true);
- }
-
- @Override
- public void setThingHandler(@Nullable ThingHandler handler) {
- if (handler instanceof WolfSmartsetSystemBridgeHandler systemBridgeHandler) {
- this.bridgeHandler = systemBridgeHandler;
- }
- }
-
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return bridgeHandler;
- }
-
- @Override
- public void activate() {
- super.activate(null);
- }
-
- @Override
- public void deactivate() {
- super.deactivate();
+ super(WolfSmartsetSystemBridgeHandler.class, SUPPORTED_SYSTEM_AND_UNIT_THING_TYPES_UIDS, 8, true);
}
@Override
}
private void backgroundDiscover() {
- var accountBridgeHandler = bridgeHandler.getAccountBridgeHandler();
+ var accountBridgeHandler = thingHandler.getAccountBridgeHandler();
if (accountBridgeHandler == null || !accountBridgeHandler.isBackgroundDiscoveryEnabled()) {
return;
}
}
private void discover() {
- if (bridgeHandler.getThing().getStatus() != ThingStatus.ONLINE) {
+ if (thingHandler.getThing().getStatus() != ThingStatus.ONLINE) {
logger.debug("WolfSmartsetSystemDiscovery: Skipping discovery because Account Bridge thing is not ONLINE");
return;
}
}
private synchronized void discoverUnits() {
- if (this.bridgeHandler != null) {
- String systemId = this.bridgeHandler.getSystemId();
- var systemConfig = this.bridgeHandler.getSystemConfig();
- if (systemConfig != null) {
- logger.debug("WolfSmartsetSystemDiscovery: Discovering units for system '{}' (id {})",
- systemConfig.getName(), systemId);
- for (var unit : this.bridgeHandler.getUnits()) {
- ThingUID bridgeUID = this.bridgeHandler.getThing().getUID();
- ThingUID unitUID = new ThingUID(UID_UNIT_THING, bridgeUID,
- unit.menuItemTabViewDTO.bundleId.toString());
- thingDiscovered(createUnitDiscoveryResult(unitUID, bridgeUID, systemConfig, unit));
- logger.debug(
- "WolfSmartsetSystemDiscovery: Unit for '{}' with id '{}' and name '{}' added with UID '{}'",
- systemId, unit.menuItemTabViewDTO.bundleId, unit.menuItemTabViewDTO.tabName, unitUID);
- }
+ String systemId = thingHandler.getSystemId();
+ var systemConfig = thingHandler.getSystemConfig();
+ if (systemConfig != null) {
+ logger.debug("WolfSmartsetSystemDiscovery: Discovering units for system '{}' (id {})",
+ systemConfig.getName(), systemId);
+ for (var unit : thingHandler.getUnits()) {
+ ThingUID bridgeUID = thingHandler.getThing().getUID();
+ ThingUID unitUID = new ThingUID(UID_UNIT_THING, bridgeUID, unit.menuItemTabViewDTO.bundleId.toString());
+ thingDiscovered(createUnitDiscoveryResult(unitUID, bridgeUID, systemConfig, unit));
+ logger.debug(
+ "WolfSmartsetSystemDiscovery: Unit for '{}' with id '{}' and name '{}' added with UID '{}'",
+ systemId, unit.menuItemTabViewDTO.bundleId, unit.menuItemTabViewDTO.tabName, unitUID);
}
}
}
import org.openhab.core.thing.binding.ThingActions;
import org.openhab.core.thing.binding.ThingActionsScope;
import org.openhab.core.thing.binding.ThingHandler;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Scott Hanson - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = XActions.class)
@ThingActionsScope(name = "x")
@NonNullByDefault
public class XActions implements ThingActions {
import static org.openhab.binding.xmltv.internal.XmlTVBindingConstants.*;
import org.eclipse.jdt.annotation.NonNullByDefault;
-import org.eclipse.jdt.annotation.Nullable;
import org.openhab.binding.xmltv.internal.configuration.XmlChannelConfiguration;
import org.openhab.binding.xmltv.internal.handler.XmlTVHandler;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResult;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
import org.openhab.core.thing.ThingStatus;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
import org.osgi.service.component.annotations.Activate;
import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Gaël L'hopital - Initial contribution
*/
-@Component(service = ThingHandlerService.class)
+@Component(scope = ServiceScope.PROTOTYPE, service = XmlTVDiscoveryService.class)
@NonNullByDefault
-public class XmlTVDiscoveryService extends AbstractDiscoveryService implements ThingHandlerService {
+public class XmlTVDiscoveryService extends AbstractThingHandlerDiscoveryService<XmlTVHandler> {
private static final int SEARCH_TIME = 5;
private final Logger logger = LoggerFactory.getLogger(XmlTVDiscoveryService.class);
- private @Nullable XmlTVHandler handler;
/**
* Creates a XmlTVDiscoveryService with background discovery disabled.
*/
@Activate
public XmlTVDiscoveryService() {
- super(SUPPORTED_THING_TYPES_UIDS, SEARCH_TIME);
- }
-
- @Override
- public void deactivate() {
- super.deactivate();
+ super(XmlTVHandler.class, SUPPORTED_THING_TYPES_UIDS, SEARCH_TIME);
}
@Override
protected void startScan() {
logger.debug("Starting XmlTV discovery scan");
- XmlTVHandler bridgeHandler = handler;
- if (bridgeHandler != null && bridgeHandler.getThing().getStatus() == ThingStatus.ONLINE) {
- bridgeHandler.getXmlFile().ifPresent(tv -> {
+ if (thingHandler.getThing().getStatus() == ThingStatus.ONLINE) {
+ thingHandler.getXmlFile().ifPresent(tv -> {
tv.getMediaChannels().stream().forEach(channel -> {
String channelId = channel.getId();
String uid = channelId.replaceAll("[^A-Za-z0-9_]", "_");
- ThingUID thingUID = new ThingUID(XMLTV_CHANNEL_THING_TYPE, bridgeHandler.getThing().getUID(), uid);
+ ThingUID thingUID = new ThingUID(XMLTV_CHANNEL_THING_TYPE, thingHandler.getThing().getUID(), uid);
DiscoveryResult discoveryResult = DiscoveryResultBuilder.create(thingUID)
- .withBridge(bridgeHandler.getThing().getUID())
+ .withBridge(thingHandler.getThing().getUID())
.withLabel(channel.getDisplayNames().get(0).getValue()).withRepresentationProperty(uid)
.withProperty(XmlChannelConfiguration.CHANNEL_ID, channelId).build();
});
}
}
-
- @Override
- public void setThingHandler(ThingHandler handler) {
- if (handler instanceof XmlTVHandler tvHandler) {
- this.handler = tvHandler;
- }
- }
-
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return handler;
- }
}
import org.openhab.core.thing.binding.ThingActions;
import org.openhab.core.thing.binding.ThingActionsScope;
import org.openhab.core.thing.binding.ThingHandler;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Pavel Gololobov - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = XMPPActions.class)
@ThingActionsScope(name = "xmppclient")
@NonNullByDefault
public class XMPPActions implements ThingActions {
import org.openhab.core.types.StateDescriptionFragment;
import org.openhab.core.types.StateDescriptionFragmentBuilder;
import org.openhab.core.types.StateOption;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
/**
* Provide a custom channel type for available inputs
* @author David Graeff - Initial contribution
* @author Tomasz Maruszak - Refactoring the input source names.
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = { ChannelsTypeProviderAvailableInputs.class,
+ ChannelTypeProvider.class })
@NonNullByDefault
public class ChannelsTypeProviderAvailableInputs implements ChannelTypeProvider, ThingHandlerService {
private @NonNullByDefault({}) ChannelType channelType;
import org.openhab.core.types.StateDescriptionFragment;
import org.openhab.core.types.StateDescriptionFragmentBuilder;
import org.openhab.core.types.StateOption;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
/**
* Provide a custom channel type for the preset channel
* @author David Graeff - Initial contribution
* @author Tomasz Maruszak - RX-V3900 compatibility improvements
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = { ChannelsTypeProviderPreset.class, ChannelTypeProvider.class })
@NonNullByDefault
public class ChannelsTypeProviderPreset implements ChannelTypeProvider, ThingHandlerService {
private @NonNullByDefault({}) ChannelType channelType;
import java.util.Map;
import org.eclipse.jdt.annotation.NonNullByDefault;
-import org.eclipse.jdt.annotation.Nullable;
import org.openhab.binding.yamahareceiver.internal.YamahaReceiverBindingConstants.Zone;
import org.openhab.binding.yamahareceiver.internal.handler.YamahaBridgeHandler;
import org.openhab.binding.yamahareceiver.internal.state.DeviceInformationState;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResult;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
-import org.openhab.core.config.discovery.DiscoveryService;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
/**
* After the AVR bridge thing has been added and a connection could be established,
* @author David Gräff - Initial contribution
* @author Tomasz Maruszak - Introduced config object
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = ZoneDiscoveryService.class)
@NonNullByDefault
-public class ZoneDiscoveryService extends AbstractDiscoveryService implements DiscoveryService, ThingHandlerService {
-
- private @Nullable YamahaBridgeHandler handler;
+public class ZoneDiscoveryService extends AbstractThingHandlerDiscoveryService<YamahaBridgeHandler> {
/**
* Constructs a zone discovery service.
* Call {@link ZoneDiscoveryService#destroy()} to unregister the service after use.
*/
public ZoneDiscoveryService() {
- super(ZONE_THING_TYPES_UIDS, 0, false);
- }
-
- @Override
- public void activate() {
- super.activate(null);
- }
-
- @Override
- public void deactivate() {
- super.deactivate();
+ super(YamahaBridgeHandler.class, ZONE_THING_TYPES_UIDS, 0, false);
}
@Override
}
@Override
- public void setThingHandler(@Nullable ThingHandler handler) {
- if (handler instanceof YamahaBridgeHandler bridgeHandler) {
- bridgeHandler.setZoneDiscoveryService(this);
- this.handler = bridgeHandler;
- }
- }
-
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return handler;
+ public void initialize() {
+ thingHandler.setZoneDiscoveryService(this);
+ super.initialize();
}
}
import java.io.IOException;
import java.util.Arrays;
import java.util.Collection;
-import java.util.Collections;
+import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
import org.eclipse.jdt.annotation.NonNullByDefault;
import org.openhab.binding.yamahareceiver.internal.ChannelsTypeProviderAvailableInputs;
@Override
public Collection<Class<? extends ThingHandlerService>> getServices() {
- return Collections
- .unmodifiableList(Stream.of(ChannelsTypeProviderAvailableInputs.class, ChannelsTypeProviderPreset.class)
- .collect(Collectors.toList()));
+ return List.of(ChannelsTypeProviderAvailableInputs.class, ChannelsTypeProviderPreset.class);
}
/**
import org.openhab.core.thing.binding.ThingActions;
import org.openhab.core.thing.binding.ThingActionsScope;
import org.openhab.core.thing.binding.ThingHandler;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
/**
* The {@link YIOremoteDockActions} is responsible for handling the action commands
*
* @author Michael Loercher - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = YIOremoteDockActions.class)
@ThingActionsScope(name = "yioremote")
@NonNullByDefault
public class YIOremoteDockActions implements ThingActions {
import org.openhab.core.thing.binding.ThingActions;
import org.openhab.core.thing.binding.ThingActionsScope;
import org.openhab.core.thing.binding.ThingHandler;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Mark Hilbush - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = ZmActions.class)
@ThingActionsScope(name = "zoneminder")
@NonNullByDefault
public class ZmActions implements ThingActions {
import org.eclipse.jdt.annotation.Nullable;
import org.openhab.binding.zoneminder.internal.handler.Monitor;
import org.openhab.binding.zoneminder.internal.handler.ZmBridgeHandler;
-import org.openhab.core.config.discovery.AbstractDiscoveryService;
+import org.openhab.core.config.discovery.AbstractThingHandlerDiscoveryService;
import org.openhab.core.config.discovery.DiscoveryResult;
import org.openhab.core.config.discovery.DiscoveryResultBuilder;
-import org.openhab.core.config.discovery.DiscoveryService;
import org.openhab.core.thing.ThingTypeUID;
import org.openhab.core.thing.ThingUID;
-import org.openhab.core.thing.binding.ThingHandler;
-import org.openhab.core.thing.binding.ThingHandlerService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.ServiceScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Mark Hilbush - Initial contribution
*/
+@Component(scope = ServiceScope.PROTOTYPE, service = MonitorDiscoveryService.class)
@NonNullByDefault
-public class MonitorDiscoveryService extends AbstractDiscoveryService implements DiscoveryService, ThingHandlerService {
+public class MonitorDiscoveryService extends AbstractThingHandlerDiscoveryService<ZmBridgeHandler> {
private final Logger logger = LoggerFactory.getLogger(MonitorDiscoveryService.class);
private static final int DISCOVERY_INITIAL_DELAY_SECONDS = 10;
private static final int DISCOVERY_TIMEOUT_SECONDS = 6;
- private @NonNullByDefault({}) ZmBridgeHandler bridgeHandler;
-
private @Nullable Future<?> discoveryJob;
public MonitorDiscoveryService() {
- super(SUPPORTED_MONITOR_THING_TYPES_UIDS, DISCOVERY_TIMEOUT_SECONDS, true);
- }
-
- @Override
- public void activate() {
- super.activate(null);
- }
-
- @Override
- public void deactivate() {
- super.deactivate();
- }
-
- @Override
- public void setThingHandler(@Nullable ThingHandler handler) {
- if (handler instanceof ZmBridgeHandler zmBridgeHandler) {
- bridgeHandler = zmBridgeHandler;
- }
- }
-
- @Override
- public @Nullable ThingHandler getThingHandler() {
- return bridgeHandler;
+ super(ZmBridgeHandler.class, SUPPORTED_MONITOR_THING_TYPES_UIDS, DISCOVERY_TIMEOUT_SECONDS, true);
}
@Override
}
private void backgroundDiscoverMonitors() {
- if (!bridgeHandler.isBackgroundDiscoveryEnabled()) {
+ if (!thingHandler.isBackgroundDiscoveryEnabled()) {
return;
}
logger.debug("ZoneminderDiscovery: Running background discovery scan");
}
private synchronized void discoverMonitors() {
- ThingUID bridgeUID = bridgeHandler.getThing().getUID();
- Integer alarmDuration = bridgeHandler.getDefaultAlarmDuration();
- Integer imageRefreshInterval = bridgeHandler.getDefaultImageRefreshInterval();
- for (Monitor monitor : bridgeHandler.getSavedMonitors()) {
+ ThingUID bridgeUID = thingHandler.getThing().getUID();
+ Integer alarmDuration = thingHandler.getDefaultAlarmDuration();
+ Integer imageRefreshInterval = thingHandler.getDefaultImageRefreshInterval();
+ for (Monitor monitor : thingHandler.getSavedMonitors()) {
String id = monitor.getId();
String name = monitor.getName();
ThingUID thingUID = new ThingUID(UID_MONITOR, bridgeUID, monitor.getId());
projects / openhab-addons.git / commitdiff