import org.eclipse.smarthome.core.thing.Thing; //导入依赖的package包/类
@Override
public void unregisterHandler(Thing thing) {
    if (thing.getThingTypeUID().equals(THING_TYPE_BRIDGE)) {
        super.unregisterHandler(thing);
        ServiceRegistration<?> serviceRegistration = this.discoveryServiceRegs.get(thing.getUID());
        if (serviceRegistration != null) {
            serviceRegistration.unregister();
            discoveryServiceRegs.remove(thing.getUID());
            logger.info("Unregister discovery service for HEOS player and HEOS groups by bridge '{}'",
                    thing.getUID().getId());
        }
    }
    if (thing.getThingTypeUID().equals(THING_TYPE_PLAYER) || thing.getThingTypeUID().equals(THING_TYPE_GROUP)) {
        super.unregisterHandler(thing);
        ServiceRegistration<AudioSink> reg = audioSinkRegistrations.get(thing.getUID().toString());
        if (reg != null) {
            reg.unregister();
        }
    }

}
 

import org.eclipse.smarthome.core.thing.Thing; //导入依赖的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.core.thing.Thing; //导入依赖的package包/类
@Override
protected ThingHandler createHandler(Thing thing) {
    ThingTypeUID thingTypeUID = thing.getThingTypeUID();

    if (thingTypeUID.equals(WMBusBindingConstants.THING_TYPE_BRIDGE)) {
        // create handler for WMBus bridge
        logger.debug("Creating (handler for) WMBus bridge.");
        if (thing instanceof Bridge) {
            WMBusBridgeHandler handler = new WMBusBridgeHandler((Bridge) thing);
            registerDiscoveryService(handler);
            return handler;
        } else {
            return null;
        }
    } else if (thingTypeUID.equals(WMBusBindingConstants.THING_TYPE_TECHEM_HKV)) {
        // create handler for Techem HKV device
        logger.debug("Creating (handler for) TechemHKV device.");
        return new WMBusTechemHKVHandler(thing);
    } else {
        return null;
    }
}
 

import org.eclipse.smarthome.core.thing.Thing; //导入依赖的package包/类
@Override
protected ThingHandler createHandler(Thing thing) {

    ThingTypeUID thingTypeUID = thing.getThingTypeUID();

    if (thingTypeUID.equals(MegaDBindingConstants.THING_TYPE_UID_BRIDGE)) {
        MegaDBridgeHandler handler = new MegaDBridgeHandler((Bridge) thing);
        return handler;
    }

    if (supportsThingType(thingTypeUID)) {
        return new MegaDHandler(thing);
    }

    return null;
}
 

import org.eclipse.smarthome.core.thing.Thing; //导入依赖的package包/类
@Override
public Thing createThing(ThingTypeUID thingTypeUID, Configuration configuration, ThingUID thingUID,
        ThingUID bridgeUID) {
    logger.trace("Create Thing for Type {}", thingUID.toString());
    if (MegaDBindingConstants.THING_TYPE_UID_BRIDGE.equals(thingTypeUID)) {

        logger.trace("Create Bride: {}", thingTypeUID);
        return super.createThing(thingTypeUID, configuration, thingUID, null);
    } else {
        if (supportsThingType(thingTypeUID)) {
            logger.trace("Create Thing: {}", thingTypeUID);
            return super.createThing(thingTypeUID, configuration, thingUID, bridgeUID);
        }
    }

    throw new IllegalArgumentException("The thing type " + thingTypeUID + " is not supported by the binding.");
}
 

import org.eclipse.smarthome.core.thing.Thing; //导入依赖的package包/类
@Override
public Thing createThing(ThingTypeUID thingTypeUID, Configuration configuration, ThingUID thingUID,
		ThingUID bridgeUID) {

	if (IP_2WIRE_INTERFACE_THING_TYPE.equals(thingTypeUID)) {
		ThingUID bticinoBridgeUID = getBridgeThingUID(thingTypeUID, thingUID, configuration);
		logger.debug("createThing: {}", bticinoBridgeUID);
		return super.createThing(thingTypeUID, configuration, bticinoBridgeUID, null);
	}
	else if (supportsThingType(thingTypeUID)) {
		ThingUID deviceUID = getBtcinoDeviceUID(thingTypeUID, thingUID, configuration, bridgeUID);
		logger.debug("createThing: {}", deviceUID);
		return super.createThing(thingTypeUID, configuration, deviceUID, bridgeUID);
	}
	throw new IllegalArgumentException("The thing type " + thingTypeUID + " is not supported by the binding.");
}
 

