/*******************************************************************************
* Copyright (c) 2004, 2007 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.provider.xmpp;
import java.io.IOException;
import java.net.ConnectException;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import org.eclipse.ecf.core.ContainerConnectException;
import org.eclipse.ecf.core.events.ContainerDisconnectedEvent;
import org.eclipse.ecf.core.events.ContainerDisconnectingEvent;
import org.eclipse.ecf.core.identity.ID;
import org.eclipse.ecf.core.identity.IDFactory;
import org.eclipse.ecf.core.identity.Namespace;
import org.eclipse.ecf.core.security.Callback;
import org.eclipse.ecf.core.security.CallbackHandler;
import org.eclipse.ecf.core.security.IConnectContext;
import org.eclipse.ecf.core.security.ObjectCallback;
import org.eclipse.ecf.core.security.UnsupportedCallbackException;
import org.eclipse.ecf.core.sharedobject.SharedObjectAddException;
import org.eclipse.ecf.core.sharedobject.util.IQueueEnqueue;
import org.eclipse.ecf.core.user.User;
import org.eclipse.ecf.core.util.Event;
import org.eclipse.ecf.filetransfer.ISendFileTransferContainerAdapter;
import org.eclipse.ecf.internal.provider.xmpp.Messages;
import org.eclipse.ecf.internal.provider.xmpp.XMPPChatRoomContainer;
import org.eclipse.ecf.internal.provider.xmpp.XMPPChatRoomManager;
import org.eclipse.ecf.internal.provider.xmpp.XMPPContainerAccountManager;
import org.eclipse.ecf.internal.provider.xmpp.XMPPContainerContext;
import org.eclipse.ecf.internal.provider.xmpp.XMPPContainerPresenceHelper;
import org.eclipse.ecf.internal.provider.xmpp.XmppPlugin;
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.filetransfer.XMPPOutgoingFileTransferHelper;
import org.eclipse.ecf.internal.provider.xmpp.search.XMPPUserSearchManager;
import org.eclipse.ecf.internal.provider.xmpp.smack.ECFConnection;
import org.eclipse.ecf.internal.provider.xmpp.smack.ECFConnectionObjectPacketEvent;
import org.eclipse.ecf.internal.provider.xmpp.smack.ECFConnectionPacketEvent;
import org.eclipse.ecf.presence.IAccountManager;
import org.eclipse.ecf.presence.IPresenceContainerAdapter;
import org.eclipse.ecf.presence.chatroom.IChatRoomContainer;
import org.eclipse.ecf.presence.chatroom.IChatRoomManager;
import org.eclipse.ecf.presence.im.IChatManager;
import org.eclipse.ecf.presence.roster.IRosterManager;
import org.eclipse.ecf.presence.search.IUserSearchManager;
import org.eclipse.ecf.presence.service.IPresenceService;
import org.eclipse.ecf.provider.comm.AsynchEvent;
import org.eclipse.ecf.provider.comm.ConnectionCreateException;
import org.eclipse.ecf.provider.comm.ISynchAsynchConnection;
import org.eclipse.ecf.provider.generic.ClientSOContainer;
import org.eclipse.ecf.provider.generic.ContainerMessage;
import org.eclipse.ecf.provider.generic.SOConfig;
import org.eclipse.ecf.provider.generic.SOContainerConfig;
import org.eclipse.ecf.provider.generic.SOContext;
import org.eclipse.ecf.provider.generic.SOWrapper;
import org.eclipse.ecf.provider.xmpp.identity.XMPPID;
import org.eclipse.osgi.util.NLS;
import org.jivesoftware.smack.Roster;
import org.jivesoftware.smack.XMPPConnection;
import org.jivesoftware.smack.packet.IQ;
import org.jivesoftware.smack.packet.Message;
import org.jivesoftware.smack.packet.Packet;
import org.jivesoftware.smack.packet.Presence;
import org.jivesoftware.smackx.packet.MUCUser;
import org.jivesoftware.smackx.packet.XHTMLExtension;
/**
* @since 3.0
*/
public class XMPPContainer extends ClientSOContainer implements
IPresenceService {
public static final int DEFAULT_KEEPALIVE = 30000;
public static final String CONNECT_NAMESPACE = XmppPlugin.getDefault()
.getNamespaceIdentifier();
public static final String CONTAINER_HELPER_ID = XMPPContainer.class
.getName() + ".xmpphandler"; //$NON-NLS-1$
protected static final String GOOGLE_SERVICENAME = "gmail.com"; //$NON-NLS-1$
private static final String[] googleHosts = { GOOGLE_SERVICENAME,
"talk.google.com", "googlemail.com" }; //$NON-NLS-1$ //$NON-NLS-2$
public static final String XMPP_GOOGLE_OVERRIDE_PROP_NAME = "ecf.xmpp.google.override"; //$NON-NLS-1$
private static Set googleNames = new HashSet();
static {
for (int i = 0; i < googleHosts.length; i++)
googleNames.add(googleHosts[i]);
final String override = System
.getProperty(XMPP_GOOGLE_OVERRIDE_PROP_NAME);
if (override != null)
googleNames.add(override.toLowerCase());
}
protected int keepAlive = 0;
XMPPContainerAccountManager accountManager = null;
XMPPChatRoomManager chatRoomManager = null;
XMPPOutgoingFileTransferHelper outgoingFileTransferContainerAdapter = null;
XMPPContainerPresenceHelper presenceHelper = null;
/**
* @since 3.0
*/
XMPPUserSearchManager searchManager = null;
protected ID presenceHelperID = null;
protected XMPPContainer(SOContainerConfig config, int keepAlive)
throws Exception {
super(config);
this.keepAlive = keepAlive;
accountManager = new XMPPContainerAccountManager();
chatRoomManager = new XMPPChatRoomManager(getID());
searchManager = new XMPPUserSearchManager();
this.presenceHelperID = IDFactory.getDefault().createStringID(
CONTAINER_HELPER_ID);
presenceHelper = new XMPPContainerPresenceHelper(this);
outgoingFileTransferContainerAdapter = new XMPPOutgoingFileTransferHelper(
this);
}
public XMPPContainer() throws Exception {
this(DEFAULT_KEEPALIVE);
}
public XMPPContainer(int ka) throws Exception {
this(new SOContainerConfig(IDFactory.getDefault().createGUID()), ka);
}
public XMPPContainer(String userhost, int ka) throws Exception {
this(new SOContainerConfig(IDFactory.getDefault().createStringID(
userhost)), ka);
}
/**
* @since 3.2
*/
protected boolean verifySharedObjectMessageTarget(ID containerID) {
return true;
}
/**
* @since 3.2
*/
protected void sendMessage(ContainerMessage data) throws IOException {
synchronized (getConnectLock()) {
ID connectedID = getConnectedID();
if (connectedID == null)
throw new ConnectException("Container not connected"); //$NON-NLS-1$
synchronized (getGroupMembershipLock()) {
if (!connectedID.equals(data.getToContainerID()))
queueContainerMessage(data);
}
}
}
public IRosterManager getRosterManager() {
return presenceHelper.getRosterManager();
}
/**
* @since 3.0
*/
public IUserSearchManager getUserSearchManager() {
return searchManager;
}
public IAccountManager getAccountManager() {
return accountManager;
}
public IChatRoomManager getChatRoomManager() {
return chatRoomManager;
}
public IChatManager getChatManager() {
return presenceHelper.getChatManager();
}
/*
* (non-Javadoc)
*
* @see org.eclipse.ecf.provider.generic.SOContainer#getConnectNamespace()
*/
public Namespace getConnectNamespace() {
return IDFactory.getDefault().getNamespaceByName(
XmppPlugin.getDefault().getNamespaceIdentifier());
}
/*
* (non-Javadoc)
*
* @see
* org.eclipse.ecf.provider.generic.ClientSOContainer#connect(org.eclipse
* .ecf.core.identity.ID, org.eclipse.ecf.core.security.IConnectContext)
*/
public void connect(ID remote, IConnectContext joinContext)
throws ContainerConnectException {
try {
getSharedObjectManager().addSharedObject(presenceHelperID,
presenceHelper, null);
super.connect(remote, joinContext);
XmppPlugin.getDefault().registerService(this);
} catch (final ContainerConnectException e) {
disconnect();
throw e;
} catch (final SharedObjectAddException e1) {
disconnect();
throw new ContainerConnectException(NLS.bind(
Messages.XMPPContainer_EXCEPTION_ADDING_SHARED_OBJECT,
presenceHelperID), e1);
}
}
/*
* (non-Javadoc)
*
* @see org.eclipse.ecf.provider.generic.ClientSOContainer#disconnect()
*/
public void disconnect() {
final ID groupID = getConnectedID();
fireContainerEvent(new ContainerDisconnectingEvent(this.getID(),
groupID));
synchronized (getConnectLock()) {
// If we are currently connected
if (isConnected()) {
XmppPlugin.getDefault().unregisterService(this);
final ISynchAsynchConnection conn = getConnection();
synchronized (conn) {
synchronized (getGroupMembershipLock()) {
handleLeave(groupID, conn);
}
}
}
this.connection = null;
remoteServerID = null;
accountManager.setConnection(null);
chatRoomManager.setConnection(null, null, null);
outgoingFileTransferContainerAdapter.setConnection(null);
presenceHelper.disconnect();
getSharedObjectManager().removeSharedObject(presenceHelperID);
}
// notify listeners
fireContainerEvent(new ContainerDisconnectedEvent(this.getID(), groupID));
}
/*
* (non-Javadoc)
*
* @see org.eclipse.ecf.provider.generic.ClientSOContainer#dispose()
*/
public void dispose() {
chatRoomManager.dispose();
accountManager.dispose();
outgoingFileTransferContainerAdapter.dispose();
super.dispose();
}
/*
* (non-Javadoc)
*
* @see
* org.eclipse.ecf.provider.generic.SOContainer#getAdapter(java.lang.Class)
*/
public Object getAdapter(Class clazz) {
if (clazz.equals(IPresenceContainerAdapter.class))
return this;
if (clazz.equals(ISendFileTransferContainerAdapter.class))
return outgoingFileTransferContainerAdapter;
else
return super.getAdapter(clazz);
}
private String trimResourceFromJid(String jid) {
int slashIndex = jid.indexOf('/');
if (slashIndex > 0) {
return jid.substring(slashIndex + 1);
} else
return null;
}
private void resetTargetResource(ID originalTarget, Object serverData) {
// Reset resource to that given by server
if (originalTarget instanceof XMPPID) {
XMPPID xmppOriginalTarget = (XMPPID) originalTarget;
if (serverData != null && serverData instanceof String) {
String jid = (String) serverData;
String jidResource = trimResourceFromJid(jid);
if (jidResource != null) {
xmppOriginalTarget.setResourceName(jidResource);
}
}
}
}
protected ID handleConnectResponse(ID originalTarget, Object serverData)
throws Exception {
if (originalTarget != null && !originalTarget.equals(getID())) {
// First reset target resource to whatever the server says it is
resetTargetResource(originalTarget, serverData);
addNewRemoteMember(originalTarget, null);
final ECFConnection conn = getECFConnection();
accountManager.setConnection(conn.getXMPPConnection());
chatRoomManager.setConnection(getConnectNamespace(),
originalTarget, conn);
searchManager.setConnection(getConnectNamespace(), originalTarget,
conn);
searchManager.setEnabled(!isGoogle(originalTarget));
presenceHelper.setUser(new User(originalTarget));
outgoingFileTransferContainerAdapter.setConnection(conn
.getXMPPConnection());
return originalTarget;
} else
throw new ConnectException(
Messages.XMPPContainer_EXCEPTION_INVALID_RESPONSE_FROM_SERVER);
}
/*
* (non-Javadoc)
*
* @see
* org.eclipse.ecf.provider.generic.ClientSOContainer#createConnection(org
* .eclipse.ecf.core.identity.ID, java.lang.Object)
*/
protected ISynchAsynchConnection createConnection(ID remoteSpace,
Object data) throws ConnectionCreateException {
final boolean google = isGoogle(remoteSpace);
return new ECFConnection(google, getConnectNamespace(), receiver);
}
protected boolean isGoogle(ID remoteSpace) {
if (remoteSpace instanceof XMPPID) {
final XMPPID theID = (XMPPID) remoteSpace;
final String host = theID.getHostname();
if (host == null)
return false;
return googleNames.contains(host.toLowerCase());
}
return false;
}
/*
* (non-Javadoc)
*
* @see
* org.eclipse.ecf.provider.generic.ClientSOContainer#getConnectData(org
* .eclipse.ecf.core.identity.ID,
* org.eclipse.ecf.core.security.IConnectContext)
*/
protected Object getConnectData(ID remote, IConnectContext joinContext)
throws IOException, UnsupportedCallbackException {
final Callback[] callbacks = createAuthorizationCallbacks();
if (joinContext != null && callbacks != null && callbacks.length > 0) {
final CallbackHandler handler = joinContext.getCallbackHandler();
if (handler != null) {
handler.handle(callbacks);
}
if (callbacks[0] instanceof ObjectCallback) {
final ObjectCallback cb = (ObjectCallback) callbacks[0];
return cb.getObject();
}
}
return null;
}
protected Object createConnectData(ID target, Callback[] cbs, Object data) {
// first one is password callback
if (cbs.length > 0) {
if (cbs[0] instanceof ObjectCallback) {
final ObjectCallback cb = (ObjectCallback) cbs[0];
return cb.getObject();
}
}
return data;
}
protected Callback[] createAuthorizationCallbacks() {
final Callback[] cbs = new Callback[1];
cbs[0] = new ObjectCallback();
return cbs;
}
/*
* (non-Javadoc)
*
* @see
* org.eclipse.ecf.provider.generic.ClientSOContainer#getConnectTimeout()
*/
protected int getConnectTimeout() {
return keepAlive;
}
protected Roster getRoster() throws IOException {
final ECFConnection connection = getECFConnection();
if (connection != null) {
return connection.getRoster();
} else
return null;
}
protected void deliverEvent(Event evt) {
final SOWrapper wrap = getSharedObjectWrapper(presenceHelperID);
if (wrap != null)
wrap.deliverEvent(evt);
}
protected void handleXMPPMessage(Packet aPacket) throws IOException {
if (!handleAsExtension(aPacket)) {
if (aPacket instanceof IQ) {
deliverEvent(new IQEvent((IQ) aPacket));
} else if (aPacket instanceof Message) {
deliverEvent(new MessageEvent((Message) aPacket));
} else if (aPacket instanceof Presence) {
deliverEvent(new PresenceEvent((Presence) aPacket));
} else {
log(NLS.bind(Messages.XMPPContainer_UNEXPECTED_XMPP_MESSAGE,
aPacket.toXML()), null);
}
}
}
protected boolean handleAsExtension(Packet packet) {
final Iterator i = packet.getExtensions().iterator();
for (; i.hasNext();) {
final Object extension = i.next();
if (extension instanceof XHTMLExtension) {
final XHTMLExtension xhtmlExtension = (XHTMLExtension) extension;
deliverEvent(new MessageEvent((Message) packet,
xhtmlExtension.getBodies()));
return true;
}
if (packet instanceof Presence && extension instanceof MUCUser) {
return true;
}
}
return false;
}
/*
* (non-Javadoc)
*
* @see
* org.eclipse.ecf.provider.generic.SOContainer#createSharedObjectContext
* (org.eclipse.ecf.provider.generic.SOConfig,
* org.eclipse.ecf.core.sharedobject.util.IQueueEnqueue)
*/
protected SOContext createSharedObjectContext(SOConfig soconfig,
IQueueEnqueue queue) {
return new XMPPContainerContext(soconfig.getSharedObjectID(),
soconfig.getHomeContainerID(), this, soconfig.getProperties(),
queue);
}
/*
* (non-Javadoc)
*
* @see
* org.eclipse.ecf.provider.generic.ClientSOContainer#processAsynch(org.
* eclipse.ecf.provider.comm.AsynchEvent)
*/
protected void processAsynch(AsynchEvent e) {
try {
if (e instanceof ECFConnectionPacketEvent) {
// It's a regular xmpp message
handleXMPPMessage((Packet) e.getData());
return;
} else if (e instanceof ECFConnectionObjectPacketEvent) {
// It's an ECF object message
final ECFConnectionObjectPacketEvent evt = (ECFConnectionObjectPacketEvent) e;
final Object obj = evt.getObjectValue();
// this should be a ContainerMessage
final Object cm = deserializeContainerMessage((byte[]) obj);
if (cm == null)
throw new IOException(
Messages.XMPPContainer_EXCEPTION_DESERIALIZED_OBJECT_NULL);
final ContainerMessage contMessage = (ContainerMessage) cm;
final IChatRoomContainer chat = chatRoomManager
.findReceiverChatRoom(contMessage.getToContainerID());
if (chat != null && chat instanceof XMPPChatRoomContainer) {
final XMPPChatRoomContainer cont = (XMPPChatRoomContainer) chat;
cont.handleContainerMessage(contMessage);
return;
}
final Object data = contMessage.getData();
if (data instanceof ContainerMessage.CreateMessage) {
handleCreateMessage(contMessage);
} else if (data instanceof ContainerMessage.CreateResponseMessage) {
handleCreateResponseMessage(contMessage);
} else if (data instanceof ContainerMessage.SharedObjectMessage) {
handleSharedObjectMessage(contMessage);
} else if (data instanceof ContainerMessage.SharedObjectDisposeMessage) {
handleSharedObjectDisposeMessage(contMessage);
} else {
debug(NLS
.bind(Messages.XMPPContainer_UNRECOGONIZED_CONTAINER_MESSAGE,
contMessage));
}
} else {
// Unexpected type...
log(NLS.bind(Messages.XMPPContainer_UNEXPECTED_EVENT, e), null);
}
} catch (final Exception except) {
log(NLS.bind(Messages.XMPPContainer_EXCEPTION_HANDLING_ASYCH_EVENT,
e), except);
}
}
public ECFConnection getECFConnection() {
return (ECFConnection) super.getConnection();
}
public XMPPConnection getXMPPConnection() {
final ECFConnection conn = getECFConnection();
if (conn == null)
return null;
else
return conn.getXMPPConnection();
}
// utility methods
protected void log(String msg, Throwable e) {
XmppPlugin.log(msg, e);
}
}