/****************************************************************************
* Copyright (c) 2006, 2007 Remy Suen, 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:
* Remy Suen <remy.suen@gmail.com> - initial API and implementation
*****************************************************************************/
package org.eclipse.ecf.internal.provider.msn;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.eclipse.ecf.core.ContainerConnectException;
import org.eclipse.ecf.core.IContainer;
import org.eclipse.ecf.core.IContainerListener;
import org.eclipse.ecf.core.events.ContainerConnectedEvent;
import org.eclipse.ecf.core.events.ContainerConnectingEvent;
import org.eclipse.ecf.core.events.ContainerDisconnectedEvent;
import org.eclipse.ecf.core.events.ContainerDisconnectingEvent;
import org.eclipse.ecf.core.events.ContainerDisposeEvent;
import org.eclipse.ecf.core.events.IContainerEvent;
import org.eclipse.ecf.core.identity.ID;
import org.eclipse.ecf.core.identity.IDCreateException;
import org.eclipse.ecf.core.identity.IDFactory;
import org.eclipse.ecf.core.identity.Namespace;
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.user.IUser;
import org.eclipse.ecf.core.util.ECFException;
import org.eclipse.ecf.presence.IAccountManager;
import org.eclipse.ecf.presence.IIMMessageListener;
import org.eclipse.ecf.presence.IPresence;
import org.eclipse.ecf.presence.IPresenceContainerAdapter;
import org.eclipse.ecf.presence.IPresenceListener;
import org.eclipse.ecf.presence.IPresenceSender;
import org.eclipse.ecf.presence.chatroom.IChatRoomManager;
import org.eclipse.ecf.presence.history.IHistory;
import org.eclipse.ecf.presence.history.IHistoryManager;
import org.eclipse.ecf.presence.im.ChatMessage;
import org.eclipse.ecf.presence.im.ChatMessageEvent;
import org.eclipse.ecf.presence.im.IChat;
import org.eclipse.ecf.presence.im.IChatManager;
import org.eclipse.ecf.presence.im.IChatMessageSender;
import org.eclipse.ecf.presence.im.ITypingMessageSender;
import org.eclipse.ecf.presence.im.TypingMessage;
import org.eclipse.ecf.presence.im.TypingMessageEvent;
import org.eclipse.ecf.presence.im.IChatMessage.Type;
import org.eclipse.ecf.presence.roster.IRoster;
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.IRosterListener;
import org.eclipse.ecf.presence.roster.IRosterManager;
import org.eclipse.ecf.presence.roster.IRosterSubscriptionListener;
import org.eclipse.ecf.presence.roster.IRosterSubscriptionSender;
import org.eclipse.ecf.presence.search.ICriteria;
import org.eclipse.ecf.presence.search.ISearch;
import org.eclipse.ecf.presence.search.IRestriction;
import org.eclipse.ecf.presence.search.IUserSearchListener;
import org.eclipse.ecf.presence.search.IUserSearchManager;
import org.eclipse.ecf.presence.search.UserSearchException;
import org.eclipse.ecf.presence.search.message.IMessageSearchManager;
import org.eclipse.ecf.presence.service.IPresenceService;
import org.eclipse.ecf.protocol.msn.ChatSession;
import org.eclipse.ecf.protocol.msn.Contact;
import org.eclipse.ecf.protocol.msn.Group;
import org.eclipse.ecf.protocol.msn.MsnClient;
import org.eclipse.ecf.protocol.msn.Status;
import org.eclipse.ecf.protocol.msn.events.IChatSessionListener;
import org.eclipse.ecf.protocol.msn.events.IContactListListener;
import org.eclipse.ecf.protocol.msn.events.IContactListener;
import org.eclipse.ecf.protocol.msn.events.ISessionListener;
final class MSNContainer implements IContainer, IChatManager,
IChatMessageSender, IPresenceService, IPresenceSender, IRoster,
IRosterManager, IRosterSubscriptionSender, ITypingMessageSender {
private final Map chatSessions;
private final List containerListeners;
private final List updateListeners;
private final List messageListeners;
private final List presenceListeners;
private final List subscriptionListeners;
private final List entries;
private final IUser user;
private final Namespace namespace;
private final ID guid;
private MsnClient client;
private MSNID connectID;
protected IHistoryManager historyManager = new IHistoryManager() {
public IHistory getHistory(ID partnerID, Map options) {
// TODO Auto-generated method stub
return null;
}
public boolean isActive() {
// TODO Auto-generated method stub
return false;
}
public void setActive(boolean active) {
// TODO Auto-generated method stub
}
public Object getAdapter(Class adapter) {
// TODO Auto-generated method stub
return null;
}
};
MSNContainer() throws IDCreateException {
guid = IDFactory.getDefault().createGUID();
namespace = IDFactory.getDefault().getNamespaceByName(
Activator.NAMESPACE_ID);
user = new Account();
chatSessions = new Hashtable();
containerListeners = new ArrayList();
updateListeners = new ArrayList();
messageListeners = new ArrayList();
presenceListeners = new ArrayList();
subscriptionListeners = new ArrayList();
entries = new ArrayList();
}
public void connect(ID targetID, IConnectContext connectContext)
throws ContainerConnectException {
if (!(targetID instanceof MSNID)) {
throw new ContainerConnectException(
Messages.MSNContainer_TargetIDNotMSNID);
}
client = new MsnClient();
ObjectCallback[] cb = { new ObjectCallback() };
try {
connectContext.getCallbackHandler().handle(cb);
client.addSessionListener(new ISessionListener() {
public void sessionConnected(ChatSession session) {
try {
Contact contact = session.getParticipants()[0];
final ID toID = namespace
.createInstance(new Object[] { contact
.getEmail() });
chatSessions.put(toID, session);
session.addChatSessionListener(new ChatSessionListener(
toID));
} catch (IDCreateException e) {
// ignored since this should not be possible
}
}
});
client.getContactList().addContactListListener(
new IContactListListener() {
public void contactAdded(Contact contact) {
final MSNRosterEntry entry = new MSNRosterEntry(
MSNContainer.this, contact, namespace);
for (int i = 0; i < entries.size(); i++) {
Object e = entries.get(i);
if (e instanceof MSNRosterGroup) {
MSNRosterGroup group = (MSNRosterGroup) e;
if (group.getGroup().contains(contact)) {
MSNRosterEntry check = group
.getEntryFor(contact);
if (check == null) {
check = entry;
contact
.addContactListener(new IContactListener() {
public void nameChanged(
String name) {
firePresence(
entry
.getID(),
entry
.getPresence());
fireRosterUpdate(entry);
}
public void personalMessageChanged(
String personalMessage) {
entry
.updatePersonalMessage();
firePresence(
entry
.getID(),
entry
.getPresence());
fireRosterUpdate(entry);
}
public void statusChanged(
Status status) {
firePresence(
entry
.getID(),
entry
.getPresence());
fireRosterUpdate(entry);
}
});
group.add(check);
fireRosterEntryAdded(check);
}
fireRosterUpdate(group);
return;
}
} else {
MSNRosterEntry check = (MSNRosterEntry) e;
if (entry.getContact().equals(
check.getContact())) {
fireRosterEntryAdded(check);
fireRosterUpdate(check.getParent());
return;
}
}
}
contact.addContactListener(new IContactListener() {
public void nameChanged(String name) {
firePresence(entry.getID(), entry
.getPresence());
fireRosterUpdate(entry);
}
public void personalMessageChanged(
String personalMessage) {
entry.updatePersonalMessage();
firePresence(entry.getID(), entry
.getPresence());
fireRosterUpdate(entry);
}
public void statusChanged(Status status) {
firePresence(entry.getID(), entry
.getPresence());
fireRosterUpdate(entry);
}
});
entries.add(entry);
entry.setParent(MSNContainer.this);
fireRosterEntryAdded(entry);
fireRosterUpdate(MSNContainer.this);
}
public void contactRemoved(Contact contact) {
MSNRosterEntry entry = findEntry(entries, contact
.getEmail());
if (entry != null) {
fireHandleUnsubscribed(entry.getUser().getID());
fireRosterEntryRemoved(entry);
fireRosterUpdate(entry.getParent());
if (entry.getContact().getGroups().isEmpty()) {
entry.setParent(MSNContainer.this);
fireRosterUpdate(MSNContainer.this);
}
}
}
public void contactAddedUser(String email) {
try {
fireHandleSubscriptionRequest(namespace
.createInstance(new Object[] { email }));
} catch (IDCreateException e) {
// ignored
}
}
public void contactRemovedUser(String email) {
// nothing to do
}
public void groupAdded(Group group) {
entries.add(new MSNRosterGroup(MSNContainer.this,
group));
}
});
fireContainerEvent(new ContainerConnectingEvent(guid, targetID));
client.connect(targetID.getName(), (String) cb[0].getObject());
connectID = (MSNID) targetID;
fireContainerEvent(new ContainerConnectedEvent(guid, connectID));
Activator.getDefault().registerService(this);
} catch (UnsupportedCallbackException e) {
throw new ContainerConnectException(e);
} catch (IOException e) {
throw new ContainerConnectException(e);
}
}
private MSNRosterEntry findEntry(Collection entries, String email) {
for (Iterator it = entries.iterator(); it.hasNext();) {
Object o = it.next();
if (o instanceof IRosterGroup) {
MSNRosterEntry entry = findEntry(((IRosterGroup) o)
.getEntries(), email);
if (entry != null) {
return entry;
}
} else {
MSNRosterEntry entry = (MSNRosterEntry) o;
if (entry.getUser().getID().getName().equals(email)) {
return entry;
}
}
}
return null;
}
public void disconnect() {
if (client != null) {
fireContainerEvent(new ContainerDisconnectingEvent(guid, connectID));
client.disconnect();
fireContainerEvent(new ContainerDisconnectedEvent(guid, connectID));
for (Iterator it = chatSessions.values().iterator(); it.hasNext();) {
((ChatSession) it.next()).close();
}
chatSessions.clear();
connectID = null;
client = null;
Activator.getDefault().unregisterService(this);
}
}
public void dispose() {
disconnect();
fireContainerEvent(new ContainerDisposeEvent(guid));
}
private void fireContainerEvent(IContainerEvent event) {
synchronized (containerListeners) {
for (int i = 0; i < containerListeners.size(); i++) {
((IContainerListener) containerListeners.get(i))
.handleEvent(event);
}
}
}
private void fireMessageEvent(ID fromID, String message) {
synchronized (messageListeners) {
for (int i = 0; i < messageListeners.size(); i++) {
((IIMMessageListener) messageListeners.get(i))
.handleMessageEvent(new ChatMessageEvent(fromID,
new ChatMessage(fromID, message)));
}
}
}
private void fireTypingMessageEvent(ID fromID) {
synchronized (messageListeners) {
for (int i = 0; i < messageListeners.size(); i++) {
((IIMMessageListener) messageListeners.get(i))
.handleMessageEvent(new TypingMessageEvent(fromID,
new TypingMessage(fromID, true, null)));
}
}
}
private void fireRosterUpdate(IRosterItem item) {
synchronized (updateListeners) {
for (int i = 0; i < updateListeners.size(); i++) {
((IRosterListener) updateListeners.get(i)).handleRosterUpdate(
this, item);
}
}
}
private void fireRosterEntryAdded(IRosterEntry entry) {
synchronized (updateListeners) {
for (int i = 0; i < updateListeners.size(); i++) {
((IRosterListener) updateListeners.get(i))
.handleRosterEntryAdd(entry);
}
}
}
private void fireRosterEntryRemoved(IRosterEntry entry) {
synchronized (updateListeners) {
for (int i = 0; i < updateListeners.size(); i++) {
((IRosterListener) updateListeners.get(i))
.handleRosterEntryRemove(entry);
}
}
}
private void firePresence(ID id, IPresence presence) {
synchronized (presenceListeners) {
for (int i = 0; i < presenceListeners.size(); i++) {
((IPresenceListener) presenceListeners.get(i)).handlePresence(
id, presence);
}
}
}
private void fireHandleSubscriptionRequest(ID fromID) {
synchronized (subscriptionListeners) {
for (int i = 0; i < subscriptionListeners.size(); i++) {
((IRosterSubscriptionListener) subscriptionListeners.get(i))
.handleSubscribeRequest(fromID);
}
}
}
private void fireHandleUnsubscribed(ID fromID) {
synchronized (subscriptionListeners) {
for (int i = 0; i < subscriptionListeners.size(); i++) {
((IRosterSubscriptionListener) subscriptionListeners.get(i))
.handleUnsubscribed(fromID);
}
}
}
public Object getAdapter(Class serviceType) {
if (serviceType != null && serviceType.isInstance(this)) {
return this;
} else {
return null;
}
}
public Namespace getConnectNamespace() {
return IDFactory.getDefault()
.getNamespaceByName(Activator.NAMESPACE_ID);
}
public ID getConnectedID() {
return connectID;
}
public ID getID() {
return guid;
}
public IAccountManager getAccountManager() {
return null;
}
public IChatRoomManager getChatRoomManager() {
return null;
}
public IPresenceSender getPresenceSender() {
return this;
}
public void addListener(IContainerListener listener) {
if (listener != null) {
synchronized (containerListeners) {
if (!containerListeners.contains(listener)) {
containerListeners.add(listener);
}
}
}
}
public void removeListener(IContainerListener listener) {
if (listener != null) {
synchronized (containerListeners) {
containerListeners.remove(listener);
}
}
}
private class ChatSessionListener implements IChatSessionListener {
private ID toID;
private ChatSessionListener(ID toID) {
this.toID = toID;
}
public void contactIsTyping(Contact contact) {
fireTypingMessageEvent(toID);
}
public void contactJoined(Contact contact) {
}
public void contactLeft(Contact contact) {
chatSessions.remove(toID);
}
public void messageReceived(Contact contact, String message) {
fireMessageEvent(toID, message);
}
public void sessionTimedOut() {
chatSessions.remove(toID);
}
}
public void sendPresenceUpdate(ID toID, IPresence presence)
throws ECFException {
if (presence == null || client == null) {
throw new ECFException();
}
IPresence.Mode mode = presence.getMode();
try {
client.setPersonalMessage(presence.getStatus());
if (presence.getType() == IPresence.Type.UNAVAILABLE) {
disconnect();
} else if (mode == IPresence.Mode.AVAILABLE
|| mode == IPresence.Mode.CHAT) {
client.setStatus(Status.ONLINE);
} else if (mode == IPresence.Mode.AWAY
|| mode == IPresence.Mode.EXTENDED_AWAY) {
client.setStatus(Status.AWAY);
} else if (mode == IPresence.Mode.DND) {
client.setStatus(Status.BUSY);
} else {
client.setStatus(Status.APPEAR_OFFLINE);
}
} catch (IOException e) {
throw new ECFException(e);
}
}
public IRosterManager getRosterManager() {
return this;
}
public void addRosterListener(IRosterListener listener) {
synchronized (updateListeners) {
if (!updateListeners.contains(listener)) {
updateListeners.add(listener);
}
}
}
public IRoster getRoster() {
return this;
}
public IRosterSubscriptionSender getRosterSubscriptionSender() {
return this;
}
public void addRosterSubscriptionListener(
IRosterSubscriptionListener listener) {
if (listener != null) {
synchronized (subscriptionListeners) {
if (!subscriptionListeners.contains(listener)) {
subscriptionListeners.add(listener);
}
}
}
}
public void removeRosterSubscriptionListener(
IRosterSubscriptionListener listener) {
if (listener != null) {
synchronized (subscriptionListeners) {
subscriptionListeners.remove(listener);
}
}
}
public void removeRosterListener(IRosterListener listener) {
if (listener != null) {
synchronized (updateListeners) {
updateListeners.remove(listener);
}
}
}
public Collection getItems() {
return Collections.unmodifiableCollection(entries);
}
public IUser getUser() {
return connectID == null ? null : user;
}
public void addPresenceListener(IPresenceListener listener) {
if (listener != null) {
synchronized (presenceListeners) {
if (!presenceListeners.contains(listener)) {
presenceListeners.add(listener);
}
}
}
}
public void removePresenceListener(IPresenceListener listener) {
if (listener != null) {
synchronized (presenceListeners) {
presenceListeners.remove(listener);
}
}
}
public IChatManager getChatManager() {
return this;
}
public IChatMessageSender getChatMessageSender() {
return this;
}
public ITypingMessageSender getTypingMessageSender() {
return this;
}
public void sendChatMessage(ID toID, ID threadID, Type type,
String subject, String body, Map properties) throws ECFException {
sendChatMessage(toID, body);
}
public void sendChatMessage(ID toID, String body) throws ECFException {
try {
ChatSession cs = (ChatSession) chatSessions.get(toID);
if (cs == null) {
cs = client.createChatSession(toID.getName());
cs.addChatSessionListener(new ChatSessionListener(toID));
chatSessions.put(toID, cs);
}
cs.sendMessage(body);
} catch (IOException e) {
throw new ECFException(e);
}
}
public void sendTypingMessage(ID toID, boolean isTyping, String body)
throws ECFException {
try {
if (isTyping) {
ChatSession cs = (ChatSession) chatSessions.get(toID);
if (cs == null) {
cs = client.createChatSession(toID.getName());
cs.addChatSessionListener(new ChatSessionListener(toID));
chatSessions.put(toID, cs);
}
cs.sendTypingNotification();
}
} catch (IOException e) {
throw new ECFException(e);
}
}
public void addMessageListener(IIMMessageListener listener) {
if (listener != null) {
synchronized (messageListeners) {
if (!messageListeners.contains(listener)) {
messageListeners.add(listener);
}
}
}
}
public void removeMessageListener(IIMMessageListener listener) {
if (listener != null) {
synchronized (messageListeners) {
messageListeners.remove(listener);
}
}
}
private class Account implements IUser {
private static final long serialVersionUID = 7497082891662391996L;
public Object getAdapter(Class adapter) {
return null;
}
public ID getID() {
return connectID;
}
public Map getProperties() {
return null;
}
public String getName() {
return client.getUserEmail();
}
public String getNickname() {
return client.getDisplayName();
}
}
public void sendRosterAdd(String user, String name, String[] groups)
throws ECFException {
try {
client.getContactList().addContact(user, name);
} catch (IOException e) {
throw new ECFException(e);
}
}
public void sendRosterRemove(ID userID) throws ECFException {
MSNRosterEntry entry = findEntry(entries, userID.getName());
if (entry != null) {
try {
client.getContactList().removeContact(entry.getContact());
} catch (IOException e) {
throw new ECFException(e);
}
}
}
public String getName() {
IUser user = getUser();
return user == null ? null : user.getName();
}
public IRosterItem getParent() {
return null;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.ecf.presence.im.IChatManager#getHistoryManager()
*/
public IHistoryManager getHistoryManager() {
// TODO Auto-generated method stub
return historyManager;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.ecf.presence.roster.IRoster#getPresenceContainerAdapter()
*/
public IPresenceContainerAdapter getPresenceContainerAdapter() {
return this;
}
/* (non-Javadoc)
* @see org.eclipse.ecf.presence.im.IChatManager#createChat(org.eclipse.ecf.core.identity.ID)
*/
public IChat createChat(ID targetUser, IIMMessageListener messageListener) throws ECFException {
// TODO Auto-generated method stub
return null;
}
/**
* TODO Implement a User Search Manager for MSN
* for while it just returns a manger
* to inform that user search is not allow
* for this provider see {@link IUserSearchManager#isEnabled()}
*/
public IUserSearchManager getUserSearchManager() {
return new IUserSearchManager(){
public ICriteria createCriteria() {
// TODO Auto-generated method stub
return null;
}
public IRestriction createRestriction() {
// TODO Auto-generated method stub
return null;
}
public String[] getUserPropertiesFields()
throws ContainerConnectException {
// TODO Auto-generated method stub
return null;
}
public boolean isEnabled() {
// TODO Auto-generated method stub
return false;
}
public ISearch search(ICriteria criteria)
throws UserSearchException {
// TODO Auto-generated method stub
return null;
}
public void search(ICriteria criteria, IUserSearchListener listener) {
// TODO Auto-generated method stub
}
};
}
public IMessageSearchManager getMessageSearchManager() {
// TODO Auto-generated method stub
return null;
}
}