Java OnOffType.OFF属性代码示例

double convertData(org.openhab.core.types.State state) {
	if (state instanceof DecimalType) {
		return ((DecimalType) state).doubleValue();				
	}
	else if(state instanceof OnOffType) {
		if(state == OnOffType.OFF)
			return 0;
		else
			return 1;
	}
	else if(state instanceof OpenClosedType) {
		if(state == OpenClosedType.CLOSED)
			return 0;
		else
			return 1;
	}
	else {
		logger.debug("Unsupported item type in chart: {}", state.getClass().toString());
		return 0;
	}
}
 

/**
 * Creates an openHAB {@link State} in accordance to the class of the given {@code propertyValue}. Currently
 * {@link Date}, {@link BigDecimal}, {@link Temperature} and {@link Boolean} are handled explicitly. All other
 * {@code dataTypes} are mapped to {@link StringType}.
 * <p>
 * If {@code propertyValue} is {@code null}, {@link UnDefType#NULL} will be returned.
 * 
 * Copied/adapted from the Koubachi binding.
 * 
 * @param propertyValue
 * 
 * @return the new {@link State} in accordance with {@code dataType}. Will never be {@code null}.
 */
private State createState(Object propertyValue) {
	if (propertyValue == null) {
		return UnDefType.NULL;
	}

	Class<?> dataType = propertyValue.getClass();

	if (Date.class.isAssignableFrom(dataType)) {
		Calendar calendar = Calendar.getInstance();
		calendar.setTime((Date) propertyValue);
		return new DateTimeType(calendar);
	} else if (Integer.class.isAssignableFrom(dataType)) {
		return new DecimalType((Integer) propertyValue);
	} else if (BigDecimal.class.isAssignableFrom(dataType)) {
		return new DecimalType((BigDecimal) propertyValue);
	} else if (Boolean.class.isAssignableFrom(dataType)) {
		if ((Boolean) propertyValue) {
			return OnOffType.ON;
		} else {
			return OnOffType.OFF;
		}
	} else {
		return new StringType(propertyValue.toString());
	}
}
 

@Override
protected void execute() {
	logger.debug("VDRMonitor execute called");
	if (vdrBinding != null) {
		for (VDRConfig vdrConfig : vdrBinding.vdrConfigCache.values()) {
			Boolean recording = checkRecording(vdrConfig);
			if (recording != null) {
				if (eventPublisher != null) {
					VDRBindingProvider bindingProvider = vdrBinding
							.findFirstMatchingBindingProviderByVDRId(vdrConfig.vdrId);
					if (bindingProvider != null) {
						String itemName = bindingProvider
								.getBindingItemName(vdrConfig.vdrId,
										VDRCommandType.RECORDING);
						State newState = recording.booleanValue() ? OnOffType.ON
								: OnOffType.OFF;
						eventPublisher.postUpdate(itemName, newState);

					}
				}
			}
		}
	} else {
		logger.info("VDRBinding not available");
	}
}
 

/**
 * {@inheritDoc}
 */
@Override
protected void internalReceiveUpdate(String itemName, State newState) {

	PLCBusBindingConfig config = tryGetConfigFor(itemName);

	if (config == null) {
		logger.error("No config found for %s", itemName);
		return;
	}

	IPLCBusController controller = PLCBusController.create(serialPortGateway);

	if (newState == UnDefType.UNDEF) {
		StatusResponse response = controller.requestStatusFor(config.getUnit());

		State status = (response.isUnitOn()) ? OnOffType.ON : OnOffType.OFF;
		this.eventPublisher.postUpdate(itemName, status);
	}
}
 

/**
 * {@inheritDoc}
 */
@Override
public State getStateAs(Class<? extends State> typeClass) {
	if(typeClass==OnOffType.class) {
		// if it is not completely off, we consider the dimmer to be on
		return state.equals(PercentType.ZERO) ? OnOffType.OFF : OnOffType.ON;
	} else if(typeClass==DecimalType.class) {
		if(state instanceof PercentType) {
			return new DecimalType(((PercentType) state).toBigDecimal().divide(new BigDecimal(100), 8, RoundingMode.UP));
		}
	}
	return super.getStateAs(typeClass);
}
 

/**
 * Returns the current heating state
 * @param itemType
 * @return
 */
