Java State.equals方法代码示例

import org.openhab.core.types.State; //导入方法依赖的package包/类
/**
 * Publishes a state change on the openhab bus
 * @param state the new state to publish on the openhab bus
 * @param changeType whether to always publish or not
 */
public void stateChanged(State state, StateChangeType changeType) {
	State oldState = m_state.get(state.getClass());
	if (oldState == null) {
		logger.trace("new state: {}:{}", state.getClass().getSimpleName(), state);
		// state has changed, must publish
		publishState(state);
	} else {
		logger.trace("old state: {}:{}=?{}", state.getClass().getSimpleName(), oldState, state);
		// only publish if state has changed or it is requested explicitly
		if (changeType == StateChangeType.ALWAYS || !oldState.equals(state)) {
			publishState(state);
		}
	}
	m_state.put(state.getClass(), state);
}
 

import org.openhab.core.types.State; //导入方法依赖的package包/类
public void updateItem(String itemName, String couplerName, int module,
		boolean states[]) {
	for (WagoBindingProvider provider : providers) {
		if (provider.providesBindingFor(itemName)) {
			WagoBindingConfig conf = provider.getConfig(itemName);
			if (conf.couplerName.equals(couplerName)
					&& conf.module == module) {
				State currentState = conf.getItemState();
				State newState = conf
						.translateBoolean2State(states[conf.channel]);
				if (!newState.equals(currentState)) {
					eventPublisher.postUpdate(itemName, newState);
				}
			}
		}
	}
}
 

import org.openhab.core.types.State; //导入方法依赖的package包/类
/**
 * Posts update event to OpenHAB bus for "coil" type slaves
 * @param binding ModbusBinding to get item configuration from BindingProviding
 * @param registers data received from slave device in the last pollInterval
 * @param item item to update
 */
protected void internalUpdateItem(String slaveName, BitVector coils,
		String itemName) {
	for (ModbusBindingProvider provider : providers) {
		if (provider.providesBindingFor(itemName)) {
			ModbusBindingConfig config = provider.getConfig(itemName);
			if (config.slaveName.equals(slaveName)) {
				boolean state = coils.getBit(config.readRegister);
				State currentState = provider.getConfig(itemName).getItemState();
				State newState = provider.getConfig(itemName).translateBoolean2State(state);
				if (!newState.equals(currentState)) {
					eventPublisher.postUpdate(itemName, newState);
				}
			}
		}
	}
}
 

import org.openhab.core.types.State; //导入方法依赖的package包/类
/**
 * @{inheritDoc
 */
public State calculate(List<Item> items) {
	if(items.size()>0) {
		State state = items.get(0).getState(); 
		for(int i=1; i<items.size(); i++) {
			if(!state.equals(items.get(i).getState())) {
				return UnDefType.UNDEF;
			}
		}
		return state;
	} else {
		return UnDefType.UNDEF;
	}
}
 

import org.openhab.core.types.State; //导入方法依赖的package包/类
/**
 * Only update the property if newState is different than it's current state.   
 */
private void updateIfChanged(String instance, String property, State newState) {
	DenonBindingProvider firstProvider = getFirstMatchingProvider(instance, property);
	if (firstProvider != null) {
		DenonBindingConfig config = firstProvider.getConfig(instance, property);
		try {
			State oldState = itemRegistry.getItem(config.getItemName()).getState();
			if (!oldState.equals(newState)) {
				eventPublisher.postUpdate(config.getItemName(), newState);
			}
		} catch (ItemNotFoundException e) {
			logger.debug("Cannot find item " + config.getItemName() + " in the registry", e);
		}
	}
}
 

import org.openhab.core.types.State; //导入方法依赖的package包/类
/**
 * Update an item with value from 1-wire device property
 * 
 * @param pvItemName
 */
