/**
* Finds and returns a child thing for a given UID of this bridge.
*
* @param uid uid of the child thing
* @return child thing with the given uid or null if thing was not found
*/
public Thing getThingByUID(ThingUID uid) {
Bridge bridge = getThing();
List<Thing> things = bridge.getThings();
for (Thing thing : things) {
if (thing.getUID().equals(uid)) {
return thing;
}
}
return null;
}
protected void requestParentRefresh() {
logger.debug("Updating parent modules of {}", configuration.getEquipmentId());
for (Thing thing : getBridge().getThings()) {
ThingHandler thingHandler = thing.getHandler();
if (thingHandler instanceof NetatmoDeviceHandler) {
@SuppressWarnings("unchecked")
NetatmoDeviceHandler<NetatmoDeviceConfiguration> deviceHandler =
(NetatmoDeviceHandler<NetatmoDeviceConfiguration>) thingHandler;
NetatmoDeviceConfiguration deviceConfiguration = deviceHandler.configuration;
if (deviceConfiguration.getEquipmentId().equalsIgnoreCase(configuration.getParentId())) {
// I'm your father Luke
thingHandler.handleCommand(null, RefreshType.REFRESH);
}
}
}
}
@Override
protected ThingHandler createHandler(Thing thing) {
if (thing.getThingTypeUID().equals(TELLDUSCOREBRIDGE_THING_TYPE)) {
TelldusCoreBridgeHandler handler = new TelldusCoreBridgeHandler((Bridge) thing);
registerDeviceDiscoveryService(handler);
return handler;
} else if (thing.getThingTypeUID().equals(TELLDUSLIVEBRIDGE_THING_TYPE)) {
TelldusLiveBridgeHandler handler = new TelldusLiveBridgeHandler((Bridge) thing);
registerDeviceDiscoveryService(handler);
return handler;
} else if (supportsThingType(thing.getThingTypeUID())) {
return new TelldusDevicesHandler(thing);
} else {
logger.debug("ThingHandler not found for {}", thing.getThingTypeUID());
return null;
}
}
@Override
protected ThingHandler createHandler(Thing thing) {
ThingTypeUID thingTypeUID = thing.getThingTypeUID();
if (SUPPORTED_THING_TYPES_UIDS.contains(thingTypeUID)) {
return new EnOceanHandler(thing);
}
return null;
}
@Override
protected ThingHandler createHandler(Thing thing) {
ThingTypeUID thingTypeUID = thing.getThingTypeUID();
if (thingTypeUID.equals(YahooWeatherBindingConstants.THING_TYPE_WEATHER)) {
return new YahooWeatherHandler(thing);
}
return null;
}
@Override
protected ThingHandler createHandler(Thing thing) {
ThingTypeUID thingTypeUID = thing.getThingTypeUID();
if (thingTypeUID.equals(THING_TYPE_SAMPLE)) {
return new nest2Handler(thing);
}
return null;
}
@Override
protected ThingHandler createHandler(Thing thing) {
ThingTypeUID thingTypeUID = thing.getThingTypeUID();
if (thingTypeUID.equals(THING_TYPE_COMPUTER)) {
return new SysteminfoHandler(thing);
}
return null;
}
private int getFreeId() {
int id = 1;
List<Number> takenIds = new ArrayList<Number>();
// Which ids are taken in Thing list of OpenHAB
Collection<Thing> thingList = thingRegistry.getAll();
Iterator<Thing> iterator = thingList.iterator();
while (iterator.hasNext()) {
Thing thing = iterator.next();
Configuration conf = thing.getConfiguration();
if (conf != null) {
Object nodeIdobj = conf.get("nodeId");
if (nodeIdobj != null) {
int nodeId = Integer.parseInt(nodeIdobj.toString());
takenIds.add(nodeId);
}
}
}
// Which ids are already given by the binding, but not yet in the thing list?
Iterator<Number> iteratorGiven = givenIds.iterator();
while (iteratorGiven.hasNext()) {
takenIds.add(iteratorGiven.next());
}
// generate new id
boolean foundId = false;
while (!foundId) {
Random rand = new Random(System.currentTimeMillis());
int newId = rand.nextInt((254 - 1) + 1) + 1;
if (!takenIds.contains(newId)) {
id = newId;
foundId = true;
}
}
return id;
}
@Override
protected ThingHandler createHandler(Thing thing) {
ThingTypeUID thingTypeUID = thing.getThingTypeUID();
if (thingTypeUID.equals(URTSI_DEVICE_THING_TYPE) && thing instanceof Bridge) {
return new UrtsiDeviceHandler((Bridge) thing);
} else if (thingTypeUID.equals(RTS_DEVICE_THING_TYPE)) {
return new RtsDeviceHandler(thing);
}
return null;
}
/**
* Maps thing into thing data transfer object (DTO).
*
* @param thing the thing
* @return the thing DTO object
*/
public static ThingDTO map(Thing thing) {
List<ChannelDTO> channelDTOs = new ArrayList<>();
for (Channel channel : thing.getChannels()) {
ChannelDTO channelDTO = ChannelDTOMapper.map(channel);
channelDTOs.add(channelDTO);
}
String thingTypeUID = thing.getThingTypeUID().getAsString();
String thingUID = thing.getUID().toString();
String bridgeUID = thing.getBridgeUID() != null ? thing.getBridgeUID().toString() : null;
return new ThingDTO(
thingTypeUID,
thingUID,
thing.getLabel(),
bridgeUID,
channelDTOs,
thing.getConfiguration(),
thing.getProperties(),
thing.getLocation());
}
@Override
protected ThingHandler createHandler(Thing thing) {
ThingTypeUID thingTypeUID = thing.getThingTypeUID();
if (thingTypeUID.equals(SQUEEZEBOXPLAYER_THING_TYPE)) {
return new SqueezeBoxPlayerHandler(thing);
}
if (thingTypeUID.equals(SQUEEZEBOXSERVER_THING_TYPE)) {
logger.trace("Returning handler for bridge thing {}", thing);
SqueezeBoxServerHandler handler = new SqueezeBoxServerHandler((Bridge) thing);
registerSqueezeBoxPlayerDiscoveryService(handler);
return handler;
}
return null;
}
@Override
protected ThingHandler createHandler(Thing thing) {
ThingTypeUID thingTypeUID = thing.getThingTypeUID();
if (thingTypeUID.equals(THING_TYPE_IPBRIDGE)) {
return new IPBridgeHandler((Bridge) thing);
} else if (thingTypeUID.equals(THING_TYPE_DIMMER)) {
return new DimmerHandler(thing);
} else if (thingTypeUID.equals(THING_TYPE_SWITCH)) {
return new SwitchHandler(thing);
} else if (thingTypeUID.equals(THING_TYPE_OCCUPANCYSENSOR)) {
return new OccupancySensorHandler(thing);
} else if (thingTypeUID.equals(THING_TYPE_KEYPAD)) {
return new KeypadHandler(thing);
}
return null;
}
/** {@inheritDoc} */
@Override
public void dscAlarmEventReceived(EventObject event, Thing thing) {
if (thing != null) {
if (getThing() == thing) {
DSCAlarmEvent dscAlarmEvent = (DSCAlarmEvent) event;
DSCAlarmMessage apiMessage = dscAlarmEvent.getDSCAlarmMessage();
ChannelUID channelUID = null;
DSCAlarmCode apiCode =
DSCAlarmCode.getDSCAlarmCodeValue(
apiMessage.getMessageInfo(DSCAlarmMessageInfoType.CODE));
String apiData = apiMessage.getMessageInfo(DSCAlarmMessageInfoType.DATA);
logger.debug("dscAlarmEventRecieved(): Thing - {} Command - {}", thing.getUID(), apiCode);
switch (apiCode) {
case KeypadLEDState: /* 510 */
case KeypadLEDFlashState: /* 511 */
keypadLEDStateEventHandler(event);
break;
case LEDStatus: /* 903 */
int aData = Integer.parseInt(apiData.substring(0, 1));
int state =
Integer.parseInt(
apiMessage.getMessageInfo(DSCAlarmMessageInfoType.DATA).substring(1));
switch (aData) {
case 1:
channelUID = new ChannelUID(getThing().getUID(), KEYPAD_READY_LED);
properties.setLEDState(LEDStateType.READY_LED_STATE, state);
updateChannel(channelUID);
break;
case 2:
channelUID = new ChannelUID(getThing().getUID(), KEYPAD_ARMED_LED);
properties.setLEDState(LEDStateType.ARMED_LED_STATE, state);
updateChannel(channelUID);
break;
case 3:
channelUID = new ChannelUID(getThing().getUID(), KEYPAD_MEMORY_LED);
properties.setLEDState(LEDStateType.MEMORY_LED_STATE, state);
updateChannel(channelUID);
break;
case 4:
channelUID = new ChannelUID(getThing().getUID(), KEYPAD_BYPASS_LED);
properties.setLEDState(LEDStateType.BYPASS_LED_STATE, state);
updateChannel(channelUID);
break;
case 5:
channelUID = new ChannelUID(getThing().getUID(), KEYPAD_TROUBLE_LED);
properties.setLEDState(LEDStateType.TROUBLE_LED_STATE, state);
updateChannel(channelUID);
break;
case 6:
channelUID = new ChannelUID(getThing().getUID(), KEYPAD_PROGRAM_LED);
properties.setLEDState(LEDStateType.PROGRAM_LED_STATE, state);
updateChannel(channelUID);
break;
case 7:
channelUID = new ChannelUID(getThing().getUID(), KEYPAD_FIRE_LED);
properties.setLEDState(LEDStateType.FIRE_LED_STATE, state);
updateChannel(channelUID);
break;
case 8:
channelUID = new ChannelUID(getThing().getUID(), KEYPAD_BACKLIGHT_LED);
properties.setLEDState(LEDStateType.BACKLIGHT_LED_STATE, state);
updateChannel(channelUID);
break;
case 9:
channelUID = new ChannelUID(getThing().getUID(), KEYPAD_AC_LED);
properties.setLEDState(LEDStateType.AC_LED_STATE, state);
updateChannel(channelUID);
break;
default:
break;
}
default:
break;
}
}
}
}
/** {@inheritDoc} */
@Override
public void dscAlarmEventReceived(EventObject event, Thing thing) {
if (thing != null) {
DSCAlarmEvent dscAlarmEvent = (DSCAlarmEvent) event;
DSCAlarmMessage dscAlarmMessage = dscAlarmEvent.getDSCAlarmMessage();
setTimeStampState(dscAlarmMessage.getMessageInfo(DSCAlarmMessageInfoType.TIME_STAMP));
boolean suppressPanelMsg = false;
if (getThing() == thing) {
ChannelUID channelUID = null;
DSCAlarmCode apiCode =
DSCAlarmCode.getDSCAlarmCodeValue(
dscAlarmMessage.getMessageInfo(DSCAlarmMessageInfoType.CODE));
logger.debug("dscAlarmEventRecieved(): Thing - {} Command - {}", thing.getUID(), apiCode);
int state = 0;
switch (apiCode) {
case CommandAcknowledge: /* 500 */
if (getSuppressAcknowledgementMsgs()) {
suppressPanelMsg = true;
}
break;
case SystemError: /* 502 */
panelSystemError(dscAlarmMessage);
break;
case TimeDateBroadcast: /* 550 */
channelUID = new ChannelUID(getThing().getUID(), PANEL_TIME);
String panelTime = dscAlarmMessage.getMessageInfo(DSCAlarmMessageInfoType.DATA);
updateProperties(channelUID, state, panelTime);
updateChannel(channelUID);
channelUID = new ChannelUID(getThing().getUID(), PANEL_TIME_BROADCAST);
updateProperties(channelUID, 1, "");
updateChannel(channelUID);
if (getSuppressAcknowledgementMsgs()) {
suppressPanelMsg = true;
}
break;
case FireKeyAlarm: /* 621 */
state = 1;
case FireKeyRestored: /* 622 */
channelUID = new ChannelUID(getThing().getUID(), PANEL_FIRE_KEY_ALARM);
updateProperties(channelUID, state, "");
updateChannel(channelUID);
break;
case AuxiliaryKeyAlarm: /* 623 */
state = 1;
case AuxiliaryKeyRestored: /* 624 */
channelUID = new ChannelUID(getThing().getUID(), PANEL_AUX_KEY_ALARM);
updateProperties(channelUID, state, "");
updateChannel(channelUID);
break;
case PanicKeyAlarm: /* 625 */
state = 1;
case PanicKeyRestored: /* 626 */
channelUID = new ChannelUID(getThing().getUID(), PANEL_PANIC_KEY_ALARM);
updateProperties(channelUID, state, "");
updateChannel(channelUID);
break;
case AuxiliaryInputAlarm: /* 631 */
state = 1;
case AuxiliaryInputAlarmRestored: /* 632 */
channelUID = new ChannelUID(getThing().getUID(), PANEL_AUX_INPUT_ALARM);
updateProperties(channelUID, state, "");
updateChannel(channelUID);
break;
case TroubleLEDOn: /* 840 */
channelUID = new ChannelUID(getThing().getUID(), PANEL_TROUBLE_LED);
updateProperties(channelUID, 1, "");
updateChannel(channelUID);
break;
case TroubleLEDOff: /* 841 */
channelUID = new ChannelUID(getThing().getUID(), PANEL_SERVICE_REQUIRED);
updateProperties(channelUID, 0, "");
updateChannel(channelUID);
channelUID = new ChannelUID(getThing().getUID(), PANEL_AC_TROUBLE);
updateProperties(channelUID, 0, "");
updateChannel(channelUID);
channelUID = new ChannelUID(getThing().getUID(), PANEL_TELEPHONE_TROUBLE);
updateProperties(channelUID, 0, "");
updateChannel(channelUID);
channelUID = new ChannelUID(getThing().getUID(), PANEL_FTC_TROUBLE);
updateProperties(channelUID, 0, "");
updateChannel(channelUID);
channelUID = new ChannelUID(getThing().getUID(), PANEL_ZONE_FAULT);
updateProperties(channelUID, 0, "");
updateChannel(channelUID);
channelUID = new ChannelUID(getThing().getUID(), PANEL_ZONE_TAMPER);
updateProperties(channelUID, 0, "");
updateChannel(channelUID);
channelUID = new ChannelUID(getThing().getUID(), PANEL_ZONE_LOW_BATTERY);
updateProperties(channelUID, 0, "");
updateChannel(channelUID);
channelUID = new ChannelUID(getThing().getUID(), PANEL_TIME_LOSS);
updateProperties(channelUID, 0, "");
updateChannel(channelUID);
channelUID = new ChannelUID(getThing().getUID(), PANEL_TROUBLE_LED);
updateProperties(channelUID, 0, "");
updateChannel(channelUID);
break;
case PanelBatteryTrouble: /* 800 */
case PanelACTrouble: /* 802 */
case SystemBellTrouble: /* 806 */
case TLMLine1Trouble: /* 810 */
case TLMLine2Trouble: /* 812 */
case FTCTrouble: /* 814 */
case GeneralDeviceLowBattery: /* 821 */
case WirelessKeyLowBatteryTrouble: /* 825 */
case HandheldKeypadLowBatteryTrouble: /* 827 */
case GeneralSystemTamper: /* 829 */
case HomeAutomationTrouble: /* 831 */
case KeybusFault: /* 896 */
channelUID = new ChannelUID(getThing().getUID(), PANEL_TROUBLE_MESSAGE);
updateProperties(
channelUID, 0, dscAlarmMessage.getMessageInfo(DSCAlarmMessageInfoType.DESCRIPTION));
updateChannel(channelUID);
break;
case PanelBatteryTroubleRestore: /* 801 */
case PanelACRestore: /* 803 */
case SystemBellTroubleRestore: /* 807 */
case TLMLine1TroubleRestore: /* 811 */
case TLMLine2TroubleRestore: /* 813 */
case GeneralDeviceLowBatteryRestore: /* 822 */
case WirelessKeyLowBatteryTroubleRestore: /* 826 */
case HandheldKeypadLowBatteryTroubleRestore: /* 828 */
case GeneralSystemTamperRestore: /* 830 */
case HomeAutomationTroubleRestore: /* 832 */
case KeybusFaultRestore: /* 897 */
channelUID = new ChannelUID(getThing().getUID(), PANEL_TROUBLE_MESSAGE);
updateProperties(channelUID, 0, "");
updateChannel(channelUID);
break;
case VerboseTroubleStatus: /* 849 */
verboseTroubleStatusHandler(event);
break;
case CodeRequired: /* 900 */
dscAlarmBridgeHandler.sendCommand(DSCAlarmCode.CodeSend, getUserCode());
break;
default:
break;
}
}
if (!suppressPanelMsg) {
setPanelMessage(dscAlarmMessage.getMessageInfo(DSCAlarmMessageInfoType.DESCRIPTION));
}
}
}
@Override
public ConfigDescription getConfigDescription(URI uri, Locale locale) {
if (uri == null) {
return null;
}
if ("thing".equals(uri.getScheme()) == false) {
return null;
}
ThingUID thingUID = new ThingUID(uri.getSchemeSpecificPart());
ThingType thingType = thingTypeRegistry.getThingType(thingUID.getThingTypeUID());
if (thingType == null) {
return null;
}
// Is this a zwave thing?
if (!thingUID.getBindingId().equals(ZWaveBindingConstants.BINDING_ID)) {
return null;
}
// And make sure this is a node because we want to get the id off the end...
if (!thingUID.getId().startsWith("node")) {
return null;
}
int nodeId = Integer.parseInt(thingUID.getId().substring(4));
Thing thing = getThing(thingUID);
if (thing == null) {
return null;
}
ThingUID bridgeUID = thing.getBridgeUID();
// Get the controller for this thing
Thing bridge = getThing(bridgeUID);
if (bridge == null) {
return null;
}
// Get its handler and node
ZWaveControllerHandler handler = (ZWaveControllerHandler) bridge.getHandler();
ZWaveNode node = handler.getNode(nodeId);
List<ConfigDescriptionParameterGroup> groups = new ArrayList<ConfigDescriptionParameterGroup>();
List<ConfigDescriptionParameter> parameters = new ArrayList<ConfigDescriptionParameter>();
groups.add(new ConfigDescriptionParameterGroup("actions", "", false, "Actions", null));
groups.add(new ConfigDescriptionParameterGroup("thingcfg", "home", false, "Device Configuration", null));
parameters.add(ConfigDescriptionParameterBuilder
.create(ZWaveBindingConstants.CONFIGURATION_POLLPERIOD, Type.INTEGER).withLabel("Polling Period")
.withDescription("Set the minimum polling period for this device<BR/>"
+ "Note that the polling period may be longer than set since the binding treats "
+ "polls as the lowest priority data within the network.")
.withDefault("1800").withGroupName("thingcfg").build());
// If we support the wakeup class, then add the configuration
if (node.getCommandClass(ZWaveCommandClass.CommandClass.WAKE_UP) != null) {
groups.add(new ConfigDescriptionParameterGroup("wakeup", "sleep", false, "Wakeup Configuration", null));
parameters.add(ConfigDescriptionParameterBuilder
.create(ZWaveBindingConstants.CONFIGURATION_WAKEUPINTERVAL, Type.TEXT).withLabel("Wakeup Interval")
.withDescription("Sets the number of seconds that the device will wakeup<BR/>"
+ "Setting a shorter time will allow openHAB to configure the device more regularly, but may use more battery power.<BR>"
+ "<B>Note:</B> This setting does not impact device notifications such as alarms.")
.withDefault("").withGroupName("wakeup").build());
parameters.add(
ConfigDescriptionParameterBuilder.create(ZWaveBindingConstants.CONFIGURATION_WAKEUPNODE, Type.TEXT)
.withLabel("Wakeup Node").withAdvanced(true)
.withDescription("Sets the wakeup node to which the device will send notifications.<BR/>"
+ "This should normally be set to the openHAB controller - "
+ "if it isn't, openHAB will not receive notifications when the device wakes up, "
+ "and will not be able to configure the device.")
.withDefault("").withGroupName("wakeup").build());
}
// If we support the node name class, then add the configuration
if (node.getCommandClass(ZWaveCommandClass.CommandClass.NODE_NAMING) != null) {
parameters.add(
ConfigDescriptionParameterBuilder.create(ZWaveBindingConstants.CONFIGURATION_NODENAME, Type.TEXT)
.withLabel("Node Name").withDescription("Sets a string for the device name")
.withGroupName("thingcfg").withDefault("").build());
parameters.add(ConfigDescriptionParameterBuilder
.create(ZWaveBindingConstants.CONFIGURATION_NODELOCATION, Type.TEXT)
.withDescription("Sets a string for the device location").withLabel("Node Location").withDefault("")
.withGroupName("thingcfg").build());
}
// If we support the switch_all class, then add the configuration
if (node.getCommandClass(ZWaveCommandClass.CommandClass.SWITCH_ALL) != null) {
List<ParameterOption> options = new ArrayList<ParameterOption>();
options.add(new ParameterOption("0", "Exclude from All On and All Off groups"));
options.add(new ParameterOption("1", "Include in All On group"));
options.add(new ParameterOption("2", "Include in All Off group"));
options.add(new ParameterOption("255", "Include in All On and All Off groups"));
parameters.add(ConfigDescriptionParameterBuilder
.create(ZWaveBindingConstants.CONFIGURATION_SWITCHALLMODE, Type.TEXT).withLabel("Switch All Mode")
.withDescription("Set the mode for the switch when receiving SWITCH ALL commands.").withDefault("0")
.withGroupName("thingcfg").withOptions(options).build());
}
// If we support DOOR_LOCK - add options
if (node.getCommandClass(ZWaveCommandClass.CommandClass.DOOR_LOCK) != null) {
parameters.add(ConfigDescriptionParameterBuilder
.create(ZWaveBindingConstants.CONFIGURATION_DOORLOCKTIMEOUT, Type.TEXT).withLabel("Lock Timeout")
.withDescription("Set the timeout on the lock.").withDefault("30").withGroupName("thingcfg")
.build());
}
ZWaveUserCodeCommandClass userCodeClass = (ZWaveUserCodeCommandClass) node
.getCommandClass(ZWaveCommandClass.CommandClass.USER_CODE);
if (userCodeClass != null && userCodeClass.getNumberOfSupportedCodes() > 0) {
groups.add(new ConfigDescriptionParameterGroup("usercode", "lock", false, "User Code", null));
for (int code = 1; code <= userCodeClass.getNumberOfSupportedCodes(); code++) {
parameters.add(ConfigDescriptionParameterBuilder
.create(ZWaveBindingConstants.CONFIGURATION_USERCODE + code, Type.TEXT)
.withLabel("Code " + code).withDescription("Set the user code (4 to 10 numbers)")
.withDefault("").withGroupName("usercode").build());
}
}
List<ParameterOption> options = new ArrayList<ParameterOption>();
options.add(new ParameterOption(ZWaveBindingConstants.ACTION_CHECK_VALUE.toString(), "Do"));
