diff --git a/src/main/java/com/calclab/emite/browser/client/AutoConfig.java b/src/main/java/com/calclab/emite/browser/client/AutoConfig.java index 0c258293..77311625 100644 --- a/src/main/java/com/calclab/emite/browser/client/AutoConfig.java +++ b/src/main/java/com/calclab/emite/browser/client/AutoConfig.java @@ -20,14 +20,18 @@ package com.calclab.emite.browser.client; +import java.util.HashMap; import java.util.logging.Logger; +import com.calclab.emite.core.client.LoginXmpp; +import com.calclab.emite.core.client.LoginXmppMap; import com.calclab.emite.core.client.conn.XmppConnection; import com.calclab.emite.core.client.xmpp.session.XmppSession; import com.google.gwt.event.logical.shared.CloseEvent; import com.google.gwt.event.logical.shared.CloseHandler; import com.google.gwt.user.client.Window; import com.google.inject.Inject; +import com.google.inject.Provider; /** * This class object auto-configures some emite components and behaviours based @@ -53,14 +57,29 @@ public class AutoConfig { private static final String PARAM_SESSION = "emite.session"; protected static final String LOGOUT = "logout"; - private final XmppConnection connection; - private final XmppSession session; + private XmppConnection connection = null; + private XmppSession session = null; @Inject - public AutoConfig(final XmppConnection connection, final XmppSession session) { - this.connection = connection; - this.session = session; + public AutoConfig(final @LoginXmppMap HashMap loginXmppMap, Provider loginXmppProv) { + + String instanceId = PageAssist.getMeta("emite.user"); + + if (instanceId != null) { + + LoginXmpp loginXmpp; + if (loginXmppMap.get(instanceId)==null) { + loginXmpp = loginXmppProv.get(); + loginXmpp.setInstanceId(instanceId); + loginXmppMap.put(instanceId, loginXmpp); + } else { + loginXmpp =loginXmppMap.get(instanceId); + } + this.connection = loginXmpp.xmppConnection; + this.session = loginXmpp.xmppSession; + initialize(); + } } private void initialize() { diff --git a/src/main/java/com/calclab/emite/core/client/CoreModule.java b/src/main/java/com/calclab/emite/core/client/CoreModule.java index 227e2e90..a54dc4f5 100644 --- a/src/main/java/com/calclab/emite/core/client/CoreModule.java +++ b/src/main/java/com/calclab/emite/core/client/CoreModule.java @@ -20,6 +20,8 @@ package com.calclab.emite.core.client; +import java.util.HashMap; + import com.calclab.emite.core.client.bosh.XmppBoshConnection; import com.calclab.emite.core.client.conn.XmppConnection; import com.calclab.emite.core.client.events.EmiteEventBus; @@ -58,16 +60,23 @@ public class CoreModule extends AbstractGinModule { @Override protected void configure() { bind(Services.class).to(GWTServices.class).in(Singleton.class); - bind(XmppConnection.class).to(XmppBoshConnection.class).in(Singleton.class); - bind(XmppSession.class).to(XmppSessionLogic.class).in(Singleton.class); - bind(IMSessionManager.class).in(Singleton.class); - bind(SASLManager.class).in(Singleton.class); - bind(ResourceBindingManager.class).in(Singleton.class); - bind(SessionComponentsRegistry.class).in(Singleton.class); + bind(XmppConnection.class).to(XmppBoshConnection.class);//.in(Singleton.class); + bind(XmppSession.class).to(XmppSessionLogic.class);//.in(Singleton.class); + bind(IMSessionManager.class);//.in(Singleton.class); + bind(SASLManager.class);//.in(Singleton.class); + bind(ResourceBindingManager.class);//.in(Singleton.class); + bind(SessionComponentsRegistry.class);//.in(Singleton.class); + bind(LoginXmpp.class); } + @Provides @Singleton @LoginXmppMap + HashMap provideLoginXmppMap() { + HashMap loginXmppMap = new HashMap(); + return loginXmppMap; + } + @Provides - @Singleton + //@Singleton EmiteEventBus provideEmiteEventBus() { return EventBusFactory.create("emite"); } diff --git a/src/main/java/com/calclab/emite/core/client/LoginXmpp.java b/src/main/java/com/calclab/emite/core/client/LoginXmpp.java new file mode 100644 index 00000000..f0783b82 --- /dev/null +++ b/src/main/java/com/calclab/emite/core/client/LoginXmpp.java @@ -0,0 +1,193 @@ +package com.calclab.emite.core.client; + +//import com.calclab.emite.core.client.conn.Connection; +//import com.calclab.emite.core.client.xmpp.session.Session; +//import com.calclab.emite.im.client.roster.Roster; +import com.calclab.emite.core.client.conn.XmppConnection; +import com.calclab.emite.core.client.xmpp.session.XmppSession; +import com.calclab.emite.im.client.roster.XmppRoster; +import com.calclab.emite.core.client.events.EmiteEventBus; +import com.calclab.emite.core.client.events.EventBusFactory; +import com.calclab.emite.core.client.services.Services; +import com.calclab.emite.core.client.xmpp.resource.ResourceBindingManager; +import com.calclab.emite.core.client.xmpp.sasl.SASLManager; +import com.calclab.emite.core.client.xmpp.session.IMSessionManager; +import com.calclab.emite.core.client.xmpp.session.SessionComponentsRegistry; + +import com.calclab.emite.im.client.ImComponents; +import com.calclab.emite.im.client.chat.ChatManager; +import com.calclab.emite.im.client.chat.ChatSelectionStrategy; +import com.calclab.emite.im.client.presence.PresenceManager; +import com.calclab.emite.im.client.roster.SubscriptionHandler; +import com.calclab.emite.im.client.roster.SubscriptionManager; +import com.calclab.emite.reconnect.client.SessionReconnect; +import com.calclab.emite.xep.avatar.client.AvatarManager; +import com.calclab.emite.xep.chatstate.client.ChatStateComponents; +import com.calclab.emite.xep.chatstate.client.StateManager; +import com.calclab.emite.xep.disco.client.DiscoveryManager; +import com.calclab.emite.xep.muc.client.MucComponents; +import com.calclab.emite.xep.muc.client.RoomManager; +import com.calclab.emite.xep.mucchatstate.client.MUCChatStateManager; +import com.calclab.emite.xep.mucdisco.client.RoomDiscoveryManager; +import com.calclab.emite.xep.privacylists.client.PrivacyListsManager; +import com.calclab.emite.xep.search.client.SearchManager; +import com.calclab.emite.xep.storage.client.PrivateStorageManager; +import com.calclab.emite.xep.vcard.client.VCardManager; +import com.google.gwt.core.client.GWT; +import com.google.inject.Inject; + + +public class LoginXmpp implements MultiInstance{ + public XmppConnection xmppConnection; //Converted from singleton + public XmppSession xmppSession; //Converted from singleton + public SASLManager saslManager; //Converted from singleton + public ResourceBindingManager bindingManager; //Converted from singleton + public IMSessionManager iMSessionManager; //Converted from singleton + + //Gets set inside xmppBoshConnection + public EmiteEventBus eventBus; //Converted from singleton + + //Services is tied to a connection + public Services services; //Doesn't have internal state so does not need to be converted from Singleton + + //public Connection connection; //Converted from singleton + //public Session session; //Converted from singleton + + public ChatManager chatManager; //Is bound to PairChatManager - search for bind(ChatManager + //Converted from Singleton + public PresenceManager presenceManager; //Converted from Singleton + //public Roster roster; //Converted from Singleton + public SubscriptionManager subscriptionManager; //Converted from Singleton + public SubscriptionHandler subscriptionHandler; //Converted from Singleton + /*The following two items do not care about outside classes but they are singletons so they could step on each others toes*/ + //public ImComponents imComponents; + + + //The following is a singleton that is tied to Session and it has internal state, therefore even though its creation does not require + //knowing instance id of hablar and it does not depend on others, others depend on it and its internal state + //, we still need to convert it to a non singleton and tie it to this instance. + public SessionComponentsRegistry registry; //Converted from Singleton + + //public ChatSelectionStrategy chatSelectionStrategy; + public XmppRoster xmppRoster; //Converted from Singleton + public StateManager stateManager; //Converted from Singleton + public RoomManager roomManager; //Converted from Singleton + public DiscoveryManager discoveryManager; //Converted from Singleton + public RoomDiscoveryManager roomDiscoveryManager; //Converted from Singleton + public PrivateStorageManager privateStorageManager; //Converted from Singleton + public VCardManager vCardManager; //Converted from Singleton + public SearchManager searchManager; //Converted from Singleton + public ChatStateComponents chatStateComponents; //Singleton + public MucComponents mucComponents; //Singleton + public MUCChatStateManager mucChatStateManager; + private PrivacyListsManager privacyListsManager; + private SessionReconnect reconnectModule; + private AvatarManager avatarManager; + + + + //XmppInjector ginjector = GWT.create(XmppInjector.class); + + @Inject + LoginXmpp(XmppConnection xmppConnection, XmppSession xmppSession, SASLManager saslManager, ResourceBindingManager bindingManager, + IMSessionManager iMSessionManager, SessionComponentsRegistry registry, + //Connection connection, + //Session session, + //Roster roster, + //EmiteEventBus eventBus, + Services services, + ChatManager chatManager, PresenceManager presenceManager, + SubscriptionManager subscriptionManager, SubscriptionHandler subscriptionHandler, + //ImComponents imComponents, + XmppRoster xmppRoster, RoomManager roomManager, DiscoveryManager discoveryManager, RoomDiscoveryManager roomDiscoveryManager, + PrivateStorageManager privateStorageManager, VCardManager vCardManager, SearchManager searchManager, StateManager stateManager, + ChatStateComponents chatStateComponents, MucComponents mucComponents, MUCChatStateManager mucChatStateManager, + PrivacyListsManager privacyListsManager, + SessionReconnect reconnectModule, + AvatarManager avatarManager + //ChatSelectionStrategy chatSelectionStrategy, + + ) { + + this.xmppConnection = xmppConnection; + this.xmppSession = xmppSession; + this.saslManager = saslManager; + this.bindingManager = bindingManager; + this.iMSessionManager = iMSessionManager; + this.registry = registry; + //this.connection = Suco.get(Connection.class); + //this.session = Suco.get(Session.class); + //this.eventBus = eventBus; + this.services = services; + + + this.chatManager = chatManager; + this.stateManager = stateManager; + this.discoveryManager = discoveryManager; + this.roomDiscoveryManager = roomDiscoveryManager; + this.presenceManager = presenceManager; + //this.roster = roster; + this.subscriptionManager = subscriptionManager; + this.subscriptionHandler = subscriptionHandler; + //this.imComponents = imComponents; + //this.chatSelectionStrategy = chatSelectionStrategy; + this.xmppRoster = xmppRoster; + this.roomManager = roomManager; + this.privateStorageManager = privateStorageManager; + this.vCardManager = vCardManager; + this.searchManager = searchManager; + this.chatStateComponents = chatStateComponents; + this.mucComponents = mucComponents; + + this.stateManager = stateManager; + this.mucChatStateManager = mucChatStateManager; + this.privacyListsManager = privacyListsManager; + this.reconnectModule = reconnectModule; + this.avatarManager = avatarManager; + + } + + @Override + public void setInstanceId(String instanceId) { + + eventBus = EventBusFactory.create("emite" + instanceId); + + xmppConnection.setInstanceId(instanceId); + xmppSession.setInstanceId(instanceId ); + saslManager.setInstanceId(instanceId); + bindingManager.setInstanceId(instanceId); + iMSessionManager.setInstanceId(instanceId); + registry.setInstanceId(instanceId); + //connection.setInstanceId(instanceId); + //session.setInstanceId(instanceId); + eventBus.setInstanceId(instanceId); + services.setInstanceId(instanceId); + + //Registry adder + chatStateComponents.setInstanceId(instanceId); + stateManager.setInstanceId(instanceId); + + //Registry adder + mucComponents.setInstanceId(instanceId); + roomManager.setInstanceId(instanceId); + + mucChatStateManager.setInstanceId(instanceId); + + discoveryManager.setInstanceId(instanceId); + roomDiscoveryManager.setInstanceId(instanceId); + presenceManager.setInstanceId(instanceId); + privateStorageManager.setInstanceId(instanceId); + subscriptionManager.setInstanceId(instanceId); + xmppRoster.setInstanceId(instanceId); + //roster.setInstanceId(instanceId); + subscriptionHandler.setInstanceId(instanceId); + chatManager.setInstanceId(instanceId); + vCardManager.setInstanceId(instanceId); + searchManager.setInstanceId(instanceId); + reconnectModule.setInstanceId(instanceId); + + privacyListsManager.setInstanceId(instanceId); + avatarManager.setInstanceId(instanceId); + } + +} diff --git a/src/main/java/com/calclab/emite/core/client/LoginXmppMap.java b/src/main/java/com/calclab/emite/core/client/LoginXmppMap.java new file mode 100644 index 00000000..493b33da --- /dev/null +++ b/src/main/java/com/calclab/emite/core/client/LoginXmppMap.java @@ -0,0 +1,5 @@ +package com.calclab.emite.core.client; + +public @interface LoginXmppMap { + +} diff --git a/src/main/java/com/calclab/emite/core/client/MultiInstance.java b/src/main/java/com/calclab/emite/core/client/MultiInstance.java new file mode 100644 index 00000000..32984d78 --- /dev/null +++ b/src/main/java/com/calclab/emite/core/client/MultiInstance.java @@ -0,0 +1,5 @@ +package com.calclab.emite.core.client; + +public interface MultiInstance { + public void setInstanceId(String instanceId) ; +} diff --git a/src/main/java/com/calclab/emite/core/client/bosh/XmppBoshConnection.java b/src/main/java/com/calclab/emite/core/client/bosh/XmppBoshConnection.java index 6dcf82ad..2e288de6 100644 --- a/src/main/java/com/calclab/emite/core/client/bosh/XmppBoshConnection.java +++ b/src/main/java/com/calclab/emite/core/client/bosh/XmppBoshConnection.java @@ -20,9 +20,11 @@ package com.calclab.emite.core.client.bosh; +import java.util.HashMap; import java.util.List; import java.util.logging.Logger; +import com.calclab.emite.core.client.LoginXmppMap; import com.calclab.emite.core.client.conn.ConnectionSettings; import com.calclab.emite.core.client.conn.StanzaSentEvent; import com.calclab.emite.core.client.conn.XmppConnection; @@ -36,80 +38,32 @@ import com.calclab.emite.core.client.services.Services; import com.google.inject.Inject; import com.google.inject.Singleton; +import com.calclab.emite.core.client.LoginXmpp; /** * A Bosh connection implementation. * * @see XmppConnection */ -@Singleton +//@Singleton public class XmppBoshConnection extends XmppConnectionBoilerPlate { private static final Logger logger = Logger.getLogger(XmppBoshConnection.class.getName()); private int activeConnections; - private final Services services; - private final ConnectorCallback listener; + private Services services; + private ConnectorCallback listener; private boolean shouldCollectResponses; private final RetryControl retryControl = new RetryControl(); - @Inject - public XmppBoshConnection(final EmiteEventBus eventBus, final Services services) { - super(eventBus); - this.services = services; + private String instanceId; + private HashMap loginXmppMap; - listener = new ConnectorCallback() { - @Override - public void onError(final String request, final Throwable throwable) { - if (isActive()) { - final int e = incrementErrors(); - logger.severe("Connection error #" + e + ": " + throwable.getMessage()); - if (e > retryControl.maxRetries) { - fireError("Connection error: " + throwable.toString()); - disconnect(); - } else { - final int scedTime = retryControl.retry(e); - fireRetry(e, scedTime); - services.schedule(scedTime, new ScheduledAction() { - @Override - public void run() { - logger.info("Error retry: " + e); - send(request); - } - }); - } - } - } - - @Override - public void onResponseReceived(final int statusCode, final String content, final String originalRequest) { - clearErrors(); - activeConnections--; - if (isActive()) { - // TODO: check if is the same code in other than FF and make - // tests - if (statusCode == 404) { - fireError("404 Connection Error (session removed ?!) : " + content); - disconnect(); - } else if (statusCode != 200 && statusCode != 0) { - // setActive(false); - // fireError("Bad status: " + statusCode); - onError(originalRequest, new Exception("Bad status: " + statusCode + " " + content)); - } else { - final IPacket response = services.toXML(content); - if (response != null && "body".equals(response.getName())) { - clearErrors(); - fireResponse(content); - handleResponse(response); - } else { - onError(originalRequest, new Exception("Bad response: " + statusCode + " " + content)); - // fireError("Bad response: " + content); - } - } - } - } - }; + @Inject + public XmppBoshConnection(final @LoginXmppMap HashMap loginXmppMap) { + super(null); + this.loginXmppMap = loginXmppMap; } @Override @@ -324,4 +278,75 @@ private void sendBody(final boolean force) { } } + @Override + public void setInstanceId(String instanceId) { + // TODO Auto-generated method stub + + this.instanceId = instanceId; + + //eventBus.setInstanceId(instanceId); + //services.setInstanceId(instanceId); + + LoginXmpp loginXmpp = loginXmppMap.get(instanceId); + //this.connection = loginXmpp.xmppConnection; + + this.eventBus = loginXmpp.eventBus; + + logger.info("Creating XmppBoshConnection"); + this.services = loginXmpp.services; + + listener = new ConnectorCallback() { + + @Override + public void onError(final String request, final Throwable throwable) { + if (isActive()) { + final int e = incrementErrors(); + logger.severe("Connection error #" + e + ": " + throwable.getMessage()); + if (e > retryControl.maxRetries) { + fireError("Connection error: " + throwable.toString()); + disconnect(); + } else { + final int scedTime = retryControl.retry(e); + fireRetry(e, scedTime); + services.schedule(scedTime, new ScheduledAction() { + @Override + public void run() { + logger.info("Error retry: " + e); + send(request); + } + }); + } + } + } + + @Override + public void onResponseReceived(final int statusCode, final String content, final String originalRequest) { + clearErrors(); + activeConnections--; + if (isActive()) { + // TODO: check if is the same code in other than FF and make + // tests + if (statusCode == 404) { + fireError("404 Connection Error (session removed ?!) : " + content); + disconnect(); + } else if (statusCode != 200 && statusCode != 0) { + // setActive(false); + // fireError("Bad status: " + statusCode); + onError(originalRequest, new Exception("Bad status: " + statusCode + " " + content)); + } else { + final IPacket response = services.toXML(content); + if (response != null && "body".equals(response.getName())) { + clearErrors(); + fireResponse(content); + handleResponse(response); + } else { + onError(originalRequest, new Exception("Bad response: " + statusCode + " " + content)); + // fireError("Bad response: " + content); + } + } + } + } + }; + } + } diff --git a/src/main/java/com/calclab/emite/core/client/conn/XmppConnection.java b/src/main/java/com/calclab/emite/core/client/conn/XmppConnection.java index e724b605..079b5707 100644 --- a/src/main/java/com/calclab/emite/core/client/conn/XmppConnection.java +++ b/src/main/java/com/calclab/emite/core/client/conn/XmppConnection.java @@ -20,6 +20,7 @@ package com.calclab.emite.core.client.conn; +import com.calclab.emite.core.client.MultiInstance; import com.calclab.emite.core.client.bosh.StreamSettings; import com.calclab.emite.core.client.events.EmiteEventBus; import com.calclab.emite.core.client.packet.IPacket; @@ -28,7 +29,7 @@ /** * A connection to a xmpp server */ -public interface XmppConnection { +public interface XmppConnection extends MultiInstance { /** * Add a handler to know when a response (text) arrived from server diff --git a/src/main/java/com/calclab/emite/core/client/conn/XmppConnectionBoilerPlate.java b/src/main/java/com/calclab/emite/core/client/conn/XmppConnectionBoilerPlate.java index f427e10c..a1bd8c23 100644 --- a/src/main/java/com/calclab/emite/core/client/conn/XmppConnectionBoilerPlate.java +++ b/src/main/java/com/calclab/emite/core/client/conn/XmppConnectionBoilerPlate.java @@ -38,7 +38,7 @@ public abstract class XmppConnectionBoilerPlate implements XmppConnection { private static final Logger logger = Logger.getLogger(XmppConnectionBoilerPlate.class.getName()); - protected final EmiteEventBus eventBus; + protected EmiteEventBus eventBus; private int errors; private boolean active; private StreamSettings stream; diff --git a/src/main/java/com/calclab/emite/core/client/events/EmiteEventBus.java b/src/main/java/com/calclab/emite/core/client/events/EmiteEventBus.java index bada8cf4..902ec64f 100644 --- a/src/main/java/com/calclab/emite/core/client/events/EmiteEventBus.java +++ b/src/main/java/com/calclab/emite/core/client/events/EmiteEventBus.java @@ -20,12 +20,13 @@ package com.calclab.emite.core.client.events; +import com.calclab.emite.core.client.MultiInstance; import com.google.gwt.event.shared.EventHandler; import com.google.gwt.event.shared.GwtEvent; import com.google.gwt.event.shared.GwtEvent.Type; import com.google.gwt.event.shared.HandlerRegistration; -public interface EmiteEventBus { +public interface EmiteEventBus extends MultiInstance { HandlerRegistration addHandler(Type type, H handler); void fireEvent(GwtEvent event); diff --git a/src/main/java/com/calclab/emite/core/client/events/GwtEmiteEventBus.java b/src/main/java/com/calclab/emite/core/client/events/GwtEmiteEventBus.java index 4c6a5a8f..2147d334 100644 --- a/src/main/java/com/calclab/emite/core/client/events/GwtEmiteEventBus.java +++ b/src/main/java/com/calclab/emite/core/client/events/GwtEmiteEventBus.java @@ -31,6 +31,8 @@ public class GwtEmiteEventBus extends HandlerManager implements EmiteEventBus { private final String eventBusName; + private String instanceId; + GwtEmiteEventBus(final String eventBusName) { super(null); this.eventBusName = eventBusName; @@ -43,4 +45,9 @@ public void fireEvent(final GwtEvent event) { super.fireEvent(event); } + @Override + public void setInstanceId(String instanceId) { + this.instanceId = instanceId; + } + } diff --git a/src/main/java/com/calclab/emite/core/client/services/Services.java b/src/main/java/com/calclab/emite/core/client/services/Services.java index 5e887233..45c2a965 100644 --- a/src/main/java/com/calclab/emite/core/client/services/Services.java +++ b/src/main/java/com/calclab/emite/core/client/services/Services.java @@ -20,9 +20,10 @@ package com.calclab.emite.core.client.services; +import com.calclab.emite.core.client.MultiInstance; import com.calclab.emite.core.client.packet.IPacket; -public interface Services { +public interface Services extends MultiInstance { long getCurrentTime(); void schedule(int msecs, ScheduledAction action); diff --git a/src/main/java/com/calclab/emite/core/client/services/gwt/GWTServices.java b/src/main/java/com/calclab/emite/core/client/services/gwt/GWTServices.java index ea476fc7..96167bb0 100644 --- a/src/main/java/com/calclab/emite/core/client/services/gwt/GWTServices.java +++ b/src/main/java/com/calclab/emite/core/client/services/gwt/GWTServices.java @@ -31,8 +31,11 @@ @Singleton public class GWTServices implements Services { + String instanceId; + @Inject public GWTServices() { + } @Override @@ -60,4 +63,10 @@ public IPacket toXML(final String xml) { return GWTXMLService.toXML(xml); } + @Override + public void setInstanceId(String instanceId) { + this.instanceId = instanceId; + + } + } diff --git a/src/main/java/com/calclab/emite/core/client/xmpp/resource/ResourceBindingManager.java b/src/main/java/com/calclab/emite/core/client/xmpp/resource/ResourceBindingManager.java index d90143dd..93094e7c 100644 --- a/src/main/java/com/calclab/emite/core/client/xmpp/resource/ResourceBindingManager.java +++ b/src/main/java/com/calclab/emite/core/client/xmpp/resource/ResourceBindingManager.java @@ -20,6 +20,9 @@ package com.calclab.emite.core.client.xmpp.resource; +import java.util.HashMap; +import com.calclab.emite.core.client.LoginXmppMap; +import com.calclab.emite.core.client.MultiInstance; import com.calclab.emite.core.client.conn.StanzaEvent; import com.calclab.emite.core.client.conn.StanzaHandler; import com.calclab.emite.core.client.conn.XmppConnection; @@ -28,15 +31,30 @@ import com.calclab.emite.core.client.xmpp.stanzas.XmppURI; import com.google.inject.Inject; import com.google.inject.Singleton; +import com.calclab.emite.core.client.LoginXmpp; -@Singleton -public class ResourceBindingManager { - - private final XmppConnection connection; +//@Singleton +public class ResourceBindingManager implements MultiInstance { + private XmppConnection connection; + private HashMap loginXmppMap; @Inject - public ResourceBindingManager(final XmppConnection connection) { - this.connection = connection; + public ResourceBindingManager( final @LoginXmppMap HashMap loginXmppMap) { + this.loginXmppMap = loginXmppMap; + } + + public void bindResource(final String resource) { + final IQ iq = new IQ(IQ.Type.set); + iq.setId("bind-resource"); + iq.addChild("bind", "urn:ietf:params:xml:ns:xmpp-bind").addChild("resource", null).setText(resource); + + connection.send(iq); + } + + @Override + public void setInstanceId(String instanceId) { + LoginXmpp loginXmpp = loginXmppMap.get(instanceId); + this.connection = loginXmpp.xmppConnection; connection.addStanzaReceivedHandler(new StanzaHandler() { @Override @@ -48,15 +66,6 @@ public void onStanza(final StanzaEvent event) { } } }); - - } - - public void bindResource(final String resource) { - final IQ iq = new IQ(IQ.Type.set); - iq.setId("bind-resource"); - iq.addChild("bind", "urn:ietf:params:xml:ns:xmpp-bind").addChild("resource", null).setText(resource); - - connection.send(iq); } } diff --git a/src/main/java/com/calclab/emite/core/client/xmpp/sasl/SASLManager.java b/src/main/java/com/calclab/emite/core/client/xmpp/sasl/SASLManager.java index c6fa37b9..64709eb1 100644 --- a/src/main/java/com/calclab/emite/core/client/xmpp/sasl/SASLManager.java +++ b/src/main/java/com/calclab/emite/core/client/xmpp/sasl/SASLManager.java @@ -20,6 +20,11 @@ package com.calclab.emite.core.client.xmpp.sasl; +import java.util.HashMap; + +import com.calclab.emite.core.client.LoginXmpp; +import com.calclab.emite.core.client.LoginXmppMap; +import com.calclab.emite.core.client.MultiInstance; import com.calclab.emite.core.client.conn.StanzaEvent; import com.calclab.emite.core.client.conn.StanzaHandler; import com.calclab.emite.core.client.conn.XmppConnection; @@ -30,36 +35,22 @@ import com.google.inject.Inject; import com.google.inject.Singleton; -@Singleton -public class SASLManager { +//@Singleton +public class SASLManager implements MultiInstance { private static final String SEP = new String(new char[] { 0 }); private static final String XMLNS = "urn:ietf:params:xml:ns:xmpp-sasl"; - private final XmppConnection connection; + private XmppConnection connection; private final DecoderRegistry decoders; - private final EmiteEventBus eventBus; + private EmiteEventBus eventBus; private Credentials currentCredentials; + private final HashMap loginXmppMap; - @Inject - public SASLManager(final XmppConnection connection, final DecoderRegistry decoders) { - this.connection = connection; - eventBus = connection.getEventBus(); - this.decoders = decoders; - - connection.addStanzaReceivedHandler(new StanzaHandler() { - @Override - public void onStanza(final StanzaEvent event) { - final IPacket stanza = event.getStanza(); - final String name = stanza.getName(); - if ("failure".equals(name)) { // & XMLNS - eventBus.fireEvent(new AuthorizationResultEvent()); - } else if ("success".equals(name)) { - eventBus.fireEvent(new AuthorizationResultEvent(currentCredentials)); - } - currentCredentials = null; - } - }); - } + @Inject + public SASLManager(final DecoderRegistry decoders, final @LoginXmppMap HashMap loginXmppMap) { + this.loginXmppMap = loginXmppMap; + this.decoders = decoders; + } /** * Add a handler to know when an authorization transaction has a result @@ -100,4 +91,28 @@ private String encodeForPlainMethod(final String domain, final String userName, return Base64Coder.encodeString(auth); } + @Override + public void setInstanceId(String instanceId) { + + LoginXmpp loginXmpp = loginXmppMap.get(instanceId); + this.connection = loginXmpp.xmppConnection; + eventBus = connection.getEventBus(); + + connection.addStanzaReceivedHandler(new StanzaHandler() { + @Override + public void onStanza(final StanzaEvent event) { + final IPacket stanza = event.getStanza(); + final String name = stanza.getName(); + if ("failure".equals(name)) { // & XMLNS + eventBus.fireEvent(new AuthorizationResultEvent()); + } else if ("success".equals(name)) { + eventBus.fireEvent(new AuthorizationResultEvent(currentCredentials)); + } + //Ted Gulesserian: Check - this used to be commented in my code + //currentCredentials = null; + } + }); + + } + } diff --git a/src/main/java/com/calclab/emite/core/client/xmpp/session/IMSessionManager.java b/src/main/java/com/calclab/emite/core/client/xmpp/session/IMSessionManager.java index 3c85e688..957911d7 100644 --- a/src/main/java/com/calclab/emite/core/client/xmpp/session/IMSessionManager.java +++ b/src/main/java/com/calclab/emite/core/client/xmpp/session/IMSessionManager.java @@ -20,6 +20,11 @@ package com.calclab.emite.core.client.xmpp.session; +import java.util.HashMap; + +import com.calclab.emite.core.client.LoginXmpp; +import com.calclab.emite.core.client.LoginXmppMap; +import com.calclab.emite.core.client.MultiInstance; import com.calclab.emite.core.client.conn.StanzaEvent; import com.calclab.emite.core.client.conn.StanzaHandler; import com.calclab.emite.core.client.conn.XmppConnection; @@ -35,24 +40,17 @@ * * @see http://www.xmpp.org/extensions/xep-0206.html#preconditions-sasl */ -@Singleton -public class IMSessionManager { - private final XmppConnection connection; +//@Singleton +public class IMSessionManager implements MultiInstance { + private XmppConnection connection; + private HashMap loginXmppMap; + + @Inject + public IMSessionManager(final @LoginXmppMap HashMap loginXmppMap) { + this.loginXmppMap = loginXmppMap; + } - @Inject - public IMSessionManager(final XmppConnection connection) { - this.connection = connection; - connection.addStanzaReceivedHandler(new StanzaHandler() { - @Override - public void onStanza(final StanzaEvent event) { - final IPacket stanza = event.getStanza(); - if ("im-session-request".equals(stanza.getAttribute("id"))) { - connection.getEventBus().fireEvent(new SessionRequestResultEvent(XmppURI.uri(stanza.getAttribute("to")))); - } - } - }); - } /** * Request the session @@ -67,4 +65,21 @@ public void requestSession(final XmppURI uri) { connection.send(iq); } + + @Override + public void setInstanceId(String instanceId) { + LoginXmpp loginXmpp = loginXmppMap.get(instanceId); + this.connection = loginXmpp.xmppConnection; + + connection.addStanzaReceivedHandler(new StanzaHandler() { + @Override + public void onStanza(final StanzaEvent event) { + final IPacket stanza = event.getStanza(); + if ("im-session-request".equals(stanza.getAttribute("id"))) { + connection.getEventBus().fireEvent(new SessionRequestResultEvent(XmppURI.uri(stanza.getAttribute("to")))); + } + } + }); + + } } diff --git a/src/main/java/com/calclab/emite/core/client/xmpp/session/SessionComponentsRegistry.java b/src/main/java/com/calclab/emite/core/client/xmpp/session/SessionComponentsRegistry.java index 3b882272..aaaef671 100644 --- a/src/main/java/com/calclab/emite/core/client/xmpp/session/SessionComponentsRegistry.java +++ b/src/main/java/com/calclab/emite/core/client/xmpp/session/SessionComponentsRegistry.java @@ -23,6 +23,7 @@ import java.util.HashSet; import java.util.logging.Logger; +import com.calclab.emite.core.client.MultiInstance; import com.google.inject.Inject; import com.google.inject.Provider; import com.google.inject.Singleton; @@ -33,8 +34,8 @@ * * All the providers registered are called when the XmppSession is created */ -@Singleton -public class SessionComponentsRegistry { +//@Singleton +public class SessionComponentsRegistry implements MultiInstance { private static final Logger logger = Logger.getLogger(SessionComponentsRegistry.class.getName()); @@ -68,4 +69,11 @@ public void createComponents() { providers.clear(); componentsCreated = true; } + + @Override + public void setInstanceId(String instanceId) { + // TODO Auto-generated method stub + // Ted Gulesserian - there is work to be done here. + + } } diff --git a/src/main/java/com/calclab/emite/core/client/xmpp/session/SessionReady.java b/src/main/java/com/calclab/emite/core/client/xmpp/session/SessionReady.java index 568b2ce8..de3eb559 100644 --- a/src/main/java/com/calclab/emite/core/client/xmpp/session/SessionReady.java +++ b/src/main/java/com/calclab/emite/core/client/xmpp/session/SessionReady.java @@ -38,8 +38,12 @@ public class SessionReady { private boolean enabled; @Inject - public SessionReady(final XmppSession session) { - enabled = true; + public SessionReady() { + + } + + public void setSession(final XmppSession session) { + enabled = true; session.addSessionStateChangedHandler(true, new StateChangedHandler() { @Override @@ -51,7 +55,7 @@ public void onStateChanged(final StateChangedEvent event) { } } } - }); + }); } public void setEnabled(final boolean enabled) { diff --git a/src/main/java/com/calclab/emite/core/client/xmpp/session/XmppSession.java b/src/main/java/com/calclab/emite/core/client/xmpp/session/XmppSession.java index 39eec2fe..dbda8b57 100644 --- a/src/main/java/com/calclab/emite/core/client/xmpp/session/XmppSession.java +++ b/src/main/java/com/calclab/emite/core/client/xmpp/session/XmppSession.java @@ -20,6 +20,7 @@ package com.calclab.emite.core.client.xmpp.session; +import com.calclab.emite.core.client.MultiInstance; import com.calclab.emite.core.client.bosh.StreamSettings; import com.calclab.emite.core.client.events.EmiteEventBus; import com.calclab.emite.core.client.events.IQHandler; @@ -36,7 +37,7 @@ * The most important object in Xmpp emite module. You can login, send and * receive stanzas. It also allows you to pause and resume the session. */ -public interface XmppSession { +public interface XmppSession extends MultiInstance { /** * Add a handler to know when a stanza is going to be send. Allows to modify * a stanza before is sent to the server. @@ -216,4 +217,5 @@ public interface XmppSession { * @see SessionStates */ public void setSessionState(String state); + public void setInstanceId(String intanceId); } diff --git a/src/main/java/com/calclab/emite/core/client/xmpp/session/XmppSessionBoilerPlate.java b/src/main/java/com/calclab/emite/core/client/xmpp/session/XmppSessionBoilerPlate.java index acebe785..82288aa9 100644 --- a/src/main/java/com/calclab/emite/core/client/xmpp/session/XmppSessionBoilerPlate.java +++ b/src/main/java/com/calclab/emite/core/client/xmpp/session/XmppSessionBoilerPlate.java @@ -34,13 +34,13 @@ import com.google.gwt.event.shared.HandlerRegistration; public abstract class XmppSessionBoilerPlate implements XmppSession { - protected final EmiteEventBus eventBus; + protected EmiteEventBus eventBus; private String state; public XmppSessionBoilerPlate(final EmiteEventBus eventBus) { this.eventBus = eventBus; state = SessionStates.disconnected; - } + } @Override public HandlerRegistration addBeforeSendStanzaHandler(final PacketHandler handler) { diff --git a/src/main/java/com/calclab/emite/core/client/xmpp/session/XmppSessionLogic.java b/src/main/java/com/calclab/emite/core/client/xmpp/session/XmppSessionLogic.java index b34440c7..3ab29423 100644 --- a/src/main/java/com/calclab/emite/core/client/xmpp/session/XmppSessionLogic.java +++ b/src/main/java/com/calclab/emite/core/client/xmpp/session/XmppSessionLogic.java @@ -21,8 +21,11 @@ package com.calclab.emite.core.client.xmpp.session; import java.util.ArrayList; +import java.util.HashMap; import java.util.logging.Logger; +import com.calclab.emite.core.client.LoginXmpp; +import com.calclab.emite.core.client.LoginXmppMap; import com.calclab.emite.core.client.bosh.StreamSettings; import com.calclab.emite.core.client.conn.ConnectionStateChangedEvent; import com.calclab.emite.core.client.conn.ConnectionStateChangedEvent.ConnectionState; @@ -54,98 +57,27 @@ * * @see XmppSession */ -@Singleton +//@Singleton public class XmppSessionLogic extends XmppSessionBoilerPlate { private static final Logger logger = Logger.getLogger(XmppSessionLogic.class.getName()); private XmppURI userUri; - private final XmppConnection connection; - private final IQManager iqManager; - private final ArrayList queuedStanzas; + private XmppConnection connection; + private IQManager iqManager; + private ArrayList queuedStanzas; private Credentials credentials; - private final SessionComponentsRegistry registry; + private SessionComponentsRegistry registry; + private HashMap loginXmppMap; + private SASLManager saslManager; + ResourceBindingManager bindingManager; + IMSessionManager iMSessionManager; + LoginXmpp loginXmpp = null; @Inject - public XmppSessionLogic(final XmppConnection connection, final SASLManager saslManager, final ResourceBindingManager bindingManager, - final IMSessionManager iMSessionManager, final SessionComponentsRegistry registry) { - super(connection.getEventBus()); - this.registry = registry; - this.connection = connection; - iqManager = new IQManager(); - queuedStanzas = new ArrayList(); - - connection.addStanzaReceivedHandler(new StanzaHandler() { - @Override - public void onStanza(final StanzaEvent event) { - final IPacket stanza = event.getStanza(); - final String name = stanza.getName(); - if (name.equals("message")) { - eventBus.fireEvent(new MessageReceivedEvent(new Message(stanza))); - } else if (name.equals("presence")) { - eventBus.fireEvent(new PresenceReceivedEvent(new Presence(stanza))); - } else if (name.equals("iq")) { - final String type = stanza.getAttribute("type"); - if ("get".equals(type) || "set".equals(type)) { - eventBus.fireEvent(new IQReceivedEvent(new IQ(stanza))); - } else { - iqManager.handle(stanza); - } - } else if (credentials != null && ("stream:features".equals(name)||"features".equals(name)) && stanza.hasChild("mechanisms")) { - setSessionState(SessionStates.connecting); - saslManager.sendAuthorizationRequest(credentials); - credentials = null; - } - } - }); - - connection.addConnectionStateChangedHandler(new ConnectionStateChangedHandler() { - @Override - public void onStateChanged(final ConnectionStateChangedEvent event) { - if (event.is(ConnectionState.error)) { - logger.severe("Connection error: " + event.getDescription()); - setSessionState(SessionStates.error); - } else if (event.is(ConnectionState.disconnected)) { - setSessionState(SessionStates.disconnected); - } - } - }); - - // Do not use manager, in order to be able to mock on testing - AuthorizationResultEvent.bind(eventBus, new AuthorizationResultHandler() { - @Override - public void onAuthorization(final AuthorizationResultEvent event) { - if (event.isSucceed()) { - setSessionState(SessionStates.authorized); - connection.restartStream(); - bindingManager.bindResource(event.getXmppUri().getResource()); - } else { - setSessionState(SessionStates.notAuthorized); - disconnect(); - } - } - }); - - // Do not use manager, in order to be able to mock on testing - ResourceBindResultEvent.bind(eventBus, new ResourceBindResultHandler() { - @Override - public void onBinded(final ResourceBindResultEvent event) { - setSessionState(SessionStates.binded); - iMSessionManager.requestSession(event.getXmppUri()); - } - }); - - // Do not use manager, in order to be able to mock on testing - SessionRequestResultEvent.bind(eventBus, new SessionRequestResultHandler() { - @Override - public void onSessionRequestResult(final SessionRequestResultEvent event) { - if (event.isSucceed()) { - setLoggedIn(event.getXmppUri()); - } else { - disconnect(); - } - } - }); + public XmppSessionLogic(@LoginXmppMap HashMap loginXmppMap) { + super(null); + this.loginXmppMap = loginXmppMap; } @Override @@ -258,4 +190,94 @@ public XmppConnection getConnection() { return connection; } + + @Override + public void setInstanceId(String instanceId) { + + loginXmpp = loginXmppMap.get(instanceId); + + eventBus = loginXmpp.eventBus; + + registry = loginXmpp.registry; + connection = loginXmpp.xmppConnection; + saslManager = loginXmpp.saslManager; + bindingManager = loginXmpp.bindingManager; + iMSessionManager = loginXmpp.iMSessionManager; + iqManager = new IQManager(); + queuedStanzas = new ArrayList(); + + + connection.addStanzaReceivedHandler(new StanzaHandler() { + @Override + public void onStanza(final StanzaEvent event) { + final IPacket stanza = event.getStanza(); + final String name = stanza.getName(); + if (name.equals("message")) { + eventBus.fireEvent(new MessageReceivedEvent(new Message(stanza))); + } else if (name.equals("presence")) { + eventBus.fireEvent(new PresenceReceivedEvent(new Presence(stanza))); + } else if (name.equals("iq")) { + final String type = stanza.getAttribute("type"); + if ("get".equals(type) || "set".equals(type)) { + eventBus.fireEvent(new IQReceivedEvent(new IQ(stanza))); + } else { + iqManager.handle(stanza); + } + } else if (credentials != null && ("stream:features".equals(name)||"features".equals(name)) && stanza.hasChild("mechanisms")) { + setSessionState(SessionStates.connecting); + saslManager.sendAuthorizationRequest(credentials); + credentials = null; + } + } + }); + + connection.addConnectionStateChangedHandler(new ConnectionStateChangedHandler() { + @Override + public void onStateChanged(final ConnectionStateChangedEvent event) { + if (event.is(ConnectionState.error)) { + logger.severe("Connection error: " + event.getDescription()); + setSessionState(SessionStates.error); + } else if (event.is(ConnectionState.disconnected)) { + setSessionState(SessionStates.disconnected); + } + } + }); + + // Do not use manager, in order to be able to mock on testing + AuthorizationResultEvent.bind(eventBus, new AuthorizationResultHandler() { + @Override + public void onAuthorization(final AuthorizationResultEvent event) { + if (event.isSucceed()) { + setSessionState(SessionStates.authorized); + connection.restartStream(); + bindingManager.bindResource(event.getXmppUri().getResource()); + } else { + setSessionState(SessionStates.notAuthorized); + disconnect(); + } + } + }); + + // Do not use manager, in order to be able to mock on testing + ResourceBindResultEvent.bind(eventBus, new ResourceBindResultHandler() { + @Override + public void onBinded(final ResourceBindResultEvent event) { + setSessionState(SessionStates.binded); + iMSessionManager.requestSession(event.getXmppUri()); + } + }); + + // Do not use manager, in order to be able to mock on testing + SessionRequestResultEvent.bind(eventBus, new SessionRequestResultHandler() { + @Override + public void onSessionRequestResult(final SessionRequestResultEvent event) { + if (event.isSucceed()) { + setLoggedIn(event.getXmppUri()); + } else { + disconnect(); + } + } + }); + + } } diff --git a/src/main/java/com/calclab/emite/im/client/ImComponents.java b/src/main/java/com/calclab/emite/im/client/ImComponents.java index 11740c93..0ba39a93 100644 --- a/src/main/java/com/calclab/emite/im/client/ImComponents.java +++ b/src/main/java/com/calclab/emite/im/client/ImComponents.java @@ -20,6 +20,11 @@ package com.calclab.emite.im.client; +import java.util.HashMap; + +import com.calclab.emite.core.client.LoginXmpp; +import com.calclab.emite.core.client.LoginXmppMap; +import com.calclab.emite.core.client.MultiInstance; import com.calclab.emite.core.client.xmpp.session.SessionComponentsRegistry; import com.calclab.emite.im.client.chat.ChatManager; import com.calclab.emite.im.client.presence.PresenceManager; @@ -37,17 +42,45 @@ * @see SessionComponentsRegistry */ @Singleton -public class ImComponents { +public class ImComponents implements MultiInstance { + Provider chatManager; + Provider presenceManager; + Provider subscriptionManager; + Provider subcriptionHandler; + Provider xmppRoster; + HashMap loginXmppMap; + private LoginXmpp loginXmpp; @Inject public ImComponents(final SessionComponentsRegistry registry, final Provider chatManager, final Provider presenceManager, final Provider subscriptionManager, final Provider subcriptionHandler, - final Provider xmppRoster) { + final Provider xmppRoster, @LoginXmppMap HashMap loginXmppMap, LoginXmpp loginXmpp) { + this.chatManager = chatManager; + this.presenceManager = presenceManager; + this.subscriptionManager = subscriptionManager; + this.subcriptionHandler = subcriptionHandler; + this.xmppRoster = xmppRoster; + this.loginXmppMap = loginXmppMap; + this.loginXmpp = loginXmpp; +/* registry.addProvider(chatManager); registry.addProvider(presenceManager); registry.addProvider(subscriptionManager); registry.addProvider(subcriptionHandler); registry.addProvider(xmppRoster); +*/ + } + @Override + public void setInstanceId(String instanceId) { + loginXmppMap.put(instanceId, loginXmpp); + loginXmpp.setInstanceId(instanceId); + + loginXmpp.registry.addProvider(chatManager); + loginXmpp.registry.addProvider(presenceManager); + loginXmpp.registry.addProvider(subscriptionManager); + loginXmpp.registry.addProvider(subcriptionHandler); + loginXmpp.registry.addProvider(xmppRoster); + } } diff --git a/src/main/java/com/calclab/emite/im/client/ImModule.java b/src/main/java/com/calclab/emite/im/client/ImModule.java index 99454d32..621c5e65 100644 --- a/src/main/java/com/calclab/emite/im/client/ImModule.java +++ b/src/main/java/com/calclab/emite/im/client/ImModule.java @@ -20,6 +20,7 @@ package com.calclab.emite.im.client; +import com.calclab.emite.browser.client.PageAssist; import com.calclab.emite.im.client.chat.ChatManager; import com.calclab.emite.im.client.chat.ChatSelectionStrategy; import com.calclab.emite.im.client.chat.PairChatManager; @@ -48,13 +49,14 @@ public class ImModule extends AbstractGinModule { @Override protected void configure() { - bind(ChatManager.class).to(PairChatManager.class).in(Singleton.class); - bind(PresenceManager.class).to(PresenceManagerImpl.class).in(Singleton.class); - bind(SubscriptionManager.class).to(SubscriptionManagerImpl.class).in(Singleton.class); - bind(SubscriptionHandler.class).in(Singleton.class); - bind(XmppRoster.class).to(XmppRosterLogic.class).in(Singleton.class); - bind(ImComponents.class).asEagerSingleton(); - bind(ChatSelectionStrategy.class).annotatedWith(Names.named("Pair")).to(PairChatSelectionStrategy.class).in(Singleton.class); + bind(ChatManager.class).to(PairChatManager.class);//.in(Singleton.class); + bind(PresenceManager.class).to(PresenceManagerImpl.class);//.in(Singleton.class); + bind(SubscriptionManager.class).to(SubscriptionManagerImpl.class);//.in(Singleton.class); + bind(SubscriptionHandler.class);//.in(Singleton.class); + bind(XmppRoster.class).to(XmppRosterLogic.class);//.in(Singleton.class); + bind(ImComponents.class).asEagerSingleton(); //Maybe necessary for browsermodule + bind(ChatSelectionStrategy.class).annotatedWith(Names.named("Pair")).to(PairChatSelectionStrategy.class).in( + Singleton.class); } } diff --git a/src/main/java/com/calclab/emite/im/client/chat/AbstractChat.java b/src/main/java/com/calclab/emite/im/client/chat/AbstractChat.java index 1f2508a5..9d7c550f 100644 --- a/src/main/java/com/calclab/emite/im/client/chat/AbstractChat.java +++ b/src/main/java/com/calclab/emite/im/client/chat/AbstractChat.java @@ -60,7 +60,7 @@ public boolean isReady() { } @Override - public void receive(final Message message) { + public void receive(Message message) { chatEventBus.fireEvent(new BeforeReceiveMessageEvent(message)); chatEventBus.fireEvent(new MessageReceivedEvent(message)); } diff --git a/src/main/java/com/calclab/emite/im/client/chat/AbstractChatManager.java b/src/main/java/com/calclab/emite/im/client/chat/AbstractChatManager.java index 3e27120c..61027bed 100644 --- a/src/main/java/com/calclab/emite/im/client/chat/AbstractChatManager.java +++ b/src/main/java/com/calclab/emite/im/client/chat/AbstractChatManager.java @@ -39,6 +39,18 @@ public AbstractChatManager(final XmppSession session, final ChatSelectionStrateg forwardMessagesToChats(); controlSessionStatus(); } + + public AbstractChatManager(ChatSelectionStrategy strategy) { + super(strategy); + // TODO Auto-generated constructor stub + } + + @Override + public void setInstanceId(String instanceId) { + super.setInstanceId(instanceId); + forwardMessagesToChats(); + controlSessionStatus(); + } @Override public void close(final Chat chat) { diff --git a/src/main/java/com/calclab/emite/im/client/chat/ChatManager.java b/src/main/java/com/calclab/emite/im/client/chat/ChatManager.java index 3ef88398..eee89880 100644 --- a/src/main/java/com/calclab/emite/im/client/chat/ChatManager.java +++ b/src/main/java/com/calclab/emite/im/client/chat/ChatManager.java @@ -22,6 +22,7 @@ import java.util.Collection; +import com.calclab.emite.core.client.MultiInstance; import com.calclab.emite.core.client.xmpp.stanzas.XmppURI; import com.calclab.emite.im.client.chat.events.ChatChangedHandler; import com.google.gwt.event.shared.HandlerRegistration; @@ -32,7 +33,7 @@ * There are one implementation for one-to-one conversations (PairChatManager) * and many-to-many conversations (RoomManagerImpl) */ -public interface ChatManager { +public interface ChatManager extends MultiInstance { /** * Add a handler to track chat changes. The following changes can ocurr from diff --git a/src/main/java/com/calclab/emite/im/client/chat/ChatManagerBoilerplate.java b/src/main/java/com/calclab/emite/im/client/chat/ChatManagerBoilerplate.java index eb6deabf..772ebe12 100644 --- a/src/main/java/com/calclab/emite/im/client/chat/ChatManagerBoilerplate.java +++ b/src/main/java/com/calclab/emite/im/client/chat/ChatManagerBoilerplate.java @@ -21,8 +21,10 @@ package com.calclab.emite.im.client.chat; import java.util.Collection; +import java.util.HashMap; import java.util.HashSet; +import com.calclab.emite.core.client.LoginXmpp; import com.calclab.emite.core.client.events.EmiteEventBus; import com.calclab.emite.core.client.events.EventBusFactory; import com.calclab.emite.core.client.xmpp.session.XmppSession; @@ -31,12 +33,14 @@ import com.calclab.emite.im.client.chat.events.ChatChangedHandler; import com.google.gwt.event.shared.HandlerRegistration; -public abstract class ChatManagerBoilerplate implements ChatManager { - protected final XmppSession session; +public abstract class ChatManagerBoilerplate implements ChatManager { + + protected XmppSession session; protected ChatSelectionStrategy strategy; protected final HashSet chats; protected final EmiteEventBus managerEventBus; + protected HashMap loginXmppMap = null; public ChatManagerBoilerplate(final XmppSession session, final ChatSelectionStrategy strategy) { this.session = session; @@ -45,6 +49,20 @@ public ChatManagerBoilerplate(final XmppSession session, final ChatSelectionStra chats = new HashSet(); } + public ChatManagerBoilerplate(ChatSelectionStrategy strategy) { + this.strategy = strategy; + chats = new HashSet(); + this.managerEventBus = EventBusFactory.create("chatManager"); + } + + @Override + public void setInstanceId(String instanceId) { + + //loginXmppMap = GinjectorHolder.getGinjector().getLoginXmppMap(); + LoginXmpp loginXmpp = loginXmppMap.get(instanceId); + this.session = loginXmpp.xmppSession; + } + @Override public HandlerRegistration addChatChangedHandler(final ChatChangedHandler handler) { return ChatChangedEvent.bind(managerEventBus, handler); @@ -70,5 +88,7 @@ public void setChatSelectionStrategy(final ChatSelectionStrategy strategy) { assert strategy != null : "The ChatSelectionStrategy can't be null!"; this.strategy = strategy; } + + } diff --git a/src/main/java/com/calclab/emite/im/client/chat/PairChatManager.java b/src/main/java/com/calclab/emite/im/client/chat/PairChatManager.java index 447645bb..c37effad 100644 --- a/src/main/java/com/calclab/emite/im/client/chat/PairChatManager.java +++ b/src/main/java/com/calclab/emite/im/client/chat/PairChatManager.java @@ -20,6 +20,10 @@ package com.calclab.emite.im.client.chat; +import java.util.HashMap; + +import com.calclab.emite.core.client.LoginXmpp; +import com.calclab.emite.core.client.LoginXmppMap; import com.calclab.emite.core.client.xmpp.session.XmppSession; import com.google.inject.Inject; import com.google.inject.Singleton; @@ -30,16 +34,24 @@ * * @see ChatManager */ -@Singleton +//@Singleton public class PairChatManager extends AbstractChatManager { +/* public PairChatManager(final XmppSession session) { this(session, new PairChatSelectionStrategy()); } +*/ @Inject - public PairChatManager(final XmppSession session, @Named("Pair") final ChatSelectionStrategy strategy) { - super(session, strategy); + public PairChatManager(@Named("Pair") final ChatSelectionStrategy strategy, final @LoginXmppMap HashMap loginXmppMap) { + super( strategy); + this.loginXmppMap = loginXmppMap; + } + + @Override + public void setInstanceId(String instanceId) { + super.setInstanceId(instanceId); } @Override diff --git a/src/main/java/com/calclab/emite/im/client/presence/PresenceManager.java b/src/main/java/com/calclab/emite/im/client/presence/PresenceManager.java index 7824a2ea..3558ab6f 100644 --- a/src/main/java/com/calclab/emite/im/client/presence/PresenceManager.java +++ b/src/main/java/com/calclab/emite/im/client/presence/PresenceManager.java @@ -20,6 +20,7 @@ package com.calclab.emite.im.client.presence; +import com.calclab.emite.core.client.MultiInstance; import com.calclab.emite.core.client.xmpp.stanzas.Presence; import com.calclab.emite.im.client.presence.events.OwnPresenceChangedHandler; import com.google.gwt.event.shared.HandlerRegistration; @@ -31,7 +32,7 @@ * * @see http://xmpp.org/rfcs/rfc3921.html#presence */ -public interface PresenceManager { +public interface PresenceManager extends MultiInstance { /** * Adds a handler to know when the current user's presence changed * diff --git a/src/main/java/com/calclab/emite/im/client/presence/PresenceManagerImpl.java b/src/main/java/com/calclab/emite/im/client/presence/PresenceManagerImpl.java index 6b849e9a..eb48090b 100644 --- a/src/main/java/com/calclab/emite/im/client/presence/PresenceManagerImpl.java +++ b/src/main/java/com/calclab/emite/im/client/presence/PresenceManagerImpl.java @@ -20,8 +20,11 @@ package com.calclab.emite.im.client.presence; +import java.util.HashMap; import java.util.logging.Logger; +import com.calclab.emite.core.client.LoginXmpp; +import com.calclab.emite.core.client.LoginXmppMap; import com.calclab.emite.core.client.events.ErrorEvent; import com.calclab.emite.core.client.events.PresenceEvent; import com.calclab.emite.core.client.events.PresenceHandler; @@ -42,54 +45,21 @@ /** * @see PresenceManager */ -@Singleton +//@Singleton public class PresenceManagerImpl implements PresenceManager { private static final Logger logger = Logger.getLogger(PresenceManagerImpl.class.getName()); private Presence ownPresence; static final Presence INITIAL_PRESENCE = new Presence(Type.unavailable, null, null); - private final XmppSession session; + private XmppSession session; - @Inject - public PresenceManagerImpl(final XmppSession session, final SessionReady sessionReady) { - sessionReady.setEnabled(false); - this.session = session; - setOwnPresence(INITIAL_PRESENCE); - - // Upon connecting to the server and becoming an active resource, a - // client SHOULD request the roster before sending initial presence - session.addSessionStateChangedHandler(true, new StateChangedHandler() { - @Override - public void onStateChanged(final StateChangedEvent event) { - if (event.is(SessionStates.rosterReady)) { - logger.fine("Sending initial presence"); - final Presence ownPresence = getOwnPresence(); - final Presence initialPresence = ownPresence != INITIAL_PRESENCE ? ownPresence : new Presence(session.getCurrentUserURI()); - session.send(initialPresence); - setOwnPresence(initialPresence); - session.setSessionState(SessionStates.ready); - } else if (event.is(SessionStates.loggingOut)) { - sendUnavailablePresence(session.getCurrentUserURI()); - } else if (event.is(SessionStates.disconnected)) { - setOwnPresence(INITIAL_PRESENCE); - } - } - }); - - session.addPresenceReceivedHandler(new PresenceHandler() { - @Override - public void onPresence(final PresenceEvent event) { - final Presence presence = event.getPresence(); - final Type type = presence.getType(); - if (type == Type.probe) { - session.send(getOwnPresence()); - } else if (type == Type.error) { - session.getEventBus().fireEvent(new ErrorEvent("presenceError", "we received an error presence", presence)); - } - } - }); + private HashMap loginXmppMap; + @Inject + public PresenceManagerImpl(final @LoginXmppMap HashMap loginXmppMap) { + this.loginXmppMap= loginXmppMap; + } @Override @@ -140,4 +110,50 @@ private void setOwnPresence(final Presence presence) { session.getEventBus().fireEvent(new OwnPresenceChangedEvent(oldPresence, presence)); } + @Override + public void setInstanceId(String instanceId) { + LoginXmpp loginXmpp = loginXmppMap.get(instanceId); + this.session = loginXmpp.xmppSession; + + SessionReady sessionReady = new SessionReady(); + sessionReady.setSession(session); + sessionReady.setEnabled(false); + + setOwnPresence(INITIAL_PRESENCE); + + // Upon connecting to the server and becoming an active resource, a + // client SHOULD request the roster before sending initial presence + session.addSessionStateChangedHandler(true, new StateChangedHandler() { + @Override + public void onStateChanged(final StateChangedEvent event) { + if (event.is(SessionStates.rosterReady)) { + logger.fine("Sending initial presence"); + final Presence ownPresence = getOwnPresence(); + final Presence initialPresence = ownPresence != INITIAL_PRESENCE ? ownPresence : new Presence(session.getCurrentUserURI()); + session.send(initialPresence); + setOwnPresence(initialPresence); + session.setSessionState(SessionStates.ready); + } else if (event.is(SessionStates.loggingOut)) { + sendUnavailablePresence(session.getCurrentUserURI()); + } else if (event.is(SessionStates.disconnected)) { + setOwnPresence(INITIAL_PRESENCE); + } + } + }); + + session.addPresenceReceivedHandler(new PresenceHandler() { + @Override + public void onPresence(final PresenceEvent event) { + final Presence presence = event.getPresence(); + final Type type = presence.getType(); + if (type == Type.probe) { + session.send(getOwnPresence()); + } else if (type == Type.error) { + session.getEventBus().fireEvent(new ErrorEvent("presenceError", "we received an error presence", presence)); + } + } + }); + + } + } diff --git a/src/main/java/com/calclab/emite/im/client/roster/SubscriptionHandler.java b/src/main/java/com/calclab/emite/im/client/roster/SubscriptionHandler.java index dda9b9e4..b4ecdab8 100644 --- a/src/main/java/com/calclab/emite/im/client/roster/SubscriptionHandler.java +++ b/src/main/java/com/calclab/emite/im/client/roster/SubscriptionHandler.java @@ -20,6 +20,11 @@ package com.calclab.emite.im.client.roster; +import java.util.HashMap; + +import com.calclab.emite.core.client.LoginXmpp; +import com.calclab.emite.core.client.LoginXmppMap; +import com.calclab.emite.core.client.MultiInstance; import com.calclab.emite.im.client.roster.events.SubscriptionRequestReceivedEvent; import com.calclab.emite.im.client.roster.events.SubscriptionRequestReceivedHandler; import com.google.inject.Inject; @@ -36,8 +41,8 @@ * * The default behaviour is none: do nothing */ -@Singleton -public class SubscriptionHandler { +//@Singleton +public class SubscriptionHandler implements MultiInstance { public static enum Behaviour { /** do nothing **/ @@ -49,9 +54,29 @@ public static enum Behaviour { } private Behaviour behaviour; + private final HashMap loginXmppMap; @Inject - public SubscriptionHandler(final SubscriptionManager manager) { + public SubscriptionHandler(final @LoginXmppMap HashMap loginXmppMap) { + this.loginXmppMap= loginXmppMap; + } + + /** + * Change the behaviour + * + * @param behaviour + * the desired new behaviour + */ + public void setBehaviour(final Behaviour behaviour) { + this.behaviour = behaviour; + } + + @Override + public void setInstanceId(String instanceId) { + + LoginXmpp loginXmpp = loginXmppMap.get(instanceId); + final SubscriptionManager manager = loginXmpp.subscriptionManager; + behaviour = Behaviour.none; manager.addSubscriptionRequestReceivedHandler(new SubscriptionRequestReceivedHandler() { @@ -64,17 +89,7 @@ public void onSubscriptionRequestReceived(final SubscriptionRequestReceivedEvent } } }); - - } - - /** - * Change the behaviour - * - * @param behaviour - * the desired new behaviour - */ - public void setBehaviour(final Behaviour behaviour) { - this.behaviour = behaviour; + } } diff --git a/src/main/java/com/calclab/emite/im/client/roster/SubscriptionManager.java b/src/main/java/com/calclab/emite/im/client/roster/SubscriptionManager.java index b34978a0..455f2b79 100644 --- a/src/main/java/com/calclab/emite/im/client/roster/SubscriptionManager.java +++ b/src/main/java/com/calclab/emite/im/client/roster/SubscriptionManager.java @@ -20,6 +20,7 @@ package com.calclab.emite.im.client.roster; +import com.calclab.emite.core.client.MultiInstance; import com.calclab.emite.core.client.xmpp.stanzas.XmppURI; import com.calclab.emite.im.client.roster.events.SubscriptionRequestReceivedHandler; import com.google.gwt.event.shared.HandlerRegistration; @@ -31,7 +32,7 @@ * @see http://www.xmpp.org/rfcs/rfc3921.html#sub * @see http://www.xmpp.org/rfcs/rfc3921.html#int */ -public interface SubscriptionManager { +public interface SubscriptionManager extends MultiInstance { /** * Add a handler to know when a subscription request has arrived diff --git a/src/main/java/com/calclab/emite/im/client/roster/SubscriptionManagerImpl.java b/src/main/java/com/calclab/emite/im/client/roster/SubscriptionManagerImpl.java index 57505812..0c1e5ce8 100644 --- a/src/main/java/com/calclab/emite/im/client/roster/SubscriptionManagerImpl.java +++ b/src/main/java/com/calclab/emite/im/client/roster/SubscriptionManagerImpl.java @@ -20,6 +20,10 @@ package com.calclab.emite.im.client.roster; +import java.util.HashMap; + +import com.calclab.emite.core.client.LoginXmpp; +import com.calclab.emite.core.client.LoginXmppMap; import com.calclab.emite.core.client.events.PresenceEvent; import com.calclab.emite.core.client.events.PresenceHandler; import com.calclab.emite.core.client.packet.IPacket; @@ -40,46 +44,16 @@ /** * @see SubscriptionManager */ -@Singleton +//@Singleton public class SubscriptionManagerImpl implements SubscriptionManager { protected static final PacketMatcher FILTER_NICK = MatcherFactory.byNameAndXMLNS("nick", "http://jabber.org/protocol/nick"); - private final XmppSession session; - private final XmppRoster roster; + private XmppSession session; + private XmppRoster roster; + private final HashMap loginXmppMap; @Inject - public SubscriptionManagerImpl(final XmppSession session, final XmppRoster roster) { - this.session = session; - this.roster = roster; - - session.addPresenceReceivedHandler(new PresenceHandler() { - @Override - public void onPresence(final PresenceEvent event) { - final Presence presence = event.getPresence(); - if (presence.getType() == Type.subscribe) { - final IPacket nick = presence.getFirstChild(FILTER_NICK); - session.getEventBus().fireEvent(new SubscriptionRequestReceivedEvent(presence.getFrom(), nick.getText())); - } - } - }); - - // use bind instead of roster for better testing - RosterItemChangedEvent.bind(session.getEventBus(), new RosterItemChangedHandler() { - @Override - public void onRosterItemChanged(final RosterItemChangedEvent event) { - if (event.isAdded()) { - final RosterItem item = event.getRosterItem(); - if (item.getSubscriptionState() == SubscriptionState.none) { - // && item.getAsk() == Type.subscribe) { - requestSubscribe(item.getJID()); - item.setSubscriptionState(SubscriptionState.nonePendingIn); - } else if (item.getSubscriptionState() == SubscriptionState.from) { - approveSubscriptionRequest(item.getJID(), item.getName()); - item.setSubscriptionState(SubscriptionState.fromPendingOut); - } - } - } - }); - + public SubscriptionManagerImpl(final @LoginXmppMap HashMap loginXmppMap) { + this.loginXmppMap= loginXmppMap; } @Override @@ -121,4 +95,43 @@ public void unsubscribe(final XmppURI jid) { session.send(new Presence(Type.unsubscribe, session.getCurrentUserURI().getJID(), jid.getJID())); } + @Override + public void setInstanceId(String instanceId) { + + LoginXmpp loginXmpp = loginXmppMap.get(instanceId); + + this.session = loginXmpp.xmppSession; + this.roster = loginXmpp.xmppRoster; + + session.addPresenceReceivedHandler(new PresenceHandler() { + @Override + public void onPresence(final PresenceEvent event) { + final Presence presence = event.getPresence(); + if (presence.getType() == Type.subscribe) { + final IPacket nick = presence.getFirstChild(FILTER_NICK); + session.getEventBus().fireEvent(new SubscriptionRequestReceivedEvent(presence.getFrom(), nick.getText())); + } + } + }); + + // use bind instead of roster for better testing + RosterItemChangedEvent.bind(session.getEventBus(), new RosterItemChangedHandler() { + @Override + public void onRosterItemChanged(final RosterItemChangedEvent event) { + if (event.isAdded()) { + final RosterItem item = event.getRosterItem(); + if (item.getSubscriptionState() == SubscriptionState.none) { + // && item.getAsk() == Type.subscribe) { + requestSubscribe(item.getJID()); + item.setSubscriptionState(SubscriptionState.nonePendingIn); + } else if (item.getSubscriptionState() == SubscriptionState.from) { + approveSubscriptionRequest(item.getJID(), item.getName()); + item.setSubscriptionState(SubscriptionState.fromPendingOut); + } + } + } + }); + + } + } diff --git a/src/main/java/com/calclab/emite/im/client/roster/XmppRoster.java b/src/main/java/com/calclab/emite/im/client/roster/XmppRoster.java index 7532fb28..c5bb8dc4 100644 --- a/src/main/java/com/calclab/emite/im/client/roster/XmppRoster.java +++ b/src/main/java/com/calclab/emite/im/client/roster/XmppRoster.java @@ -23,13 +23,14 @@ import java.util.Collection; import java.util.Set; +import com.calclab.emite.core.client.MultiInstance; import com.calclab.emite.core.client.xmpp.stanzas.XmppURI; import com.calclab.emite.im.client.roster.events.RosterGroupChangedHandler; import com.calclab.emite.im.client.roster.events.RosterItemChangedHandler; import com.calclab.emite.im.client.roster.events.RosterRetrievedHandler; import com.google.gwt.event.shared.HandlerRegistration; -public interface XmppRoster { +public interface XmppRoster extends MultiInstance { /** * Adds a handler to know when a roster group has changed * diff --git a/src/main/java/com/calclab/emite/im/client/roster/XmppRosterBoilerplate.java b/src/main/java/com/calclab/emite/im/client/roster/XmppRosterBoilerplate.java index 5cd72dd8..9fe55514 100644 --- a/src/main/java/com/calclab/emite/im/client/roster/XmppRosterBoilerplate.java +++ b/src/main/java/com/calclab/emite/im/client/roster/XmppRosterBoilerplate.java @@ -17,9 +17,11 @@ * You should have received a copy of the GNU Lesser General Public * License along with Emite. If not, see . */ - package com.calclab.emite.im.client.roster; +import java.util.HashMap; + +import com.calclab.emite.core.client.LoginXmpp; import com.calclab.emite.core.client.events.EmiteEventBus; import com.calclab.emite.core.client.xmpp.session.XmppSession; import com.calclab.emite.im.client.roster.events.RosterGroupChangedEvent; @@ -32,14 +34,14 @@ public abstract class XmppRosterBoilerplate implements XmppRoster { - protected final XmppSession session; + protected XmppSession session; protected EmiteEventBus eventBus; protected boolean rosterReady; + + protected HashMap loginXmppMap; + + public XmppRosterBoilerplate() { - public XmppRosterBoilerplate(final XmppSession session) { - this.session = session; - eventBus = session.getEventBus(); - rosterReady = false; } @Override @@ -62,4 +64,12 @@ public boolean isRosterReady() { return rosterReady; } + @Override + public void setInstanceId(String instanceId) { + LoginXmpp loginXmpp = loginXmppMap.get(instanceId); + this.session = loginXmpp.xmppSession; + eventBus = session.getEventBus(); + rosterReady = false; + + } } diff --git a/src/main/java/com/calclab/emite/im/client/roster/XmppRosterGroupsLogic.java b/src/main/java/com/calclab/emite/im/client/roster/XmppRosterGroupsLogic.java index e00d9b86..ad7ece2c 100644 --- a/src/main/java/com/calclab/emite/im/client/roster/XmppRosterGroupsLogic.java +++ b/src/main/java/com/calclab/emite/im/client/roster/XmppRosterGroupsLogic.java @@ -35,12 +35,18 @@ public abstract class XmppRosterGroupsLogic extends XmppRosterBoilerplate { protected final HashMap groups; private final RosterGroup all; - public XmppRosterGroupsLogic(final XmppSession session) { - super(session); + public XmppRosterGroupsLogic() { + //super(session); groups = new HashMap(); all = new RosterGroup(null); } + @Override + public void setInstanceId(String instanceId) { + super.setInstanceId(instanceId); + //this.instanceId = instanceId; + } + protected RosterGroup addGroup(final String groupName) { RosterGroup group; group = groupName != null ? new RosterGroup(groupName) : all; diff --git a/src/main/java/com/calclab/emite/im/client/roster/XmppRosterLogic.java b/src/main/java/com/calclab/emite/im/client/roster/XmppRosterLogic.java index 77a58f93..f8a3e5ec 100644 --- a/src/main/java/com/calclab/emite/im/client/roster/XmppRosterLogic.java +++ b/src/main/java/com/calclab/emite/im/client/roster/XmppRosterLogic.java @@ -22,8 +22,11 @@ import java.util.ArrayList; import java.util.Collection; +import java.util.HashMap; import java.util.List; +import com.calclab.emite.core.client.LoginXmpp; +import com.calclab.emite.core.client.LoginXmppMap; import com.calclab.emite.core.client.events.ChangedEvent.ChangeTypes; import com.calclab.emite.core.client.events.IQEvent; import com.calclab.emite.core.client.events.IQHandler; @@ -52,90 +55,14 @@ import com.google.inject.Inject; import com.google.inject.Singleton; -@Singleton +//@Singleton public class XmppRosterLogic extends XmppRosterGroupsLogic { private static final PacketMatcher ROSTER_QUERY_FILTER = MatcherFactory.byNameAndXMLNS("query", "jabber:iq:roster"); @Inject - public XmppRosterLogic(final XmppSession session) { - super(session); - - session.addSessionStateChangedHandler(true, new StateChangedHandler() { - @Override - public void onStateChanged(final StateChangedEvent event) { - if (event.is(SessionStates.loggedIn)) { - reRequestRoster(); - } - } - }); - - session.addPresenceReceivedHandler(new PresenceHandler() { - @Override - public void onPresence(final PresenceEvent event) { - final Presence presence = event.getPresence(); - final RosterItem item = getItemByJID(presence.getFrom()); - if (item != null) { - setPresence(presence, item); - } - } - - private void setPresence(final Presence presence, final RosterItem item) { - final Presence.Type type = presence.getType(); - final String resource = presence.getFrom().getResource(); - - boolean hasChanged = false; - - final boolean wasAvailable = item.getAvailableResources().contains(resource); - - if (type == Presence.Type.unavailable) { - if (wasAvailable) { - hasChanged = true; - item.setAvailable(false, resource); - } - } else { - if (!wasAvailable) { - hasChanged = true; - item.setAvailable(true, resource); - } - } - final Show showReceived = presence.getShow(); - final Show newShow = showReceived == null ? Show.notSpecified : showReceived; - - if (!newShow.equals(item.getShow())) { - hasChanged = true; - item.setShow(newShow); - } - - if (item.getStatus() == null && presence.getStatus() != null || item.getStatus() != null && !item.getStatus().equals(presence.getStatus())) { - hasChanged = true; - item.setStatus(presence.getStatus()); - } - - if (hasChanged) { - final RosterItemChangedEvent event = new RosterItemChangedEvent(ChangeTypes.modified, item); - eventBus.fireEvent(event); - fireItemChangedInGroups(event); - } - } - - }); - - session.addIQReceivedHandler(new IQHandler() { - @Override - public void onPacket(final IQEvent event) { - final IQ iq = event.getIQ(); - if (iq.isType(IQ.Type.set)) { - final IPacket query = iq.getFirstChild(ROSTER_QUERY_FILTER); - if (query != NoPacket.INSTANCE) { - for (final IPacket child : query.getChildren()) { - handleItemChanged(RosterItem.parse(child)); - } - } - session.send(new IQ(Type.result).With("to", iq.getFromAsString()).With("id", iq.getId())); - } - } - }); + public XmppRosterLogic(final @LoginXmppMap HashMap loginXmppMap) { + this.loginXmppMap = loginXmppMap; } @Override @@ -347,4 +274,87 @@ void storeItem(final RosterItem item) { addToGroup(item, groupName); } } + + @Override + public void setInstanceId(String instanceId) { + + super.setInstanceId(instanceId); + + session.addSessionStateChangedHandler(true, new StateChangedHandler() { + @Override + public void onStateChanged(final StateChangedEvent event) { + if (event.is(SessionStates.loggedIn)) { + reRequestRoster(); + } + } + }); + + session.addPresenceReceivedHandler(new PresenceHandler() { + @Override + public void onPresence(final PresenceEvent event) { + final Presence presence = event.getPresence(); + final RosterItem item = getItemByJID(presence.getFrom()); + if (item != null) { + setPresence(presence, item); + } + } + + private void setPresence(final Presence presence, final RosterItem item) { + final Presence.Type type = presence.getType(); + final String resource = presence.getFrom().getResource(); + + boolean hasChanged = false; + + final boolean wasAvailable = item.getAvailableResources().contains(resource); + + if (type == Presence.Type.unavailable) { + if (wasAvailable) { + hasChanged = true; + item.setAvailable(false, resource); + } + } else { + if (!wasAvailable) { + hasChanged = true; + item.setAvailable(true, resource); + } + } + final Show showReceived = presence.getShow(); + final Show newShow = showReceived == null ? Show.notSpecified : showReceived; + + if (!newShow.equals(item.getShow())) { + hasChanged = true; + item.setShow(newShow); + } + + if (item.getStatus() == null && presence.getStatus() != null || item.getStatus() != null && !item.getStatus().equals(presence.getStatus())) { + hasChanged = true; + item.setStatus(presence.getStatus()); + } + + if (hasChanged) { + final RosterItemChangedEvent event = new RosterItemChangedEvent(ChangeTypes.modified, item); + eventBus.fireEvent(event); + fireItemChangedInGroups(event); + } + } + + }); + + session.addIQReceivedHandler(new IQHandler() { + @Override + public void onPacket(final IQEvent event) { + final IQ iq = event.getIQ(); + if (iq.isType(IQ.Type.set)) { + final IPacket query = iq.getFirstChild(ROSTER_QUERY_FILTER); + if (query != NoPacket.INSTANCE) { + for (final IPacket child : query.getChildren()) { + handleItemChanged(RosterItem.parse(child)); + } + } + session.send(new IQ(Type.result).With("to", iq.getFromAsString()).With("id", iq.getId())); + } + } + }); + + } } diff --git a/src/main/java/com/calclab/emite/reconnect/client/ReconnectModule.java b/src/main/java/com/calclab/emite/reconnect/client/ReconnectModule.java index b1d85757..55db47f4 100644 --- a/src/main/java/com/calclab/emite/reconnect/client/ReconnectModule.java +++ b/src/main/java/com/calclab/emite/reconnect/client/ReconnectModule.java @@ -31,7 +31,7 @@ public class ReconnectModule extends AbstractGinModule { @Override protected void configure() { - bind(SessionReconnect.class).in(Singleton.class); + bind(SessionReconnect.class);//.in(Singleton.class); } } diff --git a/src/main/java/com/calclab/emite/reconnect/client/SessionReconnect.java b/src/main/java/com/calclab/emite/reconnect/client/SessionReconnect.java index 5f8fe553..22ce720b 100644 --- a/src/main/java/com/calclab/emite/reconnect/client/SessionReconnect.java +++ b/src/main/java/com/calclab/emite/reconnect/client/SessionReconnect.java @@ -20,8 +20,12 @@ package com.calclab.emite.reconnect.client; +import java.util.HashMap; import java.util.logging.Logger; +import com.calclab.emite.core.client.LoginXmpp; +import com.calclab.emite.core.client.LoginXmppMap; +import com.calclab.emite.core.client.MultiInstance; import com.calclab.emite.core.client.conn.ConnectionStateChangedEvent; import com.calclab.emite.core.client.conn.ConnectionStateChangedEvent.ConnectionState; import com.calclab.emite.core.client.conn.ConnectionStateChangedHandler; @@ -37,19 +41,38 @@ import com.google.gwt.user.client.Timer; import com.google.inject.Inject; -public class SessionReconnect { +public class SessionReconnect implements MultiInstance { private static final Logger logger = Logger.getLogger(SessionReconnect.class.getName()); private boolean shouldReconnect; private Credentials lastSuccessfulCredentials; protected int reconnectionAttempts; + + + private HashMap loginXmppMap; @Inject - public SessionReconnect(final XmppConnection connection, final XmppSession session, final SASLManager saslManager) { + public SessionReconnect(final @LoginXmppMap HashMap loginXmppMap){//final XmppConnection connection, final XmppSession session, final SASLManager saslManager) { + this.loginXmppMap = loginXmppMap; + } + + private void shouldReconnect() { + shouldReconnect = true; + reconnectionAttempts++; + } + + @Override + public void setInstanceId(String instanceId) { shouldReconnect = false; reconnectionAttempts = 0; logger.info("RECONNECT BEHAVIOUR"); + + LoginXmpp loginXmpp = loginXmppMap.get(instanceId); + + final SASLManager saslManager = loginXmpp.saslManager; + final XmppSession session = loginXmpp.xmppSession; + final XmppConnection connection = loginXmpp.xmppConnection; saslManager.addAuthorizationResultHandler(new AuthorizationResultHandler() { @Override @@ -93,11 +116,6 @@ public void onStateChanged(final ConnectionStateChangedEvent event) { } } }); - - } - - private void shouldReconnect() { - shouldReconnect = true; - reconnectionAttempts++; + } } diff --git a/src/main/java/com/calclab/emite/xep/avatar/client/AvatarManager.java b/src/main/java/com/calclab/emite/xep/avatar/client/AvatarManager.java index 71625f3a..6a58a65e 100644 --- a/src/main/java/com/calclab/emite/xep/avatar/client/AvatarManager.java +++ b/src/main/java/com/calclab/emite/xep/avatar/client/AvatarManager.java @@ -20,8 +20,12 @@ package com.calclab.emite.xep.avatar.client; +import java.util.HashMap; import java.util.List; +import com.calclab.emite.core.client.LoginXmpp; +import com.calclab.emite.core.client.LoginXmppMap; +import com.calclab.emite.core.client.MultiInstance; import com.calclab.emite.core.client.events.PresenceEvent; import com.calclab.emite.core.client.events.PresenceHandler; import com.calclab.emite.core.client.packet.IPacket; @@ -42,31 +46,19 @@ /** * XEP-0153: vCard-Based Avatars (Version 1.0) */ -public class AvatarManager { +public class AvatarManager implements MultiInstance { private static final PacketMatcher FILTER_X = MatcherFactory.byName("x"); private static final String VCARD = "vCard"; private static final String XMLNS = "vcard-temp"; private static final String PHOTO = "PHOTO"; private static final String TYPE = "TYPE"; private static final String BINVAL = "BINVAL"; - private final XmppSession session; + private XmppSession session; + private HashMap loginXmppMap; @Inject - public AvatarManager(final XmppSession session) { - this.session = session; - - session.addPresenceReceivedHandler(new PresenceHandler() { - @Override - public void onPresence(final PresenceEvent event) { - final Presence presence = event.getPresence(); - final List children = presence.getChildren(FILTER_X); - for (final IPacket child : children) { - if (child.hasAttribute("xmlns", XMLNS + ":x:update")) { - session.getEventBus().fireEvent(new HashPresenceReceivedEvent(presence)); - } - } - } - }); + public AvatarManager(final @LoginXmppMap HashMap loginXmppMap){//final XmppSession session) { + this.loginXmppMap = loginXmppMap; } @@ -127,4 +119,24 @@ public void onIQ(final IQ iq) { }); } + @Override + public void setInstanceId(String instanceId) { + LoginXmpp loginXmpp = loginXmppMap.get(instanceId); + this.session = loginXmpp.xmppSession; + + session.addPresenceReceivedHandler(new PresenceHandler() { + @Override + public void onPresence(final PresenceEvent event) { + final Presence presence = event.getPresence(); + final List children = presence.getChildren(FILTER_X); + for (final IPacket child : children) { + if (child.hasAttribute("xmlns", XMLNS + ":x:update")) { + session.getEventBus().fireEvent(new HashPresenceReceivedEvent(presence)); + } + } + } + }); + + } + } diff --git a/src/main/java/com/calclab/emite/xep/avatar/client/AvatarModule.java b/src/main/java/com/calclab/emite/xep/avatar/client/AvatarModule.java index 185d548c..05f24b81 100644 --- a/src/main/java/com/calclab/emite/xep/avatar/client/AvatarModule.java +++ b/src/main/java/com/calclab/emite/xep/avatar/client/AvatarModule.java @@ -27,7 +27,7 @@ public class AvatarModule extends AbstractGinModule { @Override protected void configure() { - bind(AvatarManager.class).in(Singleton.class); + bind(AvatarManager.class);//.in(Singleton.class); } } diff --git a/src/main/java/com/calclab/emite/xep/chatstate/client/ChatStateComponents.java b/src/main/java/com/calclab/emite/xep/chatstate/client/ChatStateComponents.java index b4738df7..6b79fefd 100644 --- a/src/main/java/com/calclab/emite/xep/chatstate/client/ChatStateComponents.java +++ b/src/main/java/com/calclab/emite/xep/chatstate/client/ChatStateComponents.java @@ -20,6 +20,11 @@ package com.calclab.emite.xep.chatstate.client; +import java.util.HashMap; + +import com.calclab.emite.core.client.LoginXmpp; +import com.calclab.emite.core.client.LoginXmppMap; +import com.calclab.emite.core.client.MultiInstance; import com.calclab.emite.core.client.xmpp.session.SessionComponentsRegistry; import com.google.inject.Inject; import com.google.inject.Provider; @@ -29,9 +34,19 @@ * * @see SessionComponentsRegistry */ -public class ChatStateComponents { +public class ChatStateComponents implements MultiInstance { + private HashMap loginXmppMap; + private Provider provider; + @Inject - public ChatStateComponents(final SessionComponentsRegistry registry, final Provider provider) { - registry.addProvider(provider); + public ChatStateComponents(final SessionComponentsRegistry registry, final Provider provider, final @LoginXmppMap HashMap loginXmppMap) { + this.provider = provider; + this.loginXmppMap = loginXmppMap; + } + + @Override + public void setInstanceId(String instanceId) { + LoginXmpp loginXmpp = loginXmppMap.get(instanceId); + loginXmpp.registry.addProvider(provider); } } diff --git a/src/main/java/com/calclab/emite/xep/chatstate/client/ChatStateModule.java b/src/main/java/com/calclab/emite/xep/chatstate/client/ChatStateModule.java index d4c4d440..e65ef81f 100644 --- a/src/main/java/com/calclab/emite/xep/chatstate/client/ChatStateModule.java +++ b/src/main/java/com/calclab/emite/xep/chatstate/client/ChatStateModule.java @@ -27,8 +27,8 @@ public class ChatStateModule extends AbstractGinModule { @Override protected void configure() { - bind(StateManager.class).in(Singleton.class); - bind(ChatStateComponents.class).asEagerSingleton(); + bind(StateManager.class);//.in(Singleton.class); + bind(ChatStateComponents.class);//.asEagerSingleton(); } } diff --git a/src/main/java/com/calclab/emite/xep/chatstate/client/StateManager.java b/src/main/java/com/calclab/emite/xep/chatstate/client/StateManager.java index 743b55e9..fcd2a32c 100644 --- a/src/main/java/com/calclab/emite/xep/chatstate/client/StateManager.java +++ b/src/main/java/com/calclab/emite/xep/chatstate/client/StateManager.java @@ -20,13 +20,18 @@ package com.calclab.emite.xep.chatstate.client; +import java.util.HashMap; import java.util.logging.Logger; +import com.calclab.emite.core.client.LoginXmpp; +import com.calclab.emite.core.client.LoginXmppMap; +import com.calclab.emite.core.client.MultiInstance; import com.calclab.emite.im.client.chat.Chat; import com.calclab.emite.im.client.chat.ChatManager; import com.calclab.emite.im.client.chat.events.ChatChangedEvent; import com.calclab.emite.im.client.chat.events.ChatChangedHandler; import com.google.inject.Inject; +import com.google.inject.Provider; /** * XEP-0085: Chat State Notifications @@ -37,30 +42,15 @@ * be a problem). * */ -public class StateManager { +public class StateManager implements MultiInstance { private static final Logger logger = Logger.getLogger(StateManager.class.getName()); + private HashMap loginXmppMap; @Inject - public StateManager(final ChatManager chatManager) { + public StateManager(final @LoginXmppMap HashMap loginXmppMap) { - chatManager.addChatChangedHandler(new ChatChangedHandler() { - @Override - public void onChatChanged(final ChatChangedEvent event) { - if (event.isCreated()) { - getChatState(event.getChat()); - } else if (event.isClosed()) { - final Chat chat = event.getChat(); - logger.finer("Removing chat state to chat: " + chat.getID()); - final ChatStateManager chatStateManager = (ChatStateManager) chat.getProperties().getData(ChatStateManager.KEY); - if (chatStateManager != null && chatStateManager.getOtherState() != ChatStateManager.ChatState.gone) { - // We are closing, then we send the gone state - chatStateManager.setOwnState(ChatStateManager.ChatState.gone); - } - chat.getProperties().setData(ChatStateManager.KEY, null); - } - } - }); + this.loginXmppMap = loginXmppMap; } @@ -79,4 +69,30 @@ private ChatStateManager createChatState(final Chat chat) { return chatStateManager; } + @Override + public void setInstanceId(String instanceId) { + + LoginXmpp loginXmpp = loginXmppMap.get(instanceId); + ChatManager chatManager = loginXmpp.chatManager; + + chatManager.addChatChangedHandler(new ChatChangedHandler() { + @Override + public void onChatChanged(final ChatChangedEvent event) { + if (event.isCreated()) { + getChatState(event.getChat()); + } else if (event.isClosed()) { + final Chat chat = event.getChat(); + logger.finer("Removing chat state to chat: " + chat.getID()); + final ChatStateManager chatStateManager = (ChatStateManager) chat.getProperties().getData(ChatStateManager.KEY); + if (chatStateManager != null && chatStateManager.getOtherState() != ChatStateManager.ChatState.gone) { + // We are closing, then we send the gone state + chatStateManager.setOwnState(ChatStateManager.ChatState.gone); + } + chat.getProperties().setData(ChatStateManager.KEY, null); + } + } + }); + + } + } diff --git a/src/main/java/com/calclab/emite/xep/disco/client/DiscoveryManager.java b/src/main/java/com/calclab/emite/xep/disco/client/DiscoveryManager.java index 7aefcbee..0fdc2f63 100644 --- a/src/main/java/com/calclab/emite/xep/disco/client/DiscoveryManager.java +++ b/src/main/java/com/calclab/emite/xep/disco/client/DiscoveryManager.java @@ -20,6 +20,7 @@ package com.calclab.emite.xep.disco.client; +import com.calclab.emite.core.client.MultiInstance; import com.calclab.emite.core.client.xmpp.stanzas.XmppURI; import com.calclab.emite.xep.disco.client.events.DiscoveryInfoResultHandler; import com.calclab.emite.xep.disco.client.events.DiscoveryItemsResultHandler; @@ -30,7 +31,7 @@ * * @see http://xmpp.org/extensions/xep-0030.html */ -public interface DiscoveryManager { +public interface DiscoveryManager extends MultiInstance { /** * Adds a handler to know when a discovery information result has arrived diff --git a/src/main/java/com/calclab/emite/xep/disco/client/DiscoveryManagerImpl.java b/src/main/java/com/calclab/emite/xep/disco/client/DiscoveryManagerImpl.java index 1c8da56c..ac830e44 100644 --- a/src/main/java/com/calclab/emite/xep/disco/client/DiscoveryManagerImpl.java +++ b/src/main/java/com/calclab/emite/xep/disco/client/DiscoveryManagerImpl.java @@ -22,6 +22,8 @@ import java.util.HashMap; +import com.calclab.emite.core.client.LoginXmpp; +import com.calclab.emite.core.client.LoginXmppMap; import com.calclab.emite.core.client.packet.MatcherFactory; import com.calclab.emite.core.client.packet.PacketMatcher; import com.calclab.emite.core.client.xmpp.session.IQResponseHandler; @@ -37,14 +39,15 @@ import com.google.inject.Inject; public class DiscoveryManagerImpl implements DiscoveryManager { - private final XmppSession session; + private XmppSession session; private final HashMap infoResults; private final HashMap itemsResults; + private HashMap loginXmppMap; public static final PacketMatcher ERROR_MATCHER = MatcherFactory.byName("error"); @Inject - public DiscoveryManagerImpl(final XmppSession xmppSession) { - session = xmppSession; + public DiscoveryManagerImpl(final @LoginXmppMap HashMap loginXmppMap) { + this.loginXmppMap = loginXmppMap; infoResults = new HashMap(); itemsResults = new HashMap(); } @@ -128,4 +131,10 @@ public void onIQ(final IQ iq) { } } + @Override + public void setInstanceId(String instanceId) { + LoginXmpp loginXmpp = loginXmppMap.get(instanceId); + this.session = loginXmpp.xmppSession; + } + } diff --git a/src/main/java/com/calclab/emite/xep/disco/client/DiscoveryModule.java b/src/main/java/com/calclab/emite/xep/disco/client/DiscoveryModule.java index 19121f5a..ebd35c9b 100644 --- a/src/main/java/com/calclab/emite/xep/disco/client/DiscoveryModule.java +++ b/src/main/java/com/calclab/emite/xep/disco/client/DiscoveryModule.java @@ -38,6 +38,6 @@ public class DiscoveryModule extends AbstractGinModule { @Override protected void configure() { - bind(DiscoveryManager.class).to(DiscoveryManagerImpl.class).in(Singleton.class); + bind(DiscoveryManager.class).to(DiscoveryManagerImpl.class);//.in(Singleton.class); } } diff --git a/src/main/java/com/calclab/emite/xep/muc/client/MucComponents.java b/src/main/java/com/calclab/emite/xep/muc/client/MucComponents.java index c4e6d992..a1fa6e0c 100644 --- a/src/main/java/com/calclab/emite/xep/muc/client/MucComponents.java +++ b/src/main/java/com/calclab/emite/xep/muc/client/MucComponents.java @@ -20,6 +20,11 @@ package com.calclab.emite.xep.muc.client; +import java.util.HashMap; + +import com.calclab.emite.core.client.LoginXmpp; +import com.calclab.emite.core.client.LoginXmppMap; +import com.calclab.emite.core.client.MultiInstance; import com.calclab.emite.core.client.xmpp.session.SessionComponentsRegistry; import com.google.inject.Inject; import com.google.inject.Provider; @@ -30,10 +35,20 @@ * @see SessionComponentsRegistry * */ -public class MucComponents { +public class MucComponents implements MultiInstance { + + final Provider provider; + private HashMap loginXmppMap; @Inject - public MucComponents(final SessionComponentsRegistry registry, final Provider provider) { - registry.addProvider(provider); + public MucComponents(final Provider provider,final @LoginXmppMap HashMap loginXmppMap) { + this.loginXmppMap = loginXmppMap; + this.provider = provider; + } + + @Override + public void setInstanceId(String instanceId) { + LoginXmpp loginXmpp = loginXmppMap.get(instanceId); + loginXmpp.registry.addProvider(provider); } } diff --git a/src/main/java/com/calclab/emite/xep/muc/client/MucModule.java b/src/main/java/com/calclab/emite/xep/muc/client/MucModule.java index d9889b67..d2cbfbe8 100644 --- a/src/main/java/com/calclab/emite/xep/muc/client/MucModule.java +++ b/src/main/java/com/calclab/emite/xep/muc/client/MucModule.java @@ -29,8 +29,8 @@ public class MucModule extends AbstractGinModule { @Override protected void configure() { - bind(RoomManager.class).to(RoomChatManager.class).in(Singleton.class); - bind(MucComponents.class).asEagerSingleton(); + bind(RoomManager.class).to(RoomChatManager.class);//.in(Singleton.class); + bind(MucComponents.class).asEagerSingleton(); //Initialization now happens in setInstance() - eager unnecessary bind(ChatSelectionStrategy.class).annotatedWith(Names.named("Room")).to(RoomChatSelectionStrategy.class).in(Singleton.class); } diff --git a/src/main/java/com/calclab/emite/xep/muc/client/RoomChatManager.java b/src/main/java/com/calclab/emite/xep/muc/client/RoomChatManager.java index 56a4d4cc..acd57bf2 100644 --- a/src/main/java/com/calclab/emite/xep/muc/client/RoomChatManager.java +++ b/src/main/java/com/calclab/emite/xep/muc/client/RoomChatManager.java @@ -22,6 +22,8 @@ import java.util.HashMap; +import com.calclab.emite.core.client.LoginXmpp; +import com.calclab.emite.core.client.LoginXmppMap; import com.calclab.emite.core.client.events.MessageEvent; import com.calclab.emite.core.client.events.MessageHandler; import com.calclab.emite.core.client.events.PresenceEvent; @@ -60,17 +62,19 @@ public class RoomChatManager extends AbstractChatManager implements RoomManager private final HashMap roomsByJID; private HistoryOptions defaultHistoryOptions; + /* public RoomChatManager(final XmppSession session) { this(session, new RoomChatSelectionStrategy()); } + */ @Inject - public RoomChatManager(final XmppSession session, @Named("Room") final ChatSelectionStrategy strategy) { - super(session, strategy); + public RoomChatManager(@Named("Room") final ChatSelectionStrategy strategy, final @LoginXmppMap HashMap loginXmppMap) { + //super(session, strategy); + super(strategy); + this.loginXmppMap = loginXmppMap; roomsByJID = new HashMap(); - forwardPresenceToRooms(); - handleRoomInvitations(); } @Override @@ -158,8 +162,8 @@ public void onMessage(final MessageEvent event) { // We extract the chat properties from the message final ChatProperties chatProperties = strategy.extractProperties(message); - final RoomInvitation invitation = new RoomInvitation(invitationStanza.getFrom(), message.getFrom(), invitationStanza - .getFirstChild("reason").getText(), chatProperties); + final RoomInvitation invitation = new RoomInvitation(invitationStanza.getFrom(), message.getFrom(), + invitationStanza.getFirstChild("reason").getText(), chatProperties); session.getEventBus().fireEvent(new RoomInvitationEvent(invitation)); } } @@ -180,4 +184,12 @@ protected Chat createChat(final ChatProperties properties) { } return new RoomChat(session, properties); } + @Override + public void setInstanceId(String instanceId) { + + super.setInstanceId(instanceId); + + forwardPresenceToRooms(); + handleRoomInvitations(); + } } diff --git a/src/main/java/com/calclab/emite/xep/muc/client/RoomManager.java b/src/main/java/com/calclab/emite/xep/muc/client/RoomManager.java index 00d71717..d657f84f 100644 --- a/src/main/java/com/calclab/emite/xep/muc/client/RoomManager.java +++ b/src/main/java/com/calclab/emite/xep/muc/client/RoomManager.java @@ -20,6 +20,7 @@ package com.calclab.emite.xep.muc.client; +import com.calclab.emite.core.client.MultiInstance; import com.calclab.emite.core.client.xmpp.stanzas.XmppURI; import com.calclab.emite.im.client.chat.ChatManager; import com.calclab.emite.xep.muc.client.events.RoomInvitationHandler; @@ -30,7 +31,7 @@ * * @see ChatManager */ -public interface RoomManager extends ChatManager { +public interface RoomManager extends ChatManager, MultiInstance{ /** * Accepts a room invitation event * diff --git a/src/main/java/com/calclab/emite/xep/mucchatstate/client/MUCChatStateManager.java b/src/main/java/com/calclab/emite/xep/mucchatstate/client/MUCChatStateManager.java index 0ef11cb3..68fbe949 100644 --- a/src/main/java/com/calclab/emite/xep/mucchatstate/client/MUCChatStateManager.java +++ b/src/main/java/com/calclab/emite/xep/mucchatstate/client/MUCChatStateManager.java @@ -20,8 +20,12 @@ package com.calclab.emite.xep.mucchatstate.client; +import java.util.HashMap; import java.util.logging.Logger; +import com.calclab.emite.core.client.LoginXmpp; +import com.calclab.emite.core.client.LoginXmppMap; +import com.calclab.emite.core.client.MultiInstance; import com.calclab.emite.im.client.chat.Chat; import com.calclab.emite.im.client.chat.events.ChatChangedEvent; import com.calclab.emite.im.client.chat.events.ChatChangedHandler; @@ -38,25 +42,15 @@ * forearmed. * */ -public class MUCChatStateManager { +public class MUCChatStateManager implements MultiInstance { private static final Logger logger = Logger.getLogger(MUCChatStateManager.class.getName()); + private HashMap loginXmppMap; @Inject - public MUCChatStateManager(final RoomManager chatManager) { + public MUCChatStateManager( final @LoginXmppMap HashMap loginXmppMap) { - chatManager.addChatChangedHandler(new ChatChangedHandler() { - @Override - public void onChatChanged(final ChatChangedEvent event) { - if (event.isCreated()) { - getRoomOccupantsChatStateManager((Room) event.getChat()); - } else if (event.isClosed()) { - final Chat chat = event.getChat(); - logger.finer("Removing chat state to chat: " + chat.getID()); - chat.getProperties().setData(RoomChatStateManager.KEY, null); - } - } - }); + this.loginXmppMap = loginXmppMap; } public RoomChatStateManager getRoomOccupantsChatStateManager(final Room room) { @@ -75,4 +69,27 @@ private RoomChatStateManager createChatState(final Room room) { return stateManager; } + @Override + public void setInstanceId(String instanceId) { + + + final RoomManager chatManager; + + LoginXmpp loginXmpp = loginXmppMap.get(instanceId); + chatManager = loginXmpp.roomManager; + + chatManager.addChatChangedHandler(new ChatChangedHandler() { + @Override + public void onChatChanged(final ChatChangedEvent event) { + if (event.isCreated()) { + getRoomOccupantsChatStateManager((Room) event.getChat()); + } else if (event.isClosed()) { + final Chat chat = event.getChat(); + logger.finer("Removing chat state to chat: " + chat.getID()); + chat.getProperties().setData(RoomChatStateManager.KEY, null); + } + } + }); + } + } diff --git a/src/main/java/com/calclab/emite/xep/mucdisco/client/MucDiscoveryModule.java b/src/main/java/com/calclab/emite/xep/mucdisco/client/MucDiscoveryModule.java index 7f6dd6d7..dafa95dd 100644 --- a/src/main/java/com/calclab/emite/xep/mucdisco/client/MucDiscoveryModule.java +++ b/src/main/java/com/calclab/emite/xep/mucdisco/client/MucDiscoveryModule.java @@ -27,7 +27,7 @@ public class MucDiscoveryModule extends AbstractGinModule { @Override protected void configure() { - bind(RoomDiscoveryManager.class).to(RoomDiscoveryManagerImpl.class).in(Singleton.class); + bind(RoomDiscoveryManager.class).to(RoomDiscoveryManagerImpl.class);//.in(Singleton.class); } } diff --git a/src/main/java/com/calclab/emite/xep/mucdisco/client/RoomDiscoveryManager.java b/src/main/java/com/calclab/emite/xep/mucdisco/client/RoomDiscoveryManager.java index 85814f83..2d9f2062 100644 --- a/src/main/java/com/calclab/emite/xep/mucdisco/client/RoomDiscoveryManager.java +++ b/src/main/java/com/calclab/emite/xep/mucdisco/client/RoomDiscoveryManager.java @@ -20,6 +20,7 @@ package com.calclab.emite.xep.mucdisco.client; +import com.calclab.emite.core.client.MultiInstance; import com.calclab.emite.core.client.xmpp.stanzas.XmppURI; import com.calclab.emite.xep.disco.client.FeatureSupportedCallback; @@ -27,7 +28,7 @@ * Implements some discovery use cases from * http://xmpp.org/extensions/xep-0045.html */ -public interface RoomDiscoveryManager { +public interface RoomDiscoveryManager extends MultiInstance { /** * Discover the room items of the given entity diff --git a/src/main/java/com/calclab/emite/xep/mucdisco/client/RoomDiscoveryManagerImpl.java b/src/main/java/com/calclab/emite/xep/mucdisco/client/RoomDiscoveryManagerImpl.java index 533caa89..65cea98b 100644 --- a/src/main/java/com/calclab/emite/xep/mucdisco/client/RoomDiscoveryManagerImpl.java +++ b/src/main/java/com/calclab/emite/xep/mucdisco/client/RoomDiscoveryManagerImpl.java @@ -21,8 +21,11 @@ package com.calclab.emite.xep.mucdisco.client; import java.util.ArrayList; +import java.util.HashMap; import java.util.List; +import com.calclab.emite.core.client.LoginXmpp; +import com.calclab.emite.core.client.LoginXmppMap; import com.calclab.emite.core.client.xmpp.stanzas.XmppURI; import com.calclab.emite.xep.disco.client.DiscoveryManager; import com.calclab.emite.xep.disco.client.FeatureSupportedCallback; @@ -33,11 +36,12 @@ public class RoomDiscoveryManagerImpl implements RoomDiscoveryManager { - private final DiscoveryManager discoveryManager; + private DiscoveryManager discoveryManager; + private HashMap loginXmppMap; @Inject - public RoomDiscoveryManagerImpl(final DiscoveryManager discoveryManager) { - this.discoveryManager = discoveryManager; + public RoomDiscoveryManagerImpl(final @LoginXmppMap HashMap loginXmppMap) { + this.loginXmppMap = loginXmppMap; } @Override @@ -62,4 +66,12 @@ public void isMucSupported(final XmppURI targetUri, final FeatureSupportedCallba discoveryManager.areFeaturesSupported(targetUri, callback, "http://jabber.org/protocol/muc"); } + @Override + public void setInstanceId(String instanceId) { + LoginXmpp loginXmpp = loginXmppMap.get(instanceId); + + this.discoveryManager = loginXmpp.discoveryManager; + + } + } diff --git a/src/main/java/com/calclab/emite/xep/privacylists/client/PrivacyListsManager.java b/src/main/java/com/calclab/emite/xep/privacylists/client/PrivacyListsManager.java index cdf09956..0db52626 100644 --- a/src/main/java/com/calclab/emite/xep/privacylists/client/PrivacyListsManager.java +++ b/src/main/java/com/calclab/emite/xep/privacylists/client/PrivacyListsManager.java @@ -20,6 +20,11 @@ package com.calclab.emite.xep.privacylists.client; +import java.util.HashMap; + +import com.calclab.emite.core.client.LoginXmpp; +import com.calclab.emite.core.client.LoginXmppMap; +import com.calclab.emite.core.client.MultiInstance; import com.calclab.emite.core.client.packet.IPacket; import com.calclab.emite.core.client.xmpp.session.IQResponseHandler; import com.calclab.emite.core.client.xmpp.session.XmppSession; @@ -30,12 +35,15 @@ /** * Will (i hope!) implement http://www.xmpp.org/extensions/xep-0016.html */ -public class PrivacyListsManager { - private final XmppSession session; +public class PrivacyListsManager implements MultiInstance { + private XmppSession session; + private HashMap loginXmppMap; @Inject - public PrivacyListsManager(final XmppSession session) { - this.session = session; + public PrivacyListsManager( final @LoginXmppMap HashMap loginXmppMap) { + //this.session = session; + + this.loginXmppMap = loginXmppMap; } /** @@ -65,4 +73,10 @@ public void onIQ(final IQ iq) { }); } + + @Override + public void setInstanceId(String instanceId) { + this.session =loginXmppMap.get(instanceId).xmppSession; + + } } diff --git a/src/main/java/com/calclab/emite/xep/privacylists/client/PrivacyListsModule.java b/src/main/java/com/calclab/emite/xep/privacylists/client/PrivacyListsModule.java index 4e63e590..d4ab3a7e 100644 --- a/src/main/java/com/calclab/emite/xep/privacylists/client/PrivacyListsModule.java +++ b/src/main/java/com/calclab/emite/xep/privacylists/client/PrivacyListsModule.java @@ -34,7 +34,7 @@ public class PrivacyListsModule extends AbstractGinModule { @Override protected void configure() { - bind(PrivacyListsManager.class).in(Singleton.class); + bind(PrivacyListsManager.class);//.in(Singleton.class); } } diff --git a/src/main/java/com/calclab/emite/xep/search/client/SearchManager.java b/src/main/java/com/calclab/emite/xep/search/client/SearchManager.java index 0ea58752..d2ab0001 100644 --- a/src/main/java/com/calclab/emite/xep/search/client/SearchManager.java +++ b/src/main/java/com/calclab/emite/xep/search/client/SearchManager.java @@ -23,6 +23,7 @@ import java.util.HashMap; import java.util.List; +import com.calclab.emite.core.client.MultiInstance; import com.calclab.emite.core.client.xmpp.session.ResultListener; import com.calclab.emite.core.client.xmpp.stanzas.XmppURI; import com.calclab.emite.xep.dataforms.client.Form; @@ -34,7 +35,7 @@ * * @see http://xmpp.org/extensions/xep-0055.html */ -public interface SearchManager { +public interface SearchManager extends MultiInstance { /** * Set the host service where send the requests. Usually you send all the diff --git a/src/main/java/com/calclab/emite/xep/search/client/SearchManagerImpl.java b/src/main/java/com/calclab/emite/xep/search/client/SearchManagerImpl.java index 95bf9f99..1a3c91e2 100644 --- a/src/main/java/com/calclab/emite/xep/search/client/SearchManagerImpl.java +++ b/src/main/java/com/calclab/emite/xep/search/client/SearchManagerImpl.java @@ -25,6 +25,8 @@ import java.util.HashMap; import java.util.List; +import com.calclab.emite.core.client.LoginXmpp; +import com.calclab.emite.core.client.LoginXmppMap; import com.calclab.emite.core.client.packet.IPacket; import com.calclab.emite.core.client.packet.MatcherFactory; import com.calclab.emite.core.client.packet.NoPacket; @@ -53,14 +55,15 @@ private static interface IQResultCallback { public static final String IQ_SEARCH = "jabber:iq:search"; private static final String XML_LANG = "xml:lang"; private static final String SEARCH_CATEGORY = "search"; - private final XmppSession session; + private XmppSession session; private final PacketMatcher filterQuery; private XmppURI host; + private HashMap loginXmppMap; @Inject - public SearchManagerImpl(final XmppSession session) { - this.session = session; + public SearchManagerImpl(final @LoginXmppMap HashMap loginXmppMap) { + this.loginXmppMap = loginXmppMap; filterQuery = MatcherFactory.byNameAndXMLNS("query", IQ_SEARCH); } @@ -204,4 +207,10 @@ public void onIQ(final IQ iq) { } else throw new RuntimeException(SHOULD_BE_CONNECTED); } + + @Override + public void setInstanceId(String instanceId) { + LoginXmpp loginXmpp = loginXmppMap.get(instanceId); + this.session = loginXmpp.xmppSession; + } } diff --git a/src/main/java/com/calclab/emite/xep/search/client/SearchModule.java b/src/main/java/com/calclab/emite/xep/search/client/SearchModule.java index eb92d314..2eecec49 100644 --- a/src/main/java/com/calclab/emite/xep/search/client/SearchModule.java +++ b/src/main/java/com/calclab/emite/xep/search/client/SearchModule.java @@ -37,7 +37,7 @@ public class SearchModule extends AbstractGinModule { @Override protected void configure() { - bind(SearchManager.class).to(SearchManagerImpl.class).in(Singleton.class); + bind(SearchManager.class).to(SearchManagerImpl.class);//.in(Singleton.class); } } diff --git a/src/main/java/com/calclab/emite/xep/storage/client/PrivateStorageManager.java b/src/main/java/com/calclab/emite/xep/storage/client/PrivateStorageManager.java index f47e8a21..6a948e65 100644 --- a/src/main/java/com/calclab/emite/xep/storage/client/PrivateStorageManager.java +++ b/src/main/java/com/calclab/emite/xep/storage/client/PrivateStorageManager.java @@ -20,6 +20,11 @@ package com.calclab.emite.xep.storage.client; +import java.util.HashMap; + +import com.calclab.emite.core.client.LoginXmpp; +import com.calclab.emite.core.client.LoginXmppMap; +import com.calclab.emite.core.client.MultiInstance; import com.calclab.emite.core.client.xmpp.session.IQResponseHandler; import com.calclab.emite.core.client.xmpp.session.XmppSession; import com.calclab.emite.core.client.xmpp.stanzas.IQ; @@ -31,15 +36,16 @@ /** * Implements http://xmpp.org/extensions/xep-0049.html */ -public class PrivateStorageManager { +public class PrivateStorageManager implements MultiInstance { private static final String XMLNS = "jabber:iq:private"; private static final String ID = "priv"; - private final XmppSession session; + private XmppSession session; + private HashMap loginXmppMap; @Inject - public PrivateStorageManager(final XmppSession session) { - this.session = session; + public PrivateStorageManager(final @LoginXmppMap HashMap loginXmppMap) { + this.loginXmppMap = loginXmppMap; } public void retrieve(final SimpleStorageData data, final PrivateStorageResponseHandler handler) { @@ -69,4 +75,9 @@ public void onIQ(final IQ iq) { } }); } + + @Override + public void setInstanceId(String instanceId) { + this.session = loginXmppMap.get(instanceId).xmppSession; + } } diff --git a/src/main/java/com/calclab/emite/xep/storage/client/PrivateStorageModule.java b/src/main/java/com/calclab/emite/xep/storage/client/PrivateStorageModule.java index 89766fe4..1722fda6 100644 --- a/src/main/java/com/calclab/emite/xep/storage/client/PrivateStorageModule.java +++ b/src/main/java/com/calclab/emite/xep/storage/client/PrivateStorageModule.java @@ -30,7 +30,7 @@ public class PrivateStorageModule extends AbstractGinModule { @Override protected void configure() { - bind(PrivateStorageManager.class).in(Singleton.class); + bind(PrivateStorageManager.class);//.in(Singleton.class); } } diff --git a/src/main/java/com/calclab/emite/xep/vcard/client/VCardManager.java b/src/main/java/com/calclab/emite/xep/vcard/client/VCardManager.java index a56554d1..1544c2e9 100644 --- a/src/main/java/com/calclab/emite/xep/vcard/client/VCardManager.java +++ b/src/main/java/com/calclab/emite/xep/vcard/client/VCardManager.java @@ -20,6 +20,7 @@ package com.calclab.emite.xep.vcard.client; +import com.calclab.emite.core.client.MultiInstance; import com.calclab.emite.core.client.xmpp.stanzas.XmppURI; import com.calclab.emite.xep.vcard.client.events.VCardResponseHandler; import com.google.gwt.event.shared.HandlerRegistration; @@ -28,7 +29,7 @@ * The manager to VCards. Implements http://xmpp.org/extensions/xep-0054.html * */ -public interface VCardManager { +public interface VCardManager extends MultiInstance { /** * Adds a handler to know when a VCardResponse is received diff --git a/src/main/java/com/calclab/emite/xep/vcard/client/VCardManagerImpl.java b/src/main/java/com/calclab/emite/xep/vcard/client/VCardManagerImpl.java index 0aae4077..e9ca1b17 100644 --- a/src/main/java/com/calclab/emite/xep/vcard/client/VCardManagerImpl.java +++ b/src/main/java/com/calclab/emite/xep/vcard/client/VCardManagerImpl.java @@ -20,6 +20,10 @@ package com.calclab.emite.xep.vcard.client; +import java.util.HashMap; + +import com.calclab.emite.core.client.LoginXmpp; +import com.calclab.emite.core.client.LoginXmppMap; import com.calclab.emite.core.client.xmpp.session.IQResponseHandler; import com.calclab.emite.core.client.xmpp.session.XmppSession; import com.calclab.emite.core.client.xmpp.stanzas.IQ; @@ -35,14 +39,15 @@ * * @see VCardManager */ -@Singleton +//@Singleton public class VCardManagerImpl implements VCardManager { private static final String ID_PREFIX = "vcard"; - private final XmppSession session; + private XmppSession session; + private HashMap loginXmppMap; @Inject - public VCardManagerImpl(final XmppSession session) { - this.session = session; + public VCardManagerImpl(final @LoginXmppMap HashMap loginXmppMap) { + this.loginXmppMap = loginXmppMap; } @Override @@ -101,4 +106,10 @@ protected void handleVCard(final IQ result, final VCardResponseHandler handler) } session.getEventBus().fireEvent(event); } + + @Override + public void setInstanceId(String instanceId) { + LoginXmpp loginXmpp = loginXmppMap.get(instanceId); + this.session = loginXmpp.xmppSession; + } } diff --git a/src/main/java/com/calclab/emite/xep/vcard/client/VCardModule.java b/src/main/java/com/calclab/emite/xep/vcard/client/VCardModule.java index 68cb5192..601bb4bf 100644 --- a/src/main/java/com/calclab/emite/xep/vcard/client/VCardModule.java +++ b/src/main/java/com/calclab/emite/xep/vcard/client/VCardModule.java @@ -30,7 +30,7 @@ public class VCardModule extends AbstractGinModule { @Override protected void configure() { - bind(VCardManager.class).to(VCardManagerImpl.class).in(Singleton.class); + bind(VCardManager.class).to(VCardManagerImpl.class);//.in(Singleton.class); } }