public void updateItemFromOneWire(String pvItemName) {
	if (OneWireConnection.getConnection() != null) {

		AbstractOneWireDevicePropertyBindingConfig pvBindingConfig = (AbstractOneWireDevicePropertyBindingConfig) getBindingConfig(pvItemName);

		if (pvBindingConfig == null) {
			logger.error("no bindingConfig found for itemName=" + pvItemName + " cannot update! It will be removed from scheduler");
			ivOneWireReaderScheduler.removeItem(pvItemName);
			return;
		}

		String lvReadValue = OneWireConnection.readFromOneWire(pvBindingConfig);

		Item lvItem = getItem(pvItemName);
		if (lvReadValue != null) {
			Type lvNewType = pvBindingConfig.convertReadValueToType(lvReadValue);
			if (lvItem != null) {
				synchronized (lvItem) {
					State lvNewState = (State) lvNewType;
					State lvCachedState = ivCacheItemStates.get(pvItemName);
					if (!ivPostOnlyChangedValues || !lvNewState.equals(lvCachedState)) {
						ivCacheItemStates.remove(pvItemName);
						ivCacheItemStates.put(pvItemName, lvNewState);
						eventPublisher.postUpdate(lvItem.getName(), lvNewState);
					} else {
						logger.debug("didn't post update to eventPublisher, because state did not changed for item "+pvItemName);
					}
				}
			} else {
				logger.error("There is no Item for ItemName=" + pvItemName);
			}
		} else {
			logger.error("Set Item for itemName=" + pvItemName + " to Undefined, because the readvalue is null");
			ivCacheItemStates.remove(pvItemName);
			eventPublisher.postUpdate(lvItem.getName(), UnDefType.UNDEF);
		}
	}
}
 

import org.openhab.core.types.State; //导入方法依赖的package包/类
/**
 * @{inheritDoc}
 */
@Override
protected void execute() {
	logger.trace("Connecting to {}" + baseURL);	

	clearState();
	
	
	String xmlDoc = fetchStateFromController();
	
	if(xmlDoc == null)
		return;
	
	for (AutelisBindingProvider provider : providers) {
		for (String itemName : provider.getItemNames()) {
			Item item = provider.getItem(itemName);
			String config = provider.getAutelisBindingConfigString(itemName);
			XPathFactory xpathFactory = XPathFactory.newInstance();
			XPath xpath = xpathFactory.newXPath();
			try {
				InputSource is = new InputSource(new StringReader(xmlDoc));
				String value = xpath.evaluate("response/" + config.replace('.', '/'), is);
				State state = toState(item.getClass(), value);
				State oldState = stateMap.put(itemName, state);
				if(!state.equals(oldState)){
					logger.debug("updating item {} with state {}", itemName, state);
					eventPublisher.postUpdate(itemName, state);
				}
			} catch (XPathExpressionException e) {
				logger.warn("could not parse xml",e);
			}

		}
	}
}
 

import org.openhab.core.types.State; //导入方法依赖的package包/类
public State calculate(List<Item> items) {
	State result = super.calculate(items);
	State notResult = 
		result.equals(activeState) ? passiveState : activeState;
	return notResult;
}
 

import org.openhab.core.types.State; //导入方法依赖的package包/类
/**
 * Push the state of all channels to the Nikobus.
 * 
 * @param moduleChannel
 */
public void publishStateToNikobus(ModuleChannel moduleChannel,
		NikobusBinding binding) {

	log.trace("Publishing group {}-{} status to eventbus and nikobus",
			address, group);

	// update the channel on the event bus..
	binding.postUpdate(moduleChannel.getName(),
			moduleChannel.getState());

	StringBuilder command = new StringBuilder();
	command.append(statusUpdateGroup);
	command.append(address);

	for (int i = 0; i < 6; i++) {

		if (channels[i] == null) {
			// no channel defined
			command.append(LOW_BYTE);
			continue;
		}

		State channelState = channels[i].getState();
		if (channelState == null || channelState.equals(OnOffType.OFF)
				|| channelState.equals(PercentType.ZERO)) {
			command.append(LOW_BYTE);
		} else if (channelState.equals(UpDownType.UP)) {
			command.append(UP_BYTE);
		} else if (channelState.equals(UpDownType.DOWN)) {
			command.append(DOWN_BYTE);
		} else if (channelState instanceof PercentType){
			// calculate dimmer value...
			PercentType currentState = (PercentType) channelState;
			int value = BigDecimal.valueOf(255).multiply(currentState.toBigDecimal()).divide(BigDecimal.valueOf(100), 0,
					BigDecimal.ROUND_UP).intValue();
			command.append(StringUtils.leftPad(Integer.toHexString(value), 2, "0").toUpperCase());
		} else {
			command.append(HIGH_BYTE);
		}

	}

	command.append(HIGH_BYTE);

	NikobusCommand cmd = new NikobusCommand(CRCUtil.appendCRC2(
			STATUS_CHANGE_CMD + CRCUtil.appendCRC(command.toString())));

	try {
		binding.sendCommand(cmd);
	} catch (Exception e) {
		log.error("Error sending command.", e);
	}
}
 

