* * Most XMPP servers use a sub-domain for the chat service (eg chat.example.com * for the XMPP server example.com). You must ensure that the room address you're * trying to connect to includes the proper chat sub-domain. * * @param connection the XMPP connection. * @param room the name of the room in the form "roomName@service", where * "service" is the hostname at which the multi-user chat * service is running. */ public MultiUserChat(XMPPConnection connection, String room) { this.connection = connection; this.room = room; init(); } /** * Returns true if the specified user supports the Multi-User Chat protocol. * * @param connection the connection to use to perform the service discovery. * @param user the user to check. A fully qualified xmpp ID, e.g. jdoe@example.com. * @return a boolean indicating whether the specified user supports the MUC protocol. */ public static boolean isServiceEnabled(XMPPConnection connection, String user) { try { DiscoverInfo result = ServiceDiscoveryManager.getInstanceFor(connection).discoverInfo(user); return result.containsFeature(discoNamespace); } catch (XMPPException e) { e.printStackTrace(); return false; } } /** * Returns an Iterator on the rooms where the user has joined using a given connection. * The Iterator will contain Strings where each String represents a room * (e.g. room@muc.jabber.org). * * @param connection the connection used to join the rooms. * @return an Iterator on the rooms where the user has joined using a given connection. */ private static Iterator getJoinedRooms(XMPPConnection connection) { ArrayList rooms = (ArrayList)joinedRooms.get(connection); if (rooms != null) { return rooms.iterator(); } // Return an iterator on an empty collection (i.e. the user never joined a room) return new ArrayList().iterator(); } /** * Returns an Iterator on the rooms where the requested user has joined. The Iterator will * contain Strings where each String represents a room (e.g. room@muc.jabber.org). * * @param connection the connection to use to perform the service discovery. * @param user the user to check. A fully qualified xmpp ID, e.g. jdoe@example.com. * @return an Iterator on the rooms where the requested user has joined. */ public static Iterator getJoinedRooms(XMPPConnection connection, String user) { try { ArrayList answer = new ArrayList(); // Send the disco packet to the user DiscoverItems result = ServiceDiscoveryManager.getInstanceFor(connection).discoverItems(user, discoNode); // Collect the entityID for each returned item for (Iterator items=result.getItems(); items.hasNext();) { answer.add(((DiscoverItems.Item)items.next()).getEntityID()); } return answer.iterator(); } catch (XMPPException e) { e.printStackTrace(); // Return an iterator on an empty collection return new ArrayList().iterator(); } } /** * Returns the name of the room this GroupChat object represents. * * @return the groupchat room name. */ public String getRoom() { return room; } /** * 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.
* * 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. (@see MultiUserChat.sendConfigurationForm(Form))
* * 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. (@see MultiUserChat.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 room@service/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()); // Wait for a presence packet back from the server. PacketFilter responseFilter = new AndFilter( new FromContainsFilter(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."); } /** * Joins the chat room using the specified nickname. If already joined * using another nickname, this method will first leave the room and then * re-join using the new nickname. The default timeout of Smack for a reply * from the group chat server that the join succeeded will be used. After * joining the room, the room will decide the amount of history to send. * * @param nickname the nickname to use. * @throws XMPPException if an error occurs joining the room. In particular, a * 401 error can occur if no password was provided and one is required; or a * 403 error can occur if the user is banned; or a * 404 error can occur if the room does not exist or is locked; or a * 407 error can occur if user is not on the member list; or a * 409 error can occur if someone is already in the group chat with the same nickname. */ public void join(String nickname) throws XMPPException { join(nickname, SmackConfiguration.getPacketReplyTimeout(), null, -1, -1, -1, null); } /** * Joins the chat room using the specified nickname and password. If already joined * using another nickname, this method will first leave the room and then * re-join using the new nickname. The default timeout of Smack for a reply * from the group chat server that the join succeeded will be used. After * joining the room, the room will decide the amount of history to send.
* * A password is required when joining password protected rooms. If the room does * not require a password there is no need to provide one. * * @param nickname the nickname to use. * @param password the password to use. * @throws XMPPException if an error occurs joining the room. In particular, a * 401 error can occur if no password was provided and one is required; or a * 403 error can occur if the user is banned; or a * 404 error can occur if the room does not exist or is locked; or a * 407 error can occur if user is not on the member list; or a * 409 error can occur if someone is already in the group chat with the same nickname. */ public void join(String nickname, String password) throws XMPPException { join(nickname, SmackConfiguration.getPacketReplyTimeout(), password, -1, -1, -1, null); } /** * Joins the chat room using the specified nickname and password. If already joined * using another nickname, this method will first leave the room and then * re-join using the new nickname.
* * This method provides different parameters to control the amount of history to receive when * joining the room. If you don't complete any of these parameters the room will decide the * amount of history to return. If you decide to control the amount of history to receive, you * can use some or all of the following parameters: *
* * If the room does not already exist when the user seeks to enter it, the server will * decide to create a new room or not. * * @param nickname the nickname to use. * @param timeout the number of seconds to wait for reply from the group chat server. * @param password the password to use. * @param maxchars the total number of characters to receive in the history. * @param maxstanzas the total number of messages to receive in the history. * @param seconds the number of seconds to use to filter the messages received during * that time. * @param since the since date to use to filter the messages received during that time. * @throws XMPPException if an error occurs joining the room. In particular, a * 401 error can occur if no password was provided and one is required; or a * 403 error can occur if the user is banned; or a * 404 error can occur if the room does not exist or is locked; or a * 407 error can occur if user is not on the member list; or a * 409 error can occur if someone is already in the group chat with the same nickname. */ public synchronized void join( String nickname, long timeout, String password, int maxchars, int maxstanzas, int seconds, Date since) throws XMPPException { // TODO Review protocol (too many params). Use setters or history class? 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) { leave(); } // We join a room by sending a presence packet where the "to" // field is in the form "roomName@service/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 (maxchars > -1 || maxstanzas > -1 || seconds > -1 || since != null) { MUCInitialPresence.History history = new MUCInitialPresence.History(); if (maxchars > -1) { history.setMaxChars(maxchars); } if (maxstanzas > -1) { history.setMaxStanzas(maxstanzas); } if (seconds > -1) { history.setSeconds(seconds); } if (since != null) { history.setSince(since); } mucInitialPresence.setHistory(history); } joinPresence.addExtension(mucInitialPresence); // Wait for a presence packet back from the server. PacketFilter responseFilter = new AndFilter( new FromContainsFilter(room + "/" + nickname), new PacketTypeFilter(Presence.class)); PacketCollector response = connection.createPacketCollector(responseFilter); // Send join packet. connection.sendPacket(joinPresence); // Wait up to a certain number of seconds for a reply. Presence presence = (Presence) response.nextResult(timeout); // 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()); } this.nickname = nickname; joined = true; userHasJoined(); } /** * Returns true if currently in the group chat (after calling the {@link * #join(String)} method. * * @return true if currently in the group chat room. */ public boolean isJoined() { return joined; } /** * Leave the chat room. */ public synchronized void leave() { // If not joined already, do nothing. if (!joined) { return; } // We leave a room by sending a presence packet where the "to" // field is in the form "roomName@service/nickname" Presence leavePresence = new Presence(Presence.Type.UNAVAILABLE); leavePresence.setTo(room + "/" + nickname); connection.sendPacket(leavePresence); // Reset participant information. participantsMap = new HashMap(); nickname = null; joined = false; userHasLeft(); } /** * Returns the room's configuration form that the room's owner can use or null if * no configuration is possible. The configuration form allows to set the room's language, * enable logging, specify room's type, etc.. * * @return the Form that contains the fields to complete together with the instrucions or * null if no configuration is possible. * @throws XMPPException if an error occurs asking the configuration form for the room. */ public Form getConfigurationForm() throws XMPPException { MUCOwner iq = new MUCOwner(); iq.setTo(room); iq.setType(IQ.Type.GET); // Wait for a presence packet back from the server. PacketFilter responseFilter = new PacketIDFilter(iq.getPacketID()); PacketCollector response = connection.createPacketCollector(responseFilter); // Request the configuration form to the server. connection.sendPacket(iq); // Wait up to a certain number of seconds for a reply. IQ answer = (IQ) response.nextResult(SmackConfiguration.getPacketReplyTimeout()); // Stop queuing results response.cancel(); if (answer == null) { throw new XMPPException("No response from server."); } else if (answer.getError() != null) { throw new XMPPException(answer.getError()); } return Form.getFormFrom(answer); } /** * Sends the completed configuration form to the server. The room will be configured * with the new settings defined in the form. If the form is empty then the server * will create an instant room (will use default configuration). * * @param form the form with the new settings. * @throws XMPPException if an error occurs setting the new rooms' configuration. */ public void sendConfigurationForm(Form form) throws XMPPException { MUCOwner iq = new MUCOwner(); iq.setTo(room); iq.setType(IQ.Type.SET); iq.addExtension(form.getDataFormToSend()); // Send the completed configuration form to the server. connection.sendPacket(iq); // TODO Check for possible returned errors? permission errors? // TODO Check that the form is of type "submit" or "cancel" } /** * Returns the room's registration form that an unaffiliated user, can use to become a member * of the room or null if no registration is possible. Some rooms may restrict the * privilege to register members and allow only room admins to add new members.
* * If the user requesting registration requirements is not allowed to register with the room * (e.g. because that privilege has been restricted), the room will return a "Not Allowed" * error to the user (error code 405). * * @return the registration Form that contains the fields to complete together with the * instrucions or null if no registration is possible. * @throws XMPPException if an error occurs asking the registration form for the room or a * 405 error if the user is not allowed to register with the room. */ public Form getRegistrationForm() throws XMPPException { Registration reg = new Registration(); reg.setType(IQ.Type.GET); reg.setTo(room); PacketFilter filter = new AndFilter(new PacketIDFilter(reg.getPacketID()), new PacketTypeFilter(IQ.class)); PacketCollector collector = connection.createPacketCollector(filter); connection.sendPacket(reg); IQ result = (IQ) collector.nextResult(SmackConfiguration.getPacketReplyTimeout()); collector.cancel(); if (result == null) { throw new XMPPException("No response from server."); } else if (result.getType() == IQ.Type.ERROR) { throw new XMPPException(result.getError()); } return Form.getFormFrom(result); } /** * Sends the completed registration form to the server. After the user successfully submits * the form, the room may queue the request for review by the room admins or may immediately * add the user to the member list by changing the user's affiliation from "none" to "member.
* * If the desired room nickname is already reserved for that room, the room will return a * "Conflict" error to the user (error code 409). If the room does not support registration, * it will return a "Service Unavailable" error to the user (error code 503). * * @param form the completed registration form. * @throws XMPPException if an error occurs submitting the registration form. In particular, a * 409 error can occur if the desired room nickname is already reserved for that room; * or a 503 error can occur if the room does not support registration. */ public void sendRegistrationForm(Form form) throws XMPPException { Registration reg = new Registration(); reg.setType(IQ.Type.SET); reg.setTo(room); reg.addExtension(form.getDataFormToSend()); PacketFilter filter = new AndFilter(new PacketIDFilter(reg.getPacketID()), new PacketTypeFilter(IQ.class)); PacketCollector collector = connection.createPacketCollector(filter); connection.sendPacket(reg); IQ result = (IQ) collector.nextResult(SmackConfiguration.getPacketReplyTimeout()); collector.cancel(); if (result == null) { throw new XMPPException("No response from server."); } else if (result.getType() == IQ.Type.ERROR) { throw new XMPPException(result.getError()); } } /** * Sends a request to the server to destroy the room. The sender of the request * should be the room's owner. If the sender of the destroy request is not the room's owner * then the server will answer a "Forbidden" error (403). * * @param reason the reason for the room destruction. * @param alternateJID the JID of an alternate location. * @throws XMPPException if an error occurs while trying to destroy the room. * An error can occur which will be wrapped by an XMPPException -- * XMPP error code 403. The error code can be used to present more * appropiate error messages to end-users. */ public void destroy(String reason, String alternateJID) throws XMPPException { MUCOwner iq = new MUCOwner(); iq.setTo(room); iq.setType(IQ.Type.SET); // Create the reason for the room destruction MUCOwner.Destroy destroy = new MUCOwner.Destroy(); destroy.setReason(reason); destroy.setJid(alternateJID); iq.setDestroy(destroy); // Wait for a presence packet back from the server. PacketFilter responseFilter = new PacketIDFilter(iq.getPacketID()); PacketCollector response = connection.createPacketCollector(responseFilter); // Send the room destruction request. connection.sendPacket(iq); // Wait up to a certain number of seconds for a reply. IQ answer = (IQ) response.nextResult(SmackConfiguration.getPacketReplyTimeout()); // Stop queuing results response.cancel(); if (answer == null) { throw new XMPPException("No response from server."); } else if (answer.getError() != null) { throw new XMPPException(answer.getError()); } // Reset participant information. participantsMap = new HashMap(); nickname = null; joined = false; userHasLeft(); } /** * Invites another user to the room in which one is an occupant. The invitation * will be sent to the room which in turn will forward the invitation to the invitee.
* * If the room is password-protected, the invitee will receive a password to use to join * the room. If the room is members-only, the the invitee may be added to the member list. * * @param participant the user to invite to the room.(e.g. hecate@shakespeare.lit) * @param reason the reason why the user is being invited. */ public void invite(String participant, String reason) { // TODO listen for 404 error code when inviter supplies a non-existent JID Message message = new Message(room); // Create the MUCUser packet that will include the invitation MUCUser mucUser = new MUCUser(); MUCUser.Invite invite = new MUCUser.Invite(); invite.setTo(participant); invite.setReason(reason); mucUser.setInvite(invite); // Add the MUCUser packet that includes the invitation to the message message.addExtension(mucUser); connection.sendPacket(message); } /** * Informs the sender of an invitation that the invitee declines the invitation. The rejection * will be sent to the room which in turn will forward the rejection to the inviter. * * @param conn the connection to use for sending the rejection. * @param room the room that sent the original invitation. * @param inviter the inviter of the declined invitation. * @param reason the reason why the invitee is declining the invitation. */ public static void decline(XMPPConnection conn, String room, String inviter, String reason) { Message message = new Message(room); // Create the MUCUser packet that will include the rejection MUCUser mucUser = new MUCUser(); MUCUser.Decline decline = new MUCUser.Decline(); decline.setTo(inviter); decline.setReason(reason); mucUser.setDecline(decline); // Add the MUCUser packet that includes the rejection message.addExtension(mucUser); conn.sendPacket(message); } /** * Adds a listener to invitation notifications. The listener will be fired anytime * an invitation is received. * * @param conn the connection where the listener will be applied. * @param listener an invitation listener. */ public static void addInvitationListener(XMPPConnection conn, InvitationListener listener) { InvitationsMonitor.getInvitationsMonitor(conn).addInvitationListener(listener); } /** * Removes a listener to invitation notifications. The listener will be fired anytime * an invitation is received. * * @param conn the connection where the listener was applied. * @param listener an invitation listener. */ public static void removeInvitationListener(XMPPConnection conn, InvitationListener listener) { InvitationsMonitor.getInvitationsMonitor(conn).removeInvitationListener(listener); } /** * Adds a listener to invitation rejections notifications. The listener will be fired anytime * an invitation is declined. * * @param listener an invitation rejection listener. */ public void addInvitationRejectionListener(InvitationRejectionListener listener) { synchronized (invitationRejectionListeners) { if (!invitationRejectionListeners.contains(listener)) { invitationRejectionListeners.add(listener); } } } /** * Removes a listener from invitation rejections notifications. The listener will be fired * anytime an invitation is declined. * * @param listener an invitation rejection listener. */ public void removeInvitationRejectionListener(InvitationRejectionListener listener) { synchronized (invitationRejectionListeners) { invitationRejectionListeners.remove(listener); } } /** * Fires invitation rejection listeners. */ private void fireInvitationRejectionListeners(String invitee, String reason) { InvitationRejectionListener[] listeners = null; synchronized (invitationRejectionListeners) { listeners = new InvitationRejectionListener[invitationRejectionListeners.size()]; invitationRejectionListeners.toArray(listeners); } for (int i = 0; i < listeners.length; i++) { listeners[i].invitationDeclined(invitee, reason); } } /** * Adds a listener to subject change notifications. The listener will be fired anytime * the room's subject changes. * * @param listener a subject updated listener. */ public void addSubjectUpdatedListener(SubjectUpdatedListener listener) { synchronized (subjectUpdatedListeners) { if (!subjectUpdatedListeners.contains(listener)) { subjectUpdatedListeners.add(listener); } } } /** * Removes a listener from subject change notifications. The listener will be fired * anytime the room's subject changes. * * @param listener a subject updated listener. */ public void removeSubjectUpdatedListener(SubjectUpdatedListener listener) { synchronized (subjectUpdatedListeners) { subjectUpdatedListeners.remove(listener); } } /** * Fires subject updated listeners. */ private void fireSubjectUpdatedListeners(String subject, String from) { SubjectUpdatedListener[] listeners = null; synchronized (subjectUpdatedListeners) { listeners = new SubjectUpdatedListener[subjectUpdatedListeners.size()]; subjectUpdatedListeners.toArray(listeners); } for (int i = 0; i < listeners.length; i++) { listeners[i].subjectUpdated(subject, from); } } /** * Returns the last known room's subject or null if the user hasn't joined the room * or the room does not have a subject yet. In case the room has a subject, as soon as the * user joins the room a message with the current room's subject will be received.
* * To be notified every time the room's subject change you should add a listener * to this room. (@see addSubjectUpdatedListener(SubjectUpdatedListener))
*
* To change the room's subject use changeSubject(String).
*
* @return the room's subject or null if the user hasn't joined the room or the
* room does not have a subject yet.
*/
public String getSubject() {
return subject;
}
/**
* Returns the reserved room nickname for the user in the room. A user may have a reserved
* nickname, for example through explicit room registration or database integration. In such
* cases it may be desirable for the user to discover the reserved nickname before attempting
* to enter the room.
*
* @return the reserved room nickname or null if none.
*/
public String getReservedNickname() {
try {
DiscoverInfo result =
ServiceDiscoveryManager.getInstanceFor(connection).discoverInfo(
room,
"x-roomuser-item");
// Look for an Identity that holds the reserved nickname and return its name
for (Iterator identities = result.getIdentities(); identities.hasNext();) {
DiscoverInfo.Identity identity = (DiscoverInfo.Identity) identities.next();
return identity.getName();
}
// If no Identity was found then the user does not have a reserved room nickname
return null;
}
catch (XMPPException e) {
e.printStackTrace();
return null;
}
}
/**
* Returns the nickname that was used to join the room, or null if not
* currently joined.
*
* @return the nickname currently being used.
*/
public String getNickname() {
return nickname;
}
/**
* Changes the participant's nickname to a new nickname within the room. Each room participant
* will receive two presence packets. One of type "unavailable" for the old nickname and one
* indicating availability for the new nickname. The unavailable presence will contain the new
* nickname and an appropriate status code (namely 303) as extended presence information. The
* status code 303 indicates that the participant is changing his/her nickname.
*
* @param nickname the new nickname within the room.
* @throws XMPPException if the new nickname is already in use by another occupant.
*/
public void changeNickname(String nickname) throws XMPPException {
if (nickname == null || nickname.equals("")) {
throw new IllegalArgumentException("Nickname must not be null or blank.");
}
// Check that we already have joined the room before attempting to change the
// nickname.
if (!joined) {
throw new IllegalStateException("Must be logged into the room to change nickname.");
}
// We change the nickname by sending a presence packet where the "to"
// field is in the form "roomName@service/nickname"
// We don't have to signal the MUC support again
Presence joinPresence = new Presence(Presence.Type.AVAILABLE);
joinPresence.setTo(room + "/" + nickname);
// Wait for a presence packet back from the server.
PacketFilter responseFilter =
new AndFilter(
new FromContainsFilter(room + "/" + nickname),
new PacketTypeFilter(Presence.class));
PacketCollector response = connection.createPacketCollector(responseFilter);
// Send 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());
}
this.nickname = nickname;
}
/**
* Changes the participant's availability status within the room. The presence type
* will remain available but with a new status that describes the presence update and
* a new presence mode (e.g. Extended away).
*
* @param status a text message describing the presence update.
* @param mode the mode type for the presence update.
*/
public void changeAvailabilityStatus(String status, Presence.Mode mode) {
if (nickname == null || nickname.equals("")) {
throw new IllegalArgumentException("Nickname must not be null or blank.");
}
// Check that we already have joined the room before attempting to change the
// availability status.
if (!joined) {
throw new IllegalStateException(
"Must be logged into the room to change the " + "availability status.");
}
// We change the availability status by sending a presence packet to the room with the
// new presence status and mode
Presence joinPresence = new Presence(Presence.Type.AVAILABLE);
joinPresence.setStatus(status);
joinPresence.setMode(mode);
joinPresence.setTo(room + "/" + nickname);
// Send join packet.
connection.sendPacket(joinPresence);
}
/**
* Kicks a visitor or participant from the room. The kicked participant will receive a presence
* of type "unavailable" including a status code 307 and optionally along with the reason
* (if provided) and the bare JID of the user who initiated the kick. After the participant
* was kicked from the room, the rest of the participants will receive a presence of type
* "unavailable". The presence will include a status code 307 which means that the participant
* was kicked from the room.
*
* @param nickname the nickname of the participant or visitor to kick from the room
* (e.g. "john").
* @param reason the reason why the participant or visitor is being kicked from the room.
* @throws XMPPException if an error occurs kicking the participant. In particular, a
* 405 error can occur if a moderator or a user with an affiliation of "owner" or "admin"
* was intended to be kicked (i.e. Not Allowed error); or a
* 403 error can occur if the participant that intended to kick another participant does
* not have kicking privileges (i.e. Forbidden error); or a
* 400 error can occur if the provided nickname is not present in the room.
*/
public void kickParticipant(String nickname, String reason) throws XMPPException {
MUCAdmin iq = new MUCAdmin();
iq.setTo(room);
iq.setType(IQ.Type.SET);
// Set the role to "none". This will request the room to kick the participant or visitor
MUCAdmin.Item item = new MUCAdmin.Item(null, "none");
item.setNick(nickname);
item.setReason(reason);
iq.addItem(item);
// Wait for a response packet back from the server.
PacketFilter responseFilter = new PacketIDFilter(iq.getPacketID());
PacketCollector response = connection.createPacketCollector(responseFilter);
// Send the kick request to the server.
connection.sendPacket(iq);
// Wait up to a certain number of seconds for a reply.
IQ answer = (IQ) response.nextResult(SmackConfiguration.getPacketReplyTimeout());
// Stop queuing results
response.cancel();
if (answer == null) {
throw new XMPPException("No response from server.");
}
else if (answer.getError() != null) {
throw new XMPPException(answer.getError());
}
}
/**
* Grants voice to a visitor in the room. In a moderated room, a moderator may want to manage
* who does and does not have "voice" in the room. To have voice means that a room participant
* is able to send messages to the room occupants.
*
* @param nickname the nickname of the visitor to grant voice in the room (e.g. "john").
* @throws XMPPException if an error occurs granting voice to a visitor. In particular, a
* 403 error can occur if the participant that intended to grant voice is not
* a moderator in this room (i.e. Forbidden error); or a
* 400 error can occur if the provided nickname is not present in the room.
*/
public void grantVoice(String nickname) throws XMPPException {
MUCAdmin iq = new MUCAdmin();
iq.setTo(room);
iq.setType(IQ.Type.SET);
// Set the role to "participant". This will grant voice to the visitor
MUCAdmin.Item item = new MUCAdmin.Item(null, "participant");
item.setNick(nickname);
iq.addItem(item);
// Wait for a response packet back from the server.
PacketFilter responseFilter = new PacketIDFilter(iq.getPacketID());
PacketCollector response = connection.createPacketCollector(responseFilter);
// Send the grant voice request to the server.
connection.sendPacket(iq);
// Wait up to a certain number of seconds for a reply.
IQ answer = (IQ) response.nextResult(SmackConfiguration.getPacketReplyTimeout());
// Stop queuing results
response.cancel();
if (answer == null) {
throw new XMPPException("No response from server.");
}
else if (answer.getError() != null) {
throw new XMPPException(answer.getError());
}
}
/**
* Revokes voice from a participant in the room. In a moderated room, a moderator may want to
* revoke a participant's privileges to speak. To have voice means that a room participant
* is able to send messages to the room occupants.
*
* @param nickname the nickname of the participant to revoke voice (e.g. "john").
* @throws XMPPException if an error occurs revoking voice from a participant. In particular, a
* 405 error can occur if a moderator or a user with an affiliation of "owner" or "admin"
* was tried to revoke his voice (i.e. Not Allowed error); or a
* 400 error can occur if the provided nickname is not present in the room.
*/
public void revokeVoice(String nickname) throws XMPPException {
MUCAdmin iq = new MUCAdmin();
iq.setTo(room);
iq.setType(IQ.Type.SET);
// Set the role to "visitor". This will revoke voice from the participant
MUCAdmin.Item item = new MUCAdmin.Item(null, "visitor");
item.setNick(nickname);
iq.addItem(item);
// Wait for a response packet back from the server.
PacketFilter responseFilter = new PacketIDFilter(iq.getPacketID());
PacketCollector response = connection.createPacketCollector(responseFilter);
// Send the revoke voice request to the server.
connection.sendPacket(iq);
// Wait up to a certain number of seconds for a reply.
IQ answer = (IQ) response.nextResult(SmackConfiguration.getPacketReplyTimeout());
// Stop queuing results
response.cancel();
if (answer == null) {
throw new XMPPException("No response from server.");
}
else if (answer.getError() != null) {
throw new XMPPException(answer.getError());
}
}
/**
* Bans a user from the room. An admin or owner of the room can ban users from a room. This
* means that the banned user will no longer be able to join the room unless the ban has been
* removed. If the banned user was present in the room then he/she will be removed from the
* room and notified that he/she was banned along with the reason (if provided) and the bare
* XMPP user ID of the user who initiated the ban.
*
* @param jid the bare XMPP user ID of the user to ban (e.g. "user@host.org").
* @param reason the reason why the user was banned.
* @throws XMPPException if an error occurs banning a user. In particular, a
* 405 error can occur if a moderator or a user with an affiliation of "owner" or "admin"
* was tried to be banned (i.e. Not Allowed error).
*/
public void banUser(String jid, String reason) throws XMPPException {
MUCAdmin iq = new MUCAdmin();
iq.setTo(room);
iq.setType(IQ.Type.SET);
// Set the affiliation to "outcast". This will ban the user
MUCAdmin.Item item = new MUCAdmin.Item("outcast", null);
item.setJid(jid);
item.setReason(reason);
iq.addItem(item);
// Wait for a response packet back from the server.
PacketFilter responseFilter = new PacketIDFilter(iq.getPacketID());
PacketCollector response = connection.createPacketCollector(responseFilter);
// Send the ban user request to the server.
connection.sendPacket(iq);
// Wait up to a certain number of seconds for a reply.
IQ answer = (IQ) response.nextResult(SmackConfiguration.getPacketReplyTimeout());
// Stop queuing results
response.cancel();
if (answer == null) {
throw new XMPPException("No response from server.");
}
else if (answer.getError() != null) {
throw new XMPPException(answer.getError());
}
}
/**
* Grants membership to a user. Only administrators are able to grant membership. A user
* that becomes a room member will be able to enter a room of type Members-Only (i.e. a room
* that a user cannot enter without being on the member list).
*
* @param jid the XMPP user ID of the user to grant membership (e.g. "user@host.org").
* @throws XMPPException if an error occurs granting membership to a user.
*/
public void grantMembership(String jid) throws XMPPException {
MUCAdmin iq = new MUCAdmin();
iq.setTo(room);
iq.setType(IQ.Type.SET);
// Set the affiliation to "member". This will grant membership to the user
MUCAdmin.Item item = new MUCAdmin.Item("member", null);
item.setJid(jid);
iq.addItem(item);
// Wait for a response packet back from the server.
PacketFilter responseFilter = new PacketIDFilter(iq.getPacketID());
PacketCollector response = connection.createPacketCollector(responseFilter);
// Send the grant membership request to the server.
connection.sendPacket(iq);
// Wait up to a certain number of seconds for a reply.
IQ answer = (IQ) response.nextResult(SmackConfiguration.getPacketReplyTimeout());
// Stop queuing results
response.cancel();
if (answer == null) {
throw new XMPPException("No response from server.");
}
else if (answer.getError() != null) {
throw new XMPPException(answer.getError());
}
}
/**
* Revokes a user's membership. Only administrators are able to revoke membership. A user
* that becomes a room member will be able to enter a room of type Members-Only (i.e. a room
* that a user cannot enter without being on the member list). If the user is in the room and
* the room is of type members-only then the user will be removed from the room.
*
* @param jid the bare XMPP user ID of the user to grant membership (e.g. "user@host.org").
* @throws XMPPException if an error occurs revoking membership to a user.
*/
public void revokeMembership(String jid) throws XMPPException {
MUCAdmin iq = new MUCAdmin();
iq.setTo(room);
iq.setType(IQ.Type.SET);
// Set the affiliation to "none". This will revoke a user's membership
MUCAdmin.Item item = new MUCAdmin.Item("none", null);
item.setJid(jid);
iq.addItem(item);
// Wait for a response packet back from the server.
PacketFilter responseFilter = new PacketIDFilter(iq.getPacketID());
PacketCollector response = connection.createPacketCollector(responseFilter);
// Send the revoke membership request to the server.
connection.sendPacket(iq);
// Wait up to a certain number of seconds for a reply.
IQ answer = (IQ) response.nextResult(SmackConfiguration.getPacketReplyTimeout());
// Stop queuing results
response.cancel();
if (answer == null) {
throw new XMPPException("No response from server.");
}
else if (answer.getError() != null) {
throw new XMPPException(answer.getError());
}
}
/**
* Grants moderator privileges to a participant or visitor. Room administrators may grant
* moderator privileges. A moderator is allowed to kick users, grant and revoke voice, invite
* other users, modify room's subject plus all the partcipants privileges.
*
* @param nickname the nickname of the occupant to grant moderator privileges.
* @throws XMPPException if an error occurs granting moderator privileges to a user.
*/
public void grantModerator(String nickname) throws XMPPException {
MUCAdmin iq = new MUCAdmin();
iq.setTo(room);
iq.setType(IQ.Type.SET);
// Set the role to "moderator". This will grant moderator privileges
MUCAdmin.Item item = new MUCAdmin.Item(null, "moderator");
item.setNick(nickname);
iq.addItem(item);
// Wait for a response packet back from the server.
PacketFilter responseFilter = new PacketIDFilter(iq.getPacketID());
PacketCollector response = connection.createPacketCollector(responseFilter);
// Send the grant moderator privileges request to the server.
connection.sendPacket(iq);
// Wait up to a certain number of seconds for a reply.
IQ answer = (IQ) response.nextResult(SmackConfiguration.getPacketReplyTimeout());
// Stop queuing results
response.cancel();
if (answer == null) {
throw new XMPPException("No response from server.");
}
else if (answer.getError() != null) {
throw new XMPPException(answer.getError());
}
}
/**
* Revokes moderator privileges from another user. The occupant that loses moderator
* privileges will become a participant. Room administrators may revoke moderator privileges
* only to occupants whose affiliation is member or none. This means that an administrator is
* not allowed to revoke moderator privileges from other room administrators or owners.
*
* @param nickname the nickname of the occupant to revoke moderator privileges.
* @throws XMPPException if an error occurs revoking moderator privileges from a user.
*/
public void revokeModerator(String nickname) throws XMPPException {
MUCAdmin iq = new MUCAdmin();
iq.setTo(room);
iq.setType(IQ.Type.SET);
// Set the role to "participant". This will revoke moderator privileges
MUCAdmin.Item item = new MUCAdmin.Item(null, "participant");
item.setNick(nickname);
iq.addItem(item);
// Wait for a response packet back from the server.
PacketFilter responseFilter = new PacketIDFilter(iq.getPacketID());
PacketCollector response = connection.createPacketCollector(responseFilter);
// Send the revoke moderator privileges request to the server.
connection.sendPacket(iq);
// Wait up to a certain number of seconds for a reply.
IQ answer = (IQ) response.nextResult(SmackConfiguration.getPacketReplyTimeout());
// Stop queuing results
response.cancel();
if (answer == null) {
throw new XMPPException("No response from server.");
}
else if (answer.getError() != null) {
throw new XMPPException(answer.getError());
}
}
/**
* Grants ownership privileges to another user. Room owners may grant ownership privileges.
* Some room implementations will not allow to grant ownership privileges to other users.
* An owner is allowed to change defining room features as well as perform all administrative
* functions.
*
* @param jid the bare XMPP user ID of the user to grant ownership (e.g. "user@host.org").
* @throws XMPPException if an error occurs granting ownership privileges to a user.
*/
public void grantOwnership(String jid) throws XMPPException {
MUCAdmin iq = new MUCAdmin();
iq.setTo(room);
iq.setType(IQ.Type.SET);
// Set the affiliation to "owner". This will grant a user's ownership
MUCAdmin.Item item = new MUCAdmin.Item("owner", null);
item.setJid(jid);
iq.addItem(item);
// Wait for a response packet back from the server.
PacketFilter responseFilter = new PacketIDFilter(iq.getPacketID());
PacketCollector response = connection.createPacketCollector(responseFilter);
// Send the grant ownership request to the server.
connection.sendPacket(iq);
// Wait up to a certain number of seconds for a reply.
IQ answer = (IQ) response.nextResult(SmackConfiguration.getPacketReplyTimeout());
// Stop queuing results
response.cancel();
if (answer == null) {
throw new XMPPException("No response from server.");
}
else if (answer.getError() != null) {
throw new XMPPException(answer.getError());
}
}
/**
* Revokes ownership privileges from another user. The occupant that loses ownership
* privileges will become an administrator. Room owners may revoke ownership privileges.
* Some room implementations will not allow to grant ownership privileges to other users.
*
* @param jid the bare XMPP user ID of the user to grant ownership (e.g. "user@host.org").
* @throws XMPPException if an error occurs granting ownership privileges to a user.
*/
public void revokeOwnership(String jid) throws XMPPException {
MUCAdmin iq = new MUCAdmin();
iq.setTo(room);
iq.setType(IQ.Type.SET);
// Set the affiliation to "admin". This will revoke a user's ownership
MUCAdmin.Item item = new MUCAdmin.Item("admin", null);
item.setJid(jid);
iq.addItem(item);
// Wait for a response packet back from the server.
PacketFilter responseFilter = new PacketIDFilter(iq.getPacketID());
PacketCollector response = connection.createPacketCollector(responseFilter);
// Send the revoke ownership request to the server.
connection.sendPacket(iq);
// Wait up to a certain number of seconds for a reply.
IQ answer = (IQ) response.nextResult(SmackConfiguration.getPacketReplyTimeout());
// Stop queuing results
response.cancel();
if (answer == null) {
throw new XMPPException("No response from server.");
}
else if (answer.getError() != null) {
throw new XMPPException(answer.getError());
}
}
/**
* Grants administrator privileges to another user. Room owners may grant administrator
* privileges to a member or unaffiliated user. An administrator is allowed to perform
* administrative functions such as banning users and edit moderator list.
*
* @param jid the bare XMPP user ID of the user to grant administrator privileges
* (e.g. "user@host.org").
* @throws XMPPException if an error occurs granting administrator privileges to a user.
*/
public void grantAdmin(String jid) throws XMPPException {
MUCAdmin iq = new MUCAdmin();
iq.setTo(room);
iq.setType(IQ.Type.SET);
// Set the affiliation to "admin". This will grant administrator privileges
MUCAdmin.Item item = new MUCAdmin.Item("admin", null);
item.setJid(jid);
iq.addItem(item);
// Wait for a response packet back from the server.
PacketFilter responseFilter = new PacketIDFilter(iq.getPacketID());
PacketCollector response = connection.createPacketCollector(responseFilter);
// Send the grant administrator privileges request to the server.
connection.sendPacket(iq);
// Wait up to a certain number of seconds for a reply.
IQ answer = (IQ) response.nextResult(SmackConfiguration.getPacketReplyTimeout());
// Stop queuing results
response.cancel();
if (answer == null) {
throw new XMPPException("No response from server.");
}
else if (answer.getError() != null) {
throw new XMPPException(answer.getError());
}
}
/**
* Revokes administrator privileges from a user. The occupant that loses administrator
* privileges will become a member. Room owners may revoke administrator privileges from
* a member or unaffiliated user.
*
* @param jid the bare XMPP user ID of the user to revoke administrator privileges
* (e.g. "user@host.org").
* @throws XMPPException if an error occurs revoking administrator privileges from a user.
*/
public void revokeAdmin(String jid) throws XMPPException {
MUCAdmin iq = new MUCAdmin();
iq.setTo(room);
iq.setType(IQ.Type.SET);
// Set the affiliation to "member". This will revoke a user's ownership
MUCAdmin.Item item = new MUCAdmin.Item("member", null);
item.setJid(jid);
iq.addItem(item);
// Wait for a response packet back from the server.
PacketFilter responseFilter = new PacketIDFilter(iq.getPacketID());
PacketCollector response = connection.createPacketCollector(responseFilter);
// Send the revoke ownership request to the server.
connection.sendPacket(iq);
// Wait up to a certain number of seconds for a reply.
IQ answer = (IQ) response.nextResult(SmackConfiguration.getPacketReplyTimeout());
// Stop queuing results
response.cancel();
if (answer == null) {
throw new XMPPException("No response from server.");
}
else if (answer.getError() != null) {
throw new XMPPException(answer.getError());
}
}
/**
* Returns the number of participants in the group chat.
* * Note: this value will only be accurate after joining the group chat, and * may fluctuate over time. If you query this value directly after joining the * group chat it may not be accurate, as it takes a certain amount of time for * the server to send all presence packets to this client. * * @return the number of participants in the group chat. */ public int getParticipantCount() { synchronized (participantsMap) { return participantsMap.size(); } } /** * Returns an Iterator (of Strings) for the list of fully qualified participants * in the group chat. For example, "conference@chat.jivesoftware.com/SomeUser". * Typically, a client would only display the nickname of the participant. To * get the nickname from the fully qualified name, use the * {@link org.jivesoftware.smack.util.StringUtils#parseResource(String)} method. * Note: this value will only be accurate after joining the group chat, and may * fluctuate over time. * * @return an Iterator for the participants in the group chat. */ public Iterator getParticipants() { synchronized (participantsMap) { return Collections.unmodifiableList(new ArrayList(participantsMap.keySet())).iterator(); } } /** * Returns the presence info for a particular participant, or null if the participant * is not in the room.
*
* @param participant the room occupant to search for his presence. The format of participant must
* be: roomName@service/nickname (e.g. darkcave@macbeth.shakespeare.lit/thirdwitch).
* @return the participant's current presence, or null if the user is unavailable
* or if no presence information is available.
*/
public Presence getParticipantPresence(String participant) {
return (Presence) participantsMap.get(participant);
}
/**
* Returns the participant's full JID when joining a Non-Anonymous room or null
* if the room is of type anonymous. If the room is of type semi-anonymous only the
* moderators will have access to the participants full JID.
*
* @param participant the room occupant to search for his JID. The format of participant must
* be: roomName@service/nickname (e.g. darkcave@macbeth.shakespeare.lit/thirdwitch).
* @return the participant's full JID when joining a Non-Anonymous room otherwise returns
* null.
*/
public String getParticipantJID(String participant) {
// Get the participant's presence
Presence presence = getParticipantPresence(participant);
// Get the MUC User extension
MUCUser mucUser = getMUCUserExtension(presence);
if (mucUser != null) {
return mucUser.getItem().getJid();
}
return null;
}
/**
* Adds a packet listener that will be notified of any new Presence packets
* sent to the group chat. Using a listener is a suitable way to know when the list
* of participants should be re-loaded due to any changes.
*
* @param listener a packet listener that will be notified of any presence packets
* sent to the group chat.
*/
public void addParticipantListener(PacketListener listener) {
connection.addPacketListener(listener, presenceFilter);
}
/**
* Sends a message to the chat room.
*
* @param text the text of the message to send.
* @throws XMPPException if sending the message fails.
*/
public void sendMessage(String text) throws XMPPException {
Message message = new Message(room, Message.Type.GROUP_CHAT);
message.setBody(text);
connection.sendPacket(message);
}
/**
* Returns a new Chat for sending private messages to a given room participant.
* The Chat's participant address is the room's JID (i.e. roomName@service/nick). The server
* service will change the 'from' address to the sender's room JID and delivering the message
* to the intended recipient's full JID.
*
* @param participant occupant unique room JID (e.g. 'darkcave@macbeth.shakespeare.lit/Paul').
* @return new Chat for sending private messages to a given room participant.
*/
public Chat createPrivateChat(String participant) {
return new Chat(connection, participant);
}
/**
* Creates a new Message to send to the chat room.
*
* @return a new Message addressed to the chat room.
*/
public Message createMessage() {
return new Message(room, Message.Type.GROUP_CHAT);
}
/**
* Sends a Message to the chat room.
*
* @param message the message.
* @throws XMPPException if sending the message fails.
*/
public void sendMessage(Message message) throws XMPPException {
connection.sendPacket(message);
}
/**
* Polls for and returns the next message, or null if there isn't
* a message immediately available. This method provides significantly different
* functionalty than the {@link #nextMessage()} method since it's non-blocking.
* In other words, the method call will always return immediately, whereas the
* nextMessage method will return only when a message is available (or after
* a specific timeout).
*
* @return the next message if one is immediately available and
* null otherwise.
*/
public Message pollMessage() {
return (Message) messageCollector.pollResult();
}
/**
* Returns the next available message in the chat. The method call will block
* (not return) until a message is available.
*
* @return the next message.
*/
public Message nextMessage() {
return (Message) messageCollector.nextResult();
}
/**
* Returns the next available message in the chat. The method call will block
* (not return) until a packet is available or the timeout has elapased.
* If the timeout elapses without a result, null will be returned.
*
* @param timeout the maximum amount of time to wait for the next message.
* @return the next message, or null if the timeout elapses without a
* message becoming available.
*/
public Message nextMessage(long timeout) {
return (Message) messageCollector.nextResult(timeout);
}
/**
* Adds a packet listener that will be notified of any new messages in the
* group chat. Only "group chat" messages addressed to this group chat will
* be delivered to the listener. If you wish to listen for other packets
* that may be associated with this group chat, you should register a
* PacketListener directly with the XMPPConnection with the appropriate
* PacketListener.
*
* @param listener a packet listener.
*/
public void addMessageListener(PacketListener listener) {
connection.addPacketListener(listener, messageFilter);
}
/**
* Changes the subject within the room. As a default, only users with a role of "moderator"
* are allowed to change the subject in a room. Although some rooms may be configured to
* allow a mere participant or even a visitor to change the subject.
*
* @param subject the new room's subject to set.
* @throws XMPPException if someone without appropriate privileges attempts to change the
* room subject will throw an error with code 403 (i.e. Forbidden)
*/
public void changeSubject(final String subject) throws XMPPException {
Message message = new Message(room, Message.Type.GROUP_CHAT);
message.setSubject(subject);
// Wait for an error or confirmation message back from the server.
PacketFilter responseFilter =
new AndFilter(
new FromContainsFilter(room),
new PacketTypeFilter(Message.class));
responseFilter = new AndFilter(responseFilter, new PacketFilter() {
public boolean accept(Packet packet) {
Message msg = (Message) packet;
return subject.equals(msg.getSubject());
}
});
PacketCollector response = connection.createPacketCollector(responseFilter);
// Send change subject packet.
connection.sendPacket(message);
// Wait up to a certain number of seconds for a reply.
Message answer =
(Message) response.nextResult(SmackConfiguration.getPacketReplyTimeout());
// Stop queuing results
response.cancel();
if (answer == null) {
throw new XMPPException("No response from server.");
}
else if (answer.getError() != null) {
throw new XMPPException(answer.getError());
}
}
/**
* Notification message that the user has joined the room.
*/
private synchronized void userHasJoined() {
// Update the list of joined rooms through this connection
ArrayList rooms = (ArrayList)joinedRooms.get(connection);
if (rooms == null) {
rooms = new ArrayList();
joinedRooms.put(connection, rooms);
}
rooms.add(room);
}
/**
* Notification message that the user has left the room.
*/
private synchronized void userHasLeft() {
// Update the list of joined rooms through this connection
ArrayList rooms = (ArrayList)joinedRooms.get(connection);
if (rooms == null) {
return;
}
rooms.remove(room);
}
/**
* Returns the MUCUser packet extension included in the packet or null if none.
*
* @param packet the packet that may include the MUCUser extension.
* @return the MUCUser found in the packet.
*/
private MUCUser getMUCUserExtension(Packet packet) {
if (packet != null) {
// Get the MUC User extension
return (MUCUser) packet.getExtension("x", "http://jabber.org/protocol/muc#user");
}
return null;
}
public void addUserStatusListener(UserStatusListener listener) {
synchronized (userStatusListeners) {
if (!userStatusListeners.contains(listener)) {
userStatusListeners.add(listener);
}
}
}
public void removeUserStatusListener(UserStatusListener listener) {
synchronized (userStatusListeners) {
userStatusListeners.remove(listener);
}
}
private void fireUserStatusListeners(String methodName, Object[] params) {
UserStatusListener[] listeners = null;
synchronized (userStatusListeners) {
listeners = new UserStatusListener[userStatusListeners.size()];
userStatusListeners.toArray(listeners);
}
// Get the classes of the method parameters
Class[] paramClasses = new Class[params.length];
for (int i = 0; i < params.length; i++) {
paramClasses[i] = params[i].getClass();
}
try {
// Get the method to execute based on the requested methodName and parameters classes
Method method = UserStatusListener.class.getDeclaredMethod(methodName, paramClasses);
for (int i = 0; i < listeners.length; i++) {
method.invoke(listeners[i], params);
}
} catch (NoSuchMethodException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
public void addParticipantStatusListener(ParticipantStatusListener listener) {
synchronized (participantStatusListeners) {
if (!participantStatusListeners.contains(listener)) {
participantStatusListeners.add(listener);
}
}
}
public void removeParticipantStatusListener(ParticipantStatusListener listener) {
synchronized (participantStatusListeners) {
participantStatusListeners.remove(listener);
}
}
private void fireParticipantStatusListeners(String methodName, String param) {
ParticipantStatusListener[] listeners = null;
synchronized (participantStatusListeners) {
listeners = new ParticipantStatusListener[participantStatusListeners.size()];
participantStatusListeners.toArray(listeners);
}
try {
// Get the method to execute based on the requested methodName and parameter
Method method =
ParticipantStatusListener.class.getDeclaredMethod(
methodName,
new Class[] { String.class });
for (int i = 0; i < listeners.length; i++) {
method.invoke(listeners[i], new Object[] {param});
}
} catch (NoSuchMethodException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
private void init() {
// Create a collector for incoming messages.
messageFilter =
new AndFilter(
new FromContainsFilter(room),
new MessageTypeFilter(Message.Type.GROUP_CHAT));
messageFilter = new AndFilter(messageFilter, new PacketFilter() {
public boolean accept(Packet packet) {
Message msg = (Message) packet;
return msg.getBody() != null;
}
});
messageCollector = connection.createPacketCollector(messageFilter);
// Create a listener for subject updates.
subjectFilter =
new AndFilter(
new FromContainsFilter(room),
new MessageTypeFilter(Message.Type.GROUP_CHAT));
subjectFilter = new AndFilter(subjectFilter, new PacketFilter() {
public boolean accept(Packet packet) {
Message msg = (Message) packet;
return msg.getSubject() != null;
}
});
subjectListener = new PacketListener() {
public void processPacket(Packet packet) {
Message msg = (Message) packet;
// Update the room subject
subject = msg.getSubject();
// Fire event for subject updated listeners
fireSubjectUpdatedListeners(
msg.getSubject(),
msg.getFrom());
}
};
connection.addPacketListener(subjectListener, subjectFilter);
// Create a listener for all presence updates.
presenceFilter =
new AndFilter(new FromContainsFilter(room), new PacketTypeFilter(Presence.class));
presenceListener = new PacketListener() {
public void processPacket(Packet packet) {
Presence presence = (Presence) packet;
String from = presence.getFrom();
String myRoomJID = room + "/" + nickname;
boolean isUserStatusModification = presence.getFrom().equals(myRoomJID);
if (presence.getType() == Presence.Type.AVAILABLE) {
Presence oldPresence;
synchronized (participantsMap) {
oldPresence = (Presence)participantsMap.get(from);
participantsMap.put(from, presence);
}
if (oldPresence != null) {
// Get the previous participant's affiliation & role
MUCUser mucExtension = getMUCUserExtension(oldPresence);
String oldAffiliation = mucExtension.getItem().getAffiliation();
String oldRole = mucExtension.getItem().getRole();
// Get the new participant's affiliation & role
mucExtension = getMUCUserExtension(presence);
String newAffiliation = mucExtension.getItem().getAffiliation();
String newRole = mucExtension.getItem().getRole();
// Fire role modification events
checkRoleModifications(oldRole, newRole, isUserStatusModification, from);
// Fire affiliation modification events
checkAffiliationModifications(
oldAffiliation,
newAffiliation,
isUserStatusModification,
from);
}
}
else if (presence.getType() == Presence.Type.UNAVAILABLE) {
synchronized (participantsMap) {
participantsMap.remove(from);
}
MUCUser mucUser = getMUCUserExtension(presence);
if (mucUser != null && mucUser.getStatus() != null) {
// Fire events according to the received presence code
checkPresenceCode(
mucUser.getStatus().getCode(),
presence.getFrom().equals(myRoomJID),
mucUser,
from);
}
}
}
};
connection.addPacketListener(presenceListener, presenceFilter);
// Listens for all messages that include a MUCUser extension and fire the invitation
// rejection listeners if the message includes an invitation rejection.
declinesFilter = new PacketExtensionFilter("x", "http://jabber.org/protocol/muc#user");
declinesListener = new PacketListener() {
public void processPacket(Packet packet) {
// Get the MUC User extension
MUCUser mucUser = getMUCUserExtension(packet);
// Check if the MUCUser informs that the invitee has declined the invitation
if (mucUser.getDecline() != null) {
// Fire event for invitation rejection listeners
fireInvitationRejectionListeners(
mucUser.getDecline().getFrom(),
mucUser.getDecline().getReason());
}
};
};
connection.addPacketListener(declinesListener, declinesFilter);
}
/**
* Fires notification events if the role of a room occupant has changed. If the occupant that
* changed his role is your occupant then the UserStatusListeners added to this
* MultiUserChat will be fired. On the other hand, if the occupant that changed
* his role is not yours then the ParticipantStatusListeners added to this
* MultiUserChat will be fired. The following table shows the events that will
* be fired depending on the previous and new role of the occupant.
*
*
* | Old | New | Events |
| None | Visitor | -- |
| Visitor | Participant | voiceGranted |
| Participant | Moderator | moderatorGranted |
| None | Participant | voiceGranted |
| None | Moderator | voiceGranted + moderatorGranted |
| Visitor | Moderator | voiceGranted + moderatorGranted |
| Moderator | Participant | moderatorRevoked |
| Participant | Visitor | voiceRevoked |
| Visitor | None | -- |
| Moderator | Visitor | voiceRevoked + moderatorRevoked |
| Moderator | None | voiceRevoked + moderatorRevoked |
| Participant | None | voiceRevoked |
UserStatusListeners added to this MultiUserChat will be fired.
* On the other hand, if the occupant that changed his affiliation is not yours then the
* ParticipantStatusListeners added to this MultiUserChat will be
* fired. The following table shows the events that will be fired depending on the previous
* and new affiliation of the occupant.
*
*
* | Old | New | Events |
| None | Member | membershipGranted |
| Member | Admin | membershipRevoked + adminGranted |
| Admin | Owner | adminRevoked + ownershipGranted |
| None | Admin | adminGranted |
| None | Owner | ownershipGranted |
| Member | Owner | membershipRevoked + ownershipGranted |
| Owner | Admin | ownershipRevoked + adminGranted |
| Admin | Member | adminRevoked + membershipGranted |
| Member | None | membershipRevoked |
| Owner | Member | ownershipRevoked + membershipGranted |
| Owner | None | ownershipRevoked |
| Admin | None | adminRevoked |
* * If this is the first monitor's listener then the monitor will be initialized in * order to start listening to room invitations. * * @param listener an invitation listener. */ public void addInvitationListener(InvitationListener listener) { synchronized (invitationsListeners) { // If this is the first monitor's listener then initialize the listeners // on the connection to detect room invitations if (invitationsListeners.size() == 0) { init(); } if (!invitationsListeners.contains(listener)) { invitationsListeners.add(listener); } } } /** * Removes a listener to invitation notifications. The listener will be fired anytime * an invitation is received.
* * If there are no more listeners to notifiy for room invitations then the monitor will * be stopped. As soon as a new listener is added to the monitor, the monitor will resume * monitoring the connection for new room invitations. * * @param listener an invitation listener. */ public void removeInvitationListener(InvitationListener listener) { synchronized (invitationsListeners) { if (invitationsListeners.contains(listener)) { invitationsListeners.remove(listener); } // If there are no more listeners to notifiy for room invitations // then proceed to cancel/release this monitor if (invitationsListeners.size() == 0) { cancel(); } } } /** * Fires invitation listeners. */ private void fireInvitationListeners( String room, String inviter, String reason, String password) { InvitationListener[] listeners = null; synchronized (invitationsListeners) { listeners = new InvitationListener[invitationsListeners.size()]; invitationsListeners.toArray(listeners); } for (int i = 0; i < listeners.length; i++) { listeners[i].invitationReceived(connection, room, inviter, reason, password); } } public void connectionClosed() { cancel(); } public void connectionClosedOnError(Exception e) { cancel(); } /** * Initializes the listeners to detect received room invitations and to detect when the * connection gets closed. As soon as a room invitation is received the invitations * listeners will be fired. When the connection gets closed the monitor will remove * his listeners on the connection. */ private void init() { // Listens for all messages that include a MUCUser extension and fire the invitation // listeners if the message includes an invitation. invitationFilter = new PacketExtensionFilter("x", "http://jabber.org/protocol/muc#user"); invitationPacketListener = new PacketListener() { public void processPacket(Packet packet) { // Get the MUCUser extension MUCUser mucUser = (MUCUser) packet.getExtension("x", "http://jabber.org/protocol/muc#user"); // Check if the MUCUser extension includes an invitation if (mucUser.getInvite() != null) { // Fire event for invitation listeners fireInvitationListeners( packet.getFrom(), mucUser.getInvite().getFrom(), mucUser.getInvite().getReason(), mucUser.getPassword()); } }; }; connection.addPacketListener(invitationPacketListener, invitationFilter); // Add a listener to detect when the connection gets closed in order to // cancel/release this monitor connection.addConnectionListener(this); } /** * Cancels all the listeners that this InvitationsMonitor has added to the connection. */ private void cancel() { connection.removePacketListener(invitationPacketListener); connection.removeConnectionListener(this); } } }