import org.eclipse.smarthome.config.discovery.DiscoveryService; //导入依赖的package包/类
@Override
protected ThingHandler createHandler(Thing thing) {
    ThingTypeUID thingTypeUID = thing.getThingTypeUID();

    if (thingTypeUID.equals(THING_TYPE_HOME)) {
        TadoHomeHandler tadoHomeHandler = new TadoHomeHandler((Bridge) thing);

        TadoDiscoveryService discoveryService = new TadoDiscoveryService(tadoHomeHandler);
        bundleContext.registerService(DiscoveryService.class.getName(), discoveryService,
                new Hashtable<String, Object>());

        return tadoHomeHandler;
    } else if (thingTypeUID.equals(THING_TYPE_ZONE)) {
        return new TadoZoneHandler(thing);
    } else if (thingTypeUID.equals(THING_TYPE_MOBILE_DEVICE)) {
        return new TadoMobileDeviceHandler(thing);
    }

    return null;
}
 

import org.eclipse.smarthome.config.discovery.DiscoveryService; //导入依赖的package包/类
@Override
protected ThingHandler createHandler(Thing thing) {
    ElementsDiscoveryService discoveryService = null;
    if (ElementsBindingConstants.THING_TYPE_BASE.equals(thing.getThingTypeUID())) {
        logger.debug("discovery service register");

        ElementsBridgeHandler bridgetHandler = new ElementsBridgeHandler(thing, discoveryService);

        discoveryService = new ElementsDiscoveryService((Bridge) thing, 15);
        this.discoveryServiceReg = bundleContext.registerService(DiscoveryService.class.getName(), discoveryService,
                new Hashtable<String, Object>());
        logger.debug("done ElementsDiscoveryService");
        return bridgetHandler;
    }
    return new ElementsThingHandler(thing);
}
 

import org.eclipse.smarthome.config.discovery.DiscoveryService; //导入依赖的package包/类
@Override
public void initialize() {
    this.config = getThing().getConfiguration().as(IPBridgeConfig.class);

    if (validConfiguration(this.config)) {
        LutronDeviceDiscoveryService discovery = new LutronDeviceDiscoveryService(this);

        this.discoveryServiceRegistration = this.bundleContext.registerService(DiscoveryService.class, discovery,
                null);

        this.scheduler.schedule(new Runnable() {
            @Override
            public void run() {
                connect();
            }
        }, 0, TimeUnit.SECONDS);
    }
}
 

import org.eclipse.smarthome.config.discovery.DiscoveryService; //导入依赖的package包/类
/**
 * If a thing is discovered, the method checks if the thing is already known
 * and the state is only temporary set to OFFLINE. If so initialize() of the
 * thing is called.
 */

@Override
public void thingDiscovered(DiscoveryService source, DiscoveryResult result) {
    if (handlerList.containsKey(result.getThingUID())) {
        if (thingOnlineState.containsKey(result.getThingUID())) {
            if (thingOnlineState.get(result.getThingUID()).equals(ThingStatus.OFFLINE)) {
                handlerList.get(result.getThingUID()).initialize();
            }
        }

    }

}
 

