git.basschouten.com Git - openhab-addons.git/blob

   1 /**
   2  * Copyright (c) 2010-2020 Contributors to the openHAB project
   3  *
   4  * See the NOTICE file(s) distributed with this work for additional
   5  * information.
   6  *
   7  * This program and the accompanying materials are made available under the
   8  * terms of the Eclipse Public License 2.0 which is available at
   9  * http://www.eclipse.org/legal/epl-2.0
  10  *
  11  * SPDX-License-Identifier: EPL-2.0
  12  */
  13 package org.openhab.binding.caddx.internal.handler;
  14
  15 import java.util.HashMap;
  16
  17 import org.eclipse.jdt.annotation.NonNullByDefault;
  18 import org.eclipse.jdt.annotation.Nullable;
  19 import org.openhab.binding.caddx.internal.CaddxBindingConstants;
  20 import org.openhab.binding.caddx.internal.CaddxEvent;
  21 import org.openhab.binding.caddx.internal.CaddxMessage;
  22 import org.openhab.binding.caddx.internal.CaddxMessageType;
  23 import org.openhab.binding.caddx.internal.CaddxProperty;
  24 import org.openhab.core.library.types.OnOffType;
  25 import org.openhab.core.library.types.StringType;
  26 import org.openhab.core.thing.ChannelUID;
  27 import org.openhab.core.thing.Thing;
  28 import org.openhab.core.thing.ThingStatus;
  29 import org.openhab.core.types.Command;
  30 import org.openhab.core.types.RefreshType;
  31 import org.slf4j.Logger;
  32 import org.slf4j.LoggerFactory;
  33
  34 /**
  35  * This is a class for handling a Panel type Thing.
  36  *
  37  * @author Georgios Moutsos - Initial contribution
  38  */
  39 @NonNullByDefault
  40 public class ThingHandlerPanel extends CaddxBaseThingHandler {
  41     private final Logger logger = LoggerFactory.getLogger(ThingHandlerPanel.class);
  42     private @Nullable HashMap<String, String> panelLogMessagesMap = null;
  43     private @Nullable String communicatorStackPointer = null;
  44
  45     /**
  46      * Constructor.
  47      *
  48      * @param thing
  49      */
  50     public ThingHandlerPanel(Thing thing) {
  51         super(thing, CaddxThingType.PANEL);
  52     }
  53
  54     @Override
  55     public void updateChannel(ChannelUID channelUID, String data) {
  56         if (channelUID.getId().equals(CaddxBindingConstants.PANEL_FIRMWARE_VERSION)
  57                 || channelUID.getId().startsWith("panel_log_message_")) {
  58             updateState(channelUID, new StringType(data));
  59         } else {
  60             // All Panel channels are OnOffType
  61             OnOffType onOffType;
  62
  63             onOffType = ("true".equals(data)) ? OnOffType.ON : OnOffType.OFF;
  64             updateState(channelUID, onOffType);
  65         }
  66     }
  67
  68     @Override
  69     public void handleCommand(ChannelUID channelUID, Command command) {
  70         logger.trace("handleCommand(): Command Received - {} {}.", channelUID, command);
  71
  72         String cmd = null;
  73         String data = null;
  74         CaddxBridgeHandler bridgeHandler = getCaddxBridgeHandler();
  75         if (bridgeHandler == null) {
  76             return;
  77         }
  78
  79         if (command instanceof RefreshType) {
  80             if (CaddxBindingConstants.PANEL_FIRMWARE_VERSION.equals(channelUID.getId())) {
  81                 cmd = CaddxBindingConstants.PANEL_INTERFACE_CONFIGURATION_REQUEST;
  82                 data = "";
  83             } else if (CaddxBindingConstants.PANEL_LOG_MESSAGE_N_0.equals(channelUID.getId())) {
  84                 cmd = CaddxBindingConstants.PANEL_SYSTEM_STATUS_REQUEST;
  85                 data = "";
  86             } else {
  87                 return;
  88             }
  89
  90             bridgeHandler.sendCommand(cmd, data);
  91         } else {
  92             logger.debug("Unknown command {}", command);
  93         }
  94     }
  95
  96     @Override
  97     public void caddxEventReceived(CaddxEvent event, Thing thing) {
  98         logger.trace("caddxEventReceived(): Event Received - {}.", event);
  99
 100         if (getThing().equals(thing)) {
 101             CaddxMessage message = event.getCaddxMessage();
 102             CaddxMessageType mt = message.getCaddxMessageType();
 103             ChannelUID channelUID = null;
 104
 105             // Log event messages have special handling
 106             if (CaddxMessageType.SYSTEM_STATUS_MESSAGE.equals(mt)) {
 107                 handleSystemStatusMessage(message);
 108             } else if (CaddxMessageType.LOG_EVENT_MESSAGE.equals(mt)) {
 109                 handleLogEventMessage(message);
 110             } else {
 111                 for (CaddxProperty p : mt.properties) {
 112                     if (!p.getId().isEmpty()) {
 113                         String value = message.getPropertyById(p.getId());
 114                         channelUID = new ChannelUID(getThing().getUID(), p.getId());
 115                         updateChannel(channelUID, value);
 116                     }
 117                 }
 118             }
 119
 120             updateStatus(ThingStatus.ONLINE);
 121         }
 122     }
 123
 124     /*
 125      * Gets the pointer into the panel's log messages ring buffer
 126      * and sends the command for the retrieval of the last event_message
 127      */
 128     private void handleSystemStatusMessage(CaddxMessage message) {
 129         // Get the bridge handler
 130         CaddxBridgeHandler bridgeHandler = getCaddxBridgeHandler();
 131         if (bridgeHandler == null) {
 132             return;
 133         }
 134
 135         String pointer = message.getPropertyById("panel_communicator_stack_pointer");
 136         communicatorStackPointer = pointer;
 137
 138         // build map of log message channels to event numbers
 139         HashMap<String, String> map = new HashMap<String, String>();
 140         map.put(pointer, CaddxBindingConstants.PANEL_LOG_MESSAGE_N_0);
 141         bridgeHandler.sendCommand(CaddxBindingConstants.PANEL_LOG_EVENT_REQUEST, pointer);
 142         panelLogMessagesMap = map;
 143     }
 144
 145     /*
 146      * This function handles the panel log messages.
 147      * If the received event_number matches our communication stack pointer then this is the last panel message. The
 148      * channel gets updated and the required log message requests are generated for the update of the other log message
 149      * channels
 150      */
 151     private void handleLogEventMessage(CaddxMessage message) {
 152         // Get the bridge handler
 153         CaddxBridgeHandler bridgeHandler = getCaddxBridgeHandler();
 154         if (bridgeHandler == null) {
 155             return;
 156         }
 157
 158         String eventNumberString = message.getPropertyById("panel_log_event_number");
 159         String eventSizeString = message.getPropertyById("panel_log_event_size");
 160
 161         // build the message
 162         LogEventMessage logEventMessage = new LogEventMessage(message);
 163
 164         logger.trace("Log_event: {}", logEventMessage);
 165
 166         // get the channel id from the map
 167         HashMap<String, String> logMap = panelLogMessagesMap;
 168         String id = logMap.get(eventNumberString);
 169         if (logMap != null && id != null) {
 170             ChannelUID channelUID = new ChannelUID(getThing().getUID(), id);
 171             updateChannel(channelUID, logEventMessage.toString());
 172         }
 173
 174         if (communicatorStackPointer != null && eventNumberString.equals(communicatorStackPointer)) {
 175             HashMap<String, String> map = new HashMap<String, String>();
 176
 177             int eventNumber = Integer.parseInt(eventNumberString);
 178             int eventSize = Integer.parseInt(eventSizeString);
 179
 180             // Retrieve at maximum the 10 last log messages from the panel
 181             int messagesToRetrieve = Math.min(eventSize, 10);
 182             for (int i = 1; i < messagesToRetrieve; i++) {
 183                 eventNumber--;
 184                 if (eventNumber < 0) {
 185                     eventNumber = eventSize;
 186                 }
 187
 188                 map.put(Integer.toString(eventNumber), "panel_log_message_n_" + i);
 189                 bridgeHandler.sendCommand(CaddxBindingConstants.PANEL_LOG_EVENT_REQUEST, Integer.toString(eventNumber));
 190             }
 191
 192             communicatorStackPointer = null;
 193             panelLogMessagesMap = map;
 194         }
 195     }
 196 }