import org.openhab.core.types.State; //导入方法依赖的package包/类
/**
 * {@inheritDoc}
 * 
 * The channel group can only process status update commands. These commands
 * are sent by the module in response to a status request and contain
 * the ON/OFF/Dimming status of the different channels.
 */
@Override
public void processNikobusCommand(NikobusCommand cmd, NikobusBinding binding) {

	String command = cmd.getCommand();

	// check if it was an ACK for a status request
	if (command.startsWith(STATUS_REQUEST_ACK)) {
		if (command.startsWith(STATUS_REQUEST_ACK + statusRequestGroup)) {
			nextStatusResponseIsForThisGroup = Boolean.TRUE;
		} else {
			nextStatusResponseIsForThisGroup = Boolean.FALSE;
		}
		return;
	}

	if (!command.startsWith(STATUS_RESPONSE)) {
		return;
	}

	if (!command.startsWith(STATUS_RESPONSE + address)
			|| nextStatusResponseIsForThisGroup == null
			|| nextStatusResponseIsForThisGroup.equals(Boolean.FALSE)) {
		nextStatusResponseIsForThisGroup = null;
		return;
	}

	log.debug(
			"Processing nikobus command {} for module ({}-{})",
			new Object[] { cmd.getCommand(), address,
					Integer.toString(group) });
	lastUpdatedTime = System.currentTimeMillis();

	// for every channel, update the status if it was changed
	for (int i = 0; i < 6; i++) {
		if (channels[i] == null) {
			continue;
		}
		State currentState = channels[i].getState();
		String newValue = command.substring(9 + (i * 2), 11 + (i * 2));
		
		if (channels[i].supportsPercentType()) {					
			PercentType value = getPercentTypeFromByteString(newValue);					
			if (!currentState.equals(value)) {
				binding.postUpdate(channels[i].getName(), value);
				channels[i].setState(value);
			}	
		} else {
			if (newValue.equals(LOW_BYTE)) {
				if (channels[i].getState().equals(OnOffType.ON)) {
					binding.postUpdate(channels[i].getName(), OnOffType.OFF);
					channels[i].setState(OnOffType.OFF);
				}
			} else {
				if (channels[i].getState().equals(OnOffType.OFF)) {
					binding.postUpdate(channels[i].getName(), OnOffType.ON);
					channels[i].setState(OnOffType.ON);
				}
			}
		}
	}
}
 

