DiscoverInfo.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.disco.packet;

  19. import java.util.ArrayList;
  20. import java.util.Collections;
  21. import java.util.HashSet;
  22. import java.util.LinkedList;
  23. import java.util.List;
  24. import java.util.Set;

  26. import org.jivesoftware.smack.XMPPConnection;
  27. import org.jivesoftware.smack.packet.IQ;
  28. import org.jivesoftware.smack.packet.IqData;
  29. import org.jivesoftware.smack.util.EqualsUtil;
  30. import org.jivesoftware.smack.util.HashCode;
  31. import org.jivesoftware.smack.util.StringUtils;
  32. import org.jivesoftware.smack.util.XmlStringBuilder;

  34. import org.jxmpp.util.XmppStringUtils;

  36. /**
  37.  * A DiscoverInfo IQ packet, which is used by XMPP clients to request and receive information
  38.  * to/from other XMPP entities.<p>
  39.  *
  40.  * The received information may contain one or more identities of the requested XMPP entity, and
  41.  * a list of supported features by the requested XMPP entity.
  42.  *
  43.  * @author Gaston Dombiak
  44.  */
  45. public class DiscoverInfo extends IQ implements DiscoverInfoView {

  47.     public static final String ELEMENT = QUERY_ELEMENT;
  48.     public static final String NAMESPACE = "http://jabber.org/protocol/disco#info";

  50.     private final List<Feature> features = new ArrayList<>();
  51.     private final Set<Feature> featuresSet = new HashSet<>();
  52.     private final List<Identity> identities = new ArrayList<>();
  53.     private final Set<String> identitiesSet = new HashSet<>();
  54.     private String node;
  55.     private boolean containsDuplicateFeatures;

  57.     DiscoverInfo(DiscoverInfoBuilder builder, boolean validate) {
  58.         super(builder, ELEMENT, NAMESPACE);

  60.         features.addAll(builder.getFeatures());
  61.         identities.addAll(builder.getIdentities());
  62.         node = builder.getNode();


  65.         for (Feature feature : features) {
  66.             boolean featureIsNew = featuresSet.add(feature);
  67.             if (!featureIsNew) {
  68.                 containsDuplicateFeatures = true;
  69.             }
  70.         }

  72.         for (Identity identity : identities) {
  73.             identitiesSet.add(identity.getKey());
  74.         }

  76.         if (!validate) {
  77.             return;
  78.         }

  80.         if (containsDuplicateFeatures) {
  81.             throw new IllegalArgumentException("The disco#info request contains duplicate features.");
  82.         }
  83.     }

  85.     /**
  86.      * Copy constructor.
  87.      *
  88.      * @param d TODO javadoc me please
  89.      */
  90.     public DiscoverInfo(DiscoverInfo d) {
  91.         super(d);

  93.         // Set node
  94.         node = d.getNode();

  96.         // Copy features
  97.         features.addAll(d.features);
  98.         featuresSet.addAll(d.featuresSet);

  100.         // Copy identities
  101.         identities.addAll(d.identities);
  102.         identitiesSet.addAll(d.identitiesSet);
  103.     }

  105.     @Override
  106.     public List<Feature> getFeatures() {
  107.         return Collections.unmodifiableList(features);
  108.     }

  110.     @Override
  111.     public List<Identity> getIdentities() {
  112.         return Collections.unmodifiableList(identities);
  113.     }

  115.     /**
  116.      * Returns true if this DiscoverInfo contains at least one Identity of the given category and type.
  117.      *
  118.      * @param category the category to look for.
  119.      * @param type the type to look for.
  120.      * @return true if this DiscoverInfo contains a Identity of the given category and type.
  121.      */
  122.     public boolean hasIdentity(String category, String type) {
  123.         String key = XmppStringUtils.generateKey(category, type);
  124.         return identitiesSet.contains(key);
  125.     }

  127.     /**
  128.      * Returns all Identities of the given category and type of this DiscoverInfo.
  129.      *
  130.      * @param category category the category to look for.
  131.      * @param type type the type to look for.
  132.      * @return a list of Identities with the given category and type.
  133.      */
  134.     public List<Identity> getIdentities(String category, String type) {
  135.         List<Identity> res = new ArrayList<>(identities.size());
  136.         for (Identity identity : identities) {
  137.             if (identity.getCategory().equals(category) && identity.getType().equals(type)) {
  138.                 res.add(identity);
  139.             }
  140.         }
  141.         return res;
  142.     }

  144.     @Override
  145.     public String getNode() {
  146.         return node;
  147.     }

  149.     /**
  150.      * Returns true if the specified feature is part of the discovered information.
  151.      *
  152.      * @param feature the feature to check
  153.      * @return true if the requests feature has been discovered
  154.      */
  155.     public boolean containsFeature(CharSequence feature) {
  156.         return features.contains(new Feature(feature));
  157.     }

  159.     public static boolean nullSafeContainsFeature(DiscoverInfo discoverInfo, CharSequence feature) {
  160.         if (discoverInfo == null) {
  161.             return false;
  162.         }

  164.         return discoverInfo.containsFeature(feature);
  165.     }

  167.     @Override
  168.     protected IQChildElementXmlStringBuilder getIQChildElementBuilder(IQChildElementXmlStringBuilder xml) {
  169.         xml.optAttribute("node", getNode());
  170.         xml.rightAngleBracket();
  171.         for (Identity identity : identities) {
  172.             xml.append(identity.toXML());
  173.         }
  174.         for (Feature feature : features) {
  175.             xml.append(feature.toXML());
  176.         }

  178.         return xml;
  179.     }

  181.     /**
  182.      * Test if a DiscoverInfo response contains duplicate identities.
  183.      *
  184.      * @return true if duplicate identities where found, otherwise false
  185.      */
  186.     public boolean containsDuplicateIdentities() {
  187.         List<Identity> checkedIdentities = new LinkedList<>();
  188.         for (Identity i : identities) {
  189.             for (Identity i2 : checkedIdentities) {
  190.                 if (i.equals(i2))
  191.                     return true;
  192.             }
  193.             checkedIdentities.add(i);
  194.         }
  195.         return false;
  196.     }

  198.     /**
  199.      * Test if a DiscoverInfo response contains duplicate features.
  200.      *
  201.      * @return true if duplicate identities where found, otherwise false
  202.      */
  203.     public boolean containsDuplicateFeatures() {
  204.         return containsDuplicateFeatures;
  205.     }

  207.     public DiscoverInfoBuilder asBuilder(String stanzaId) {
  208.         return new DiscoverInfoBuilder(this, stanzaId);
  209.     }

  211.     public static DiscoverInfoBuilder builder(XMPPConnection connection) {
  212.         return new DiscoverInfoBuilder(connection);
  213.     }

  215.     public static DiscoverInfoBuilder builder(IqData iqData) {
  216.         return new DiscoverInfoBuilder(iqData);
  217.     }

  219.     public static DiscoverInfoBuilder builder(String stanzaId) {
  220.         return new DiscoverInfoBuilder(stanzaId);
  221.     }

  223.     /**
  224.      * Represents the identity of a given XMPP entity. An entity may have many identities but all
  225.      * the identities SHOULD have the same name.<p>
  226.      *
  227.      * Refer to <a href="https://xmpp.org/registrar/disco-categories.html">XMPP Registry for Service Discovery Identities</a>
  228.      * in order to get the official registry of values for the <i>category</i> and <i>type</i>
  229.      * attributes.
  230.      *
  231.      */
  232.     public static final class Identity implements Comparable<Identity> {

  234.         private final String category;
  235.         private final String type;
  236.         private final String key;
  237.         private final String name;
  238.         private final String lang; // 'xml:lang;

  240.         /**
  241.          * Creates a new identity for an XMPP entity.
  242.          *
  243.          * @param category the entity's category (required as per XEP-30).
  244.          * @param type the entity's type (required as per XEP-30).
  245.          */
  246.         public Identity(String category, String type) {
  247.             this(category, type, null, null);
  248.         }

  250.         /**
  251.          * Creates a new identity for an XMPP entity.
  252.          * 'category' and 'type' are required by
  253.          * <a href="http://xmpp.org/extensions/xep-0030.html#schemas">XEP-30 XML Schemas</a>
  254.          *
  255.          * @param category the entity's category (required as per XEP-30).
  256.          * @param name the entity's name.
  257.          * @param type the entity's type (required as per XEP-30).
  258.          */
  259.         public Identity(String category, String name, String type) {
  260.             this(category, type, name, null);
  261.         }

  263.         /**
  264.          * Creates a new identity for an XMPP entity.
  265.          * 'category' and 'type' are required by
  266.          * <a href="http://xmpp.org/extensions/xep-0030.html#schemas">XEP-30 XML Schemas</a>
  267.          *
  268.          * @param category the entity's category (required as per XEP-30).
  269.          * @param type the entity's type (required as per XEP-30).
  270.          * @param name the entity's name.
  271.          * @param lang the entity's lang.
  272.          */
  273.         public Identity(String category, String type, String name, String lang) {
  274.             this.category = StringUtils.requireNotNullNorEmpty(category, "category cannot be null");
  275.             this.type = StringUtils.requireNotNullNorEmpty(type, "type cannot be null");
  276.             this.key = XmppStringUtils.generateKey(category, type);
  277.             this.name = name;
  278.             this.lang = lang;
  279.         }

  281.         /**
  282.          * Returns the entity's category. To get the official registry of values for the
  283.          * 'category' attribute refer to <a href="https://xmpp.org/registrar/disco-categories.html">XMPP Registry for Service Discovery Identities</a>.
  284.          *
  285.          * @return the entity's category.
  286.          */
  287.         public String getCategory() {
  288.             return category;
  289.         }

  291.         /**
  292.          * Returns the identity's name.
  293.          *
  294.          * @return the identity's name.
  295.          */
  296.         public String getName() {
  297.             return name;
  298.         }

  300.         /**
  301.          * Returns the entity's type. To get the official registry of values for the
  302.          * 'type' attribute refer to <a href="https://xmpp.org/registrar/disco-categories.html">XMPP Registry for Service Discovery Identities</a>.
  303.          *
  304.          * @return the entity's type.
  305.          */
  306.         public String getType() {
  307.             return type;
  308.         }

  310.         /**
  311.          * Returns the identities natural language if one is set.
  312.          *
  313.          * @return the value of xml:lang of this Identity
  314.          */
  315.         public String getLanguage() {
  316.             return lang;
  317.         }

  319.         private String getKey() {
  320.             return key;
  321.         }

  323.         /**
  324.          * Returns true if this identity is of the given category and type.
  325.          *
  326.          * @param category the category.
  327.          * @param type the type.
  328.          * @return true if this identity is of the given category and type.
  329.          */
  330.         public boolean isOfCategoryAndType(String category, String type) {
  331.             return this.category.equals(category) && this.type.equals(type);
  332.         }

  334.         public XmlStringBuilder toXML() {
  335.             XmlStringBuilder xml = new XmlStringBuilder();
  336.             xml.halfOpenElement("identity");
  337.             xml.xmllangAttribute(lang);
  338.             xml.attribute("category", category);
  339.             xml.optAttribute("name", name);
  340.             xml.optAttribute("type", type);
  341.             xml.closeEmptyElement();
  342.             return xml;
  343.         }

  345.         /**
  346.          * Check equality for Identity  for category, type, lang and name
  347.          * in that order as defined by
  348.          * <a href="http://xmpp.org/extensions/xep-0115.html#ver-proc">XEP-0015 5.4 Processing Method (Step 3.3)</a>.
  349.          *
  350.          */
  351.         @Override
  352.         public boolean equals(Object obj) {
  353.             return EqualsUtil.equals(this, obj, (e, o) -> {
  354.                 e.append(key, o.key)
  355.                  .append(lang, o.lang)
  356.                  .append(name, o.name);
  357.             });
  358.         }

  360.         private final HashCode.Cache hashCodeCache = new HashCode.Cache();

  362.         @Override
  363.         public int hashCode() {
  364.             return hashCodeCache.getHashCode(c ->
  365.                 c.append(key)
  366.                  .append(lang)
  367.                  .append(name)
  368.             );
  369.         }

  371.         /**
  372.          * Compares this identity with another one. The comparison order is: Category, Type, Lang.
  373.          * If all three are identical the other Identity is considered equal. Name is not used for
  374.          * comparison, as defined by XEP-0115
  375.          *
  376.          * @param other TODO javadoc me please
  377.          * @return a negative integer, zero, or a positive integer as this object is less than,
  378.          *         equal to, or greater than the specified object.
  379.          */
  380.         @Override
  381.         public int compareTo(DiscoverInfo.Identity other) {
  382.             String otherLang = other.lang == null ? "" : other.lang;
  383.             String thisLang = lang == null ? "" : lang;

  385.             // This can be removed once the deprecated constructor is removed.
  386.             String otherType = other.type == null ? "" : other.type;
  387.             String thisType = type == null ? "" : type;

  389.             if (category.equals(other.category)) {
  390.                 if (thisType.equals(otherType)) {
  391.                     if (thisLang.equals(otherLang)) {
  392.                         // Don't compare on name, XEP-30 says that name SHOULD
  393.                         // be equals for all identities of an entity
  394.                         return 0;
  395.                     } else {
  396.                         return thisLang.compareTo(otherLang);
  397.                     }
  398.                 } else {
  399.                     return thisType.compareTo(otherType);
  400.                 }
  401.             } else {
  402.                 return category.compareTo(other.category);
  403.             }
  404.         }

  406.         @Override
  407.         public String toString() {
  408.             return toXML().toString();
  409.         }
  410.     }

  412.     /**
  413.      * Represents the features offered by the item. This information helps the requester to determine
  414.      * what actions are possible with regard to this item (registration, search, join, etc.)
  415.      * as well as specific feature types of interest, if any (e.g., for the purpose of feature
  416.      * negotiation).
  417.      */
  418.     public static final class Feature {

  420.         private final String variable;

  422.         public Feature(Feature feature) {
  423.             this.variable = feature.variable;
  424.         }

  426.         public Feature(CharSequence variable) {
  427.             this(variable.toString());
  428.         }

  430.         /**
  431.          * Creates a new feature offered by an XMPP entity or item.
  432.          *
  433.          * @param variable the feature's variable.
  434.          */
  435.         public Feature(String variable) {
  436.             this.variable = StringUtils.requireNotNullNorEmpty(variable, "variable cannot be null");
  437.         }

  439.         /**
  440.          * Returns the feature's variable.
  441.          *
  442.          * @return the feature's variable.
  443.          */
  444.         public String getVar() {
  445.             return variable;
  446.         }

  448.         public XmlStringBuilder toXML() {
  449.             XmlStringBuilder xml = new XmlStringBuilder();
  450.             xml.halfOpenElement("feature");
  451.             xml.attribute("var", variable);
  452.             xml.closeEmptyElement();
  453.             return xml;
  454.         }

  456.         @Override
  457.         public boolean equals(Object obj) {
  458.             return EqualsUtil.equals(this, obj, (e, o) -> {
  459.                 e.append(variable, o.variable);
  460.             });
  461.         }

  463.         @Override
  464.         public int hashCode() {
  465.             return variable.hashCode();
  466.         }

  468.         @Override
  469.         public String toString() {
  470.             return toXML().toString();
  471.         }
  472.     }
  473. }
Created with JaCoCo 0.8.6.202009150832