mirror of
https://codeberg.org/Mercury-IM/Smack
synced 2024-06-18 09:34:53 +02:00
c636e72a9d
Previously publish() was "asynchronously" in that sense that the response of the IQ as *not* awaited, and send() would wait for the responses. It makes no sense to have that functionality this way. Instead we now make publish() to the right thing, i.e., wait for an IQ result, make send() a proxy for publish(), and mark send() deprecated. In the future, there may be a publishAsync() method which returns a Future instance.
384 lines
15 KiB
Java
384 lines
15 KiB
Java
/**
|
|
*
|
|
* Copyright the original author or authors
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
package org.jivesoftware.smackx.pubsub;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.Collection;
|
|
import java.util.List;
|
|
|
|
import org.jivesoftware.smack.SmackException.NoResponseException;
|
|
import org.jivesoftware.smack.SmackException.NotConnectedException;
|
|
import org.jivesoftware.smack.XMPPException.XMPPErrorException;
|
|
import org.jivesoftware.smack.packet.IQ.Type;
|
|
import org.jivesoftware.smack.packet.ExtensionElement;
|
|
import org.jivesoftware.smackx.disco.packet.DiscoverItems;
|
|
import org.jivesoftware.smackx.pubsub.packet.PubSub;
|
|
|
|
/**
|
|
* The main class for the majority of pubsub functionality. In general
|
|
* almost all pubsub capabilities are related to the concept of a node.
|
|
* All items are published to a node, and typically subscribed to by other
|
|
* users. These users then retrieve events based on this subscription.
|
|
*
|
|
* @author Robin Collier
|
|
*/
|
|
public class LeafNode extends Node
|
|
{
|
|
LeafNode(PubSubManager pubSubManager, String nodeId)
|
|
{
|
|
super(pubSubManager, nodeId);
|
|
}
|
|
|
|
/**
|
|
* Get information on the items in the node in standard
|
|
* {@link DiscoverItems} format.
|
|
*
|
|
* @return The item details in {@link DiscoverItems} format
|
|
* @throws XMPPErrorException
|
|
* @throws NoResponseException if there was no response from the server.
|
|
* @throws NotConnectedException
|
|
* @throws InterruptedException
|
|
*/
|
|
public DiscoverItems discoverItems() throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException
|
|
{
|
|
DiscoverItems items = new DiscoverItems();
|
|
items.setTo(pubSubManager.getServiceJid());
|
|
items.setNode(getId());
|
|
return pubSubManager.getConnection().createStanzaCollectorAndSend(items).nextResultOrThrow();
|
|
}
|
|
|
|
/**
|
|
* Get the current items stored in the node.
|
|
*
|
|
* @return List of {@link Item} in the node
|
|
* @throws XMPPErrorException
|
|
* @throws NoResponseException if there was no response from the server.
|
|
* @throws NotConnectedException
|
|
* @throws InterruptedException
|
|
*/
|
|
public <T extends Item> List<T> getItems() throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException
|
|
{
|
|
return getItems((List<ExtensionElement>) null, (List<ExtensionElement>) null);
|
|
}
|
|
|
|
/**
|
|
* Get the current items stored in the node based
|
|
* on the subscription associated with the provided
|
|
* subscription id.
|
|
*
|
|
* @param subscriptionId - The subscription id for the
|
|
* associated subscription.
|
|
* @return List of {@link Item} in the node
|
|
* @throws XMPPErrorException
|
|
* @throws NoResponseException if there was no response from the server.
|
|
* @throws NotConnectedException
|
|
* @throws InterruptedException
|
|
*/
|
|
public <T extends Item> List<T> getItems(String subscriptionId) throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException
|
|
{
|
|
PubSub request = createPubsubPacket(Type.get, new GetItemsRequest(getId(), subscriptionId));
|
|
return getItems(request);
|
|
}
|
|
|
|
/**
|
|
* Get the items specified from the node. This would typically be
|
|
* used when the server does not return the payload due to size
|
|
* constraints. The user would be required to retrieve the payload
|
|
* after the items have been retrieved via {@link #getItems()} or an
|
|
* event, that did not include the payload.
|
|
*
|
|
* @param ids Item ids of the items to retrieve
|
|
*
|
|
* @return The list of {@link Item} with payload
|
|
* @throws XMPPErrorException
|
|
* @throws NoResponseException if there was no response from the server.
|
|
* @throws NotConnectedException
|
|
* @throws InterruptedException
|
|
*/
|
|
public <T extends Item> List<T> getItems(Collection<String> ids) throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException
|
|
{
|
|
List<Item> itemList = new ArrayList<Item>(ids.size());
|
|
|
|
for (String id : ids)
|
|
{
|
|
itemList.add(new Item(id));
|
|
}
|
|
PubSub request = createPubsubPacket(Type.get, new ItemsExtension(ItemsExtension.ItemsElementType.items, getId(), itemList));
|
|
return getItems(request);
|
|
}
|
|
|
|
/**
|
|
* Get items persisted on the node, limited to the specified number.
|
|
*
|
|
* @param maxItems Maximum number of items to return
|
|
*
|
|
* @return List of {@link Item}
|
|
* @throws XMPPErrorException
|
|
* @throws NoResponseException if there was no response from the server.
|
|
* @throws NotConnectedException
|
|
* @throws InterruptedException
|
|
*/
|
|
public <T extends Item> List<T> getItems(int maxItems) throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException
|
|
{
|
|
PubSub request = createPubsubPacket(Type.get, new GetItemsRequest(getId(), maxItems));
|
|
return getItems(request);
|
|
}
|
|
|
|
/**
|
|
* Get items persisted on the node, limited to the specified number
|
|
* based on the subscription associated with the provided subscriptionId.
|
|
*
|
|
* @param maxItems Maximum number of items to return
|
|
* @param subscriptionId The subscription which the retrieval is based
|
|
* on.
|
|
*
|
|
* @return List of {@link Item}
|
|
* @throws XMPPErrorException
|
|
* @throws NoResponseException if there was no response from the server.
|
|
* @throws NotConnectedException
|
|
* @throws InterruptedException
|
|
*/
|
|
public <T extends Item> List<T> getItems(int maxItems, String subscriptionId) throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException
|
|
{
|
|
PubSub request = createPubsubPacket(Type.get, new GetItemsRequest(getId(), subscriptionId, maxItems));
|
|
return getItems(request);
|
|
}
|
|
|
|
/**
|
|
* Get items persisted on the node.
|
|
* <p>
|
|
* {@code additionalExtensions} can be used e.g. to add a "Result Set Management" extension.
|
|
* {@code returnedExtensions} will be filled with the stanza(/packet) extensions found in the answer.
|
|
* </p>
|
|
*
|
|
* @param additionalExtensions additional {@code PacketExtensions} to be added to the request.
|
|
* This is an optional argument, if provided as null no extensions will be added.
|
|
* @param returnedExtensions a collection that will be filled with the returned packet
|
|
* extensions. This is an optional argument, if provided as null it won't be populated.
|
|
* @return List of {@link Item}
|
|
* @throws NoResponseException
|
|
* @throws XMPPErrorException
|
|
* @throws NotConnectedException
|
|
* @throws InterruptedException
|
|
*/
|
|
public <T extends Item> List<T> getItems(List<ExtensionElement> additionalExtensions,
|
|
List<ExtensionElement> returnedExtensions) throws NoResponseException,
|
|
XMPPErrorException, NotConnectedException, InterruptedException {
|
|
PubSub request = createPubsubPacket(Type.get, new GetItemsRequest(getId()));
|
|
request.addExtensions(additionalExtensions);
|
|
return getItems(request, returnedExtensions);
|
|
}
|
|
|
|
private <T extends Item> List<T> getItems(PubSub request) throws NoResponseException,
|
|
XMPPErrorException, NotConnectedException, InterruptedException {
|
|
return getItems(request, null);
|
|
}
|
|
|
|
@SuppressWarnings("unchecked")
|
|
private <T extends Item> List<T> getItems(PubSub request,
|
|
List<ExtensionElement> returnedExtensions) throws NoResponseException,
|
|
XMPPErrorException, NotConnectedException, InterruptedException {
|
|
PubSub result = pubSubManager.getConnection().createStanzaCollectorAndSend(request).nextResultOrThrow();
|
|
ItemsExtension itemsElem = result.getExtension(PubSubElementType.ITEMS);
|
|
if (returnedExtensions != null) {
|
|
returnedExtensions.addAll(result.getExtensions());
|
|
}
|
|
return (List<T>) itemsElem.getItems();
|
|
}
|
|
|
|
/**
|
|
* Publishes an event to the node. This is an empty event
|
|
* with no item.
|
|
*
|
|
* This is only acceptable for nodes with {@link ConfigureForm#isPersistItems()}=false
|
|
* and {@link ConfigureForm#isDeliverPayloads()}=false.
|
|
*
|
|
* @throws NotConnectedException
|
|
* @throws InterruptedException
|
|
* @throws XMPPErrorException
|
|
* @throws NoResponseException
|
|
* @deprecated use {@link #publish()} instead.
|
|
*/
|
|
@Deprecated
|
|
public void send() throws NotConnectedException, InterruptedException, NoResponseException, XMPPErrorException
|
|
{
|
|
publish();
|
|
}
|
|
|
|
/**
|
|
* Publishes an event to the node. This is a simple item
|
|
* with no payload.
|
|
*
|
|
* If the id is null, an empty item (one without an id) will be sent.
|
|
* Please note that this is not the same as {@link #send()}, which
|
|
* publishes an event with NO item.
|
|
*
|
|
* @param item - The item being sent
|
|
* @throws NotConnectedException
|
|
* @throws InterruptedException
|
|
* @throws XMPPErrorException
|
|
* @throws NoResponseException
|
|
* @deprecated use {@link #publish(Item)} instead.
|
|
*/
|
|
@SuppressWarnings("unchecked")
|
|
@Deprecated
|
|
public <T extends Item> void send(T item) throws NotConnectedException, InterruptedException, NoResponseException, XMPPErrorException
|
|
{
|
|
publish(item);
|
|
}
|
|
|
|
/**
|
|
* Publishes multiple events to the node. Same rules apply as in {@link #publish(Item)}.
|
|
*
|
|
* In addition, if {@link ConfigureForm#isPersistItems()}=false, only the last item in the input
|
|
* list will get stored on the node, assuming it stores the last sent item.
|
|
*
|
|
* @param items - The collection of items being sent
|
|
* @throws NotConnectedException
|
|
* @throws InterruptedException
|
|
* @throws XMPPErrorException
|
|
* @throws NoResponseException
|
|
* @deprecated use {@link #publish(Collection)} instead.
|
|
*/
|
|
@Deprecated
|
|
public <T extends Item> void send(Collection<T> items) throws NotConnectedException, InterruptedException, NoResponseException, XMPPErrorException
|
|
{
|
|
publish(items);
|
|
}
|
|
|
|
/**
|
|
* Publishes an event to the node. This is an empty event
|
|
* with no item.
|
|
*
|
|
* This is only acceptable for nodes with {@link ConfigureForm#isPersistItems()}=false
|
|
* and {@link ConfigureForm#isDeliverPayloads()}=false.
|
|
*
|
|
* @throws XMPPErrorException
|
|
* @throws NoResponseException
|
|
* @throws NotConnectedException
|
|
* @throws InterruptedException
|
|
*
|
|
*/
|
|
public void publish() throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException
|
|
{
|
|
PubSub packet = createPubsubPacket(Type.set, new NodeExtension(PubSubElementType.PUBLISH, getId()));
|
|
|
|
pubSubManager.getConnection().createStanzaCollectorAndSend(packet).nextResultOrThrow();
|
|
}
|
|
|
|
/**
|
|
* Publishes an event to the node. This can be either a simple item
|
|
* with no payload, or one with it. This is determined by the Node
|
|
* configuration.
|
|
*
|
|
* If the node has <b>deliver_payload=false</b>, the Item must not
|
|
* have a payload.
|
|
*
|
|
* If the id is null, an empty item (one without an id) will be sent.
|
|
* Please note that this is not the same as {@link #send()}, which
|
|
* publishes an event with NO item.
|
|
*
|
|
* @param item - The item being sent
|
|
* @throws XMPPErrorException
|
|
* @throws NoResponseException
|
|
* @throws NotConnectedException
|
|
* @throws InterruptedException
|
|
*
|
|
*/
|
|
@SuppressWarnings("unchecked")
|
|
public <T extends Item> void publish(T item) throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException
|
|
{
|
|
Collection<T> items = new ArrayList<T>(1);
|
|
items.add((item == null ? (T)new Item() : item));
|
|
publish(items);
|
|
}
|
|
|
|
/**
|
|
* Publishes multiple events to the node. Same rules apply as in {@link #send(Item)}.
|
|
*
|
|
* In addition, if {@link ConfigureForm#isPersistItems()}=false, only the last item in the input
|
|
* list will get stored on the node, assuming it stores the last sent item.
|
|
*
|
|
* @param items - The collection of {@link Item} objects being sent
|
|
* @throws XMPPErrorException
|
|
* @throws NoResponseException
|
|
* @throws NotConnectedException
|
|
* @throws InterruptedException
|
|
*
|
|
*/
|
|
public <T extends Item> void publish(Collection<T> items) throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException
|
|
{
|
|
PubSub packet = createPubsubPacket(Type.set, new PublishItem<T>(getId(), items));
|
|
|
|
pubSubManager.getConnection().createStanzaCollectorAndSend(packet).nextResultOrThrow();
|
|
}
|
|
|
|
/**
|
|
* Purges the node of all items.
|
|
*
|
|
* <p>Note: Some implementations may keep the last item
|
|
* sent.
|
|
* @throws XMPPErrorException
|
|
* @throws NoResponseException if there was no response from the server.
|
|
* @throws NotConnectedException
|
|
* @throws InterruptedException
|
|
*/
|
|
public void deleteAllItems() throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException
|
|
{
|
|
PubSub request = createPubsubPacket(Type.set, new NodeExtension(PubSubElementType.PURGE_OWNER, getId()), PubSubElementType.PURGE_OWNER.getNamespace());
|
|
|
|
pubSubManager.getConnection().createStanzaCollectorAndSend(request).nextResultOrThrow();
|
|
}
|
|
|
|
/**
|
|
* Delete the item with the specified id from the node.
|
|
*
|
|
* @param itemId The id of the item
|
|
* @throws XMPPErrorException
|
|
* @throws NoResponseException
|
|
* @throws NotConnectedException
|
|
* @throws InterruptedException
|
|
*/
|
|
public void deleteItem(String itemId) throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException
|
|
{
|
|
Collection<String> items = new ArrayList<String>(1);
|
|
items.add(itemId);
|
|
deleteItem(items);
|
|
}
|
|
|
|
/**
|
|
* Delete the items with the specified id's from the node.
|
|
*
|
|
* @param itemIds The list of id's of items to delete
|
|
* @throws XMPPErrorException
|
|
* @throws NoResponseException if there was no response from the server.
|
|
* @throws NotConnectedException
|
|
* @throws InterruptedException
|
|
*/
|
|
public void deleteItem(Collection<String> itemIds) throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException
|
|
{
|
|
List<Item> items = new ArrayList<Item>(itemIds.size());
|
|
|
|
for (String id : itemIds)
|
|
{
|
|
items.add(new Item(id));
|
|
}
|
|
PubSub request = createPubsubPacket(Type.set, new ItemsExtension(ItemsExtension.ItemsElementType.retract, getId(), items));
|
|
pubSubManager.getConnection().createStanzaCollectorAndSend(request).nextResultOrThrow();
|
|
}
|
|
}
|