mirror of
https://codeberg.org/Mercury-IM/Smack
synced 2024-11-05 08:05:58 +01:00
1da02cbfd8
git-svn-id: http://svn.igniterealtime.org/svn/repos/smack/trunk@2307 b35dd754-fafc-0310-a699-88a17e54d16e
396 lines
No EOL
16 KiB
Java
396 lines
No EOL
16 KiB
Java
/**
|
|
* $RCSfile$
|
|
* $Revision$
|
|
* $Date$
|
|
*
|
|
* Copyright (C) 2002-2003 Jive Software. All rights reserved.
|
|
* ====================================================================
|
|
* The Jive Software License (based on Apache Software License, Version 1.1)
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
*
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
*
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in
|
|
* the documentation and/or other materials provided with the
|
|
* distribution.
|
|
*
|
|
* 3. The end-user documentation included with the redistribution,
|
|
* if any, must include the following acknowledgment:
|
|
* "This product includes software developed by
|
|
* Jive Software (http://www.jivesoftware.com)."
|
|
* Alternately, this acknowledgment may appear in the software itself,
|
|
* if and wherever such third-party acknowledgments normally appear.
|
|
*
|
|
* 4. The names "Smack" and "Jive Software" must not be used to
|
|
* endorse or promote products derived from this software without
|
|
* prior written permission. For written permission, please
|
|
* contact webmaster@jivesoftware.com.
|
|
*
|
|
* 5. Products derived from this software may not be called "Smack",
|
|
* nor may "Smack" appear in their name, without prior written
|
|
* permission of Jive Software.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
|
|
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
|
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
* DISCLAIMED. IN NO EVENT SHALL JIVE SOFTWARE OR
|
|
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
|
|
* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
|
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
|
|
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
|
|
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
* ====================================================================
|
|
*/
|
|
|
|
package org.jivesoftware.smackx;
|
|
|
|
import java.util.*;
|
|
|
|
import org.jivesoftware.smack.*;
|
|
import org.jivesoftware.smack.filter.*;
|
|
import org.jivesoftware.smack.packet.*;
|
|
import org.jivesoftware.smackx.packet.*;
|
|
|
|
/**
|
|
* Manages discovery of services in XMPP entities. This class provides:
|
|
* <ol>
|
|
* <li>A registry of supported features in this XMPP entity.
|
|
* <li>Automatic response when this XMPP entity is queried for information.
|
|
* <li>Ability to discover items and information of remote XMPP entities.
|
|
* <li>Ability to publish publicly available items.
|
|
* </ol>
|
|
*
|
|
* @author Gaston Dombiak
|
|
*/
|
|
public class ServiceDiscoveryManager {
|
|
|
|
private static Map instances = new Hashtable();
|
|
|
|
private XMPPConnection connection;
|
|
private List features = new ArrayList();
|
|
private Map nodeInformationProviders = new Hashtable();
|
|
|
|
// Create a new ServiceDiscoveryManager on every established connection
|
|
static {
|
|
XMPPConnection.addConnectionListener(new ConnectionEstablishedListener() {
|
|
public void connectionEstablished(XMPPConnection connection) {
|
|
new ServiceDiscoveryManager(connection);
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Creates a new ServiceDiscoveryManager for a given XMPPConnection. This means that the
|
|
* service manager will respond to any service discovery request that the connection may
|
|
* receive.
|
|
*
|
|
* @param connection the connection to which a ServiceDiscoveryManager is going to be created
|
|
*/
|
|
public ServiceDiscoveryManager(XMPPConnection connection) {
|
|
this.connection = connection;
|
|
init();
|
|
}
|
|
|
|
/**
|
|
* Returns the ServiceDiscoveryManager instance associated with a given XMPPConnection.
|
|
*
|
|
* @param connection the connection used to look for the proper ServiceDiscoveryManager
|
|
* @return the ServiceDiscoveryManager associated with a given XMPPConnection
|
|
*/
|
|
public static ServiceDiscoveryManager getInstanceFor(XMPPConnection connection) {
|
|
return (ServiceDiscoveryManager) instances.get(connection);
|
|
}
|
|
|
|
/**
|
|
* Initializes the packet listeners of the connection that will answer to any
|
|
* service discovery request.
|
|
*/
|
|
private void init() {
|
|
// Register the new instance and associate it with the connection
|
|
instances.put(connection, this);
|
|
// Add a listener to the connection that removes the registered instance when
|
|
// the connection is closed
|
|
connection.addConnectionListener(new ConnectionListener() {
|
|
public void connectionClosed() {
|
|
// Unregister this instance since the connection has been closed
|
|
instances.remove(connection);
|
|
}
|
|
|
|
public void connectionClosedOnError(Exception e) {
|
|
// Unregister this instance since the connection has been closed
|
|
instances.remove(connection);
|
|
}
|
|
});
|
|
|
|
// Listen for disco#items requests and answer with an empty result
|
|
PacketFilter packetFilter = new PacketTypeFilter(DiscoverItems.class);
|
|
PacketListener packetListener = new PacketListener() {
|
|
public void processPacket(Packet packet) {
|
|
DiscoverItems discoverItems = (DiscoverItems) packet;
|
|
// Send back the items defined in the client if the request is of type GET
|
|
if (discoverItems != null && discoverItems.getType() == IQ.Type.GET) {
|
|
DiscoverItems response = new DiscoverItems();
|
|
response.setType(IQ.Type.RESULT);
|
|
response.setTo(discoverItems.getFrom());
|
|
response.setPacketID(discoverItems.getPacketID());
|
|
|
|
// Add the defined items related to the requested node. Look for
|
|
// the NodeInformationProvider associated with the requested node.
|
|
if (getNodeInformationProvider(discoverItems.getNode()) != null) {
|
|
Iterator items =
|
|
getNodeInformationProvider(discoverItems.getNode()).getNodeItems();
|
|
while (items.hasNext()) {
|
|
response.addItem((DiscoverItems.Item) items.next());
|
|
}
|
|
}
|
|
connection.sendPacket(response);
|
|
}
|
|
}
|
|
};
|
|
connection.addPacketListener(packetListener, packetFilter);
|
|
|
|
// Listen for disco#info requests and answer the client's supported features
|
|
// To add a new feature as supported use the #addFeature message
|
|
packetFilter = new PacketTypeFilter(DiscoverInfo.class);
|
|
packetListener = new PacketListener() {
|
|
public void processPacket(Packet packet) {
|
|
DiscoverInfo discoverInfo = (DiscoverInfo) packet;
|
|
// Answer the client's supported features if the request is of the GET type
|
|
if (discoverInfo != null && discoverInfo.getType() == IQ.Type.GET) {
|
|
DiscoverInfo response = new DiscoverInfo();
|
|
response.setType(IQ.Type.RESULT);
|
|
response.setTo(discoverInfo.getFrom());
|
|
response.setPacketID(discoverInfo.getPacketID());
|
|
// Add the registered features to the response
|
|
synchronized (features) {
|
|
for (Iterator it = getFeatures(); it.hasNext();) {
|
|
response.addFeature((String) it.next());
|
|
}
|
|
}
|
|
connection.sendPacket(response);
|
|
}
|
|
}
|
|
};
|
|
connection.addPacketListener(packetListener, packetFilter);
|
|
}
|
|
|
|
/**
|
|
* Returns the NodeInformationProvider responsible for providing information
|
|
* (i.e. items) related to a given node or <tt>null</null> if none.<p>
|
|
*
|
|
* In MUC, a node could be 'http://jabber.org/protocol/muc#rooms' which means that the
|
|
* NodeInformationProvider will provide information about the rooms where the user has joined.
|
|
*
|
|
* @param node the node that contains items associated with an entity not addressable as a JID
|
|
* @return the NodeInformationProvider responsible for providing information related
|
|
* to a given node
|
|
*/
|
|
private NodeInformationProvider getNodeInformationProvider(String node) {
|
|
return (NodeInformationProvider) nodeInformationProviders.get(node);
|
|
}
|
|
|
|
/**
|
|
* Sets the NodeInformationProvider responsible for providing information
|
|
* (i.e. items) related to a given node. Every time this client receives a disco request
|
|
* regarding the items of a given node, the provider associated to that node will be the
|
|
* responsible for providing the requested information.<p>
|
|
*
|
|
* In MUC, a node could be 'http://jabber.org/protocol/muc#rooms' which means that the
|
|
* NodeInformationProvider will provide information about the rooms where the user has joined.
|
|
*
|
|
* @param node the node whose items will be provided by the NodeInformationProvider
|
|
* @return the NodeInformationProvider responsible for providing items related
|
|
* to the node
|
|
*/
|
|
public void setNodeInformationProvider(String node, NodeInformationProvider listener) {
|
|
nodeInformationProviders.put(node, listener);
|
|
}
|
|
|
|
/**
|
|
* Removes the NodeInformationProvider responsible for providing information
|
|
* (i.e. items) related to a given node. This means that no more information will be
|
|
* available for the specified node.
|
|
*
|
|
* In MUC, a node could be 'http://jabber.org/protocol/muc#rooms' which means that the
|
|
* NodeInformationProvider will provide information about the rooms where the user has joined.
|
|
*
|
|
* @param node the node to remove the associated NodeInformationProvider
|
|
*/
|
|
public void removeNodeInformationProvider(String node) {
|
|
nodeInformationProviders.remove(node);
|
|
}
|
|
|
|
/**
|
|
* Returns the supported features by this XMPP entity.
|
|
*
|
|
* @return an Iterator on the supported features by this XMPP entity
|
|
*/
|
|
public Iterator getFeatures() {
|
|
synchronized (features) {
|
|
return Collections.unmodifiableList(new ArrayList(features)).iterator();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Registers that a new feature is supported by this XMPP entity. When this client is
|
|
* queried for its information the registered features will be answered.
|
|
*
|
|
* @param feature the feature to register as supported
|
|
*/
|
|
public void addFeature(String feature) {
|
|
synchronized (features) {
|
|
features.add(feature);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Removes the specified feature from the supported features by this XMPP entity.
|
|
*
|
|
* @param feature the feature to remove from the supported features
|
|
*/
|
|
public void removeFeature(String feature) {
|
|
synchronized (features) {
|
|
features.remove(feature);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns true if the specified feature is registered in the ServiceDiscoveryManager.
|
|
*
|
|
* @param feature the feature to look for
|
|
* @return a boolean indicating if the specified featured is registered or not
|
|
*/
|
|
public boolean includesFeature(String feature) {
|
|
synchronized (features) {
|
|
return features.contains(feature);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns the discovered information of a given XMPP entity addressed by its JID.
|
|
*
|
|
* @param entityID the address of the XMPP entity
|
|
* @return the discovered information
|
|
* @throws XMPPException if the operation failed for some reason
|
|
*/
|
|
public DiscoverInfo discoverInfo(String entityID) throws XMPPException {
|
|
return discoverInfo(entityID, null);
|
|
}
|
|
|
|
/**
|
|
* Returns the discovered information of a given XMPP entity addressed by its JID and
|
|
* note attribute. Use this message only when trying to query information which is not
|
|
* directly addressable.
|
|
*
|
|
* @param entityID the address of the XMPP entity
|
|
* @param node the attribute that supplements the 'jid' attribute
|
|
* @return the discovered information
|
|
* @throws XMPPException if the operation failed for some reason
|
|
*/
|
|
public DiscoverInfo discoverInfo(String entityID, String node) throws XMPPException {
|
|
// Discover the entity's info
|
|
DiscoverInfo disco = new DiscoverInfo();
|
|
disco.setType(IQ.Type.GET);
|
|
disco.setTo(entityID);
|
|
disco.setNode(node);
|
|
|
|
// Create a packet collector to listen for a response.
|
|
PacketCollector collector =
|
|
connection.createPacketCollector(new PacketIDFilter(disco.getPacketID()));
|
|
|
|
connection.sendPacket(disco);
|
|
|
|
// Wait up to 5 seconds for a result.
|
|
IQ result = (IQ) collector.nextResult(SmackConfiguration.getPacketReplyTimeout());
|
|
if (result == null) {
|
|
throw new XMPPException("No response from the server.");
|
|
}
|
|
if (result.getType() == IQ.Type.ERROR) {
|
|
throw new XMPPException(result.getError());
|
|
}
|
|
return (DiscoverInfo) result;
|
|
}
|
|
|
|
/**
|
|
* Returns the discovered items of a given XMPP entity addressed by its JID.
|
|
*
|
|
* @param entityID the address of the XMPP entity
|
|
* @return the discovered information
|
|
* @throws XMPPException if the operation failed for some reason
|
|
*/
|
|
public DiscoverItems discoverItems(String entityID) throws XMPPException {
|
|
return discoverItems(entityID, null);
|
|
}
|
|
|
|
/**
|
|
* Returns the discovered items of a given XMPP entity addressed by its JID and
|
|
* note attribute. Use this message only when trying to query information which is not
|
|
* directly addressable.
|
|
*
|
|
* @param entityID the address of the XMPP entity
|
|
* @param node the attribute that supplements the 'jid' attribute
|
|
* @return the discovered items
|
|
* @throws XMPPException if the operation failed for some reason
|
|
*/
|
|
public DiscoverItems discoverItems(String entityID, String node) throws XMPPException {
|
|
// Discover the entity's items
|
|
DiscoverItems disco = new DiscoverItems();
|
|
disco.setType(IQ.Type.GET);
|
|
disco.setTo(entityID);
|
|
disco.setNode(node);
|
|
|
|
// Create a packet collector to listen for a response.
|
|
PacketCollector collector =
|
|
connection.createPacketCollector(new PacketIDFilter(disco.getPacketID()));
|
|
|
|
connection.sendPacket(disco);
|
|
|
|
// Wait up to 5 seconds for a result.
|
|
IQ result = (IQ) collector.nextResult(SmackConfiguration.getPacketReplyTimeout());
|
|
if (result == null) {
|
|
throw new XMPPException("No response from the server.");
|
|
}
|
|
if (result.getType() == IQ.Type.ERROR) {
|
|
throw new XMPPException(result.getError());
|
|
}
|
|
return (DiscoverItems) result;
|
|
}
|
|
|
|
/**
|
|
* Publishes new items to a parent entity. The item elements to publish MUST have at least
|
|
* a 'jid' attribute specifying the Entity ID of the item, and an action attribute which
|
|
* specifies the action being taken for that item. Possible action values are: "update" and
|
|
* "remove".
|
|
*
|
|
* @param entityID the address of the XMPP entity
|
|
* @param discoverItems the DiscoveryItems to publish
|
|
* @throws XMPPException if the operation failed for some reason
|
|
*/
|
|
public void publishItems(String entityID, DiscoverItems discoverItems) throws XMPPException {
|
|
discoverItems.setType(IQ.Type.SET);
|
|
discoverItems.setTo(entityID);
|
|
|
|
// Create a packet collector to listen for a response.
|
|
PacketCollector collector =
|
|
connection.createPacketCollector(new PacketIDFilter(discoverItems.getPacketID()));
|
|
|
|
connection.sendPacket(discoverItems);
|
|
|
|
// Wait up to 5 seconds for a result.
|
|
IQ result = (IQ) collector.nextResult(SmackConfiguration.getPacketReplyTimeout());
|
|
if (result == null) {
|
|
throw new XMPPException("No response from the server.");
|
|
}
|
|
if (result.getType() == IQ.Type.ERROR) {
|
|
throw new XMPPException(result.getError());
|
|
}
|
|
}
|
|
} |