JivePropertiesExtension.java

  1. /**
  2.  *
  3.  * Copyright 2003-2007 Jive Software.
  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.jiveproperties.packet;

  19. import java.io.ByteArrayOutputStream;
  20. import java.io.ObjectOutputStream;
  21. import java.io.Serializable;
  22. import java.util.Collection;
  23. import java.util.Collections;
  24. import java.util.HashMap;
  25. import java.util.HashSet;
  26. import java.util.Map;
  27. import java.util.logging.Level;
  28. import java.util.logging.Logger;

  30. import org.jivesoftware.smack.packet.ExtensionElement;
  31. import org.jivesoftware.smack.util.XmlStringBuilder;
  32. import org.jivesoftware.smack.util.stringencoder.Base64;

  34. /**
  35.  * Properties provide an easy mechanism for clients to share data. Each property has a
  36.  * String name, and a value that is a Java primitive (int, long, float, double, boolean)
  37.  * or any Serializable object (a Java object is Serializable when it implements the
  38.  * Serializable interface).
  39.  *
  40.  */
  41. public class JivePropertiesExtension implements ExtensionElement {
  42.     /**
  43.      * Namespace used to store packet properties.
  44.      */
  45.     public static final String NAMESPACE = "http://www.jivesoftware.com/xmlns/xmpp/properties";

  47.     public static final String ELEMENT = "properties";

  49.     private static final Logger LOGGER = Logger.getLogger(JivePropertiesExtension.class.getName());
  50.     
  51.     private final Map<String, Object> properties;

  53.     public JivePropertiesExtension() {
  54.         properties = new HashMap<String, Object>();
  55.     }

  57.     public JivePropertiesExtension(Map<String, Object> properties) {
  58.         this.properties = properties;
  59.     }

  61.     /**
  62.      * Returns the packet property with the specified name or <tt>null</tt> if the
  63.      * property doesn't exist. Property values that were originally primitives will
  64.      * be returned as their object equivalent. For example, an int property will be
  65.      * returned as an Integer, a double as a Double, etc.
  66.      *
  67.      * @param name the name of the property.
  68.      * @return the property, or <tt>null</tt> if the property doesn't exist.
  69.      */
  70.     public synchronized Object getProperty(String name) {
  71.         if (properties == null) {
  72.             return null;
  73.         }
  74.         return properties.get(name);
  75.     }

  77.     /**
  78.      * Sets a property with an Object as the value. The value must be Serializable
  79.      * or an IllegalArgumentException will be thrown.
  80.      *
  81.      * @param name the name of the property.
  82.      * @param value the value of the property.
  83.      */
  84.     public synchronized void setProperty(String name, Object value) {
  85.         if (!(value instanceof Serializable)) {
  86.             throw new IllegalArgumentException("Value must be serialiazble");
  87.         }
  88.         properties.put(name, value);
  89.     }

  91.     /**
  92.      * Deletes a property.
  93.      *
  94.      * @param name the name of the property to delete.
  95.      */
  96.     public synchronized void deleteProperty(String name) {
  97.         if (properties == null) {
  98.             return;
  99.         }
  100.         properties.remove(name);
  101.     }

  103.     /**
  104.      * Returns an unmodifiable collection of all the property names that are set.
  105.      *
  106.      * @return all property names.
  107.      */
  108.     public synchronized Collection<String> getPropertyNames() {
  109.         if (properties == null) {
  110.             return Collections.emptySet();
  111.         }
  112.         return Collections.unmodifiableSet(new HashSet<String>(properties.keySet()));
  113.     }

  115.     /**
  116.      * Returns an unmodifiable map of all properties.
  117.      *
  118.      * @return all properties.
  119.      */
  120.     public synchronized Map<String, Object> getProperties() {
  121.         if (properties == null) {
  122.             return Collections.emptyMap();
  123.         }
  124.         return Collections.unmodifiableMap(new HashMap<String, Object>(properties));
  125.     }

  127.     @Override
  128.     public String getElementName() {
  129.         return ELEMENT;
  130.     }

  132.     @Override
  133.     public String getNamespace() {
  134.         return NAMESPACE;
  135.     }

  137.     @Override
  138.     public CharSequence toXML() {
  139.         XmlStringBuilder xml = new XmlStringBuilder(this);
  140.         xml.rightAngleBracket();
  141.         // Loop through all properties and write them out.
  142.         for (String name : getPropertyNames()) {
  143.             Object value = getProperty(name);
  144.             xml.openElement("property");
  145.             xml.element("name", name);
  146.             xml.halfOpenElement("value");

  148.             String type;
  149.             String valueStr;
  150.             if (value instanceof Integer) {
  151.                 type = "integer";
  152.                 valueStr = Integer.toString((Integer) value);
  153.             }
  154.             else if (value instanceof Long) {
  155.                 type = "long";
  156.                 valueStr = Long.toString((Long) value);
  157.             }
  158.             else if (value instanceof Float) {
  159.                 type = "float";
  160.                 valueStr = Float.toString((Float) value);
  161.             }
  162.             else if (value instanceof Double) {
  163.                 type = "double";
  164.                 valueStr = Double.toString((Double) value);
  165.             }
  166.             else if (value instanceof Boolean) {
  167.                 type = "boolean";
  168.                 valueStr = Boolean.toString((Boolean) value);
  169.             }
  170.             else if (value instanceof String) {
  171.                 type = "string";
  172.                 valueStr = (String) value;
  173.             }
  174.             // Otherwise, it's a generic Serializable object. Serialized objects are in
  175.             // a binary format, which won't work well inside of XML. Therefore, we base-64
  176.             // encode the binary data before adding it.
  177.             else {
  178.                 ByteArrayOutputStream byteStream = null;
  179.                 ObjectOutputStream out = null;
  180.                 try {
  181.                     byteStream = new ByteArrayOutputStream();
  182.                     out = new ObjectOutputStream(byteStream);
  183.                     out.writeObject(value);
  184.                     type = "java-object";
  185.                     valueStr = Base64.encodeToString(byteStream.toByteArray());
  186.                 }
  187.                 catch (Exception e) {
  188.                     LOGGER.log(Level.SEVERE, "Error encoding java object", e);
  189.                     type = "java-object";
  190.                     valueStr = "Serializing error: " + e.getMessage();
  191.                 }
  192.                 finally {
  193.                     if (out != null) {
  194.                         try {
  195.                             out.close();
  196.                         }
  197.                         catch (Exception e) {
  198.                             // Ignore.
  199.                         }
  200.                     }
  201.                     if (byteStream != null) {
  202.                         try {
  203.                             byteStream.close();
  204.                         }
  205.                         catch (Exception e) {
  206.                             // Ignore.
  207.                         }
  208.                     }
  209.                 }
  210.             }
  211.             xml.attribute("type", type);
  212.             xml.rightAngleBracket();
  213.             xml.escape(valueStr);
  214.             xml.closeElement("value");
  215.             xml.closeElement("property");
  216.         }
  217.         xml.closeElement(this);

  219.         return xml;
  220.     }

  222. }
Created with JaCoCo 0.7.4.201502262128