import org.eclipse.smarthome.core.thing.Thing; //导入依赖的package包/类
public ZonePlayerHandler(Thing thing, UpnpIOService upnpIOService,
		DiscoveryServiceRegistry discoveryServiceRegistry, String opmlPartnerID) {
	super(thing);
	this.opmlPartnerID = opmlPartnerID;

	logger.debug("Creating a ZonePlayerHandler for thing '{}'", getThing()
			.getUID());
	if (upnpIOService != null) {
		this.service = upnpIOService;
	}
	if (discoveryServiceRegistry != null) {
		this.discoveryServiceRegistry = discoveryServiceRegistry;
		this.discoveryServiceRegistry.addDiscoveryListener(this);
	}

}
 

import org.eclipse.smarthome.core.thing.Thing; //导入依赖的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.core.thing.Thing; //导入依赖的package包/类
@Override
protected ThingHandler createHandler(Thing thing) {
    logger.debug("MeteoStick thing factory: createHandler {} of type {}", thing.getThingTypeUID(), thing.getUID());

    ThingTypeUID thingTypeUID = thing.getThingTypeUID();

    if (MeteostickBridgeHandler.SUPPORTED_THING_TYPES.contains(thingTypeUID)) {
        return new MeteostickBridgeHandler((Bridge) thing);
    }

    if (MeteostickSensorHandler.SUPPORTED_THING_TYPES.contains(thingTypeUID)) {
        return new MeteostickSensorHandler(thing);
    }

    return null;
}
 

import org.eclipse.smarthome.core.thing.Thing; //导入依赖的package包/类
@Override
public Thing createThing(ThingTypeUID thingTypeUID, Configuration configuration, ThingUID thingUID,
        ThingUID bridgeUID) {
    logger.trace("Create Thing for Type {}", thingUID.toString());

    String adapterID = (String) configuration.get(VitotronicBindingConstants.ADAPTER_ID);

    if (VitotronicBindingConstants.THING_TYPE_UID_BRIDGE.equals(thingTypeUID)) {

        logger.trace("Create Bride: {}", adapterID);
        return super.createThing(thingTypeUID, configuration, thingUID, null);
    } else {
        if (supportsThingType(thingTypeUID)) {
            logger.trace("Create Thing: {}", adapterID);
            return super.createThing(thingTypeUID, configuration, thingUID, bridgeUID);
        }
    }

    throw new IllegalArgumentException("The thing type " + thingTypeUID + " is not supported by the binding.");
}
 

import org.eclipse.smarthome.core.thing.Thing; //导入依赖的package包/类
@Override
protected ThingHandler createHandler(Thing thing) {
    logger.debug("createHandler for {} {}", thing, thing.getThingTypeUID());
    ThingTypeUID thingTypeUID = thing.getThingTypeUID();
    if (thingTypeUID.equals(APIBRIDGE_THING_TYPE)) {
        ToonBridgeHandler bridgeHandler = new ToonBridgeHandler((Bridge) thing);
        registerDeviceDiscoveryService(bridgeHandler);
        return bridgeHandler;
    } else if (thingTypeUID.equals(PLUG_THING_TYPE)) {
        return new ToonPlugHandler(thing);
    } else if (thingTypeUID.equals(MAIN_THING_TYPE)) {
        return new ToonDisplayHandler(thing);
    } else {
        logger.warn("ThingHandler not found for {}", thing.getThingTypeUID());
        return null;
    }
}
 

import org.eclipse.smarthome.core.thing.Thing; //导入依赖的package包/类
@Override
protected ThingHandler createHandler(Thing thing) {

    ThingTypeUID thingTypeUID = thing.getThingTypeUID();

    if (thingTypeUID.equals(THING_TYPE_IP_REGO6XX)) {
        return new IpRego6xxHeatPumpHandler(thing);
    }

    if (thingTypeUID.equals(THING_TYPE_SERIAL_REGO6XX)) {
        return new SerialRego6xxHeatPumpHandler(thing);
    }

    if (thingTypeUID.equals(THING_TYPE_IP_HUSDATA)) {
        return new IpHusdataHandler(thing);
    }

    if (thingTypeUID.equals(THING_TYPE_SERIAL_HUSDATA)) {
        return new SerialHusdataHandler(thing);
    }

    return null;
}
 

import org.eclipse.smarthome.core.thing.Thing; //导入依赖的package包/类
/**
 * Update the given properties with attributes of the given bed. If no properties are given, a new map will be
 * created.
 *
 * @param bed the source of data
 * @param properties the properties to update (this may be <code>null</code>)
 * @return the given map (or a new map if no map was given) with updated/set properties from the supplied bed
 */
