/**
* Process list of event objects. Checks whether message source contact already exist for this
* event object, if yes just update it with the new values (not sure whether we should do this, as
* it may bring old messages) and if status of provider is changed, init its details, updates its
* capabilities. It still adds the found messages source contact to the list of the new contacts,
* as later we will detect this and fire update event. If nothing found a new contact is created.
*
* @param res list of event
* @param cachedRecentMessages list of newly created source contacts or already existed but
* updated with corresponding event object
* @param isStatusChanged whether provider status changed and we are processing
*/
private void processEventObjects(
Collection<EventObject> res,
List<ComparableEvtObj> cachedRecentMessages,
boolean isStatusChanged) {
for (EventObject obj : res) {
ComparableEvtObj oldMsg = findRecentMessage(obj, recentMessages);
if (oldMsg != null) {
oldMsg.update(obj); // update
if (isStatusChanged && recentQuery != null) recentQuery.updateCapabilities(oldMsg, obj);
// we still add it to cachedRecentMessages
// later we will find it is duplicate and will fire
// update event
if (!cachedRecentMessages.contains(oldMsg)) cachedRecentMessages.add(oldMsg);
continue;
}
oldMsg = findRecentMessage(obj, cachedRecentMessages);
if (oldMsg == null) {
oldMsg = new ComparableEvtObj(obj);
if (isStatusChanged && recentQuery != null) recentQuery.updateCapabilities(oldMsg, obj);
cachedRecentMessages.add(oldMsg);
}
}
}
/**
* Adds <tt>WebRtcDataStreamListener</tt> to the list of listeners.
*
* @param listener the <tt>WebRtcDataStreamListener</tt> to be added to the listeners list.
*/
public void addChannelListener(WebRtcDataStreamListener listener) {
if (listener == null) {
throw new NullPointerException("listener");
} else {
synchronized (listeners) {
if (!listeners.contains(listener)) {
listeners.add(listener);
}
}
}
}
/**
* Expires a specific <tt>Content</tt> of this <tt>Conference</tt> (i.e. if the specified
* <tt>content</tt> is not in the list of <tt>Content</tt>s of this <tt>Conference</tt>, does
* nothing).
*
* @param content the <tt>Content</tt> to be expired by this <tt>Conference</tt>
*/
public void expireContent(Content content) {
boolean expireContent;
synchronized (contents) {
if (contents.contains(content)) {
contents.remove(content);
expireContent = true;
} else expireContent = false;
}
if (expireContent) content.expire();
}
/**
* Determines whether a specific format is supported by the <tt>Recorder</tt> represented by this
* <tt>RecordButton</tt>.
*
* @param format the format which is to be checked whether it is supported by the
* <tt>Recorder</tt> represented by this <tt>RecordButton</tt>
* @return <tt>true</tt> if the specified <tt>format</tt> is supported by the <tt>Recorder</tt>
* represented by this <tt>RecordButton</tt>; otherwise, <tt>false</tt>
*/
private boolean isSupportedFormat(String format) {
Recorder recorder;
try {
recorder = getRecorder();
} catch (OperationFailedException ofex) {
logger.error("Failed to get Recorder", ofex);
return false;
}
List<String> supportedFormats = recorder.getSupportedFormats();
return (supportedFormats != null) && supportedFormats.contains(format);
}
/**
* Updates the contact sources in the recent query if any. Done here in order to sync with
* recentMessages instance, and to check for already existing instances of contact sources.
* Normally called from the query.
*/
public void updateRecentMessages() {
if (recentQuery == null) return;
synchronized (recentMessages) {
List<SourceContact> currentContactsInQuery = recentQuery.getQueryResults();
for (ComparableEvtObj evtObj : recentMessages) {
// the contains will use the correct equals method of
// the object evtObj
if (!currentContactsInQuery.contains(evtObj)) {
MessageSourceContact newSourceContact =
new MessageSourceContact(evtObj.getEventObject(), MessageSourceService.this);
newSourceContact.initDetails(evtObj.getEventObject());
recentQuery.addQueryResult(newSourceContact);
}
}
}
}
/**
* Add the ComparableEvtObj, newly added will fire new, for existing fire update and when trimming
* the list to desired length fire remove for those that were removed
*
* @param contactsToAdd
*/
private void addNewRecentMessages(List<ComparableEvtObj> contactsToAdd) {
// now find object to fire new, and object to fire remove
// let us find duplicates and fire update
List<ComparableEvtObj> duplicates = new ArrayList<ComparableEvtObj>();
for (ComparableEvtObj msgToAdd : contactsToAdd) {
if (recentMessages.contains(msgToAdd)) {
duplicates.add(msgToAdd);
// save update
updateRecentMessageToHistory(msgToAdd);
}
}
recentMessages.removeAll(duplicates);
// now contacts to add has no duplicates, add them all
boolean changed = recentMessages.addAll(contactsToAdd);
if (changed) {
Collections.sort(recentMessages);
if (recentQuery != null) {
for (ComparableEvtObj obj : duplicates)
recentQuery.updateContact(obj, obj.getEventObject());
}
}
if (!recentMessages.isEmpty())
oldestRecentMessage = recentMessages.get(recentMessages.size() - 1).getTimestamp();
// trim
List<ComparableEvtObj> removedItems = null;
if (recentMessages.size() > numberOfMessages) {
removedItems =
new ArrayList<ComparableEvtObj>(
recentMessages.subList(numberOfMessages, recentMessages.size()));
recentMessages.removeAll(removedItems);
}
if (recentQuery != null) {
// now fire, removed for all that were in the list
// and now are removed after trim
if (removedItems != null) {
for (ComparableEvtObj msc : removedItems) {
if (!contactsToAdd.contains(msc)) recentQuery.fireContactRemoved(msc);
}
}
// fire new for all that were added, and not removed after trim
for (ComparableEvtObj msc : contactsToAdd) {
if ((removedItems == null || !removedItems.contains(msc)) && !duplicates.contains(msc)) {
MessageSourceContact newSourceContact =
new MessageSourceContact(msc.getEventObject(), MessageSourceService.this);
newSourceContact.initDetails(msc.getEventObject());
recentQuery.addQueryResult(newSourceContact);
}
}
// if recent messages were changed, indexes have change lets
// fire event for the last element which will reorder the whole
// group if needed.
if (changed) recentQuery.fireContactChanged(recentMessages.get(recentMessages.size() - 1));
}
}
/**
* Adds a specific <tt>UserCapsNodeListener</tt> to the list of <tt>UserCapsNodeListener</tt>s
* interested in events notifying about changes in the list of user caps nodes of this
* <tt>EntityCapsManager</tt>.
*
* @param listener the <tt>UserCapsNodeListener</tt> which is interested in events notifying about
* changes in the list of user caps nodes of this <tt>EntityCapsManager</tt>
*/
public void addUserCapsNodeListener(UserCapsNodeListener listener) {
if (listener == null) throw new NullPointerException("listener");
synchronized (userCapsNodeListeners) {
if (!userCapsNodeListeners.contains(listener)) userCapsNodeListeners.add(listener);
}
}
