/** @override {@link Thread}{@link #run()} to perform all asynchronous tasks. */
@Override
public void run() {
ChatRoom chatRoom = chatRoomWrapper.getChatRoom();
try {
if (password != null && password.length > 0) chatRoom.joinAs(nickName, password);
else if (nickName != null) chatRoom.joinAs(nickName);
else chatRoom.join();
done(JOIN_SUCCESS_PROP);
} catch (OperationFailedException e) {
if (logger.isTraceEnabled())
logger.trace("Failed to join chat room: " + chatRoom.getName(), e);
switch (e.getErrorCode()) {
case OperationFailedException.AUTHENTICATION_FAILED:
done(JOIN_AUTHENTICATION_FAILED_PROP);
break;
case OperationFailedException.REGISTRATION_REQUIRED:
done(JOIN_REGISTRATION_REQUIRED_PROP);
break;
case OperationFailedException.PROVIDER_NOT_REGISTERED:
done(JOIN_PROVIDER_NOT_REGISTERED_PROP);
break;
case OperationFailedException.SUBSCRIPTION_ALREADY_EXISTS:
done(JOIN_SUBSCRIPTION_ALREADY_EXISTS_PROP);
break;
default:
done(JOIN_UNKNOWN_ERROR_PROP);
}
}
}
/**
* Leaves the given chat room.
*
* @param chatRoomWrapper the chat room to leave.
* @return <tt>ChatRoomWrapper</tt> instance associated with the chat room.
*/
public ChatRoomWrapper leaveChatRoom(ChatRoomWrapper chatRoomWrapper) {
ChatRoom chatRoom = chatRoomWrapper.getChatRoom();
if (chatRoom == null) {
ResourceManagementService resources = MUCActivator.getResources();
MUCActivator.getAlertUIService()
.showAlertDialog(
resources.getI18NString("service.gui.WARNING"),
resources.getI18NString("service.gui.CHAT_ROOM_LEAVE_NOT_CONNECTED"));
return null;
}
if (chatRoom.isJoined()) chatRoom.leave();
ChatRoomWrapper existChatRoomWrapper = chatRoomList.findChatRoomWrapperFromChatRoom(chatRoom);
if (existChatRoomWrapper == null) return null;
// We save the choice of the user, before the chat room is really
// joined, because even the join fails we want the next time when
// we login to join this chat room automatically.
ConfigurationUtils.updateChatRoomStatus(
chatRoomWrapper.getParentProvider().getProtocolProvider(),
chatRoomWrapper.getChatRoomID(),
GlobalStatusEnum.OFFLINE_STATUS);
return existChatRoomWrapper;
}
/**
* Called to accept an incoming invitation. Adds the invitation chat room to the list of chat
* rooms and joins it.
*
* @param invitation the invitation to accept.
*/
public void acceptInvitation(ChatRoomInvitation invitation) {
ChatRoom chatRoom = invitation.getTargetChatRoom();
byte[] password = invitation.getChatRoomPassword();
String nickName = chatRoom.getParentProvider().getAccountID().getUserID();
joinChatRoom(chatRoom, nickName, password);
}
/**
* Checks if the menu item should be enabled or disabled.
*
* @param contact the contact associated with the menu item.
* @return <tt>true</tt> if the item should be enabled and <tt>false</tt> if not.
*/
public boolean check(SourceContact contact) {
ChatRoomWrapper chatRoomWrapper =
MUCActivator.getMUCService().findChatRoomWrapperFromSourceContact(contact);
ChatRoom chatRoom = null;
if (chatRoomWrapper != null) {
chatRoom = chatRoomWrapper.getChatRoom();
}
if ((chatRoom != null) && chatRoom.isJoined()) return false;
return true;
}
/**
* Determines whether a specific <code>ChatRoom</code> is private i.e. represents a one-to-one
* conversation which is not a channel. Since the interface {@link ChatRoom} does not expose the
* private property, an heuristic is used as a workaround: (1) a system <code>ChatRoom</code> is
* obviously not private and (2) a <code>ChatRoom</code> is private if it has only one <code>
* ChatRoomMember</code> who is not the local user.
*
* @param chatRoom the <code>ChatRoom</code> to be determined as private or not
* @return <tt>true</tt> if the specified <code>ChatRoom</code> is private; otherwise,
* <tt>false</tt>
*/
public static boolean isPrivate(ChatRoom chatRoom) {
if (!chatRoom.isSystem() && chatRoom.isJoined() && (chatRoom.getMembersCount() == 1)) {
String nickname = chatRoom.getUserNickname();
if (nickname != null) {
for (ChatRoomMember member : chatRoom.getMembers())
if (nickname.equals(member.getName())) return false;
return true;
}
}
return false;
}
/**
* Adds found result to the query results.
*
* @param room the chat room.
* @param addQueryResult indicates whether we should add the chat room to the query results or
* fire an event without adding it to the results.
* @param isAutoJoin the auto join state of the contact.
*/
private void addChatRoom(ChatRoom room, boolean addQueryResult, boolean isAutoJoin) {
if (queryString == null
|| ((room.getName().contains(queryString) || room.getIdentifier().contains(queryString)))) {
ChatRoomSourceContact contact = new ChatRoomSourceContact(room, this, isAutoJoin);
synchronized (contactResults) {
contactResults.add(contact);
}
if (addQueryResult) {
addQueryResult(contact, false);
} else {
fireContactReceived(contact, false);
}
}
}
/**
* Creates an instance of <tt>ChatRoomsListRightButtonMenu</tt>.
*
* @param chatRoomWrapper the chat room wrapper, corresponding to the selected chat room
*/
public ChatRoomRightButtonMenu(ChatRoomWrapper chatRoomWrapper) {
this.chatRoomWrapper = chatRoomWrapper;
this.setLocation(getLocation());
createMenuItem("service.gui.OPEN", ImageLoader.CHAT_ROOM_16x16_ICON, "openChatRoom");
JMenuItem joinChatRoomItem =
createMenuItem("service.gui.JOIN", ImageLoader.JOIN_ICON, "joinChatRoom");
JMenuItem joinAsChatRoomItem =
createMenuItem("service.gui.JOIN_AS", ImageLoader.JOIN_AS_ICON, "joinAsChatRoom");
JMenuItem leaveChatRoomItem =
createMenuItem("service.gui.LEAVE", ImageLoader.LEAVE_ICON, "leaveChatRoom");
createMenuItem("service.gui.REMOVE", ImageLoader.DELETE_16x16_ICON, "removeChatRoom");
ChatRoom chatRoom = chatRoomWrapper.getChatRoom();
if ((chatRoom != null) && chatRoom.isJoined()) {
joinAsChatRoomItem.setEnabled(false);
joinChatRoomItem.setEnabled(false);
} else leaveChatRoomItem.setEnabled(false);
}
/**
* Tries to match the event object to already existing ComparableEvtObj in the supplied list.
*
* @param obj the object that we will try to match.
* @param list the list we will search in.
* @return the found ComparableEvtObj
*/
private static ComparableEvtObj findRecentMessage(EventObject obj, List<ComparableEvtObj> list) {
Contact contact = null;
ChatRoom chatRoom = null;
if (obj instanceof MessageDeliveredEvent) {
contact = ((MessageDeliveredEvent) obj).getDestinationContact();
} else if (obj instanceof MessageReceivedEvent) {
contact = ((MessageReceivedEvent) obj).getSourceContact();
} else if (obj instanceof ChatRoomMessageDeliveredEvent) {
chatRoom = ((ChatRoomMessageDeliveredEvent) obj).getSourceChatRoom();
} else if (obj instanceof ChatRoomMessageReceivedEvent) {
chatRoom = ((ChatRoomMessageReceivedEvent) obj).getSourceChatRoom();
}
for (ComparableEvtObj evt : list) {
if ((contact != null && contact.equals(evt.getContact()))
|| (chatRoom != null && chatRoom.equals(evt.getRoom()))) return evt;
}
return null;
}
/**
* Joins the room with the given name though the given chat room provider.
*
* @param chatRoomName the name of the room to join.
* @param chatRoomProvider the chat room provider to join through.
*/
public void joinChatRoom(String chatRoomName, ChatRoomProviderWrapper chatRoomProvider) {
OperationSetMultiUserChat groupChatOpSet =
chatRoomProvider.getProtocolProvider().getOperationSet(OperationSetMultiUserChat.class);
ChatRoom chatRoom = null;
try {
chatRoom = groupChatOpSet.findRoom(chatRoomName);
} catch (Exception e) {
if (logger.isTraceEnabled())
logger.trace("Un exception occurred while searching for room:" + chatRoomName, e);
}
if (chatRoom != null) {
ChatRoomWrapper chatRoomWrapper = chatRoomList.findChatRoomWrapperFromChatRoom(chatRoom);
if (chatRoomWrapper == null) {
ChatRoomProviderWrapper parentProvider =
chatRoomList.findServerWrapperFromProvider(chatRoom.getParentProvider());
chatRoomWrapper = new ChatRoomWrapperImpl(parentProvider, chatRoom);
chatRoomList.addChatRoom(chatRoomWrapper);
fireChatRoomListChangedEvent(chatRoomWrapper, ChatRoomListChangeEvent.CHAT_ROOM_ADDED);
}
joinChatRoom(chatRoomWrapper);
} else
MUCActivator.getAlertUIService()
.showAlertDialog(
MUCActivator.getResources().getI18NString("service.gui.ERROR"),
MUCActivator.getResources()
.getI18NString(
"service.gui.CHAT_ROOM_NOT_EXIST",
new String[] {
chatRoomName,
chatRoomProvider.getProtocolProvider().getAccountID().getService()
}));
}
/**
* Searches for chat room wrapper in chat room list by chat room.
*
* @param chatRoom the chat room.
* @param create if <tt>true</tt> and the chat room wrapper is not found new chatRoomWrapper is
* created.
* @return found chat room wrapper or the created chat room wrapper.
*/
@Override
public ChatRoomWrapper getChatRoomWrapperByChatRoom(ChatRoom chatRoom, boolean create) {
ChatRoomWrapper chatRoomWrapper = chatRoomList.findChatRoomWrapperFromChatRoom(chatRoom);
if ((chatRoomWrapper == null) && create) {
ChatRoomProviderWrapper parentProvider =
chatRoomList.findServerWrapperFromProvider(chatRoom.getParentProvider());
chatRoomWrapper = new ChatRoomWrapperImpl(parentProvider, chatRoom);
chatRoomList.addChatRoom(chatRoomWrapper);
}
return chatRoomWrapper;
}
/**
* Extract values from <tt>EventObject</tt>.
*
* @param source
*/
public void update(EventObject source) {
this.eventObject = source;
if (source instanceof MessageDeliveredEvent) {
MessageDeliveredEvent e = (MessageDeliveredEvent) source;
this.contact = e.getDestinationContact();
this.address = contact.getAddress();
this.ppService = contact.getProtocolProvider();
this.timestamp = e.getTimestamp();
} else if (source instanceof MessageReceivedEvent) {
MessageReceivedEvent e = (MessageReceivedEvent) source;
this.contact = e.getSourceContact();
this.address = contact.getAddress();
this.ppService = contact.getProtocolProvider();
this.timestamp = e.getTimestamp();
} else if (source instanceof ChatRoomMessageDeliveredEvent) {
ChatRoomMessageDeliveredEvent e = (ChatRoomMessageDeliveredEvent) source;
this.room = e.getSourceChatRoom();
this.address = room.getIdentifier();
this.ppService = room.getParentProvider();
this.timestamp = e.getTimestamp();
} else if (source instanceof ChatRoomMessageReceivedEvent) {
ChatRoomMessageReceivedEvent e = (ChatRoomMessageReceivedEvent) source;
this.room = e.getSourceChatRoom();
this.address = room.getIdentifier();
this.ppService = room.getParentProvider();
this.timestamp = e.getTimestamp();
}
}
/**
* Joins the given chat room and manages all the exceptions that could occur during the join
* process.
*
* @param chatRoom the chat room to join
* @param nickname the nickname we're using to join
* @param password the password we're using to join
*/
public void joinChatRoom(ChatRoom chatRoom, String nickname, byte[] password) {
ChatRoomWrapper chatRoomWrapper = chatRoomList.findChatRoomWrapperFromChatRoom(chatRoom);
if (chatRoomWrapper == null) {
ChatRoomProviderWrapper parentProvider =
chatRoomList.findServerWrapperFromProvider(chatRoom.getParentProvider());
chatRoomWrapper = new ChatRoomWrapperImpl(parentProvider, chatRoom);
chatRoomList.addChatRoom(chatRoomWrapper);
fireChatRoomListChangedEvent(chatRoomWrapper, ChatRoomListChangeEvent.CHAT_ROOM_ADDED);
}
this.joinChatRoom(chatRoomWrapper, nickname, password);
}
public static ChatRoom getChatRoom(String name) {
for (ChatRoom room : chatRooms) {
if (name.equals(room.getName())) return room;
}
return null;
}
/**
* Creates a <tt>ChatRoomWrapper</tt> by specifying the corresponding chat room.
*
* @param chatRoom the chat room to which this wrapper corresponds.
*/
public ChatRoomWrapper(ChatRoom chatRoom) {
this(chatRoom.getParentProvider(), chatRoom.getIdentifier(), chatRoom.getName());
this.chatRoom = chatRoom;
}
public void sendMessage(String message) {
ChatRoom.showMessage(this, message);
}
public void rename(String name) {
chat.renameRoom(this, name);
this.name = name;
}
/**
* Creates a chat room, by specifying the chat room name, the parent protocol provider and
* eventually, the contacts invited to participate in this chat room.
*
* @param roomName the name of the room
* @param protocolProvider the parent protocol provider.
* @param contacts the contacts invited when creating the chat room.
* @param reason
* @param join whether we should join the room after creating it.
* @param persistent whether the newly created room will be persistent.
* @param isPrivate whether the room will be private or public.
* @return the <tt>ChatRoomWrapper</tt> corresponding to the created room
*/
public ChatRoomWrapper createChatRoom(
String roomName,
ProtocolProviderService protocolProvider,
Collection<String> contacts,
String reason,
boolean join,
boolean persistent,
boolean isPrivate) {
ChatRoomWrapper chatRoomWrapper = null;
OperationSetMultiUserChat groupChatOpSet =
protocolProvider.getOperationSet(OperationSetMultiUserChat.class);
// If there's no group chat operation set we have nothing to do here.
if (groupChatOpSet == null) return null;
ChatRoom chatRoom = null;
try {
HashMap<String, Object> roomProperties = new HashMap<String, Object>();
roomProperties.put("isPrivate", isPrivate);
chatRoom = groupChatOpSet.createChatRoom(roomName, roomProperties);
if (join) {
chatRoom.join();
for (String contact : contacts) chatRoom.invite(contact, reason);
}
} catch (OperationFailedException ex) {
logger.error("Failed to create chat room.", ex);
MUCActivator.getAlertUIService()
.showAlertDialog(
MUCActivator.getResources().getI18NString("service.gui.ERROR"),
MUCActivator.getResources()
.getI18NString(
"service.gui.CREATE_CHAT_ROOM_ERROR",
new String[] {protocolProvider.getProtocolDisplayName()}),
ex);
} catch (OperationNotSupportedException ex) {
logger.error("Failed to create chat room.", ex);
MUCActivator.getAlertUIService()
.showAlertDialog(
MUCActivator.getResources().getI18NString("service.gui.ERROR"),
MUCActivator.getResources()
.getI18NString(
"service.gui.CREATE_CHAT_ROOM_ERROR",
new String[] {protocolProvider.getProtocolDisplayName()}),
ex);
}
if (chatRoom != null) {
ChatRoomProviderWrapper parentProvider =
chatRoomList.findServerWrapperFromProvider(protocolProvider);
// if there is the same room ids don't add new wrapper as old one
// maybe already created
chatRoomWrapper = chatRoomList.findChatRoomWrapperFromChatRoom(chatRoom);
if (chatRoomWrapper == null) {
chatRoomWrapper = new ChatRoomWrapperImpl(parentProvider, chatRoom);
chatRoomWrapper.setPersistent(persistent);
chatRoomList.addChatRoom(chatRoomWrapper);
}
}
return chatRoomWrapper;
}
/**
* Test equality of contact to chat room. This test recognizes that chat rooms may have equal
* names but connected to different accounts.
*
* @param contact the contact
* @param chatRoom the chat room
* @return returns <tt>true</tt> if they are equal, or <tt>false</tt> if they are different
*/
private boolean contactEqualsChatRoom(
final ChatRoomSourceContact contact, final ChatRoom chatRoom) {
return contact.getProvider() == chatRoom.getParentProvider()
&& chatRoom.getIdentifier().equals(contact.getContactAddress());
}