import org.openhab.core.types.State; //导入方法依赖的package包/类
private void internalPropertyUpdate(String property, State value, boolean incremental) throws Exception {
	int bound = 0;

	if (value == null) {
		logger.trace("internalPropertyUpdate: Value is null for Property '{}', ignored.", property);
		return;
	}

	for (BindingProvider provider : providers) {
		if (provider instanceof MiosBindingProvider) {
			MiosBindingProviderImpl miosProvider = (MiosBindingProviderImpl) provider;

			for (String itemName : miosProvider.getItemNamesForProperty(property)) {

				MiosBindingConfig config = miosProvider.getMiosBindingConfig(itemName);

				if (config != null) {
					// Transform whatever value we have, based upon the
					// Transformation Service specified in the Binding
					// Config.

					State newValue = config.transformIn(value);

					if (newValue != value) {
						logger.trace("internalPropertyUpdate: transformation performed, from '{}' to '{}'", value,
								newValue);

						value = newValue;
					}

					//
					// Set the value only if:
					// * we're running Incrementally OR;
					// * the CURRENT value is UNDEFINED OR;
					// * the CURRENT value is different from the NEW value
					//
					// This is to handle a case where the MiOS Unit
					// "restarts" and floods us with a bunch of the same
					// data. In this case, we don't want to flood the Items,
					// since it may re-trigger a bunch of Rules in an
					// unnecessary manner.
					//
					if (incremental) {
						logger.debug("internalPropertyUpdate: BOUND (Incr) Updating '{} {mios=\"{}\"}' to '{}'",
								itemName, property, value);

						eventPublisher.postUpdate(itemName, value);
					} else {
						ItemRegistry reg = miosProvider.getItemRegistry();
						State oldValue = reg.getItem(itemName).getState();

						if ((oldValue == null && value != null)
								|| (UnDefType.UNDEF.equals(oldValue) && !UnDefType.UNDEF.equals(value))
								|| !oldValue.equals(value)) {
							logger.debug(
									"internalPropertyUpdate: BOUND (Full) Updating '{} {mios=\"{}\"}' to '{}', was '{}'",
									new Object[] { itemName, property, value, oldValue });

							eventPublisher.postUpdate(itemName, value);
						} else {
							logger.trace(
									"internalPropertyUpdate: BOUND (Full) Ignoring '{} {mios=\"{}\"}' to '{}', was '{}'",
									new Object[] { itemName, property, value, oldValue });
						}
					}
					bound++;
				} else {
					logger.trace("internalPropertyUpdate: Found null BindingConfig for item '{}' property '{}'",
							itemName, property);
				}
			}
		}
	}

	if (bound == 0) {
		logger.trace("internalPropertyUpdate: NOT BOUND {mios=\"{}\"}, value={}", property, value);
	} else {
		logger.trace("internalPropertyUpdate: BOUND {mios=\"{}\"}, value={}, bound {} time(s)", new Object[] {
				property, value, bound });
	}
}
 

import org.openhab.core.types.State; //导入方法依赖的package包/类
/**
 * {@inheritDoc}
 */
public EList<Widget> renderWidget(Widget w, StringBuilder sb) throws RenderException {
	Switch s = (Switch) w;
	
	String snippetName = null;
	Item item;
	try {
		item = itemUIRegistry.getItem(w.getItem());
		if(s.getMappings().size()==0) {
			if(item instanceof RollershutterItem) {
				snippetName = "rollerblind";
			} else if (item instanceof GroupItem && ((GroupItem) item).getBaseItem() instanceof RollershutterItem) {
				snippetName = "rollerblind";
			} else {
				snippetName = "switch";
			}
		} else {
			snippetName = "buttons";
		}
	} catch (ItemNotFoundException e) {
		logger.warn("Cannot determine item type of '{}'", w.getItem(), e);
		snippetName = "switch";
	}

	String snippet = getSnippet(snippetName);

	snippet = StringUtils.replace(snippet, "%id%", itemUIRegistry.getWidgetId(w));
	snippet = StringUtils.replace(snippet, "%icon%", escapeURLPath(itemUIRegistry.getIcon(w)));
	snippet = StringUtils.replace(snippet, "%item%", w.getItem());
	snippet = StringUtils.replace(snippet, "%label%", getLabel(w));
	snippet = StringUtils.replace(snippet, "%servletname%", WebAppServlet.SERVLET_NAME);
	
	State state = itemUIRegistry.getState(w);
	
	if(s.getMappings().size()==0) {
		if(state instanceof PercentType) {
			state = ((PercentType) state).intValue() > 0 ? OnOffType.ON : OnOffType.OFF;
		}
		if(state.equals(OnOffType.ON)) {
			snippet = snippet.replaceAll("%checked%", "checked=true");
		} else {
			snippet = snippet.replaceAll("%checked%", "");
		}
	} else {
		StringBuilder buttons = new StringBuilder();
		for(Mapping mapping : s.getMappings()) {
			String button = getSnippet("button");
			button = StringUtils.replace(button, "%item%",w.getItem());
			button = StringUtils.replace(button, "%cmd%", mapping.getCmd());
			button = StringUtils.replace(button, "%label%", mapping.getLabel());
			if(s.getMappings().size()>1 && state.toString().equals(mapping.getCmd())) {
				button = StringUtils.replace(button, "%type%", "Warn"); // button with red color
			} else {
				button = StringUtils.replace(button, "%type%", "Action"); // button with blue color
			}
			buttons.insert(0, button);
		}
		snippet = StringUtils.replace(snippet, "%buttons%", buttons.toString());
	}
	
	// Process the color tags
	snippet = processColor(w, snippet);

	sb.append(snippet);
	return null;
}