import org.jivesoftware.smack.XMPPException.XMPPErrorException; //导入依赖的package包/类
/**
 * Creates a node with specified configuration.
 * 
 * Note: This is the only way to create a collection node.
 * 
 * @param name The name of the node, which must be unique within the 
 * pubsub service
 * @param config The configuration for the node
 * @return The node that was created
 * @throws XMPPErrorException 
 * @throws NoResponseException 
 * @throws NotConnectedException 
 */
public Node createNode(String name, Form config) throws NoResponseException, XMPPErrorException, NotConnectedException
{
	PubSub request = PubSub.createPubsubPacket(to, Type.set, new NodeExtension(PubSubElementType.CREATE, name), null);
	boolean isLeafNode = true;
	
	if (config != null)
	{
		request.addExtension(new FormNode(FormNodeType.CONFIGURE, config));
		FormField nodeTypeField = config.getField(ConfigureNodeFields.node_type.getFieldName());
		
		if (nodeTypeField != null)
			isLeafNode = nodeTypeField.getValues().get(0).equals(NodeType.leaf.toString());
	}

	// Errors will cause exceptions in getReply, so it only returns
	// on success.
	sendPubsubPacket(con, request);
	Node newNode = isLeafNode ? new LeafNode(con, name) : new CollectionNode(con, name);
	newNode.setTo(to);
	nodeMap.put(newNode.getId(), newNode);
	
	return newNode;
}
 

import org.jivesoftware.smack.XMPPException.XMPPErrorException; //导入依赖的package包/类
/**
 * Invoking {@link InBandBytestreamManager#establishSession(String)} should
 * throw an exception if the given target does not support in-band
 * bytestream.
 * @throws SmackException 
 * @throws XMPPException 
 */
@Test
public void shouldFailIfTargetDoesNotSupportIBB() throws SmackException, XMPPException {
    InBandBytestreamManager byteStreamManager = InBandBytestreamManager.getByteStreamManager(connection);

    try {
        XMPPError xmppError = new XMPPError(
                        XMPPError.Condition.feature_not_implemented);
        IQ errorIQ = IBBPacketUtils.createErrorIQ(targetJID, initiatorJID, xmppError);
        protocol.addResponse(errorIQ);

        // start In-Band Bytestream
        byteStreamManager.establishSession(targetJID);

        fail("exception should be thrown");
    }
    catch (XMPPErrorException e) {
        assertEquals(XMPPError.Condition.feature_not_implemented,
                        e.getXMPPError().getCondition());
    }

}
 

import org.jivesoftware.smack.XMPPException.XMPPErrorException; //导入依赖的package包/类
/**
 * Sets the agent's current status with the workgroup. The presence mode affects how offers
 * are routed to the agent. The possible presence modes with their meanings are as follows:<ul>
 * <p/>
 * <li>Presence.Mode.AVAILABLE -- (Default) the agent is available for more chats
 * (equivalent to Presence.Mode.CHAT).
 * <li>Presence.Mode.DO_NOT_DISTURB -- the agent is busy and should not be disturbed.
 * However, special case, or extreme urgency chats may still be offered to the agent.
 * <li>Presence.Mode.AWAY -- the agent is not available and should not
 * have a chat routed to them (equivalent to Presence.Mode.EXTENDED_AWAY).</ul>
 *
 * @param presenceMode the presence mode of the agent.
 * @param status       sets the status message of the presence update.
 * @throws XMPPErrorException 
 * @throws NoResponseException 
 * @throws NotConnectedException 
 * @throws IllegalStateException if the agent is not online with the workgroup.
 */
public void setStatus(Presence.Mode presenceMode, String status) throws NoResponseException, XMPPErrorException, NotConnectedException {
    if (!online) {
        throw new IllegalStateException("Cannot set status when the agent is not online.");
    }

    if (presenceMode == null) {
        presenceMode = Presence.Mode.available;
    }
    this.presenceMode = presenceMode;

    Presence presence = new Presence(Presence.Type.available);
    presence.setMode(presenceMode);
    presence.setTo(this.getWorkgroupJID());

    if (status != null) {
        presence.setStatus(status);
    }
    presence.addExtension(new MetaData(this.metaData));

    PacketCollector collector = this.connection.createPacketCollectorAndSend(new AndFilter(new StanzaTypeFilter(Presence.class),
            FromMatchesFilter.create(workgroupJID)), presence);

    collector.nextResultOrThrow();
}
 

