Java Thing.getHandler方法代码示例

import org.eclipse.smarthome.core.thing.Thing; //导入方法依赖的package包/类
/**
 * Update Listeners and child Squeeze Player Things
 *
 * @param event
 */
private void updatePlayer(PlayerUpdateEvent event) {
    // update listeners like disco services
    for (SqueezeBoxPlayerEventListener listener : squeezeBoxPlayerListeners) {
        event.updateListener(listener);
    }
    // update our children
    Bridge bridge = getThing();

    if (bridge == null) {
        return;
    }

    List<Thing> things = bridge.getThings();
    for (Thing thing : things) {
        ThingHandler handler = thing.getHandler();
        if (handler instanceof SqueezeBoxPlayerEventListener && !squeezeBoxPlayerListeners.contains(handler)) {
            event.updateListener((SqueezeBoxPlayerEventListener) handler);
        }
    }
}
 

import org.eclipse.smarthome.core.thing.Thing; //导入方法依赖的package包/类
private void pollShades() throws IOException {
    Shades shades = webTargets.getShades();
    updateStatus(ThingStatus.ONLINE);
    if (shades != null) {
        Map<String, Thing> things = getThingsByShadeId();
        logger.debug("Found {} shades", things.size());
        for (Shade shade : shades.shadeData) {
            Thing thing = things.get(shade.id);
            if (thing != null) {
                HDPowerViewShadeHandler handler = ((HDPowerViewShadeHandler) thing.getHandler());
                if (handler != null) {
                    logger.debug("Handling update for shade {}", shade.id);
                    handler.onReceiveUpdate(shade);
                } else {
                    logger.debug("Skipping shade with no handler {}", shade.id);
                }
            } else {
                logger.debug("Skipping non-bound shade {}", shade.id);
            }
        }
    } else {
        logger.warn("No response to shade poll");
    }
}
 

import org.eclipse.smarthome.core.thing.Thing; //导入方法依赖的package包/类
@Override
public void addDeviceList(DeviceModel device) {
    try {
        logger.debug("set device model: {}", device);
        ThingUID thingUID = getThingUID(device);
        Thing thing = getThingByUID(thingUID);
        if (thing != null) {
            logger.debug("update thing {} with device model: {}", thingUID, device);
            DeviceHandler handler = (DeviceHandler) thing.getHandler();
            if (handler != null) {
                handler.setState(device);
            }
            updateThingFromDevice(thing, device);
        }
    } catch (Exception e) {
        logger.error("{}", e.getLocalizedMessage(), e);
    }
}
 

import org.eclipse.smarthome.core.thing.Thing; //导入方法依赖的package包/类
/**
*
*/
public ZoneMinderBaseThingHandler getZoneMinderThingHandlerFromZoneMinderId(ThingTypeUID thingTypeUID,
        String zoneMinderId) {

    // Inform thing handlers of connection
    List<Thing> things = getThing().getThings();

    for (Thing thing : things) {
        ZoneMinderBaseThingHandler thingHandler = (ZoneMinderBaseThingHandler) thing.getHandler();
        if ((thingHandler.getZoneMinderId().equals(zoneMinderId))
                && (thing.getThingTypeUID().equals(thingTypeUID))) {
            return thingHandler;
        }
    }
    return null;
}
 

import org.eclipse.smarthome.core.thing.Thing; //导入方法依赖的package包/类
/**
 * Runs when connection established.
 *
 * @throws ZoneMinderUrlNotFoundException
 * @throws IOException
 * @throws GeneralSecurityException
 * @throws IllegalArgumentException
 */
public void onConnected() {
    logger.debug("BRIDGE [{}]: onConnected(): Bridge Connected!", getThingId());
    setConnected(true);
    onBridgeConnected(this, zoneMinderConnection);

    // Inform thing handlers of connection
    List<Thing> things = getThing().getThings();

    for (Thing thing : things) {
        ZoneMinderBaseThingHandler thingHandler = (ZoneMinderBaseThingHandler) thing.getHandler();

        if (thingHandler != null) {
            try {
                thingHandler.onBridgeConnected(this, zoneMinderConnection);
            } catch (IllegalArgumentException | GeneralSecurityException | IOException
                    | ZoneMinderUrlNotFoundException e) {
                logger.error("{}: onConnected() failed - Exceprion: {}", getLogIdentifier(), e.getMessage());
            }
            logger.debug("{}: onConnected(): Bridge - {}, Thing - {}, Thing Handler - {}", getLogIdentifier(),
                    thing.getBridgeUID(), thing.getUID(), thingHandler);
        }
    }
}
 

import org.eclipse.smarthome.core.thing.Thing; //导入方法依赖的package包/类
/**
 * Runs when disconnected.
 */
