/** * Returns existing chat rooms for the given <tt>chatRoomProvider</tt>. * * @param chatRoomProvider the <tt>ChatRoomProviderWrapper</tt>, which chat rooms we're looking * for * @return existing chat rooms for the given <tt>chatRoomProvider</tt> */ public List<String> getExistingChatRooms(ChatRoomProviderWrapper chatRoomProvider) { if (chatRoomProvider == null) return null; ProtocolProviderService protocolProvider = chatRoomProvider.getProtocolProvider(); if (protocolProvider == null) return null; OperationSetMultiUserChat groupChatOpSet = protocolProvider.getOperationSet(OperationSetMultiUserChat.class); if (groupChatOpSet == null) return null; List<String> chatRooms = null; try { chatRooms = groupChatOpSet.getExistingChatRooms(); } catch (OperationFailedException e) { if (logger.isTraceEnabled()) logger.trace( "Failed to obtain existing chat rooms for server: " + protocolProvider.getAccountID().getService(), e); } catch (OperationNotSupportedException e) { if (logger.isTraceEnabled()) logger.trace( "Failed to obtain existing chat rooms for server: " + protocolProvider.getAccountID().getService(), e); } return chatRooms; }
/** * When a provider is added. As searching can be slow especially when handling special type of * messages (with subType) this need to be run in new Thread. * * @param provider ProtocolProviderService */ private void handleProviderAddedInSeparateThread( ProtocolProviderService provider, boolean isStatusChanged) { // lets check if we have cached recent messages for this provider, and // fire events if found and are newer synchronized (recentMessages) { List<ComparableEvtObj> cachedRecentMessages = getCachedRecentMessages(provider, isStatusChanged); if (cachedRecentMessages.isEmpty()) { // maybe there is no cached history for this // let's check // load it not from cache, but do a local search Collection<EventObject> res = messageHistoryService.findRecentMessagesPerContact( numberOfMessages, provider.getAccountID().getAccountUniqueID(), null, isSMSEnabled); List<ComparableEvtObj> newMsc = new ArrayList<ComparableEvtObj>(); processEventObjects(res, newMsc, isStatusChanged); addNewRecentMessages(newMsc); for (ComparableEvtObj msc : newMsc) { saveRecentMessageToHistory(msc); } } else addNewRecentMessages(cachedRecentMessages); } }
/** * Checks if equals, and if this event object is used to create a MessageSourceContact, if the * supplied <tt>Object</tt> is instance of MessageSourceContact. * * @param o the object to check. * @return <tt>true</tt> if equals. */ @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || (!(o instanceof MessageSourceContact) && getClass() != o.getClass())) return false; if (o instanceof ComparableEvtObj) { ComparableEvtObj that = (ComparableEvtObj) o; if (!address.equals(that.address)) return false; if (!ppService.equals(that.ppService)) return false; } else if (o instanceof MessageSourceContact) { MessageSourceContact that = (MessageSourceContact) o; if (!address.equals(that.getContactAddress())) return false; if (!ppService.equals(that.getProtocolProviderService())) return false; } else return false; return true; }
/** * Returns default nickname for chat room based on the given provider. * * @param pps the given protocol provider service * @return default nickname for chat room based on the given provider. */ public String getDefaultNickname(ProtocolProviderService pps) { final OperationSetServerStoredAccountInfo accountInfoOpSet = pps.getOperationSet(OperationSetServerStoredAccountInfo.class); String displayName = ""; if (accountInfoOpSet != null) { displayName = AccountInfoUtils.getDisplayName(accountInfoOpSet); } if (displayName == null || displayName.length() == 0) { displayName = MUCActivator.getGlobalDisplayDetailsService().getGlobalDisplayName(); if (displayName == null || displayName.length() == 0) { displayName = pps.getAccountID().getUserID(); if (displayName != null) { int atIndex = displayName.lastIndexOf("@"); if (atIndex > 0) displayName = displayName.substring(0, atIndex); } } } return displayName; }
/** * Searches for entries in cached recent messages in history. * * @param provider the provider which contact messages we will search * @param isStatusChanged is the search because of status changed * @return entries in cached recent messages in history. */ private List<ComparableEvtObj> getCachedRecentMessages( ProtocolProviderService provider, boolean isStatusChanged) { String providerID = provider.getAccountID().getAccountUniqueID(); List<String> recentMessagesContactIDs = getRecentContactIDs( providerID, recentMessages.size() < numberOfMessages ? null : oldestRecentMessage); List<ComparableEvtObj> cachedRecentMessages = new ArrayList<ComparableEvtObj>(); for (String contactID : recentMessagesContactIDs) { Collection<EventObject> res = messageHistoryService.findRecentMessagesPerContact( numberOfMessages, providerID, contactID, isSMSEnabled); processEventObjects(res, cachedRecentMessages, isStatusChanged); } return cachedRecentMessages; }
/** * 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; }
/** * Removes the query from protocol provider service presence listeners. * * @param pps the protocol provider service. */ public void removeQueryFromProviderPresenceListeners(ProtocolProviderService pps) { OperationSetMultiUserChat opSetMUC = pps.getOperationSet(OperationSetMultiUserChat.class); if (opSetMUC != null) { opSetMUC.removePresenceListener(this); } }
/** * Returns the multi user chat operation set for the given protocol provider. * * @param protocolProvider The protocol provider for which the multi user chat operation set is * about. * @return OperationSetMultiUserChat The telephony operation set for the given protocol provider. */ public static OperationSetMultiUserChat getMultiUserChatOpSet( ProtocolProviderService protocolProvider) { OperationSet opSet = protocolProvider.getOperationSet(OperationSetMultiUserChat.class); return (opSet instanceof OperationSetMultiUserChat) ? (OperationSetMultiUserChat) opSet : null; }
@Override public int hashCode() { int result = address.hashCode(); result = 31 * result + ppService.hashCode(); return result; }
/** * Implements the ContactListListener.contactSelected method. * * @param evt the <tt>ContactListEvent</tt> that notified us */ public void contactClicked(ContactListEvent evt) { // We're interested only in two click events. if (evt.getClickCount() < 2) return; UIContact descriptor = evt.getSourceContact(); // We're currently only interested in MetaContacts. if (descriptor.getDescriptor() instanceof MetaContact) { MetaContact metaContact = (MetaContact) descriptor.getDescriptor(); // Searching for the right proto contact to use as default for the // chat conversation. Contact defaultContact = metaContact.getDefaultContact(OperationSetBasicInstantMessaging.class); // do nothing if (defaultContact == null) { defaultContact = metaContact.getDefaultContact(OperationSetSmsMessaging.class); if (defaultContact == null) return; } ProtocolProviderService defaultProvider = defaultContact.getProtocolProvider(); OperationSetBasicInstantMessaging defaultIM = defaultProvider.getOperationSet(OperationSetBasicInstantMessaging.class); ProtocolProviderService protoContactProvider; OperationSetBasicInstantMessaging protoContactIM; boolean isOfflineMessagingSupported = defaultIM != null && !defaultIM.isOfflineMessagingSupported(); if (defaultContact.getPresenceStatus().getStatus() < 1 && (!isOfflineMessagingSupported || !defaultProvider.isRegistered())) { Iterator<Contact> protoContacts = metaContact.getContacts(); while (protoContacts.hasNext()) { Contact contact = protoContacts.next(); protoContactProvider = contact.getProtocolProvider(); protoContactIM = protoContactProvider.getOperationSet(OperationSetBasicInstantMessaging.class); if (protoContactIM != null && protoContactIM.isOfflineMessagingSupported() && protoContactProvider.isRegistered()) { defaultContact = contact; } } } ContactEventHandler contactHandler = mainFrame.getContactHandler(defaultContact.getProtocolProvider()); contactHandler.contactClicked(defaultContact, evt.getClickCount()); } else if (descriptor.getDescriptor() instanceof SourceContact) { SourceContact contact = (SourceContact) descriptor.getDescriptor(); List<ContactDetail> imDetails = contact.getContactDetails(OperationSetBasicInstantMessaging.class); List<ContactDetail> mucDetails = contact.getContactDetails(OperationSetMultiUserChat.class); if (imDetails != null && imDetails.size() > 0) { ProtocolProviderService pps = imDetails.get(0).getPreferredProtocolProvider(OperationSetBasicInstantMessaging.class); GuiActivator.getUIService() .getChatWindowManager() .startChat(contact.getContactAddress(), pps); } else if (mucDetails != null && mucDetails.size() > 0) { ChatRoomWrapper room = GuiActivator.getMUCService().findChatRoomWrapperFromSourceContact(contact); if (room == null) { // lets check by id ProtocolProviderService pps = mucDetails.get(0).getPreferredProtocolProvider(OperationSetMultiUserChat.class); room = GuiActivator.getMUCService() .findChatRoomWrapperFromChatRoomID(contact.getContactAddress(), pps); if (room == null) { GuiActivator.getMUCService() .createChatRoom( contact.getContactAddress(), pps, new ArrayList<String>(), "", false, false, false); } } if (room != null) GuiActivator.getMUCService().openChatRoom(room); } else { List<ContactDetail> smsDetails = contact.getContactDetails(OperationSetSmsMessaging.class); if (smsDetails != null && smsDetails.size() > 0) { GuiActivator.getUIService() .getChatWindowManager() .startChat(contact.getContactAddress(), true); } } } }