import org.jivesoftware.smack.XMPPException.XMPPErrorException; //导入依赖的package包/类
@Override
InputStream negotiateIncomingStream(Stanza streamInitiation) throws InterruptedException,
                SmackException, XMPPErrorException {
    // build SOCKS5 Bytestream request
    Socks5BytestreamRequest request = new ByteStreamRequest(this.manager,
                    (Bytestream) streamInitiation);

    // always accept the request
    Socks5BytestreamSession session = request.accept();

    // test input stream
    try {
        PushbackInputStream stream = new PushbackInputStream(session.getInputStream());
        int firstByte = stream.read();
        stream.unread(firstByte);
        return stream;
    }
    catch (IOException e) {
        throw new SmackException("Error establishing input stream", e);
    }
}
 

import org.jivesoftware.smack.XMPPException.XMPPErrorException; //导入依赖的package包/类
/**
 * Adds or updates a conference in the bookmarks.
 *
 * @param name the name of the conference
 * @param jid the jid of the conference
 * @param isAutoJoin whether or not to join this conference automatically on login
 * @param nickname the nickname to use for the user when joining the conference
 * @param password the password to use for the user when joining the conference
 * @throws XMPPErrorException thrown when there is an issue retrieving the current bookmarks from
 * the server.
 * @throws NoResponseException if there was no response from the server.
 * @throws NotConnectedException 
 */
public void addBookmarkedConference(String name, String jid, boolean isAutoJoin,
        String nickname, String password) throws NoResponseException, XMPPErrorException, NotConnectedException
{
    retrieveBookmarks();
    BookmarkedConference bookmark
            = new BookmarkedConference(name, jid, isAutoJoin, nickname, password);
    List<BookmarkedConference> conferences = bookmarks.getBookmarkedConferences();
    if(conferences.contains(bookmark)) {
        BookmarkedConference oldConference = conferences.get(conferences.indexOf(bookmark));
        if(oldConference.isShared()) {
            throw new IllegalArgumentException("Cannot modify shared bookmark");
        }
        oldConference.setAutoJoin(isAutoJoin);
        oldConference.setName(name);
        oldConference.setNickname(nickname);
        oldConference.setPassword(password);
    }
    else {
        bookmarks.addBookmarkedConference(bookmark);
    }
    privateDataManager.setPrivateData(bookmarks);
}
 

import org.jivesoftware.smack.XMPPException.XMPPErrorException; //导入依赖的package包/类
public String resolveRoom(XMPPConnection connection) throws XMPPException, SmackException {
    ObjectHelper.notEmpty(room, "room");

    if (room.indexOf('@', 0) != -1) {
        return room;
    }

    Iterator<String> iterator = MultiUserChat.getServiceNames(connection).iterator();
    if (!iterator.hasNext()) {
        throw new XMPPErrorException("Cannot find Multi User Chat service",
                                     new XMPPError(new XMPPError.Condition("Cannot find Multi User Chat service on connection: " + getConnectionMessage(connection))));
    }

    String chatServer = iterator.next();
    LOG.debug("Detected chat server: {}", chatServer);

    return room + "@" + chatServer;
}
 

import org.jivesoftware.smack.XMPPException.XMPPErrorException; //导入依赖的package包/类
@Override
public InputStream createIncomingStream(StreamInitiation initiation) throws XMPPErrorException,
                InterruptedException, SmackException {
    /*
     * SOCKS5 initiation listener must ignore next SOCKS5 Bytestream request with given session
     * ID
     */
    this.manager.ignoreBytestreamRequestOnce(initiation.getSessionID());

    Stanza streamInitiation = initiateIncomingStream(this.connection, initiation);
    return negotiateIncomingStream(streamInitiation);
}
 

import org.jivesoftware.smack.XMPPException.XMPPErrorException; //导入依赖的package包/类
/**
 * Answer the default privacy list. Returns <code>null</code> if there is no default list.
 * 
 * @return the privacy list of the default list.
 * @throws XMPPErrorException 
 * @throws NoResponseException 
 * @throws NotConnectedException 
 */ 