public State getOnOffState(Class<? extends Item> itemType) {
	if (itemType == StringItem.class)
		return dcbState == 1 ? StringType.valueOf("ON") : StringType
				.valueOf("OFF");
	if (itemType == SwitchItem.class)
		return dcbState == 1 ? OnOffType.ON : OnOffType.OFF;

	// Default to DecimalType
	return DecimalType.valueOf(Integer.toString(dcbState));
}
 

@Override
public State getState(LightwaveRfType type) {
	switch (type) {
	case DIMMER:
		return on ? PercentType.HUNDRED : OnOffType.OFF;
	case SWITCH:
		return on ? OnOffType.ON : OnOffType.OFF;
	default:
		return null;
	}
}
 

/**
 * Processes a monitor event for a given binding type
 * 
 * @param event
 *            the monitor event to process
 * @param bindingType
 *            the binding type of the items to process
 */
private void handleEventType(MonitorEvent event, String bindingType) {
	for (FritzboxBindingProvider provider : providers) {
		for (String itemName : provider
				.getItemNamesForType(bindingType)) {
			Class<? extends Item> itemType = provider
					.getItemType(itemName);
			org.openhab.core.types.State state = null;
			if (event.eventType.equals("DISCONNECT")) {
				state = itemType.isAssignableFrom(SwitchItem.class) ? OnOffType.OFF
						: CallType.EMPTY;
			} else if (event.eventType.equals("CONNECT")) {
				if (bindingType
						.equals(FritzboxBindingProvider.TYPE_ACTIVE)) {
					state = itemType.isAssignableFrom(SwitchItem.class) ? OnOffType.ON
							: new CallType(event.externalNo, event.line);
				} else {
					state = itemType.isAssignableFrom(SwitchItem.class) ? OnOffType.OFF
							: CallType.EMPTY;
				}
			} else if (event.eventType.equals("RING")
					&& bindingType
							.equals(FritzboxBindingProvider.TYPE_INBOUND)) {
				state = itemType.isAssignableFrom(SwitchItem.class) ? OnOffType.ON
						: new CallType(event.externalNo,
								event.internalNo);
			} else if (event.eventType.equals("CALL")
					&& bindingType
							.equals(FritzboxBindingProvider.TYPE_OUTBOUND)) {
				state = itemType.isAssignableFrom(SwitchItem.class) ? OnOffType.ON
						: new CallType(event.internalNo,
								event.externalNo);
			}
			if (state != null) {
				eventPublisher.postUpdate(itemName, state);
			}
		}
	}
}
 

public void handleSendEvent(TellstickBindingConfig config, TellstickDevice dev, Command command)
		throws TellstickException {

	int resend = config.getResend();
	long resendInterval = config.getResendInterval();
	for (int i = 0; i < resend; i++) {
		checkLastAndWait(resendInterval);
		logger.info("Send " + command + " to " + dev + " time=" + i + " conf " + config);
		switch (config.getValueSelector()) {

		case COMMAND:
			if (command == OnOffType.ON) {
				if (config.getUsageSelector() == TellstickValueSelector.DIMMABLE) {
					turnOff(dev);
					checkLastAndWait(resendInterval);
				}
				turnOn(config, dev);
			} else if (command == OnOffType.OFF) {
				turnOff(dev);
			}
			break;
		case DIMMING_LEVEL:
			if (command == OnOffType.ON) {
				turnOn(config, dev);
			} else if (command == OnOffType.OFF) {
				turnOff(dev);
			} else if (command instanceof PercentType) {
				dim(dev, (PercentType) command);
			} else if (command instanceof IncreaseDecreaseType) {
				increaseDecrease(dev, ((IncreaseDecreaseType) command));
			}
			break;
		default:
			break;
		}
	}

}
 

