Java Presence.addExtension方法代碼示例

import org.jivesoftware.smack.packet.Presence; //導入方法依賴的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.packet.Presence; //導入方法依賴的package包/類
private Presence createPresence(Presence.Mode mode) {
    String status = Preferences.getStatusMessage();
    Presence p = new Presence(Presence.Type.available);
    if (!TextUtils.isEmpty(status))
        p.setStatus(status);
    if (mode != null)
        p.setMode(mode);

    // TODO find a place for this
    p.addExtension(new CapsExtension("http://www.kontalk.org/", "none", "sha-1"));

    return p;
}
 

import org.jivesoftware.smack.packet.Presence; //導入方法依賴的package包/類
/**
 * Enter a room, as described in XEP-45 7.2.
 *
 * @param nickname
 * @param password
 * @param history
 * @param timeout
 * @return the returned presence by the service after the client send the initial presence in order to enter the room.
 * @throws NotConnectedException
 * @throws NoResponseException
 * @throws XMPPErrorException
 * @see <a href="http://xmpp.org/extensions/xep-0045.html#enter">XEP-45 7.2 Entering a Room</a>
 */
private Presence enter(String nickname, String password, DiscussionHistory history,
                long timeout) throws NotConnectedException, NoResponseException,
                XMPPErrorException {
    StringUtils.requireNotNullOrEmpty(nickname, "Nickname must not be null or blank.");
    // We enter a room by sending a presence packet where the "to"
    // field is in the form "[email protected]/nickname"
    Presence joinPresence = new Presence(Presence.Type.available);
    joinPresence.setTo(room + "/" + nickname);

    // Indicate the the client supports MUC
    MUCInitialPresence mucInitialPresence = new MUCInitialPresence();
    if (password != null) {
        mucInitialPresence.setPassword(password);
    }
    if (history != null) {
        mucInitialPresence.setHistory(history.getMUCHistory());
    }
    joinPresence.addExtension(mucInitialPresence);

    // Wait for a presence packet back from the server.
    StanzaFilter responseFilter = new AndFilter(FromMatchesFilter.createFull(room + "/"
                    + nickname), new StanzaTypeFilter(Presence.class));

    // Setup the messageListeners and presenceListeners *before* the join presence is send.
    connection.addSyncStanzaListener(messageListener, fromRoomGroupchatFilter);
    connection.addSyncStanzaListener(presenceListener, new AndFilter(fromRoomFilter,
                    StanzaTypeFilter.PRESENCE));
    connection.addSyncStanzaListener(subjectListener, new AndFilter(fromRoomFilter,
                    MessageWithSubjectFilter.INSTANCE));
    connection.addSyncStanzaListener(declinesListener, new AndFilter(new StanzaExtensionFilter(MUCUser.ELEMENT,
                    MUCUser.NAMESPACE), new NotFilter(MessageTypeFilter.ERROR)));
    connection.addPacketInterceptor(presenceInterceptor, new AndFilter(new ToFilter(room),
                    StanzaTypeFilter.PRESENCE));
    messageCollector = connection.createPacketCollector(fromRoomGroupchatFilter);

    Presence presence;
    try {
        presence = connection.createPacketCollectorAndSend(responseFilter, joinPresence).nextResultOrThrow(timeout);
    }
    catch (NoResponseException | XMPPErrorException e) {
        // Ensure that all callbacks are removed if there is an exception
        removeConnectionCallbacks();
        throw e;
    }

    this.nickname = nickname;
    joined = true;

    // Update the list of joined rooms
    multiUserChatManager.addJoinedRoom(room);
    return presence;
}
 

import org.jivesoftware.smack.packet.Presence; //導入方法依賴的package包/類
/**
 * Creates the room according to some default configuration, assign the requesting user
 * as the room owner, and add the owner to the room but not allow anyone else to enter
 * the room (effectively "locking" the room). The requesting user will join the room
 * under the specified nickname as soon as the room has been created.<p>
 *
 * To create an "Instant Room", that means a room with some default configuration that is
 * available for immediate access, the room's owner should send an empty form after creating
 * the room. {@link #sendConfigurationForm(Form)}<p>
 *
 * To create a "Reserved Room", that means a room manually configured by the room creator
 * before anyone is allowed to enter, the room's owner should complete and send a form after
 * creating the room. Once the completed configutation form is sent to the server, the server
 * will unlock the room. {@link #sendConfigurationForm(Form)}
 *
 * @param nickname the nickname to use.
 * @throws XMPPException if the room couldn't be created for some reason
 *          (e.g. room already exists; user already joined to an existant room or
 *          405 error if the user is not allowed to create the room)
 */
public synchronized void create(String nickname) throws XMPPException {
    if (nickname == null || nickname.equals("")) {
        throw new IllegalArgumentException("Nickname must not be null or blank.");
    }
    // If we've already joined the room, leave it before joining under a new
    // nickname.
    if (joined) {
        throw new IllegalStateException("Creation failed - User already joined the room.");
    }
    // We create a room by sending a presence packet to [email protected]/nick
    // and signal support for MUC. The owner will be automatically logged into the room.
    Presence joinPresence = new Presence(Presence.Type.available);
    joinPresence.setTo(room + "/" + nickname);
    // Indicate the the client supports MUC
    joinPresence.addExtension(new MUCInitialPresence());
    // Invoke presence interceptors so that extra information can be dynamically added
    for (PacketInterceptor packetInterceptor : presenceInterceptors) {
        packetInterceptor.interceptPacket(joinPresence);
    }

    // Wait for a presence packet back from the server.
    PacketFilter responseFilter =
        new AndFilter(
            new FromMatchesFilter(room + "/" + nickname),
            new PacketTypeFilter(Presence.class));
    PacketCollector response = connection.createPacketCollector(responseFilter);
    // Send create & join packet.
    connection.sendPacket(joinPresence);
    // Wait up to a certain number of seconds for a reply.
    Presence presence =
        (Presence) response.nextResult(SmackConfiguration.getPacketReplyTimeout());
    // Stop queuing results
    response.cancel();

    if (presence == null) {
        throw new XMPPException("No response from server.");
    }
    else if (presence.getError() != null) {
        throw new XMPPException(presence.getError());
    }
    // Whether the room existed before or was created, the user has joined the room
    this.nickname = nickname;
    joined = true;
    userHasJoined();

    // Look for confirmation of room creation from the server
    MUCUser mucUser = getMUCUserExtension(presence);
    if (mucUser != null && mucUser.getStatus() != null) {
        if ("201".equals(mucUser.getStatus().getCode())) {
            // Room was created and the user has joined the room
            return;
        }
    }
    // We need to leave the room since it seems that the room already existed
    leave();
    throw new XMPPException("Creation failed - Missing acknowledge of room creation.");
}