public Map<String, String> updateProperties(final Bed bed, Map<String, String> properties) {
    if (bed != null) {
        properties.put(Thing.PROPERTY_MODEL_ID, bed.getModel());
        properties.put(SleepIQBindingConstants.PROPERTY_BASE, bed.getBase());
        if (bed.isKidsBed() != null) {
            properties.put(SleepIQBindingConstants.PROPERTY_KIDS_BED, bed.isKidsBed().toString());
        }
        properties.put(SleepIQBindingConstants.PROPERTY_MAC_ADDRESS, bed.getMacAddress());
        properties.put(SleepIQBindingConstants.PROPERTY_NAME, bed.getName());
        if (bed.getPurchaseDate() != null) {
            properties.put(SleepIQBindingConstants.PROPERTY_PURCHASE_DATE, bed.getPurchaseDate().toString());
        }
        properties.put(SleepIQBindingConstants.PROPERTY_SIZE, bed.getSize());
        properties.put(SleepIQBindingConstants.PROPERTY_SKU, bed.getSku());
    }

    return properties;
}
 

import org.eclipse.smarthome.core.thing.Thing; //导入依赖的package包/类
@Override
public void onDeviceUpdated(Device device) {
    for (ThingUID thingUID : UidUtils.getThingUIDs(device, getThing())) {
        Thing gardenaThing = getThingByUID(thingUID);
        try {
            GardenaThingHandler gardenaThingHandler = (GardenaThingHandler) gardenaThing.getHandler();
            gardenaThingHandler.updateProperties(device);
            for (Channel channel : gardenaThing.getChannels()) {
                gardenaThingHandler.updateChannel(channel.getUID());
            }
            gardenaThingHandler.updateSettings(device);
            gardenaThingHandler.updateStatus(device);
        } catch (GardenaException ex) {
            logger.error("There is something wrong with your thing '{}', please check or recreate it: {}",
                    gardenaThing.getUID(), ex.getMessage());
            logger.debug("Gardena exception caught on device update.", ex);
            updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.CONFIGURATION_ERROR, ex.getMessage());
        } catch (AccountHandlerNotAvailableException ignore) {
        }
    }
}
 

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

    if (HS110.is(thingTypeUID)) {
        device = new EnergySwitchDevice();
    } else if (LB130.is(thingTypeUID) || LB230.is(thingTypeUID)) {
        device = new BulbDevice(thingTypeUID, COLOR_TEMPERATURE_LB130_MIN, COLOR_TEMPERATURE_LB130_MAX);
    } else if (LB120.is(thingTypeUID)) {
        device = new BulbDevice(thingTypeUID, COLOR_TEMPERATURE_LB120_MIN, COLOR_TEMPERATURE_LB120_MAX);
    } else if (TPLinkSmartHomeThingType.isSwitchingDevice(thingTypeUID)) {
        device = new SwitchDevice();
    } else if (TPLinkSmartHomeThingType.isBulbDevice(thingTypeUID)) {
        device = new BulbDevice(thingTypeUID);
    } else {
        return null;
    }
    return new SmartHomeHandler(thing, device);
}
 

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

    if (thingTypeUID.equals(THING_TYPE_SAMPLE)) {
        return new EventBusHandler(thing);
    }

    return null;
}
 

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

    if (thingTypeUID.equals(THING_TYPE_SIMPLE_MOTION_SENSOR)) {
        return new SimpleMotionSensorHandler(thing);
    }

    return null;
}
 

import org.eclipse.smarthome.core.thing.Thing; //导入依赖的package包/类
public HeosPlayerHandler(Thing thing, HeosSystem heos, HeosAPI api) {
    super(thing);
    this.heos = heos;
    this.api = api;
    pid = thing.getConfiguration().get(PID).toString();

}
 

import org.eclipse.smarthome.core.thing.Thing; //导入依赖的package包/类
public HeosGroupHandler(Thing thing, HeosSystem heos, HeosAPI api) {
    super(thing);
    this.heos = heos;
    this.api = api;
    gid = thing.getConfiguration().get(GID).toString();

}
 

import org.eclipse.smarthome.core.thing.Thing; //导入依赖的package包/类
/**
 * Manages the adding of the childHandler to the handlerList and sets the Status
 * of the thing to ThingStatus.ONLINE.
 * Add also the player or group channel to the bridge.
 */

@Override
public synchronized void childHandlerInitialized(ThingHandler childHandler, Thing childThing) {
    handlerList.put(childThing.getUID(), childHandler);
    thingOnlineState.put(childThing.getUID(), ThingStatus.ONLINE);
    this.addPlayerChannel(childThing);

    logger.info("Inizialize child handler for: {}.", childThing.getUID().getId());

}