@Override
public void valueChanged(ParameterAddress parameterAddress, Value valueObject) {
    ButtonState buttonState = (ButtonState) valueObject;
    Command command = null;
    if (buttonDownPressed(parameterAddress)) {
        switch (buttonState) {
        case PRESSED:
            startDimmerThread(IncreaseDecreaseType.INCREASE);
            buttonOPressedTime = System.currentTimeMillis();
            break;
        case RELEASED:
            stopDimmerThread();
            if (isLongOButtonReleased()) {
                buttonOPressedTime = 0;
            } else {
                command = OnOffType.ON;
            }
            break;
        }
    } else if (buttonUpPressed(parameterAddress)) {
        switch (buttonState) {
        case PRESSED:
            startDimmerThread(IncreaseDecreaseType.DECREASE);
            buttonIPressedTime = System.currentTimeMillis();
            break;
        case RELEASED:
            stopDimmerThread();
            if (isLongIButtonReleased()) {
                buttonIPressedTime = 0;
            } else {
                command = OnOffType.OFF;
            }
            break;
        }
    }
    postCommand(command);
}
 

@Override
public State convertToState(RFXComValueSelector valueSelector)
		throws RFXComException {

	org.openhab.core.types.State state = UnDefType.UNDEF;

	// SWITCHITEM
	if (valueSelector.getItemClass() == SwitchItem.class) {

		if (valueSelector == RFXComValueSelector.COMMAND) {
			switch (command) {
			case OFF:
				state = OnOffType.OFF;
				break;
			case ON:
				state = OnOffType.ON;
				break;
			default:
				throw new RFXComException("Can't convert value " + command
						+ " to COMMAND SwitchItem");
			}
		} else {
			throw new RFXComException("Can't convert " + valueSelector
					+ " to SwitchItem: not supported");
		}

		return state;
	}

	throw new RFXComException("Can't convert " + valueSelector + " to "
			+ valueSelector.getItemClass());

}
 

private void sendUpdates(YamahaReceiverProxy receiverProxy, String deviceUid) {
	// Get all item configurations belonging to this proxy
	Collection<YamahaReceiverBindingConfig> configs = getDeviceConfigs(deviceUid);
	try {
		for (Zone zone : Zone.values()) {
			// Poll the state from the device
			YamahaReceiverState state = receiverProxy.getState(zone);

			// Create state updates
			State powerUpdate = state.isPower() ? OnOffType.ON : OnOffType.OFF;
			State muteUpdate = state.isMute() ? OnOffType.ON : OnOffType.OFF;
			State inputUpdate = new StringType(state.getInput());
			State surroundUpdate = new StringType(state.getSurroundProgram());
			State updateVolumeDb = new DecimalType(state.getVolume());
			State updateVolumePercent = new PercentType(
					(int) dbToPercent(state.getVolume()));

			// Send updates
			sendUpdate(configs, zone, BindingType.power, powerUpdate);
			sendUpdate(configs, zone, BindingType.mute, muteUpdate);
			sendUpdate(configs, zone, BindingType.input, inputUpdate);
			sendUpdate(configs, zone, BindingType.surroundProgram, surroundUpdate);
			sendUpdate(configs, zone, BindingType.volumePercent, updateVolumePercent);
			sendUpdate(configs, zone, BindingType.volumeDb, updateVolumeDb);
		}
	} catch (IOException e) {
		logger.warn("Cannot communicate with " + receiverProxy.getHost());
	}
}
 

protected State booleanToState(Item item, boolean value) {
	if (item instanceof ContactItem) {
		return value ? OpenClosedType.OPEN : OpenClosedType.CLOSED;
	} else if (item instanceof SwitchItem) {
		return value ? OnOffType.ON : OnOffType.OFF;
	} else if (item instanceof NumberItem) {
		return value ? DECIMAL_ONE : DecimalType.ZERO;
	}

	return null;
}
 

private void updateProperty(String property, OnOffType value) {
	value = (value == null ?  OnOffType.OFF : value);
	
	for (Entry<String, String> e : watches.entrySet()) {
		if (property.equals(e.getValue())) {
			eventPublisher.postUpdate(e.getKey(), value);
		}
	}
}
 

/**
 * Converts a {@link String} value to a {@link State} for a given {@link Item}
 * @param itemType
 * @param value
 * @return {@link State}
 */
private State toState(Class<? extends Item> itemType, String value) {
	if (itemType.isAssignableFrom(NumberItem.class)) {
		return new DecimalType(value);
	} else if (itemType.isAssignableFrom(SwitchItem.class)) {
		return Integer.parseInt(value) > 0 ? OnOffType.ON : OnOffType.OFF;
	} else {
		return StringType.valueOf(value);
	}
}