import org.eclipse.smarthome.config.discovery.DiscoveryService; //导入依赖的package包/类
@Override
protected ThingHandler createHandler(Thing thing) {
    ThingTypeUID thingTypeUID = thing.getThingTypeUID();

    logger.debug("Creating coordinator handler for {}", thing);

    ZigBeeCoordinatorHandler coordinator = null;

    // Handle coordinators here
    if (thingTypeUID.equals(ZigBeeBindingConstants.COORDINATOR_TYPE_CC2531)) {
        coordinator = new ZigBeeCoordinatorCC2531Handler((Bridge) thing, translationProvider);
    }
    // if (thingTypeUID.equals(ZigBeeBindingConstants.COORDINATOR_TYPE_CONBEE)) {
    // coordinator = new ZigBeeCoordinatorConBeeHandler((Bridge) thing, translationProvider);
    // }
    if (thingTypeUID.equals(ZigBeeBindingConstants.COORDINATOR_TYPE_EMBER)) {
        coordinator = new ZigBeeCoordinatorEmberHandler((Bridge) thing, translationProvider);
    }
    if (thingTypeUID.equals(ZigBeeBindingConstants.COORDINATOR_TYPE_TELEGESIS)) {
        coordinator = new ZigBeeCoordinatorTelegesisHandler((Bridge) thing, translationProvider);
    }

    if (coordinator != null) {
        ZigBeeDiscoveryService discoveryService = new ZigBeeDiscoveryService(coordinator);
        discoveryService.activate();

        discoveryServiceRegs.put(coordinator.getThing().getUID(), bundleContext.registerService(
                DiscoveryService.class.getName(), discoveryService, new Hashtable<String, Object>()));

        return coordinator;
    }

    // Everything else gets handled in a single handler
    ZigBeeThingHandler handler = new ZigBeeThingHandler(thing, translationProvider);

    bundleContext.registerService(ConfigDescriptionProvider.class.getName(), handler,
            new Hashtable<String, Object>());

    return handler;
}
 

import org.eclipse.smarthome.config.discovery.DiscoveryService; //导入依赖的package包/类
@Override
public void start(BundleContext bundleContext) {
    if (reg != null) {
        return;
    }
    reg = bundleContext.registerService(DiscoveryService.class.getName(), this, new Hashtable<String, Object>());
}
 

import org.eclipse.smarthome.config.discovery.DiscoveryService; //导入依赖的package包/类
@Override
public void thingDiscovered(DiscoveryService source, DiscoveryResult result) {
	if(result.getThingUID().equals(this.getThing().getUID())) {
		if (getThing().getConfiguration().get(UDN)
				.equals(result.getProperties().get(UDN))) {
			logger.debug("Discovered UDN '{}' for thing '{}'", result
					.getProperties().get(UDN), getThing().getUID());
			getThing().setStatus(ThingStatus.ONLINE);
			onSubscription();
			onUpdate();
		}
	}
}
 

import org.eclipse.smarthome.config.discovery.DiscoveryService; //导入依赖的package包/类
@Override
public void thingRemoved(DiscoveryService source, ThingUID thingUID) {
	if(thingUID.equals(this.getThing().getUID())) {
		logger.debug("Setting status for thing '{}' to OFFLINE", getThing()
				.getUID());
		getThing().setStatus(ThingStatus.OFFLINE);
	}
}
 

import org.eclipse.smarthome.config.discovery.DiscoveryService; //导入依赖的package包/类
private void registerDeviceDiscoveryService(TelldusBridgeHandler tellstickBridgeHandler) {
    if (discoveryService == null) {
        discoveryService = new TellstickDiscoveryService(tellstickBridgeHandler);
        discoveryService.activate();
        bundleContext.registerService(DiscoveryService.class.getName(), discoveryService,
                new Hashtable<String, Object>());
    } else {
        discoveryService.addBridgeHandler(tellstickBridgeHandler);
    }
}
 

import org.eclipse.smarthome.config.discovery.DiscoveryService; //导入依赖的package包/类
/**
 * Adds SqueezeBoxServerHandlers to the discovery service to find SqueezeBox
 * Players
 *
 * @param squeezeBoxServerHandler
 */
private synchronized void registerSqueezeBoxPlayerDiscoveryService(
        SqueezeBoxServerHandler squeezeBoxServerHandler) {
    logger.trace("registering player discovery service");

    SqueezeBoxPlayerDiscoveryParticipant discoveryService = new SqueezeBoxPlayerDiscoveryParticipant(
            squeezeBoxServerHandler);

    // Register the PlayerListener with the SqueezeBoxServerHandler
    squeezeBoxServerHandler.registerSqueezeBoxPlayerListener(discoveryService);

    // Register the service, then add the service to the ServiceRegistration map
    discoveryServiceRegs.put(squeezeBoxServerHandler.getThing().getUID(), bundleContext
            .registerService(DiscoveryService.class.getName(), discoveryService, new Hashtable<String, Object>()));
}
 