public PrivacyList getDefaultList() throws NoResponseException, XMPPErrorException, NotConnectedException {
    Privacy privacyAnswer = this.getPrivacyWithListNames();
    String listName = privacyAnswer.getDefaultName();
    if (StringUtils.isNullOrEmpty(listName)) {
        return null;
    }
    boolean isDefaultAndActive = listName.equals(privacyAnswer.getActiveName());
    return new PrivacyList(isDefaultAndActive, true, listName, getPrivacyListItems(listName));
}
 

import org.jivesoftware.smack.XMPPException.XMPPErrorException; //导入依赖的package包/类
/**
 * Remove a privacy list.
 * 
    * @param listName the list that has changed its content.
 * @throws XMPPErrorException 
 * @throws NoResponseException 
 * @throws NotConnectedException 
 */ 
public void deletePrivacyList(String listName) throws NoResponseException, XMPPErrorException, NotConnectedException {
	// The request of the list is an privacy message with an empty list
	Privacy request = new Privacy();
	request.setPrivacyList(listName, new ArrayList<PrivacyItem>());

	// Send the package to the server
	setRequest(request);
}
 

import org.jivesoftware.smack.XMPPException.XMPPErrorException; //导入依赖的package包/类
/**
 * Return the agents name.
 *
 * @return - the agents name.
 * @throws XMPPErrorException 
 * @throws NoResponseException 
 * @throws NotConnectedException 
 */
public String getName() throws NoResponseException, XMPPErrorException, NotConnectedException {
    AgentInfo agentInfo = new AgentInfo();
    agentInfo.setType(IQ.Type.get);
    agentInfo.setTo(workgroupJID);
    agentInfo.setFrom(getUser());
    AgentInfo response = (AgentInfo) connection.createPacketCollectorAndSend(agentInfo).nextResultOrThrow();
    return response.getName();
}
 

import org.jivesoftware.smack.XMPPException.XMPPErrorException; //导入依赖的package包/类
/**
 * Changes the password of the currently logged-in account. This operation can only
 * be performed after a successful login operation has been completed. Not all servers
 * support changing passwords; an XMPPException will be thrown when that is the case.
 *
 * @throws IllegalStateException if not currently logged-in to the server.
 * @throws XMPPErrorException if an error occurs when changing the password.
 * @throws NoResponseException if there was no response from the server.
 * @throws NotConnectedException 
 */
public void changePassword(String newPassword) throws NoResponseException, XMPPErrorException, NotConnectedException {
    if (!connection().isSecureConnection() && !allowSensitiveOperationOverInsecureConnection) {
        // TODO throw exception in newer Smack versions
        LOGGER.warning("Changing password over insecure connection. "
                        + "This will throw an exception in future versions of Smack if AccountManager.sensitiveOperationOverInsecureConnection(true) is not set");
    }
    Map<String, String> map = new HashMap<String, String>();
    map.put("username",XmppStringUtils.parseLocalpart(connection().getUser()));
    map.put("password",newPassword);
    Registration reg = new Registration(map);
    reg.setType(IQ.Type.set);
    reg.setTo(connection().getServiceName());
    createPacketCollectorAndSend(reg).nextResultOrThrow();
}
 

import org.jivesoftware.smack.XMPPException.XMPPErrorException; //导入依赖的package包/类
/**
 * Client declines the use of active lists.
 * @throws XMPPErrorException 
 * @throws NoResponseException 
 * @throws NotConnectedException 
 */ 
public void declineActiveList() throws NoResponseException, XMPPErrorException, NotConnectedException {
	// The request of the list is an privacy message with an empty list
	Privacy request = new Privacy();
	request.setDeclineActiveList(true);
	
	// Send the package to the server
	setRequest(request);
}
 

import org.jivesoftware.smack.XMPPException.XMPPErrorException; //导入依赖的package包/类
/**
 * Asks the workgroup for it's Global Macros.
 *
 * @param global true to retrieve global macros, otherwise false for personal macros.
 * @return MacroGroup the root macro group.
 * @throws XMPPErrorException if an error occurs while getting information from the server.
 * @throws NoResponseException 
 * @throws NotConnectedException 
 */
