/*******************************************************************************
* Copyright (c) 2004 Composent, Inc. and others. All rights reserved. This
* program and the accompanying materials are made available under the terms of
* the Eclipse Public License v1.0 which accompanies this distribution, and is
* available at http://www.eclipse.org/legal/epl-v10.html
*
* Contributors: Composent, Inc. - initial API and implementation
******************************************************************************/
package org.eclipse.ecf.internal.provider.xmpp;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.WeakHashMap;
import org.eclipse.core.runtime.IAdapterManager;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.ecf.core.identity.ID;
import org.eclipse.ecf.core.identity.IDFactory;
import org.eclipse.ecf.core.sharedobject.ISharedObject;
import org.eclipse.ecf.core.sharedobject.ISharedObjectConfig;
import org.eclipse.ecf.core.sharedobject.ISharedObjectContext;
import org.eclipse.ecf.core.sharedobject.SharedObjectInitException;
import org.eclipse.ecf.core.sharedobject.events.ISharedObjectActivatedEvent;
import org.eclipse.ecf.core.sharedobject.events.ISharedObjectMessageEvent;
import org.eclipse.ecf.core.sharedobject.events.ISharedObjectMessageListener;
import org.eclipse.ecf.core.user.IUser;
import org.eclipse.ecf.core.user.User;
import org.eclipse.ecf.core.util.ECFException;
import org.eclipse.ecf.core.util.Event;
import org.eclipse.ecf.internal.provider.xmpp.events.IQEvent;
import org.eclipse.ecf.internal.provider.xmpp.events.MessageEvent;
import org.eclipse.ecf.internal.provider.xmpp.events.PresenceEvent;
import org.eclipse.ecf.internal.provider.xmpp.smack.ECFConnection;
import org.eclipse.ecf.presence.IPresence;
import org.eclipse.ecf.presence.IPresenceListener;
import org.eclipse.ecf.presence.IPresenceSender;
import org.eclipse.ecf.presence.im.IChatManager;
import org.eclipse.ecf.presence.im.ITypingMessage;
import org.eclipse.ecf.presence.im.TypingMessage;
import org.eclipse.ecf.presence.roster.AbstractRosterManager;
import org.eclipse.ecf.presence.roster.IRosterEntry;
import org.eclipse.ecf.presence.roster.IRosterGroup;
import org.eclipse.ecf.presence.roster.IRosterItem;
import org.eclipse.ecf.presence.roster.IRosterManager;
import org.eclipse.ecf.presence.roster.IRosterSubscriptionSender;
import org.eclipse.ecf.presence.roster.RosterGroup;
import org.eclipse.ecf.provider.xmpp.XMPPContainer;
import org.eclipse.ecf.provider.xmpp.identity.XMPPID;
import org.eclipse.ecf.provider.xmpp.identity.XMPPRoomID;
import org.eclipse.equinox.concurrent.future.IFuture;
import org.eclipse.equinox.concurrent.future.IProgressRunnable;
import org.eclipse.equinox.concurrent.future.ThreadsExecutor;
import org.jivesoftware.smack.Roster;
import org.jivesoftware.smack.RosterEntry;
import org.jivesoftware.smack.XMPPException;
import org.jivesoftware.smack.packet.IQ;
import org.jivesoftware.smack.packet.Message;
import org.jivesoftware.smack.packet.Presence;
import org.jivesoftware.smack.packet.Presence.Mode;
import org.jivesoftware.smack.packet.Presence.Type;
import org.jivesoftware.smack.packet.RosterPacket;
import org.jivesoftware.smackx.packet.VCard;
public class XMPPContainerPresenceHelper implements ISharedObject {
public static final String VCARD = "vcard";
public static final String VCARD_EMAIL = VCARD + ".email";
public static final String VCARD_EMAIL_HOME = VCARD_EMAIL + ".home";
public static final String VCARD_EMAIL_WORK = VCARD_EMAIL + ".work";
public static final String VCARD_NAME = VCARD + ".name";
public static final String VCARD_NAME_FIRST = VCARD_NAME + ".first";
public static final String VCARD_NAME_MIDDLE = VCARD_NAME + ".middle";
public static final String VCARD_NAME_LAST = VCARD_NAME + ".last";
public static final String VCARD_NAME_NICK = VCARD_NAME + ".nick";
public static final String VCARD_PHONE = VCARD + ".phone";
public static final String VCARD_PHONE_HOME = VCARD_PHONE + ".home";
public static final String VCARD_PHONE_HOME_VOICE = VCARD_PHONE_HOME
+ ".voice";
public static final String VCARD_PHONE_HOME_CELL = VCARD_PHONE_HOME
+ ".cell";
public static final String VCARD_PHONE_WORK = VCARD_PHONE + ".work";
public static final String VCARD_PHONE_WORK_VOICE = VCARD_PHONE_WORK
+ ".voice";
public static final String VCARD_PHONE_WORK_CELL = VCARD_PHONE_WORK
+ ".cell";
private ISharedObjectConfig config = null;
private final List sharedObjectMessageListeners = new ArrayList();
private XMPPContainer container = null;
private XMPPChatManager chatManager = null;
private final List presenceListeners = new ArrayList();
public XMPPContainerPresenceHelper(XMPPContainer container) {
this.container = container;
chatManager = new XMPPChatManager(this);
roster = new org.eclipse.ecf.presence.roster.Roster(container);
rosterManager = new PresenceRosterManager(roster);
}
// ISharedObject implementation
/*
* (non-Javadoc)
*
* @seeorg.eclipse.ecf.core.ISharedObject#init(org.eclipse.ecf.core.
* ISharedObjectConfig)
*/
public void init(ISharedObjectConfig initData)
throws SharedObjectInitException {
this.config = initData;
}
/*
* (non-Javadoc)
*
* @see
* org.eclipse.ecf.core.ISharedObject#handleEvent(org.eclipse.ecf.core.util
* .Event)
*/
public void handleEvent(Event event) {
trace("handleEvent(" + event + ")");
if (event instanceof ISharedObjectActivatedEvent) {
} else if (event instanceof IQEvent) {
handleIQEvent((IQEvent) event);
} else if (event instanceof MessageEvent) {
handleMessageEvent((MessageEvent) event);
} else if (event instanceof PresenceEvent) {
handlePresenceEvent((PresenceEvent) event);
} else if (event instanceof ISharedObjectMessageEvent) {
handleSharedObjectMessageEvent((ISharedObjectMessageEvent) event);
} else {
trace("unhandled event=" + event);
}
}
/*
* (non-Javadoc)
*
* @see
* org.eclipse.ecf.core.ISharedObject#handleEvents(org.eclipse.ecf.core.
* util.Event[])
*/
public void handleEvents(Event[] events) {
for (int i = 0; i < events.length; i++) {
handleEvent(events[i]);
}
}
public void disconnect() {
rosterManager.disconnect();
chatManager.disconnect();
synchronized (sharedObjectMessageListeners) {
sharedObjectMessageListeners.clear();
}
synchronized (presenceListeners) {
presenceListeners.clear();
}
vcardCache.clear();
}
/*
* (non-Javadoc)
*
* @see
* org.eclipse.ecf.core.ISharedObject#dispose(org.eclipse.ecf.core.identity
* .ID)
*/
public void dispose(ID containerID) {
vcardCache.clear();
}
/*
* (non-Javadoc)
*
* @see org.eclipse.ecf.core.ISharedObject#getAdapter(java.lang.Class)
*/
public Object getAdapter(Class adapter) {
if (adapter == null)
return null;
if (adapter.isInstance(this))
return this;
final IAdapterManager adapterManager = XmppPlugin.getDefault()
.getAdapterManager();
return (adapterManager == null) ? null : adapterManager.loadAdapter(
this, adapter.getName());
}
// end ISharedObject implementation
protected org.eclipse.ecf.presence.roster.Roster roster;
protected PresenceRosterManager rosterManager;
class PresenceRosterManager extends AbstractRosterManager {
public PresenceRosterManager(
org.eclipse.ecf.presence.roster.Roster roster) {
super(roster);
}
public void notifySubscriptionListener(ID fromID, IPresence presence) {
this.fireSubscriptionListener(fromID, presence.getType());
}
public void notifyRosterUpdate(IRosterItem changedItem) {
fireRosterUpdate(changedItem);
}
public void notifyRosterAdd(IRosterEntry entry) {
fireRosterAdd(entry);
}
public void notifyRosterRemove(IRosterEntry entry) {
fireRosterRemove(entry);
}
public void disconnect() {
getRoster().getItems().clear();
super.disconnect();
fireRosterUpdate(roster);
}
public void setUser(IUser user) {
final org.eclipse.ecf.presence.roster.Roster roster = (org.eclipse.ecf.presence.roster.Roster) getRoster();
roster.setUser(user);
notifyRosterUpdate(roster);
}
org.eclipse.ecf.presence.IPresenceSender rosterPresenceSender = new org.eclipse.ecf.presence.IPresenceSender() {
public void sendPresenceUpdate(ID toID,
org.eclipse.ecf.presence.IPresence presence)
throws ECFException {
try {
getConnectionOrThrowIfNull().sendPresenceUpdate(toID,
createPresence(presence));
} catch (final IOException e) {
traceAndThrowECFException("sendPresenceUpdate", e);
}
}
};
/*
* (non-Javadoc)
*
* @see
* org.eclipse.ecf.presence.roster.AbstractRosterManager#getPresenceSender
* ()
*/
public IPresenceSender getPresenceSender() {
return rosterPresenceSender;
}
org.eclipse.ecf.presence.roster.IRosterSubscriptionSender rosterSubscriptionSender = new org.eclipse.ecf.presence.roster.IRosterSubscriptionSender() {
/*
* (non-Javadoc)
*
* @seeorg.eclipse.ecf.presence.roster.IRosterSubscriptionSender#
* sendRosterAdd(java.lang.String, java.lang.String,
* java.lang.String[])
*/
public void sendRosterAdd(String user, String name, String[] groups)
throws ECFException {
try {
getConnectionOrThrowIfNull().sendRosterAdd(user, name,
groups);
} catch (final Exception e) {
traceAndThrowECFException("sendRosterAdd", e);
}
}
/*
* (non-Javadoc)
*
* @seeorg.eclipse.ecf.presence.roster.IRosterSubscriptionSender#
* sendRosterRemove(org.eclipse.ecf.core.identity.ID)
*/
public void sendRosterRemove(ID userID) throws ECFException {
try {
if (!(userID instanceof XMPPID))
throw new ECFException("invalid userID");
final XMPPID xmppID = (XMPPID) userID;
getConnectionOrThrowIfNull().sendRosterRemove(
xmppID.getUsernameAtHost());
} catch (final Exception e) {
traceAndThrowECFException("sendRosterRemove", e);
}
}
};
/*
* (non-Javadoc)
*
* @seeorg.eclipse.ecf.presence.roster.AbstractRosterManager#
* getRosterSubscriptionSender()
*/
public IRosterSubscriptionSender getRosterSubscriptionSender() {
return rosterSubscriptionSender;
}
/*
* (non-Javadoc)
*
* @see
* org.eclipse.ecf.presence.roster.IRosterManager#addPresenceListener
* (org.eclipse.ecf.presence.roster.IPresenceListener)
*/
public void addPresenceListener(IPresenceListener listener) {
synchronized (presenceListeners) {
presenceListeners.add(listener);
}
}
/*
* (non-Javadoc)
*
* @see
* org.eclipse.ecf.presence.roster.IRosterManager#removePresenceListener
* (org.eclipse.ecf.presence.roster.IPresenceListener)
*/
public void removePresenceListener(IPresenceListener listener) {
synchronized (presenceListeners) {
presenceListeners.remove(listener);
}
}
}
/**
* @return IRosterManager roster manager. Will not return <code>null</code>.
*/
public IRosterManager getRosterManager() {
return rosterManager;
}
/**
* @param user
* set the user for this presence helper.
*/
public void setUser(IUser user) {
rosterManager.setUser(user);
}
protected void addSharedObjectMessageListener(
ISharedObjectMessageListener listener) {
synchronized (sharedObjectMessageListeners) {
sharedObjectMessageListeners.add(listener);
}
}
protected void sendTypingMessage(ID toID, boolean isTyping, String body)
throws IOException {
getContext().sendMessage(
toID,
new TypingMessage(rosterManager.getRoster().getUser().getID(),
isTyping, body));
}
protected void handleSharedObjectMessageEvent(
ISharedObjectMessageEvent event) {
List toNotify = null;
synchronized (sharedObjectMessageListeners) {
toNotify = new ArrayList(sharedObjectMessageListeners);
}
for (final Iterator i = toNotify.iterator(); i.hasNext();) {
final ISharedObjectMessageListener l = (ISharedObjectMessageListener) i
.next();
l.handleSharedObjectMessage(event);
}
final Object data = event.getData();
if (data instanceof ITypingMessage) {
final ITypingMessage tmess = (ITypingMessage) data;
chatManager.fireTypingMessage(tmess.getFromID(), tmess);
}
}
protected void removeSharedObjectMessageListener(
ISharedObjectMessageListener listener) {
synchronized (sharedObjectMessageListeners) {
sharedObjectMessageListeners.remove(listener);
}
}
private boolean replace(IRosterItem i1, IRosterItem i2) {
if (i1 instanceof IRosterEntry) {
IRosterEntry re1 = (IRosterEntry) i1;
if (!(i2 instanceof IRosterEntry))
return false;
IRosterEntry re2 = (IRosterEntry) i2;
XMPPID id1 = (XMPPID) re1.getUser().getID();
XMPPID id2 = (XMPPID) re2.getUser().getID();
String jid1 = id1.getUsernameAtHost();
String jid2 = id2.getUsernameAtHost();
if (jid1.equals(jid2)) {
String r1 = id1.getResourceName();
String r2 = id2.getResourceName();
if (r1 == null && r2 != null)
return true;
}
}
return false;
}
private void addUnique(Collection existingItems, IRosterItem newItem) {
List toAdd = new ArrayList();
if (existingItems.size() == 0)
toAdd.add(newItem);
else {
boolean addNewItem = true;
for (Iterator i = existingItems.iterator(); i.hasNext();) {
IRosterItem existing = (IRosterItem) i.next();
// If the same then we don't add it
if (existing.equals(newItem))
addNewItem = false;
// else if the new item should replace the existing then remove
if (replace(existing, newItem))
i.remove();
}
if (addNewItem)
toAdd.add(newItem);
}
for (Iterator i = toAdd.iterator(); i.hasNext();)
existingItems.add(i.next());
}
private void addUniqueToRoster(IRosterItem[] newItems) {
Collection existingItems = roster.getItems();
synchronized (existingItems) {
for (int i = 0; i < newItems.length; i++)
addUnique(existingItems, newItems[i]);
}
rosterManager.notifyRosterUpdate(roster);
}
protected ISharedObjectContext getContext() {
return config.getContext();
}
protected String getUserNameFromXMPPAddress(XMPPID userID) {
return userID.getUsername();
}
protected IRosterEntry createRosterEntry(RosterEntry entry) {
XMPPID xmppid = createIDFromName(entry.getUser());
return createRosterEntry(xmppid, getEntryName(xmppid, entry.getName()),
entry.getGroups().iterator());
}
private String getEntryName(XMPPID xmppid, String entryName) {
return (entryName == null) ? xmppid.getUsername() : XMPPID
.unfixEscapeInNode(entryName);
}
protected IRosterEntry createRosterEntry(XMPPID xmppid,
RosterPacket.Item entry) {
return createRosterEntry(xmppid, getEntryName(xmppid, entry.getName()),
entry.getGroupNames().iterator());
}
protected void handleIQEvent(IQEvent evt) {
final IQ iq = evt.getIQ();
if (iq instanceof RosterPacket) {
// Roster packet...report to UI
final RosterPacket rosterPacket = (RosterPacket) iq;
if (rosterPacket.getType() == IQ.Type.SET
|| rosterPacket.getType() == IQ.Type.RESULT) {
for (final Iterator i = rosterPacket.getRosterItems()
.iterator(); i.hasNext();) {
final RosterPacket.Item item = (RosterPacket.Item) i.next();
final RosterPacket.ItemType itemType = item.getItemType();
XMPPID newID = createIDFromName(item.getUser());
boolean remove = false;
if (itemType == RosterPacket.ItemType.none
|| itemType == RosterPacket.ItemType.remove) {
removeItemFromRoster(roster.getItems(),
createIDFromName(item.getUser()));
remove = true;
} else {
remove = false;
addUniqueToRoster(createRosterEntries(newID, item));
}
// In both cases fire set roster entry
fireSetRosterEntry(remove, createRosterEntry(newID, item));
}
}
} else {
trace("Received non rosterpacket IQ message");
}
}
protected void fireSetRosterEntry(boolean remove, IRosterEntry entry) {
if (remove)
rosterManager.notifyRosterRemove(entry);
else
rosterManager.notifyRosterAdd(entry);
}
private void removeItemFromRoster(Collection rosterItems,
XMPPID itemIDToRemove) {
boolean removed = false;
synchronized (rosterItems) {
for (final Iterator i = rosterItems.iterator(); i.hasNext();) {
final IRosterItem item = (IRosterItem) i.next();
if (item instanceof org.eclipse.ecf.presence.roster.RosterGroup) {
final org.eclipse.ecf.presence.roster.RosterGroup group = (org.eclipse.ecf.presence.roster.RosterGroup) item;
removed = removeItemFromRosterGroup(group, itemIDToRemove);
// If group is empty, remove it too
if (group.getEntries().size() == 0)
i.remove();
} else if (item instanceof org.eclipse.ecf.presence.roster.RosterEntry) {
if (((org.eclipse.ecf.presence.roster.RosterEntry) item)
.getUser().getID().equals(itemIDToRemove)) {
i.remove();
removed = true;
}
}
}
}
if (removed)
rosterManager.notifyRosterUpdate(roster);
}
private boolean removeItemFromRosterGroup(
org.eclipse.ecf.presence.roster.RosterGroup group,
XMPPID itemIDToRemove) {
final Collection groupEntries = group.getEntries();
synchronized (groupEntries) {
for (final Iterator i = group.getEntries().iterator(); i.hasNext();) {
final org.eclipse.ecf.presence.roster.RosterEntry entry = (org.eclipse.ecf.presence.roster.RosterEntry) i
.next();
if (entry.getUser().getID().equals(itemIDToRemove)) {
i.remove();
return true;
}
}
}
return false;
}
protected void handleMessageEvent(MessageEvent evt) {
Message msg = evt.getMessage();
final String from = msg.getFrom();
final String body = msg.getBody();
final String subject = msg.getSubject();
final ID fromID = createIDFromName(from);
final ID threadID = createThreadID(msg.getThread());
msg = filterMessageType(msg);
if (msg != null) {
if (msg.getExtension("composing", //$NON-NLS-1$
"http://jabber.org/protocol/chatstates") != null) { //$NON-NLS-1$
chatManager.fireTypingMessage(fromID, new TypingMessage(fromID,
true, body));
} else if (msg.getExtension("paused", //$NON-NLS-1$
"http://jabber.org/protocol/chatstates") != null) { //$NON-NLS-1$
chatManager.fireTypingMessage(fromID, new TypingMessage(fromID,
false, body));
} else {
final Iterator xhtmlbodies = evt.getXHTMLBodies();
if (xhtmlbodies != null) {
final List xhtmlbodylist = new ArrayList();
for (; xhtmlbodies.hasNext();)
xhtmlbodylist.add(xhtmlbodies.next());
chatManager.fireXHTMLChatMessage(fromID, threadID,
msg.getType(), subject, body,
ECFConnection.getPropertiesFromPacket(msg),
xhtmlbodylist);
} else if (body != null) {
chatManager.fireChatMessage(fromID, threadID,
msg.getType(), subject, body,
ECFConnection.getPropertiesFromPacket(msg));
}
}
}
}
protected void handlePresenceEvent(PresenceEvent evt) {
final Presence xmppPresence = evt.getPresence();
final String from = xmppPresence.getFrom();
final IPresence newPresence = createIPresence(xmppPresence);
final XMPPID fromID = createIDFromName(from);
if (newPresence.getType().equals(IPresence.Type.SUBSCRIBE)
|| newPresence.getType().equals(IPresence.Type.UNSUBSCRIBE)
|| newPresence.getType().equals(IPresence.Type.SUBSCRIBED)
|| newPresence.getType().equals(IPresence.Type.UNSUBSCRIBED)) {
rosterManager.notifySubscriptionListener(fromID, newPresence);
} else {
updatePresence(fromID, newPresence);
firePresenceListeners(fromID, newPresence);
}
}
private void firePresenceListeners(ID fromID, IPresence presence) {
List toNotify = null;
synchronized (presenceListeners) {
toNotify = new ArrayList(presenceListeners);
}
for (final Iterator i = toNotify.iterator(); i.hasNext();) {
final IPresenceListener l = (IPresenceListener) i.next();
l.handlePresence(fromID, presence);
}
}
private void updatePresence(XMPPID fromID, IPresence newPresence) {
final Collection rosterItems = roster.getItems();
List newEntrys = new ArrayList();
synchronized (rosterItems) {
for (final Iterator i = roster.getItems().iterator(); i.hasNext();) {
final IRosterItem item = (IRosterItem) i.next();
if (item instanceof IRosterGroup) {
AdditionalClientRosterEntry[] es = updatePresenceInGroup(
(IRosterGroup) item, fromID, newPresence);
for (int j = 0; j < es.length; j++) {
newEntrys.add(es[j]);
}
} else if (item instanceof org.eclipse.ecf.presence.roster.RosterEntry) {
AdditionalClientRosterEntry entry = updatePresenceForMatchingEntry(
(org.eclipse.ecf.presence.roster.RosterEntry) item,
fromID, newPresence);
if (entry != null)
newEntrys.add(entry);
}
}
}
AdditionalClientRosterEntry[] entrys = (AdditionalClientRosterEntry[]) newEntrys
.toArray(new AdditionalClientRosterEntry[] {});
if (entrys.length > 0) {
for (int i = 0; i < entrys.length; i++) {
if (entrys[i].add) {
IRosterEntry entry = new org.eclipse.ecf.presence.roster.RosterEntry(
entrys[i].parent, entrys[i].user,
entrys[i].presence);
addUniqueToRoster(new IRosterItem[] { entry });
fireSetRosterEntry(false, entry);
} else {
removeItemFromRoster(rosterItems, fromID);
}
}
}
}
class AdditionalClientRosterEntry {
IRosterItem parent;
IUser user;
IPresence presence;
boolean add;
public AdditionalClientRosterEntry(IRosterItem parent, IUser user,
IPresence presence) {
this.parent = parent;
this.user = user;
this.presence = presence;
this.add = true;
}
public AdditionalClientRosterEntry(IUser user) {
this.user = user;
this.add = false;
}
}
private int countClientsInRosterGroup(
org.eclipse.ecf.presence.roster.RosterGroup group, XMPPID oldID) {
Collection groupItems = group.getEntries();
int count = 0;
for (final Iterator i = groupItems.iterator(); i.hasNext();) {
final IRosterItem item = (IRosterItem) i.next();
if (item instanceof org.eclipse.ecf.presence.roster.RosterEntry) {
org.eclipse.ecf.presence.roster.RosterEntry entry = (org.eclipse.ecf.presence.roster.RosterEntry) item;
XMPPID entryID = (XMPPID) entry.getUser().getID();
if (entryID.getUsernameAtHost().equals(
oldID.getUsernameAtHost()))
count++;
}
}
return count;
}
private int countClientsInRoster(XMPPID oldID) {
Collection rosterItems = roster.getItems();
int count = 0;
synchronized (rosterItems) {
for (final Iterator i = rosterItems.iterator(); i.hasNext();) {
final IRosterItem item = (IRosterItem) i.next();
if (item instanceof org.eclipse.ecf.presence.roster.RosterGroup) {
final org.eclipse.ecf.presence.roster.RosterGroup group = (org.eclipse.ecf.presence.roster.RosterGroup) item;
count += countClientsInRosterGroup(group, oldID);
} else if (item instanceof org.eclipse.ecf.presence.roster.RosterEntry) {
org.eclipse.ecf.presence.roster.RosterEntry entry = (org.eclipse.ecf.presence.roster.RosterEntry) item;
XMPPID entryID = (XMPPID) entry.getUser().getID();
if (entryID.getUsernameAtHost().equals(
oldID.getUsernameAtHost())) {
count++;
}
}
}
}
return count;
}
private AdditionalClientRosterEntry removeEntryFromRoster(XMPPID oldID,
org.eclipse.ecf.presence.roster.RosterEntry entry,
IPresence newPresence, IUser user) {
if (countClientsInRoster(oldID) > 1) {
// remove this client from roster
return new AdditionalClientRosterEntry(user);
} else {
// Last one, so we set resource to null and set presence to
// unavailable
oldID.setResourceName(null);
entry.setPresence(newPresence);
rosterManager.notifyRosterUpdate(entry);
return null;
}
}
private AdditionalClientRosterEntry updatePresenceForMatchingEntry(
org.eclipse.ecf.presence.roster.RosterEntry entry, XMPPID fromID,
IPresence newPresence) {
final IUser user = entry.getUser();
XMPPID oldID = (XMPPID) user.getID();
// If the username/host part matches that means we either have to update
// the resource, or create a new client
if (oldID.equals(fromID)) {
if (newPresence.getType() == IPresence.Type.UNAVAILABLE) {
return removeEntryFromRoster(oldID, entry, newPresence, user);
} else {
// set the new presence state
entry.setPresence(newPresence);
// and notify with roster update
rosterManager.notifyRosterUpdate(entry);
}
} else if (oldID.getUsernameAtHost().equals(fromID.getUsernameAtHost())) {
if (oldID.getResourceName() == null) {
oldID.setResourceName(fromID.getResourceName());
// set the new presence state
entry.setPresence(newPresence);
// and notify with roster update
rosterManager.notifyRosterUpdate(entry);
} else if (fromID.getResourceName() != null
&& !newPresence.getType()
.equals(IPresence.Type.UNAVAILABLE)) {
return new AdditionalClientRosterEntry(entry.getParent(),
new User(fromID, user.getName()), newPresence);
}
}
return null;
}
private AdditionalClientRosterEntry[] updatePresenceInGroup(
IRosterGroup group, XMPPID fromID, IPresence newPresence) {
List results = new ArrayList();
final Collection groupEntries = group.getEntries();
synchronized (groupEntries) {
for (final Iterator i = group.getEntries().iterator(); i.hasNext();) {
AdditionalClientRosterEntry newEntry = updatePresenceForMatchingEntry(
(org.eclipse.ecf.presence.roster.RosterEntry) i.next(),
fromID, newPresence);
if (newEntry != null)
results.add(newEntry);
}
}
return (AdditionalClientRosterEntry[]) results
.toArray(new AdditionalClientRosterEntry[] {});
}
protected void handleRoster(Roster roster) {
for (final Iterator i = roster.getEntries().iterator(); i.hasNext();) {
final IRosterItem[] items = createRosterEntries((RosterEntry) i
.next());
for (int j = 0; j < items.length; j++) {
this.roster.addItem(items[j]);
}
}
rosterManager.notifyRosterUpdate(this.roster);
}
protected XMPPID createIDFromName(String uname) {
try {
if (uname.lastIndexOf('@') == -1) {
return new XMPPID(container.getConnectNamespace(), "admin"
+ "@" + uname);
}
return new XMPPID(container.getConnectNamespace(), uname);
} catch (final Exception e) {
traceStack("Exception in createIDFromName", e);
return null;
}
}
protected ID createThreadID(String thread) {
try {
if (thread == null || thread.equals(""))
return null;
return IDFactory.getDefault().createStringID(thread);
} catch (final Exception e) {
traceStack("Exception in createThreadID", e);
return null;
}
}
private final Map vcardCache = new WeakHashMap();
private VCard getFromCache(String id) {
if (id == null)
return null;
return (VCard) vcardCache.get(id);
}
private void addToCache(String id, VCard card) {
vcardCache.put(id, card);
}
private VCard getVCardForPresence(Presence xmppPresence) {
VCard result = null;
if (xmppPresence.getExtension("x", "vcard-temp:x:update") != null) {
final String from = xmppPresence.getFrom();
result = getFromCache(from);
if (result == null && from != null) {
result = new VCard();
try {
result.load(container.getXMPPConnection(), from);
addToCache(from, result);
} catch (final XMPPException e) {
traceStack("vcard loading exception", e);
}
}
}
return result;
}
private Map addVCardProperties(VCard vcard, Map props) {
if (vcard == null)
return props;
final String emailHome = vcard.getEmailHome();
if (emailHome != null && !emailHome.equals(""))
props.put(VCARD_EMAIL_HOME, emailHome);
final String emailWork = vcard.getEmailWork();
if (emailWork != null && !emailWork.equals(""))
props.put(VCARD_EMAIL_WORK, emailWork);
final String firstName = vcard.getFirstName();
if (firstName != null && !firstName.equals(""))
props.put(VCARD_NAME_FIRST, firstName);
final String middleName = vcard.getMiddleName();
if (middleName != null && !middleName.equals(""))
props.put(VCARD_NAME_MIDDLE, middleName);
final String lastName = vcard.getLastName();
if (lastName != null && !lastName.equals(""))
props.put(VCARD_NAME_LAST, lastName);
final String nickName = vcard.getNickName();
if (nickName != null && !nickName.equals(""))
props.put(VCARD_NAME_NICK, nickName);
final String phoneHomeVoice = vcard.getPhoneHome("VOICE");
if (phoneHomeVoice != null && !phoneHomeVoice.equals(""))
props.put(VCARD_PHONE_HOME_VOICE, phoneHomeVoice);
final String phoneHomeCell = vcard.getPhoneHome("CELL");
if (phoneHomeCell != null && !phoneHomeCell.equals(""))
props.put(VCARD_PHONE_HOME_CELL, phoneHomeCell);
final String phoneWorkVoice = vcard.getPhoneWork("VOICE");
if (phoneWorkVoice != null && !phoneWorkVoice.equals(""))
props.put(VCARD_PHONE_WORK_VOICE, phoneWorkVoice);
final String phoneWorkCell = vcard.getPhoneWork("CELL");
if (phoneWorkCell != null && !phoneWorkCell.equals(""))
props.put(VCARD_PHONE_WORK_CELL, phoneWorkCell);
return props;
}
class XMPPPresence extends org.eclipse.ecf.presence.Presence {
private static final long serialVersionUID = 7843634971520771692L;
IFuture asyncResult = null;
String fromID = null;
XMPPPresence(String fromID, Presence xmppPresence, IFuture future) {
super(createIPresenceType(xmppPresence), xmppPresence.getStatus(),
createIPresenceMode(xmppPresence), ECFConnection
.getPropertiesFromPacket(xmppPresence), null);
this.fromID = fromID;
}
private void fillFromVCard() {
VCard card = getFromCache(fromID);
if (card == null && asyncResult != null) {
try {
card = (VCard) asyncResult.get();
asyncResult = null;
} catch (final Exception e) {
}
}
if (card != null) {
addToCache(fromID, card);
final byte[] bytes = card.getAvatar();
this.pictureData = (bytes == null) ? new byte[0] : bytes;
this.properties = addVCardProperties(card, this.properties);
}
}
/*
* (non-Javadoc)
*
* @see org.eclipse.ecf.presence.Presence#getPictureData()
*/
public byte[] getPictureData() {
fillFromVCard();
return this.pictureData;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.ecf.presence.Presence#getProperties()
*/
public Map getProperties() {
fillFromVCard();
return this.properties;
}
}
protected IPresence createIPresence(final Presence xmppPresence) {
final IFuture asyncResult = new ThreadsExecutor().execute(
new IProgressRunnable() {
public Object run(IProgressMonitor monitor)
throws Exception {
return getVCardForPresence(xmppPresence);
}
}, null);
return new XMPPPresence(xmppPresence.getFrom(), xmppPresence,
asyncResult);
}
protected Presence createPresence(IPresence ipresence) {
final Presence newPresence = new Presence(
createPresenceType(ipresence), ipresence.getStatus(), 0,
createPresenceMode(ipresence));
ECFConnection.setPropertiesInPacket(newPresence,
ipresence.getProperties());
return newPresence;
}
protected IPresence.Mode createIPresenceMode(Presence xmppPresence) {
if (xmppPresence == null)
return IPresence.Mode.AVAILABLE;
final Mode mode = xmppPresence.getMode();
if (mode == Presence.Mode.available) {
return IPresence.Mode.AVAILABLE;
} else if (mode == Presence.Mode.away) {
return IPresence.Mode.AWAY;
} else if (mode == Presence.Mode.chat) {
return IPresence.Mode.CHAT;
} else if (mode == Presence.Mode.dnd) {
return IPresence.Mode.DND;
} else if (mode == Presence.Mode.xa) {
return IPresence.Mode.EXTENDED_AWAY;
} /*
* else if (mode == Presence.Mode.INVISIBLE) { return
* IPresence.Mode.INVISIBLE; }
*/
return IPresence.Mode.AVAILABLE;
}
protected Presence.Mode createPresenceMode(IPresence ipresence) {
if (ipresence == null)
return Presence.Mode.available;
final IPresence.Mode mode = ipresence.getMode();
if (mode == IPresence.Mode.AVAILABLE) {
return Presence.Mode.available;
} else if (mode == IPresence.Mode.AWAY) {
return Presence.Mode.away;
} else if (mode == IPresence.Mode.CHAT) {
return Presence.Mode.chat;
} else if (mode == IPresence.Mode.DND) {
return Presence.Mode.dnd;
} else if (mode == IPresence.Mode.EXTENDED_AWAY) {
return Presence.Mode.xa;
} /*
* else if (mode == IPresence.Mode.INVISIBLE) { return
* Presence.Mode.INVISIBLE; }
*/
return Presence.Mode.available;
}
protected IPresence.Type createIPresenceType(Presence xmppPresence) {
if (xmppPresence == null)
return IPresence.Type.AVAILABLE;
final Type type = xmppPresence.getType();
if (type == Presence.Type.available) {
return IPresence.Type.AVAILABLE;
} else if (type == Presence.Type.error) {
return IPresence.Type.ERROR;
} else if (type == Presence.Type.subscribe) {
return IPresence.Type.SUBSCRIBE;
} else if (type == Presence.Type.subscribed) {
return IPresence.Type.SUBSCRIBED;
} else if (type == Presence.Type.unsubscribe) {
return IPresence.Type.UNSUBSCRIBE;
} else if (type == Presence.Type.unsubscribed) {
return IPresence.Type.UNSUBSCRIBED;
} else if (type == Presence.Type.unavailable) {
return IPresence.Type.UNAVAILABLE;
}
return IPresence.Type.AVAILABLE;
}
protected Presence.Type createPresenceType(IPresence ipresence) {
if (ipresence == null)
return Presence.Type.available;
final IPresence.Type type = ipresence.getType();
if (type == IPresence.Type.AVAILABLE) {
return Presence.Type.available;
} else if (type == IPresence.Type.ERROR) {
return Presence.Type.error;
} else if (type == IPresence.Type.SUBSCRIBE) {
return Presence.Type.subscribe;
} else if (type == IPresence.Type.SUBSCRIBED) {
return Presence.Type.subscribed;
} else if (type == IPresence.Type.UNSUBSCRIBE) {
return Presence.Type.unsubscribe;
} else if (type == IPresence.Type.UNSUBSCRIBED) {
return Presence.Type.unsubscribed;
} else if (type == IPresence.Type.UNAVAILABLE) {
return Presence.Type.unavailable;
}
return Presence.Type.available;
}
protected IRosterItem[] createRosterEntries(RosterEntry entry) {
final XMPPID xmppid = createIDFromName(entry.getUser());
final String name = entry.getName();
final User newUser = (name == null) ? new User(xmppid,
xmppid.getUsername()) : new User(xmppid,
XMPPID.unfixEscapeInNode(name));
return createRosterEntries(entry.getGroups().iterator(), roster,
newUser);
}
private IRosterItem[] createRosterEntries(Iterator grps,
IRosterItem parent, IUser user) {
final List result = new ArrayList();
if (grps.hasNext()) {
for (; grps.hasNext();) {
final Object o = grps.next();
// Get group name
final String groupName = (o instanceof String) ? (String) o
: ((RosterGroup) o).getName();
if (groupName == null || groupName.equals("")) {
createRosterEntries(parent, user, result);
continue;
}
// See if group is already in roster
org.eclipse.ecf.presence.roster.RosterGroup rosterGroup = findRosterGroup(
parent, groupName);
// Set flag if not
final boolean groupFound = rosterGroup != null;
if (!groupFound)
rosterGroup = new org.eclipse.ecf.presence.roster.RosterGroup(
parent, groupName);
if (findRosterEntry(rosterGroup, user) == null) {
// Now create new roster entry
new org.eclipse.ecf.presence.roster.RosterEntry(
rosterGroup, user,
new org.eclipse.ecf.presence.Presence(
IPresence.Type.UNAVAILABLE,
IPresence.Type.UNAVAILABLE.toString(),
IPresence.Mode.AWAY));
}
// Only add localGrp if not already in list
if (!groupFound)
result.add(rosterGroup);
}
} else
createRosterEntries(parent, user, result);
return (IRosterItem[]) result.toArray(new IRosterItem[] {});
}
protected IRosterEntry createRosterEntry(ID userID, String name,
Iterator grps) {
final List groups = new ArrayList();
for (; grps.hasNext();) {
final Object o = grps.next();
final String groupName = (o instanceof String) ? (String) o
: ((RosterGroup) o).getName();
final IRosterGroup localGrp = new org.eclipse.ecf.presence.roster.RosterGroup(
roster, groupName);
groups.add(localGrp);
}
final IUser user = new User(userID, name);
IRosterEntry newEntry = null;
if (groups.size() == 0)
return new org.eclipse.ecf.presence.roster.RosterEntry(roster,
user, new org.eclipse.ecf.presence.Presence(
IPresence.Type.UNAVAILABLE,
IPresence.Type.UNAVAILABLE.toString(),
IPresence.Mode.AWAY));
else
for (int i = 0; i < groups.size(); i++) {
final IRosterGroup grp = (IRosterGroup) groups.get(i);
if (i == 0)
newEntry = new org.eclipse.ecf.presence.roster.RosterEntry(
grp, user, null);
else {
grp.getEntries().add(newEntry);
newEntry.getGroups().add(grp);
}
}
return newEntry;
}
private void createRosterEntries(IRosterItem parent, IUser user, List result) {
final org.eclipse.ecf.presence.roster.RosterEntry oldEntry = findRosterEntry(
(org.eclipse.ecf.presence.roster.RosterGroup) null, user);
if (oldEntry == null) {
final org.eclipse.ecf.presence.roster.RosterEntry newEntry = new org.eclipse.ecf.presence.roster.RosterEntry(
parent, user, new org.eclipse.ecf.presence.Presence(
IPresence.Type.UNAVAILABLE,
IPresence.Type.UNAVAILABLE.toString(),
IPresence.Mode.AWAY));
result.add(newEntry);
}
}
private org.eclipse.ecf.presence.roster.RosterEntry findRosterEntry(
org.eclipse.ecf.presence.roster.RosterGroup rosterGroup, IUser user) {
if (rosterGroup != null)
return findRosterEntry(rosterGroup.getEntries(), user);
else
return findRosterEntry(roster.getItems(), user);
}
private org.eclipse.ecf.presence.roster.RosterEntry findRosterEntry(
Collection entries, IUser user) {
for (final Iterator i = entries.iterator(); i.hasNext();) {
final Object o = i.next();
if (o instanceof org.eclipse.ecf.presence.roster.RosterEntry) {
final org.eclipse.ecf.presence.roster.RosterEntry entry = (org.eclipse.ecf.presence.roster.RosterEntry) o;
if (entry.getUser().getID().equals(user.getID()))
return entry;
}
}
return null;
}
protected IRosterItem[] createRosterEntries(XMPPID id,
RosterPacket.Item entry) {
String name = entry.getName();
if (name == null)
name = id.getUsername();
name = XMPPID.unfixEscapeInNode(name);
return createRosterEntries(entry.getGroupNames().iterator(), roster,
new User(id, name));
}
protected org.eclipse.ecf.presence.roster.RosterGroup findRosterGroup(
Object parent, String grp) {
final Collection items = roster.getItems();
for (final Iterator i = items.iterator(); i.hasNext();) {
final IRosterItem item = (IRosterItem) i.next();
if (item.getName().equals(grp))
return (org.eclipse.ecf.presence.roster.RosterGroup) item;
}
return null;
}
// utility methods
protected ECFConnection getConnectionOrThrowIfNull() throws IOException {
final ECFConnection conn = container.getECFConnection();
if (conn == null)
throw new IOException("Not connected");
return conn;
}
protected void traceAndThrowECFException(String msg, Throwable t)
throws ECFException {
throw new ECFException(msg, t);
}
protected void trace(String msg) {
}
protected void traceStack(String msg, Throwable e) {
}
protected ID createRoomIDFromName(String from) {
try {
final ECFConnection ecfConnection = getConnectionOrThrowIfNull();
return new XMPPRoomID(container.getConnectNamespace(),
ecfConnection.getXMPPConnection(), from);
} catch (final Exception e) {
traceStack("Exception in createRoomIDFromName", e);
return null;
}
}
protected ID createUserIDFromName(String name) {
ID result = null;
try {
result = new XMPPID(container.getConnectNamespace(), name);
return result;
} catch (final Exception e) {
traceStack("Exception in createIDFromName", e);
return null;
}
}
protected Message.Type[] ALLOWED_MESSAGES = { Message.Type.chat,
Message.Type.error, Message.Type.headline, Message.Type.normal };
protected Message filterMessageType(Message msg) {
for (int i = 0; i < ALLOWED_MESSAGES.length; i++) {
if (ALLOWED_MESSAGES[i].equals(msg.getType())) {
return msg;
}
}
return null;
}
/**
* @return chat manager.
*/
public IChatManager getChatManager() {
return chatManager;
}
}