import org.eclipse.smarthome.config.discovery.DiscoveryService; //导入依赖的package包/类
/**
 * Creates a handler for the specific thing. THis also creates the discovery service
 * when the bridge is created.
 */
@Override
protected ThingHandler createHandler(Thing thing) {
    ThingTypeUID thingTypeUID = thing.getThingTypeUID();

    if (THING_TYPE_THERMOSTAT.equals(thingTypeUID)) {
        return new NestThermostatHandler(thing);
    }

    if (THING_TYPE_CAMERA.equals(thingTypeUID)) {
        return new NestCameraHandler(thing);
    }

    if (THING_TYPE_STRUCTURE.equals(thingTypeUID)) {
        return new NestStructureHandler(thing);
    }

    if (THING_TYPE_SMOKE_DETECTOR.equals(thingTypeUID)) {
        return new NestSmokeDetectorHandler(thing);
    }

    if (THING_TYPE_BRIDGE.equals(thingTypeUID)) {
        NestBridgeHandler handler = new NestBridgeHandler((Bridge) thing);
        NestDiscoveryService service = new NestDiscoveryService(handler);
        service.activate();
        // Register the discovery service.
        discoveryService.put(handler.getThing().getUID(),
                bundleContext.registerService(DiscoveryService.class.getName(), service, new Hashtable<>()));
        return handler;
    }

    return null;
}
 

import org.eclipse.smarthome.config.discovery.DiscoveryService; //导入依赖的package包/类
/**
 * Registers the DeviceDiscoveryService.
 */
private void registerDeviceDiscoveryService() {
    if (bundleContext != null) {
        logger.trace("Registering HomematicDeviceDiscoveryService for bridge '{}'", getThing().getUID().getId());
        discoveryService = new HomematicDeviceDiscoveryService(this);
        discoveryServiceRegistration = bundleContext.registerService(DiscoveryService.class.getName(),
                discoveryService, new Hashtable<String, Object>());
        discoveryService.activate();
    }
}
 

import org.eclipse.smarthome.config.discovery.DiscoveryService; //导入依赖的package包/类
/**
 * Registers a {@link RioSystemDeviceDiscoveryService} from the passed {@link RioSystemHandler} and activates it.
 *
 * @param bridgeHandler the {@link RioSystemHandler} for discovery services
 */
private synchronized void registerThingDiscovery(RioSystemHandler bridgeHandler) {
    RioSystemDeviceDiscoveryService discoveryService = new RioSystemDeviceDiscoveryService(bridgeHandler);
    logger.trace("Try to register Discovery service on BundleID: {} Service: {}",
            bundleContext.getBundle().getBundleId(), DiscoveryService.class.getName());

    final Hashtable<String, String> prop = new Hashtable<String, String>();

    bundleContext.registerService(DiscoveryService.class.getName(), discoveryService, prop);
    discoveryService.activate();
}
 

import org.eclipse.smarthome.config.discovery.DiscoveryService; //导入依赖的package包/类
private void registerDeviceDiscoveryService(MaxCubeBridgeHandler maxCubeBridgeHandler) {
    MaxDeviceDiscoveryService discoveryService = new MaxDeviceDiscoveryService(maxCubeBridgeHandler);
    discoveryService.activate();

    this.discoveryServiceRegs.put(maxCubeBridgeHandler.getThing().getUID(), bundleContext
            .registerService(DiscoveryService.class.getName(), discoveryService, new Hashtable<String, Object>()));
}
 