private void onDisconnected() {
    logger.debug("{}: onDisconnected(): Bridge Disconnected!", getLogIdentifier());
    setConnected(false);
    onBridgeDisconnected(this);

    // Inform thing handlers of disconnection
    List<Thing> things = getThing().getThings();

    for (Thing thing : things) {
        ZoneMinderBaseThingHandler thingHandler = (ZoneMinderBaseThingHandler) thing.getHandler();

        if (thingHandler != null) {
            thingHandler.onBridgeDisconnected(this);
            logger.debug("{}: onDisconnected(): Bridge - {}, Thing - {}, Thing Handler - {}", getLogIdentifier(),
                    thing.getBridgeUID(), thing.getUID(), thingHandler);
        }
    }
}
 

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包/类
public TadoHvacChange(Thing zoneThing) {
    if (!(zoneThing.getHandler() instanceof TadoZoneHandler)) {
        throw new IllegalArgumentException("TadoZoneThing expected, but instead got " + zoneThing);
    }

    this.zoneHandler = (TadoZoneHandler) zoneThing.getHandler();
    this.terminationConditionBuilder = TerminationConditionBuilder.of(zoneHandler);
    this.settingsBuilder = ZoneSettingsBuilder.of(zoneHandler);
}
 

import org.eclipse.smarthome.core.thing.Thing; //导入方法依赖的package包/类
private Optional<FlicButtonHandler> getFlicButtonHandler(Bdaddr bdaddr) {
    Thing flicButtonThing = bridgeHandler.getFlicButtonThing(bdaddr);

    if (flicButtonThing != null) {
        FlicButtonHandler thingHandler = (FlicButtonHandler) flicButtonThing.getHandler();
        return Optional.of(thingHandler);
    } else {
        return Optional.empty();
    }
}
 

import org.eclipse.smarthome.core.thing.Thing; //导入方法依赖的package包/类
private void restoreAllPlayerState() {
	Collection<Thing> allThings = thingRegistry.getAll();
	for (Thing aThing : allThings) {
		if (aThing.getThingTypeUID().equals(
				this.getThing().getThingTypeUID())) {
			ZonePlayerHandler handler = (ZonePlayerHandler) aThing.getHandler();
			handler.restoreState();
		}
	}
}
 

import org.eclipse.smarthome.core.thing.Thing; //导入方法依赖的package包/类
private void saveAllPlayerState() {
	Collection<Thing> allThings = thingRegistry.getAll();
	for (Thing aThing : allThings) {
		if (aThing.getThingTypeUID().equals(
				this.getThing().getThingTypeUID())) {
			ZonePlayerHandler handler = (ZonePlayerHandler) aThing.getHandler();
			handler.saveState();
		}
	}
}
 

import org.eclipse.smarthome.core.thing.Thing; //导入方法依赖的package包/类
protected ZonePlayerHandler getHandlerByName(String remotePlayerName) {

		if(thingRegistry!=null) {
			Thing thing = thingRegistry.get(new ThingUID(
					ZONEPLAYER_THING_TYPE_UID, remotePlayerName));

			if (thing == null) {
				Collection<Thing> allThings = thingRegistry.getAll();
				for (Thing aThing : allThings) {
					if (aThing.getThingTypeUID().equals(
							this.getThing().getThingTypeUID())) {
						if (aThing.getConfiguration().get(UDN)
								.equals(remotePlayerName)) {
							thing = aThing;
							break;
						}
					}
				}
			}

			if(thing != null) { 
				return (ZonePlayerHandler) thing.getHandler();
			}
		}
		return null;

	}
 

import org.eclipse.smarthome.core.thing.Thing; //导入方法依赖的package包/类
/**
 * Updates the thing for the given Homematic device.
 */
private void updateThing(HmDevice device) {
    Thing hmThing = getThingByUID(UidUtils.generateThingUID(device, getThing()));
    if (hmThing != null && hmThing.getHandler() != null) {
        HomematicThingHandler thingHandler = (HomematicThingHandler) hmThing.getHandler();
        thingHandler.thingUpdated(hmThing);
        for (Channel channel : hmThing.getChannels()) {
            thingHandler.handleRefresh(channel.getUID());
        }
    }
}
 

import org.eclipse.smarthome.core.thing.Thing; //导入方法依赖的package包/类
@Override
public void onStateUpdated(HmDatapoint dp) {
    Thing hmThing = getThingByUID(UidUtils.generateThingUID(dp.getChannel().getDevice(), getThing()));
    if (hmThing != null && hmThing.getHandler() != null) {
        final ThingStatus status = hmThing.getStatus();
        if (status == ThingStatus.ONLINE || status == ThingStatus.OFFLINE) {
            HomematicThingHandler thingHandler = (HomematicThingHandler) hmThing.getHandler();
            thingHandler.updateDatapointState(dp);
        }
    }
}
 

import org.eclipse.smarthome.core.thing.Thing; //导入方法依赖的package包/类
@Override
public HmDatapointConfig getDatapointConfig(HmDatapoint dp) {
    Thing hmThing = getThingByUID(UidUtils.generateThingUID(dp.getChannel().getDevice(), getThing()));
    if (hmThing != null && hmThing.getHandler() != null) {
        HomematicThingHandler thingHandler = (HomematicThingHandler) hmThing.getHandler();
        return thingHandler.getChannelConfig(dp);
    }
    return new HmDatapointConfig();
}