public MacroGroup getMacros(boolean global) throws NoResponseException, XMPPErrorException, NotConnectedException {
    Macros request = new Macros();
    request.setType(IQ.Type.get);
    request.setTo(workgroupJID);
    request.setPersonal(!global);

    Macros response = (Macros) connection.createPacketCollectorAndSend(request).nextResultOrThrow();
    return response.getRootGroup();
}
 

import org.jivesoftware.smack.XMPPException.XMPPErrorException; //导入依赖的package包/类
/**
 * Returns the discovered information of a given XMPP entity addressed by its JID.
 * Use null as entityID to query the server
 * 
 * @param entityID the address of the XMPP entity or null.
 * @return the discovered information.
 * @throws XMPPErrorException 
 * @throws NoResponseException 
 * @throws NotConnectedException 
 */
public DiscoverInfo discoverInfo(String entityID) throws NoResponseException, XMPPErrorException, NotConnectedException {
    if (entityID == null)
        return discoverInfo(null, null);

    // Check if the have it cached in the Entity Capabilities Manager
    DiscoverInfo info = EntityCapsManager.getDiscoverInfoByUser(entityID);

    if (info != null) {
        // We were able to retrieve the information from Entity Caps and
        // avoided a disco request, hurray!
        return info;
    }

    // Try to get the newest node#version if it's known, otherwise null is
    // returned
    EntityCapsManager.NodeVerHash nvh = EntityCapsManager.getNodeVerHashByJid(entityID);

    // Discover by requesting the information from the remote entity
    // Note that wee need to use NodeVer as argument for Node if it exists
    info = discoverInfo(entityID, nvh != null ? nvh.getNodeVer() : null);

    // If the node version is known, store the new entry.
    if (nvh != null) {
        if (EntityCapsManager.verifyDiscoverInfoVersion(nvh.getVer(), nvh.getHash(), info))
            EntityCapsManager.addDiscoverInfoByNode(nvh.getNodeVer(), info);
    }

    return info;
}
 

import org.jivesoftware.smack.XMPPException.XMPPErrorException; //导入依赖的package包/类
/**
 * Answer the privacy list items under listName with the allowed and blocked permissions.
 * 
 * @param listName the name of the list to get the allowed and blocked permissions.
 * @return a list of privacy items under the list listName.
 * @throws XMPPErrorException 
 * @throws NoResponseException 
 * @throws NotConnectedException 
 */ 
private List<PrivacyItem> getPrivacyListItems(String listName) throws NoResponseException, XMPPErrorException, NotConnectedException  {
    assert StringUtils.isNotEmpty(listName);
    // The request of the list is an privacy message with an empty list
    Privacy request = new Privacy();
    request.setPrivacyList(listName, new ArrayList<PrivacyItem>());
    
    // Send the package to the server and get the answer
    Privacy privacyAnswer = getRequest(request);
    
    return privacyAnswer.getPrivacyList(listName);
}
 

import org.jivesoftware.smack.XMPPException.XMPPErrorException; //导入依赖的package包/类
/**
 * Asks the workgroup for it's Sound Settings.
 *
 * @return soundSettings the sound settings for the specified workgroup.
 * @throws XMPPErrorException 
 * @throws NoResponseException 
 * @throws NotConnectedException 
 */
public SoundSettings getSoundSettings() throws NoResponseException, XMPPErrorException, NotConnectedException {
    SoundSettings request = new SoundSettings();
    request.setType(IQ.Type.get);
    request.setTo(workgroupJID);

    SoundSettings response = (SoundSettings) connection.createPacketCollectorAndSend(request).nextResultOrThrow();
    return response;
}
 

import org.jivesoftware.smack.XMPPException.XMPPErrorException; //导入依赖的package包/类
/**
 * Adds a roster entry to this group. If the entry was unfiled then it will be removed from 
 * the unfiled list and will be added to this group.
 * Note that this is a synchronous call -- Smack must wait for the server
 * to receive the updated roster.
 *
 * @param entry a roster entry.
 * @throws XMPPErrorException if an error occured while trying to add the entry to the group.
 * @throws NoResponseException if there was no response from the server.
 * @throws NotConnectedException 
 */