import org.eclipse.smarthome.config.discovery.DiscoveryService; //导入依赖的package包/类
private void scanForDevices() {
    try {
        DiscoveryService service = this.bundleContext.getService(this.discoveryServiceRegistration.getReference());

        if (service != null) {
            service.startScan(null);
        }
    } catch (Exception e) {
        logger.error("Error scanning for paired devices", e);
    }
}
 

import org.eclipse.smarthome.config.discovery.DiscoveryService; //导入依赖的package包/类
/**
 * Register the Thing Discovery Service for a bridge.
 *
 * @param dscAlarmBridgeHandler
 */
private void registerDSCAlarmDiscoveryService(DSCAlarmBaseBridgeHandler dscAlarmBridgeHandler) {
    DSCAlarmDiscoveryService discoveryService = new DSCAlarmDiscoveryService(dscAlarmBridgeHandler);
    discoveryService.activate();

    ServiceRegistration<?> discoveryServiceRegistration = bundleContext
            .registerService(DiscoveryService.class.getName(), discoveryService, new Hashtable<String, Object>());
    discoveryServiceRegistrations.put(dscAlarmBridgeHandler.getThing().getUID(), discoveryServiceRegistration);

    logger.debug("registerDSCAlarmDiscoveryService(): Bridge Handler - {}, Class Name - {}, Discovery Service - {}",
            dscAlarmBridgeHandler, DiscoveryService.class.getName(), discoveryService);
}
 

import org.eclipse.smarthome.config.discovery.DiscoveryService; //导入依赖的package包/类
/**
 * Register the given cloud handler to participate in discovery of new beds.
 *
 * @param cloudHandler the cloud handler to register (must not be <code>null</code>)
 */
private synchronized void registerBedDiscoveryService(final SleepIQCloudHandler cloudHandler) {
    logger.debug("Registering bed discovery service");
    SleepIQBedDiscoveryService discoveryService = new SleepIQBedDiscoveryService(cloudHandler);
    discoveryServiceReg.put(cloudHandler.getThing().getUID(), bundleContext
            .registerService(DiscoveryService.class.getName(), discoveryService, new Hashtable<String, Object>()));
}
 

import org.eclipse.smarthome.config.discovery.DiscoveryService; //导入依赖的package包/类
private synchronized void registerThingDiscovery(VitotronicBridgeHandler bridgeHandler) {
    VitotronicDiscoveryService discoveryService = new VitotronicDiscoveryService(bridgeHandler);
    logger.trace("Try to register Discovery service on BundleID: {} Service: {}",
            bundleContext.getBundle().getBundleId(), DiscoveryService.class.getName());

    Hashtable<String, String> prop = new Hashtable<String, String>();

    bundleContext.registerService(DiscoveryService.class.getName(), discoveryService, prop);
    discoveryService.activate();
}
 

import org.eclipse.smarthome.config.discovery.DiscoveryService; //导入依赖的package包/类
@Override
public void thingDiscovered(DiscoveryService source, DiscoveryResult result) {
    logger.debug("thingDiscovered: {}", result);

    if (configuration.hostName.equals(result.getProperties().get(HOST_NAME))) {
        /*
         * SamsungTV discovery services creates thing UID from UPnP UDN.
         * When thing is generated manually, thing UID may not match UPnP UDN, so store it for later use (e.g.
         * thingRemoved).
         */
        upnpThingUID = result.getThingUID();
        logger.debug("thingDiscovered, thingUID={}, discoveredUID={}", this.getThing().getUID(), upnpThingUID);
        upnpPollingJob = scheduler.schedule(this::checkAndCreateServices, 0, TimeUnit.MILLISECONDS);
    }
}
 

import org.eclipse.smarthome.config.discovery.DiscoveryService; //导入依赖的package包/类
@Override
public void thingRemoved(DiscoveryService source, ThingUID thingUID) {
    logger.debug("thingRemoved: {}", thingUID);

    if (thingUID.equals(upnpThingUID)) {
        shutdown();
        putOffline();
    }
}