IoTFieldsExtensionProvider.java

  1. /**
  2.  *
  3.  * Copyright © 2016-2019 Florian Schmaus
  4.  *
  5.  * Licensed under the Apache License, Version 2.0 (the "License");
  6.  * you may not use this file except in compliance with the License.
  7.  * You may obtain a copy of the License at
  8.  *
  9.  *     http://www.apache.org/licenses/LICENSE-2.0
  10.  *
  11.  * Unless required by applicable law or agreed to in writing, software
  12.  * distributed under the License is distributed on an "AS IS" BASIS,
  13.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14.  * See the License for the specific language governing permissions and
  15.  * limitations under the License.
  16.  */
  17. package org.jivesoftware.smackx.iot.data.provider;

  18. import java.io.IOException;
  19. import java.text.ParseException;
  20. import java.util.ArrayList;
  21. import java.util.Date;
  22. import java.util.List;
  23. import java.util.logging.Logger;

  24. import org.jivesoftware.smack.packet.XmlEnvironment;
  25. import org.jivesoftware.smack.parsing.SmackParsingException;
  26. import org.jivesoftware.smack.parsing.SmackParsingException.SmackTextParseException;
  27. import org.jivesoftware.smack.provider.ExtensionElementProvider;
  28. import org.jivesoftware.smack.util.ParserUtils;
  29. import org.jivesoftware.smack.xml.XmlPullParser;
  30. import org.jivesoftware.smack.xml.XmlPullParserException;

  31. import org.jivesoftware.smackx.iot.data.element.IoTDataField;
  32. import org.jivesoftware.smackx.iot.data.element.IoTFieldsExtension;
  33. import org.jivesoftware.smackx.iot.data.element.NodeElement;
  34. import org.jivesoftware.smackx.iot.data.element.TimestampElement;
  35. import org.jivesoftware.smackx.iot.element.NodeInfo;
  36. import org.jivesoftware.smackx.iot.parser.NodeInfoParser;

  37. import org.jxmpp.util.XmppDateTime;

  38. public class IoTFieldsExtensionProvider extends ExtensionElementProvider<IoTFieldsExtension> {

  39.     private static final Logger LOGGER = Logger.getLogger(IoTFieldsExtensionProvider.class.getName());

  40.     @Override
  41.     public IoTFieldsExtension parse(XmlPullParser parser, int initialDepth, XmlEnvironment xmlEnvironment) throws IOException, XmlPullParserException, SmackTextParseException {
  42.         int seqNr = ParserUtils.getIntegerAttributeOrThrow(parser, "seqnr", "IoT data request <accepted/> without sequence number");
  43.         boolean done = ParserUtils.getBooleanAttribute(parser, "done", false);
  44.         List<NodeElement> nodes = new ArrayList<>();
  45.         outerloop: while (true) {
  46.             final XmlPullParser.Event eventType = parser.next();
  47.             final String name = parser.getName();
  48.             switch (eventType) {
  49.             case START_ELEMENT:
  50.                 switch (name) {
  51.                 case NodeElement.ELEMENT:
  52.                     NodeElement node = parseNode(parser);
  53.                     nodes.add(node);
  54.                     break;
  55.                 }
  56.                 break;
  57.             case END_ELEMENT:
  58.                 if (parser.getDepth() == initialDepth) {
  59.                     break outerloop;
  60.                 }
  61.                 break;
  62.             default:
  63.                 // Catch all for incomplete switch (MissingCasesInEnumSwitch) statement.
  64.                 break;
  65.             }
  66.         }
  67.         return new IoTFieldsExtension(seqNr, done, nodes);
  68.     }

  69.     public NodeElement parseNode(XmlPullParser parser) throws XmlPullParserException, IOException, SmackTextParseException {
  70.         final int initialDepth = parser.getDepth();
  71.         final NodeInfo nodeInfo = NodeInfoParser.parse(parser);
  72.         List<TimestampElement> timestampElements = new ArrayList<>();
  73.         outerloop: while (true) {
  74.             final XmlPullParser.Event eventType = parser.next();
  75.             final String name = parser.getName();
  76.             switch (eventType) {
  77.             case START_ELEMENT:
  78.                 switch (name){
  79.                 case TimestampElement.ELEMENT:
  80.                     TimestampElement timestampElement = parseTimestampElement(parser);
  81.                     timestampElements.add(timestampElement);
  82.                     break;
  83.                 }
  84.                 break;
  85.             case END_ELEMENT:
  86.                 if (parser.getDepth() == initialDepth) {
  87.                     break outerloop;
  88.                 }
  89.                 break;
  90.             default:
  91.                 // Catch all for incomplete switch (MissingCasesInEnumSwitch) statement.
  92.                 break;
  93.             }
  94.         }
  95.         return new NodeElement(nodeInfo, timestampElements);
  96.     }

  97.     public TimestampElement parseTimestampElement(XmlPullParser parser) throws XmlPullParserException, IOException, SmackTextParseException {
  98.         final int initialDepth = parser.getDepth();
  99.         final String dateString = parser.getAttributeValue(null, "value");
  100.         Date date;
  101.         try {
  102.             date = XmppDateTime.parseDate(dateString);
  103.         } catch (ParseException e) {
  104.             throw new SmackParsingException.SmackTextParseException(e);
  105.         }
  106.         List<IoTDataField> fields = new ArrayList<>();
  107.         outerloop: while (true) {
  108.             final XmlPullParser.Event eventType = parser.next();
  109.             switch (eventType) {
  110.             case START_ELEMENT:
  111.                 final String name = parser.getName();
  112.                 IoTDataField field = null;
  113.                 final String fieldName = parser.getAttributeValue(null, "name");
  114.                 final String fieldValue = parser.getAttributeValue(null, "value");
  115.                 switch (name) {
  116.                 case "int": {
  117.                     int value = Integer.parseInt(fieldValue);
  118.                     field = new IoTDataField.IntField(fieldName, value);
  119.                     }
  120.                     break;
  121.                 case "boolean": {
  122.                     boolean value = Boolean.parseBoolean(fieldValue);
  123.                     field = new IoTDataField.BooleanField(fieldName, value);
  124.                     }
  125.                     break;
  126.                 default:
  127.                     LOGGER.warning("IoT Data field type '" + name + "' not implement yet. Ignoring.");
  128.                     break;
  129.                 }
  130.                 if (field != null) {
  131.                     fields.add(field);
  132.                 }
  133.                 break;
  134.             case END_ELEMENT:
  135.                 if (parser.getDepth() == initialDepth) {
  136.                     break outerloop;
  137.                 }
  138.                 break;
  139.             default:
  140.                 // Catch all for incomplete switch (MissingCasesInEnumSwitch) statement.
  141.                 break;
  142.             }
  143.         }
  144.         return new TimestampElement(date, fields);
  145.     }
  146. }