public void addEntry(RosterEntry entry) throws NoResponseException, XMPPErrorException, NotConnectedException {
    // Only add the entry if it isn't already in the list.
    synchronized (entries) {
        if (!entries.contains(entry)) {
            RosterPacket packet = new RosterPacket();
            packet.setType(IQ.Type.set);
            RosterPacket.Item item = RosterEntry.toRosterItem(entry);
            item.addGroupName(getName());
            packet.addRosterItem(item);
            // Wait up to a certain number of seconds for a reply from the server.
            connection().createPacketCollectorAndSend(packet).nextResultOrThrow();
        }
    }
}
 

import org.jivesoftware.smack.XMPPException.XMPPErrorException; //导入依赖的package包/类
/**
 * Accepting a SOCKS5 Bytestream request should fail if target is not able to connect to any of
 * the provided SOCKS5 proxies.
 * 
 * @throws Exception
 */
@Test
public void shouldFailIfRequestHasInvalidStreamHosts() throws Exception {

    try {

        // build SOCKS5 Bytestream initialization request
        Bytestream bytestreamInitialization = Socks5PacketUtils.createBytestreamInitiation(
                        initiatorJID, targetJID, sessionID);
        // add proxy that is not running
        bytestreamInitialization.addStreamHost(proxyJID, proxyAddress, 7778);

        // get SOCKS5 Bytestream manager for connection
        Socks5BytestreamManager byteStreamManager = Socks5BytestreamManager.getBytestreamManager(connection);

        // build SOCKS5 Bytestream request with the bytestream initialization
        Socks5BytestreamRequest byteStreamRequest = new Socks5BytestreamRequest(
                        byteStreamManager, bytestreamInitialization);

        // accept the stream (this is the call that is tested here)
        byteStreamRequest.accept();

        fail("exception should be thrown");
    }
    catch (XMPPErrorException e) {
        assertTrue(e.getMessage().contains("Could not establish socket with any provided host"));
    }

    // verify targets response
    assertEquals(1, protocol.getRequests().size());
    Stanza targetResponse = protocol.getRequests().remove(0);
    assertTrue(IQ.class.isInstance(targetResponse));
    assertEquals(initiatorJID, targetResponse.getTo());
    assertEquals(IQ.Type.error, ((IQ) targetResponse).getType());
    assertEquals(XMPPError.Condition.item_not_found,
                    ((IQ) targetResponse).getError().getCondition());

}
 

import org.jivesoftware.smack.XMPPException.XMPPErrorException; //导入依赖的package包/类
/**
 * Save this vCard for the user connected by 'connection'. XMPPConnection should be authenticated
 * and not anonymous.
 *
 * @throws XMPPErrorException thrown if there was an issue setting the VCard in the server.
 * @throws NoResponseException if there was no response from the server.
 * @throws NotConnectedException 
 */
public void saveVCard(VCard vcard) throws NoResponseException, XMPPErrorException, NotConnectedException {
    // XEP-54 § 3.2 "A user may publish or update his or her vCard by sending an IQ of type "set" with no 'to' address…"
    vcard.setTo(null);
    vcard.setType(IQ.Type.set);
    // Also make sure to generate a new stanza id (the given vcard could be a vcard result), in which case we don't
    // want to use the same stanza id again (although it wouldn't break if we did)
    vcard.setStanzaId(StanzaIdUtil.newStanzaId());
    connection().createPacketCollectorAndSend(vcard).nextResultOrThrow();
}
 

import org.jivesoftware.smack.XMPPException.XMPPErrorException; //导入依赖的package包/类
private void changeAffiliationByAdmin(Collection<String> jids, MUCAffiliation affiliation)
                throws NoResponseException, XMPPErrorException, NotConnectedException {
    MUCAdmin iq = new MUCAdmin();
    iq.setTo(room);
    iq.setType(IQ.Type.set);
    for (String jid : jids) {
        // Set the new affiliation.
        MUCItem item = new MUCItem(affiliation, jid);
        iq.addItem(item);
    }

    connection.createPacketCollectorAndSend(iq).nextResultOrThrow();
}