/** @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; }
/** * 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; }
/** * 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); }
/** * 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; }