diff --git a/README.md b/README.md
index 2996b2c9e..2d4959e33 100644
--- a/README.md
+++ b/README.md
@@ -14,7 +14,7 @@ Key Advantages :
   - Extremely simple to use, yet powerful API. Sending a text message to a user can be accomplished in only a few lines of code:
 
     ```java
-    XMPPConnection connection = new XMPPTCPConnection("jabber.org");
+    AbstractXMPPConnection connection = new XMPPTCPConnection("jabber.org");
     connection.connect();
     connection.login("mtucker", "password");
     Chat chat = ChatManager.getInstanceFor(connection)
diff --git a/documentation/connections.html b/documentation/connections.html
index 081e70f1a..a5f694c4f 100644
--- a/documentation/connections.html
+++ b/documentation/connections.html
@@ -20,8 +20,8 @@
 
 <p>
     The <tt>org.jivesoftware.smack.XMPPConnection</tt> class manages your connection to an XMPP
-    server. The default implementation is the <tt>org.jivesoftware.smack.XMPPConnection</tt>
-    class.  Two constructors are mainly used. The first, <tt>XMPPConnection(String)</tt> takes
+    server. A default implementation is the <tt>org.jivesoftware.smack.XMPPTCPConnection</tt>
+    class.  Two constructors are mainly used. The first, <tt>XMPPTCPConnection(String)</tt> takes
     the server name you'd like to connect to as an argument. All default connection settings will
     be used:
     <ul>
@@ -33,7 +33,7 @@
         <li>The XMPP resource name "Smack" will be used for the connection.</li>
     </ul>
 
-    Alternatively, you can use the <tt>XMPPServer(ConnectionConfiguration)</tt> constructor to
+    Alternatively, you can use the <tt>XMPPTCPConnection(ConnectionConfiguration)</tt> constructor to
     specify advanced connection settings. Some of these settings include:
 
     <ul>
@@ -61,9 +61,8 @@
 <font color="gray"><i>// Create the configuration for this new connection</i></font>
 ConnectionConfiguration config = new ConnectionConfiguration(<font color="green">"jabber.org"</font>, 5222);
 config.setCompressionEnabled(true);
-config.setSASLAuthenticationEnabled(true);
 
-Connection connection = new XMPPConnection(config);
+AbstractXMPPConnection connection = new XMPPTCPConnection(config);
 <font color="gray"><i>// Connect to the server</i></font>
 connection.connect();
 <font color="gray"><i>// Log into the server</i></font>
@@ -80,7 +79,7 @@ manager will try to immediately reconnect to the server and increase the delay b
 successive reconnections keep failing.</i>
 <br>
 In case you want to force a reconnection while the reconnetion manager is waiting for the next
-reconnection, you can just use <i>XMPPConnection#connect()</i> and a new attempt will be made.
+reconnection, you can just use <i>AbstractXMPPConnection#connect()</i> and a new attempt will be made.
 If the manual attempt also failed then the reconnection manager will still continue the
 reconnection job.
 </p>
diff --git a/documentation/debugging.html b/documentation/debugging.html
index 59e7d1cb2..c91d4b7a5 100644
--- a/documentation/debugging.html
+++ b/documentation/debugging.html
@@ -26,7 +26,7 @@ Debugging mode can be enabled in two different ways:
 
 <ol>
 	<li>Add the following line of code <b>before</b> creating new connections:<p> 
-		<tt>XMPPConnection.DEBUG_ENABLED = true;</tt><p>
+		<tt>SmackConfiguration.DEBUG_ENABLED = true;</tt><p>
 
 	<li>Set the Java system property <tt>smack.debugEnabled</tt> to true. The 
 		system property can be set on the command line such as:<p> 
@@ -39,7 +39,7 @@ add the following line to your application before opening new connections:
 </p>
 
 <p>
-<tt>XMPPConnection.DEBUG_ENABLED = false;</tt>
+<tt>SmackConfiguration.DEBUG_ENABLED = false;</tt>
 </p>
 
 <p>
diff --git a/documentation/extensions/messageevents.html b/documentation/extensions/messageevents.html
index d91492b3f..fd64fc2fe 100644
--- a/documentation/extensions/messageevents.html
+++ b/documentation/extensions/messageevents.html
@@ -99,9 +99,9 @@ for notifications and will send the message to the other user. The other user wi
 to a <i>MessageEventManager</i> that will listen and react to the event notification requested by the other user.
 <blockquote>
 <pre>      <font color="#3f7f5f">// Connect to the server and log in the users</font>
-      conn1 = new XMPPConnection(host);
+      conn1 = new XMPPTCPConnection(host);
       conn1.login(server_user1, pass1);
-      conn2 = new XMPPConnection(host);
+      conn2 = new XMPPTCPConnection(host);
       conn2.login(server_user2, pass2);
   
       <font color="#3f7f5f">// User2 creates a MessageEventManager</font>
@@ -195,7 +195,7 @@ to a <i>MessageEventManager</i> that will listen and react to the event notifica
 the requests for notifications and sends the message.
 <blockquote>
 <pre>      <font color="#3f7f5f">// Connect to the server and log in</font>
-      conn1 = new XMPPConnection(host);
+      conn1 = new XMPPTCPConnection(host);
       conn1.login(server_user1, pass1);
   
       <font color="#3f7f5f">// Create a MessageEventManager</font>
@@ -241,4 +241,4 @@ the requests for notifications and sends the message.
 
 </body>
 
-</html>
\ No newline at end of file
+</html>
diff --git a/documentation/extensions/rosterexchange.html b/documentation/extensions/rosterexchange.html
index e014da111..0a3fa9ffb 100644
--- a/documentation/extensions/rosterexchange.html
+++ b/documentation/extensions/rosterexchange.html
@@ -39,7 +39,7 @@ the second parameter is the id of the user that will receive the roster entries.
 In this example we can see how user1 sends his roster to user2. 
 <blockquote>
 <pre>      <font color="#3f7f5f">// Connect to the server and log in</font>
-      conn1 = new XMPPConnection(host);
+      conn1 = new XMPPTCPConnection(host);
       conn1.login(server_user1, pass1);
     
       <font color="#3f7f5f">// Create a new roster exchange manager on conn1</font>
@@ -69,7 +69,7 @@ the second parameter is the id of the user that will receive the roster entries.
 In this example we can see how user1 sends his roster groups to user2. 
 <blockquote>
 <pre>      <font color="#3f7f5f">// Connect to the server and log in</font>
-      conn1 = new XMPPConnection(host);
+      conn1 = new XMPPTCPConnection(host);
       conn1.login(server_user1, pass1);
     
       <font color="#3f7f5f">// Create a new roster exchange manager on conn1</font>
@@ -100,7 +100,7 @@ the second parameter is the id of the user that will receive the roster entries.
 In this example we can see how user1 sends a roster entry to user2. 
 <blockquote>
 <pre>      <font color="#3f7f5f">// Connect to the server and log in</font>
-      conn1 = new XMPPConnection(host);
+      conn1 = new XMPPTCPConnection(host);
       conn1.login(server_user1, pass1);
     
       <font color="#3f7f5f">// Create a new roster exchange manager on conn1</font>
@@ -135,9 +135,9 @@ In this example we can see how user1 sends a roster entry to user2 and user2 add
 entries to his roster. 
 <blockquote>
 <pre>      <font color="#3f7f5f">// Connect to the server and log in the users</font>
-      conn1 = new XMPPConnection(host);
+      conn1 = new XMPPTCPConnection(host);
       conn1.login(server_user1, pass1);
-      conn2 = new XMPPConnection(host);
+      conn2 = new XMPPTCPConnection(host);
       conn2.login(server_user2, pass2);
       final Roster user2_roster = conn2.getRoster();
     
@@ -176,4 +176,4 @@ entries to his roster.
 </blockquote>
 </body>
 
-</html>
\ No newline at end of file
+</html>
diff --git a/documentation/gettingstarted.html b/documentation/gettingstarted.html
index 74b19f177..f13c2b75f 100644
--- a/documentation/gettingstarted.html
+++ b/documentation/gettingstarted.html
@@ -76,18 +76,19 @@ list of initializers.
 Establishing a Connection
 </p>
 
-The <tt>XMPPConnection</tt> class is used to create a connection to an 
-XMPP server. Below are code examples for making a connection:<p>
+The classes subclassing <tt>AbstractXMPPConnection</tt> are used to
+create a connection to an XMPP server. Below are code examples for
+making a connection:<p>
 
 <div class="code">
 <pre>
 <font color="gray"><i>// Create a connection to the jabber.org server.</i></font>
-Connection conn1 = <font color="navy"><b>new</b></font> XMPPConnection(<font color="green">"jabber.org"</font>);
+AbstractXMPPConnection conn1 = <font color="navy"><b>new</b></font> XMPPTCPConnection(<font color="green">"jabber.org"</font>);
 conn1.connect();
 
 <font color="gray"><i>// Create a connection to the jabber.org server on a specific port.</i></font>
 ConnectionConfiguration config = new ConnectionConfiguration(<font color="green">"jabber.org"</font>, 5222);
-Connection conn2 = <font color="navy"><b>new</b></font> XMPPConnection(config);
+AbstractXMPPConnection conn2 = <font color="navy"><b>new</b></font> XMPPTCPConnection(config);
 conn2.connect();
 </pre></div>
 
@@ -97,7 +98,7 @@ conn2.connect();
     <a href="connections.html">XMPPConnection Management</a> for full details.</p>
 
 <p>Once you've created a connection, you should login using a username and password
-with the <tt>XMPPConnection.login(String username, String password)</tt> method.
+with the <tt>AbstractXMPPConnection.login(String username, String password)</tt> method.
 Once you've logged in, you can being chatting with other users by creating
 new <tt>Chat</tt> or <tt>GroupChat</tt> objects.
 
@@ -130,7 +131,7 @@ and "out fishing":<p>
 <font color="gray"><i>// Create a new presence. Pass in false to indicate we're unavailable.</i></font>
 Presence presence = new Presence(Presence.Type.unavailable);
 presence.setStatus(<font color="green">"Gone fishing"</font>);
-<font color="gray"><i>// Send the packet (assume we have a XMPPConnection instance called "con").</i></font>
+<font color="gray"><i>// Send the packet (assume we have a AbstractXMPPConnection instance called "con").</i></font>
 con.sendPacket(presence);
 </pre></div>
 <p>
diff --git a/smack-bosh/src/main/java/org/jivesoftware/smack/bosh/XMPPBOSHConnection.java b/smack-bosh/src/main/java/org/jivesoftware/smack/bosh/XMPPBOSHConnection.java
index ba18c2734..24321b61a 100644
--- a/smack-bosh/src/main/java/org/jivesoftware/smack/bosh/XMPPBOSHConnection.java
+++ b/smack-bosh/src/main/java/org/jivesoftware/smack/bosh/XMPPBOSHConnection.java
@@ -27,6 +27,7 @@ import java.util.logging.Logger;
 
 import javax.security.sasl.SaslException;
 
+import org.jivesoftware.smack.AbstractXMPPConnection;
 import org.jivesoftware.smack.SmackException;
 import org.jivesoftware.smack.SmackException.NotConnectedException;
 import org.jivesoftware.smack.SmackException.AlreadyLoggedInException;
@@ -59,7 +60,7 @@ import org.igniterealtime.jbosh.ComposableBody;
  * @see XMPPConnection
  * @author Guenther Niess
  */
-public class XMPPBOSHConnection extends XMPPConnection {
+public class XMPPBOSHConnection extends AbstractXMPPConnection {
     private static final Logger LOGGER = Logger.getLogger(XMPPBOSHConnection.class.getName());
 
     /**
diff --git a/smack-core/src/main/java/org/jivesoftware/smack/AbstractXMPPConnection.java b/smack-core/src/main/java/org/jivesoftware/smack/AbstractXMPPConnection.java
new file mode 100644
index 000000000..486e7bc0e
--- /dev/null
+++ b/smack-core/src/main/java/org/jivesoftware/smack/AbstractXMPPConnection.java
@@ -0,0 +1,1076 @@
+/**
+ *
+ * Copyright 2009 Jive Software.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.jivesoftware.smack;
+
+import java.io.IOException;
+import java.io.Reader;
+import java.io.Writer;
+import java.lang.reflect.Constructor;
+import java.util.Collection;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.ScheduledThreadPoolExecutor;
+import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import javax.security.sasl.SaslException;
+
+import org.jivesoftware.smack.SmackException.NoResponseException;
+import org.jivesoftware.smack.SmackException.NotConnectedException;
+import org.jivesoftware.smack.SmackException.ConnectionException;
+import org.jivesoftware.smack.SmackException.ResourceBindingNotOfferedException;
+import org.jivesoftware.smack.XMPPException.XMPPErrorException;
+import org.jivesoftware.smack.compression.XMPPInputOutputStream;
+import org.jivesoftware.smack.debugger.SmackDebugger;
+import org.jivesoftware.smack.filter.IQReplyFilter;
+import org.jivesoftware.smack.filter.PacketFilter;
+import org.jivesoftware.smack.packet.Bind;
+import org.jivesoftware.smack.packet.IQ;
+import org.jivesoftware.smack.packet.Packet;
+import org.jivesoftware.smack.packet.Presence;
+import org.jivesoftware.smack.packet.Session;
+
+public abstract class AbstractXMPPConnection implements XMPPConnection {
+    private static final Logger LOGGER = Logger.getLogger(AbstractXMPPConnection.class.getName());
+
+    /** 
+     * Counter to uniquely identify connections that are created.
+     */
+    private final static AtomicInteger connectionCounter = new AtomicInteger(0);
+
+    static {
+        // Ensure the SmackConfiguration class is loaded by calling a method in it.
+        SmackConfiguration.getVersion();
+    }
+
+    /**
+     * Get the collection of listeners that are interested in connection creation events.
+     * 
+     * @return a collection of listeners interested on new connections.
+     */
+    protected static Collection<ConnectionCreationListener> getConnectionCreationListeners() {
+        return XMPPConnectionRegistry.getConnectionCreationListeners();
+    }
+ 
+    /**
+     * A collection of ConnectionListeners which listen for connection closing
+     * and reconnection events.
+     */
+    protected final Collection<ConnectionListener> connectionListeners =
+            new CopyOnWriteArrayList<ConnectionListener>();
+
+    /**
+     * A collection of PacketCollectors which collects packets for a specified filter
+     * and perform blocking and polling operations on the result queue.
+     */
+    protected final Collection<PacketCollector> collectors = new ConcurrentLinkedQueue<PacketCollector>();
+
+    /**
+     * List of PacketListeners that will be notified when a new packet was received.
+     */
+    protected final Map<PacketListener, ListenerWrapper> recvListeners =
+            new ConcurrentHashMap<PacketListener, ListenerWrapper>();
+
+    /**
+     * List of PacketListeners that will be notified when a new packet was sent.
+     */
+    protected final Map<PacketListener, ListenerWrapper> sendListeners =
+            new ConcurrentHashMap<PacketListener, ListenerWrapper>();
+
+    /**
+     * List of PacketInterceptors that will be notified when a new packet is about to be
+     * sent to the server. These interceptors may modify the packet before it is being
+     * actually sent to the server.
+     */
+    protected final Map<PacketInterceptor, InterceptorWrapper> interceptors =
+            new ConcurrentHashMap<PacketInterceptor, InterceptorWrapper>();
+
+    /**
+     * 
+     */
+    private long packetReplyTimeout = SmackConfiguration.getDefaultPacketReplyTimeout();
+
+    /**
+     * The SmackDebugger allows to log and debug XML traffic.
+     */
+    protected SmackDebugger debugger = null;
+
+    /**
+     * The Reader which is used for the debugger.
+     */
+    protected Reader reader;
+
+    /**
+     * The Writer which is used for the debugger.
+     */
+    protected Writer writer;
+
+
+    /**
+     * The SASLAuthentication manager that is responsible for authenticating with the server.
+     */
+    protected SASLAuthentication saslAuthentication = new SASLAuthentication(this);
+
+    /**
+     * A number to uniquely identify connections that are created. This is distinct from the
+     * connection ID, which is a value sent by the server once a connection is made.
+     */
+    protected final int connectionCounterValue = connectionCounter.getAndIncrement();
+
+    /**
+     * Holds the initial configuration used while creating the connection.
+     */
+    protected final ConnectionConfiguration config;
+
+    /**
+     * Holds the Caps Node information for the used XMPP service (i.e. the XMPP server)
+     */
+    private String serviceCapsNode;
+
+    /**
+     * Defines how the from attribute of outgoing stanzas should be handled.
+     */
+    private FromMode fromMode = FromMode.OMITTED;
+
+    /**
+     * Stores whether the server supports rosterVersioning
+     */
+    private boolean rosterVersioningSupported = false;
+
+    protected XMPPInputOutputStream compressionHandler;
+
+    private final ScheduledExecutorService executorService = new ScheduledThreadPoolExecutor(2,
+                    new SmackExecutorThreadFactory(connectionCounterValue));
+
+    /**
+     * SmackExecutorThreadFactory is a *static* inner class of XMPPConnection. Note that we must not
+     * use anonymous classes in order to prevent threads from leaking.
+     */
+    private static final class SmackExecutorThreadFactory implements ThreadFactory {
+        private final int connectionCounterValue;
+        private int count = 0;
+
+        private SmackExecutorThreadFactory(int connectionCounterValue) {
+            this.connectionCounterValue = connectionCounterValue;
+        }
+
+        @Override
+        public Thread newThread(Runnable runnable) {
+            Thread thread = new Thread(runnable, "Smack Executor Service " + count++ + " ("
+                            + connectionCounterValue + ")");
+            thread.setDaemon(true);
+            return thread;
+        }
+    }
+
+    private Roster roster;
+
+    /**
+     * The used host to establish the connection to
+     */
+    private String host;
+
+    /**
+     * The used port to establish the connection to
+     */
+    private int port;
+
+    /**
+     * Set to true if the server requires the connection to be binded in order to continue.
+     * <p>
+     * Note that we use AtomicBoolean here because it allows us to set the Boolean *object*, which
+     * we also use as synchronization object. A plain non-atomic Boolean object would be newly created
+     * for every change of the boolean value, which makes it useless as object for wait()/notify().
+     */
+    private AtomicBoolean bindingRequired = new AtomicBoolean(false);
+
+    private boolean sessionSupported;
+
+    /**
+     * 
+     */
+    private IOException connectionException;
+
+    /**
+     * Flag that indicates if the user is currently authenticated with the server.
+     */
+    protected boolean authenticated = false;
+
+    /**
+     * Flag that indicates if the user was authenticated with the server when the connection
+     * to the server was closed (abruptly or not).
+     */
+    protected boolean wasAuthenticated = false;
+
+    /**
+     * Create a new XMPPConnection to a XMPP server.
+     * 
+     * @param configuration The configuration which is used to establish the connection.
+     */
+    protected AbstractXMPPConnection(ConnectionConfiguration configuration) {
+        config = configuration;
+    }
+
+    @Override
+    public ConnectionConfiguration getConfiguration() {
+        return config;
+    }
+
+    @Override
+    public String getServiceName() {
+        return config.getServiceName();
+    }
+
+    @Override
+    public String getHost() {
+        return host;
+    }
+
+    @Override
+    public int getPort() {
+        return port;
+    }
+
+    @Override
+    public abstract String getUser();
+
+    @Override
+    public abstract String getConnectionID();
+
+    @Override
+    public abstract boolean isConnected();
+
+    @Override
+    public abstract boolean isAuthenticated();
+
+    @Override
+    public abstract boolean isAnonymous();
+
+    @Override
+    public abstract boolean isSecureConnection();
+
+    protected abstract void sendPacketInternal(Packet packet) throws NotConnectedException;
+
+    @Override
+    public abstract boolean isUsingCompression();
+
+    /**
+     * Establishes a connection to the XMPP server and performs an automatic login
+     * only if the previous connection state was logged (authenticated). It basically
+     * creates and maintains a connection to the server.
+     * <p>
+     * Listeners will be preserved from a previous connection.
+     * 
+     * @throws XMPPException if an error occurs on the XMPP protocol level.
+     * @throws SmackException if an error occurs somewhere else besides XMPP protocol level.
+     * @throws IOException 
+     * @throws ConnectionException with detailed information about the failed connection.
+     */
+    public void connect() throws SmackException, IOException, XMPPException {
+        saslAuthentication.init();
+        bindingRequired.set(false);
+        sessionSupported = false;
+        connectionException = null;
+        connectInternal();
+    }
+
+    /**
+     * Abstract method that concrete subclasses of XMPPConnection need to implement to perform their
+     * way of XMPP connection establishment. Implementations must guarantee that this method will
+     * block until the last features stanzas has been parsed and the features have been reported
+     * back to XMPPConnection (e.g. by calling @{link {@link AbstractXMPPConnection#serverRequiresBinding()}
+     * and such).
+     * <p>
+     * Also implementations are required to perform an automatic login if the previous connection
+     * state was logged (authenticated).
+     *
+     * @throws SmackException
+     * @throws IOException
+     * @throws XMPPException
+     */
+    protected abstract void connectInternal() throws SmackException, IOException, XMPPException;
+
+    /**
+     * Logs in to the server using the strongest authentication mode supported by
+     * the server, then sets presence to available. If the server supports SASL authentication 
+     * then the user will be authenticated using SASL if not Non-SASL authentication will 
+     * be tried. If more than five seconds (default timeout) elapses in each step of the 
+     * authentication process without a response from the server, or if an error occurs, a 
+     * XMPPException will be thrown.<p>
+     * 
+     * Before logging in (i.e. authenticate) to the server the connection must be connected.
+     * 
+     * It is possible to log in without sending an initial available presence by using
+     * {@link ConnectionConfiguration#setSendPresence(boolean)}. If this connection is
+     * not interested in loading its roster upon login then use
+     * {@link ConnectionConfiguration#setRosterLoadedAtLogin(boolean)}.
+     * Finally, if you want to not pass a password and instead use a more advanced mechanism
+     * while using SASL then you may be interested in using
+     * {@link ConnectionConfiguration#setCallbackHandler(javax.security.auth.callback.CallbackHandler)}.
+     * For more advanced login settings see {@link ConnectionConfiguration}.
+     * 
+     * @param username the username.
+     * @param password the password or <tt>null</tt> if using a CallbackHandler.
+     * @throws XMPPException if an error occurs on the XMPP protocol level.
+     * @throws SmackException if an error occurs somehwere else besides XMPP protocol level.
+     * @throws IOException 
+     * @throws SaslException 
+     */
+    public void login(String username, String password) throws XMPPException, SmackException, SaslException, IOException {
+        login(username, password, "Smack");
+    }
+
+    /**
+     * Logs in to the server using the strongest authentication mode supported by
+     * the server, then sets presence to available. If the server supports SASL authentication 
+     * then the user will be authenticated using SASL if not Non-SASL authentication will 
+     * be tried. If more than five seconds (default timeout) elapses in each step of the 
+     * authentication process without a response from the server, or if an error occurs, a 
+     * XMPPException will be thrown.<p>
+     * 
+     * Before logging in (i.e. authenticate) to the server the connection must be connected.
+     * 
+     * It is possible to log in without sending an initial available presence by using
+     * {@link ConnectionConfiguration#setSendPresence(boolean)}. If this connection is
+     * not interested in loading its roster upon login then use
+     * {@link ConnectionConfiguration#setRosterLoadedAtLogin(boolean)}.
+     * Finally, if you want to not pass a password and instead use a more advanced mechanism
+     * while using SASL then you may be interested in using
+     * {@link ConnectionConfiguration#setCallbackHandler(javax.security.auth.callback.CallbackHandler)}.
+     * For more advanced login settings see {@link ConnectionConfiguration}.
+     * 
+     * @param username the username.
+     * @param password the password or <tt>null</tt> if using a CallbackHandler.
+     * @param resource the resource.
+     * @throws XMPPException if an error occurs on the XMPP protocol level.
+     * @throws SmackException if an error occurs somehwere else besides XMPP protocol level.
+     * @throws IOException 
+     * @throws SaslException 
+     */
+    public abstract void login(String username, String password, String resource) throws XMPPException, SmackException, SaslException, IOException;
+
+    /**
+     * Logs in to the server anonymously. Very few servers are configured to support anonymous
+     * authentication, so it's fairly likely logging in anonymously will fail. If anonymous login
+     * does succeed, your XMPP address will likely be in the form "123ABC@server/789XYZ" or
+     * "server/123ABC" (where "123ABC" and "789XYZ" is a random value generated by the server).
+     * 
+     * @throws XMPPException if an error occurs on the XMPP protocol level.
+     * @throws SmackException if an error occurs somehwere else besides XMPP protocol level.
+     * @throws IOException 
+     * @throws SaslException 
+     */
+    public abstract void loginAnonymously() throws XMPPException, SmackException, SaslException, IOException;
+
+    /**
+     * Notification message saying that the server requires the client to bind a
+     * resource to the stream.
+     */
+    protected void serverRequiresBinding() {
+        synchronized (bindingRequired) {
+            bindingRequired.set(true);
+            bindingRequired.notify();
+        }
+    }
+
+    /**
+     * Notification message saying that the server supports sessions. When a server supports
+     * sessions the client needs to send a Session packet after successfully binding a resource
+     * for the session.
+     */
+    protected void serverSupportsSession() {
+        sessionSupported = true;
+    }
+
+    protected String bindResourceAndEstablishSession(String resource) throws XMPPErrorException,
+                    ResourceBindingNotOfferedException, NoResponseException, NotConnectedException {
+
+        synchronized (bindingRequired) {
+            if (!bindingRequired.get()) {
+                try {
+                    bindingRequired.wait(getPacketReplyTimeout());
+                }
+                catch (InterruptedException e) {
+                    // Ignore
+                }
+                if (!bindingRequired.get()) {
+                    // Server never offered resource binding, which is REQURIED in XMPP client and
+                    // server
+                    // implementations as per RFC6120 7.2
+                    throw new ResourceBindingNotOfferedException();
+                }
+            }
+        }
+
+        Bind bindResource = new Bind();
+        bindResource.setResource(resource);
+
+        Bind response = (Bind) createPacketCollectorAndSend(bindResource).nextResultOrThrow();
+        String userJID = response.getJid();
+
+        if (sessionSupported && !getConfiguration().isLegacySessionDisabled()) {
+            Session session = new Session();
+            createPacketCollectorAndSend(session).nextResultOrThrow();
+        }
+        return userJID;
+    }
+
+    protected void setConnectionException(IOException exception) {
+        connectionException = exception;
+    }
+
+    protected void throwConnectionExceptionOrNoResponse() throws IOException, NoResponseException {
+        if (connectionException != null) {
+            throw connectionException;
+        } else {
+            throw new NoResponseException();
+        }
+    }
+
+    protected Reader getReader() {
+        return reader;
+    }
+
+    protected Writer getWriter() {
+        return writer;
+    }
+
+    protected void setServiceName(String serviceName) {
+        config.setServiceName(serviceName);
+    }
+    
+    protected void setLoginInfo(String username, String password, String resource) {
+        config.setLoginInfo(username, password, resource);
+    }
+    
+    protected void serverSupportsAccountCreation() {
+        AccountManager.getInstance(this).setSupportsAccountCreation(true);
+    }
+
+    protected void maybeResolveDns() throws Exception {
+        config.maybeResolveDns();
+    }
+
+    @Override
+    public void sendPacket(Packet packet) throws NotConnectedException {
+        if (!isConnected()) {
+            throw new NotConnectedException();
+        }
+        if (packet == null) {
+            throw new NullPointerException("Packet is null.");
+        }
+        switch (fromMode) {
+        case OMITTED:
+            packet.setFrom(null);
+            break;
+        case USER:
+            packet.setFrom(getUser());
+            break;
+        case UNCHANGED:
+        default:
+            break;
+        }
+        // Invoke interceptors for the new packet that is about to be sent. Interceptors may modify
+        // the content of the packet.
+        firePacketInterceptors(packet);
+        sendPacketInternal(packet);
+        // Process packet writer listeners. Note that we're using the sending thread so it's
+        // expected that listeners are fast.
+        firePacketSendingListeners(packet);
+    }
+
+    @Override
+    public Roster getRoster() {
+        if (isAnonymous()) {
+            throw new IllegalStateException("Anonymous users can't have a roster");
+        }
+        // synchronize against login()
+        synchronized(this) {
+            if (roster == null) {
+                roster = new Roster(this);
+            }
+            if (!isAuthenticated()) {
+                return roster;
+            }
+        }
+
+        // If this is the first time the user has asked for the roster after calling
+        // login, we want to wait for the server to send back the user's roster. This
+        // behavior shields API users from having to worry about the fact that roster
+        // operations are asynchronous, although they'll still have to listen for
+        // changes to the roster. Note: because of this waiting logic, internal
+        // Smack code should be wary about calling the getRoster method, and may need to
+        // access the roster object directly.
+        // Also only check for rosterInitalized is isRosterLoadedAtLogin is set, otherwise the user
+        // has to manually call Roster.reload() before he can expect a initialized roster.
+        if (!roster.rosterInitialized && config.isRosterLoadedAtLogin()) {
+            try {
+                synchronized (roster) {
+                    long waitTime = getPacketReplyTimeout();
+                    long start = System.currentTimeMillis();
+                    while (!roster.rosterInitialized) {
+                        if (waitTime <= 0) {
+                            break;
+                        }
+                        roster.wait(waitTime);
+                        long now = System.currentTimeMillis();
+                        waitTime -= now - start;
+                        start = now;
+                    }
+                }
+            }
+            catch (InterruptedException ie) {
+                // Ignore.
+            }
+        }
+        return roster;
+    }
+
+    /**
+     * Returns the SASLAuthentication manager that is responsible for authenticating with
+     * the server.
+     * 
+     * @return the SASLAuthentication manager that is responsible for authenticating with
+     *         the server.
+     */
+    protected SASLAuthentication getSASLAuthentication() {
+        return saslAuthentication;
+    }
+
+    /**
+     * Closes the connection by setting presence to unavailable then closing the connection to
+     * the XMPP server. The XMPPConnection can still be used for connecting to the server
+     * again.
+     *
+     * @throws NotConnectedException 
+     */
+    public void disconnect() throws NotConnectedException {
+        disconnect(new Presence(Presence.Type.unavailable));
+    }
+
+    /**
+     * Closes the connection. A custom unavailable presence is sent to the server, followed
+     * by closing the stream. The XMPPConnection can still be used for connecting to the server
+     * again. A custom unavailable presence is useful for communicating offline presence
+     * information such as "On vacation". Typically, just the status text of the presence
+     * packet is set with online information, but most XMPP servers will deliver the full
+     * presence packet with whatever data is set.
+     * 
+     * @param unavailablePresence the presence packet to send during shutdown.
+     * @throws NotConnectedException 
+     */
+    public synchronized void disconnect(Presence unavailablePresence) throws NotConnectedException {
+        if (!isConnected()) {
+            return;
+        }
+
+        sendPacket(unavailablePresence);
+        shutdown();
+        callConnectionClosedListener();
+    };
+
+    /**
+     * Shuts the current connection down.
+     */
+    protected abstract void shutdown();
+
+    @Override
+    public void addConnectionListener(ConnectionListener connectionListener) {
+        if (connectionListener == null) {
+            return;
+        }
+        if (!connectionListeners.contains(connectionListener)) {
+            connectionListeners.add(connectionListener);
+        }
+    }
+
+    @Override
+    public void removeConnectionListener(ConnectionListener connectionListener) {
+        connectionListeners.remove(connectionListener);
+    }
+
+    /**
+     * Get the collection of listeners that are interested in connection events.
+     * 
+     * @return a collection of listeners interested on connection events.
+     */
+    protected Collection<ConnectionListener> getConnectionListeners() {
+        return connectionListeners;
+    }
+
+    @Override
+    public PacketCollector createPacketCollectorAndSend(IQ packet) throws NotConnectedException {
+        PacketFilter packetFilter = new IQReplyFilter(packet, this);
+        // Create the packet collector before sending the packet
+        PacketCollector packetCollector = createPacketCollector(packetFilter);
+        // Now we can send the packet as the collector has been created
+        sendPacket(packet);
+        return packetCollector;
+    }
+
+    @Override
+    public PacketCollector createPacketCollector(PacketFilter packetFilter) {
+        PacketCollector collector = new PacketCollector(this, packetFilter);
+        // Add the collector to the list of active collectors.
+        collectors.add(collector);
+        return collector;
+    }
+
+    @Override
+    public void removePacketCollector(PacketCollector collector) {
+        collectors.remove(collector);
+    }
+
+    /**
+     * Get the collection of all packet collectors for this connection.
+     * 
+     * @return a collection of packet collectors for this connection.
+     */
+    protected Collection<PacketCollector> getPacketCollectors() {
+        return collectors;
+    }
+
+    @Override
+    public void addPacketListener(PacketListener packetListener, PacketFilter packetFilter) {
+        if (packetListener == null) {
+            throw new NullPointerException("Packet listener is null.");
+        }
+        ListenerWrapper wrapper = new ListenerWrapper(packetListener, packetFilter);
+        recvListeners.put(packetListener, wrapper);
+    }
+
+    @Override
+    public void removePacketListener(PacketListener packetListener) {
+        recvListeners.remove(packetListener);
+    }
+
+    /**
+     * Get a map of all packet listeners for received packets of this connection.
+     * 
+     * @return a map of all packet listeners for received packets.
+     */
+    protected Map<PacketListener, ListenerWrapper> getPacketListeners() {
+        return recvListeners;
+    }
+
+    @Override
+    public void addPacketSendingListener(PacketListener packetListener, PacketFilter packetFilter) {
+        if (packetListener == null) {
+            throw new NullPointerException("Packet listener is null.");
+        }
+        ListenerWrapper wrapper = new ListenerWrapper(packetListener, packetFilter);
+        sendListeners.put(packetListener, wrapper);
+    }
+
+    @Override
+    public void removePacketSendingListener(PacketListener packetListener) {
+        sendListeners.remove(packetListener);
+    }
+
+    /**
+     * Get a map of all packet listeners for sending packets of this connection.
+     * 
+     * @return a map of all packet listeners for sent packets.
+     */
+    protected Map<PacketListener, ListenerWrapper> getPacketSendingListeners() {
+        return sendListeners;
+    }
+
+
+    /**
+     * Process all packet listeners for sending packets.
+     * 
+     * @param packet the packet to process.
+     */
+    private void firePacketSendingListeners(Packet packet) {
+        // Notify the listeners of the new sent packet
+        for (ListenerWrapper listenerWrapper : sendListeners.values()) {
+            try {
+                listenerWrapper.notifyListener(packet);
+            }
+            catch (NotConnectedException e) {
+                LOGGER.log(Level.WARNING, "Got not connected exception, aborting");
+                break;
+            }
+        }
+    }
+
+    @Override
+    public void addPacketInterceptor(PacketInterceptor packetInterceptor,
+            PacketFilter packetFilter) {
+        if (packetInterceptor == null) {
+            throw new NullPointerException("Packet interceptor is null.");
+        }
+        interceptors.put(packetInterceptor, new InterceptorWrapper(packetInterceptor, packetFilter));
+    }
+
+    @Override
+    public void removePacketInterceptor(PacketInterceptor packetInterceptor) {
+        interceptors.remove(packetInterceptor);
+    }
+
+    /**
+     * Get a map of all packet interceptors for sending packets of this connection.
+     * 
+     * @return a map of all packet interceptors for sending packets.
+     */
+    protected Map<PacketInterceptor, InterceptorWrapper> getPacketInterceptors() {
+        return interceptors;
+    }
+
+    /**
+     * Process interceptors. Interceptors may modify the packet that is about to be sent.
+     * Since the thread that requested to send the packet will invoke all interceptors, it
+     * is important that interceptors perform their work as soon as possible so that the
+     * thread does not remain blocked for a long period.
+     * 
+     * @param packet the packet that is going to be sent to the server
+     */
+    private void firePacketInterceptors(Packet packet) {
+        if (packet != null) {
+            for (InterceptorWrapper interceptorWrapper : interceptors.values()) {
+                interceptorWrapper.notifyListener(packet);
+            }
+        }
+    }
+
+    /**
+     * Initialize the {@link #debugger}. You can specify a customized {@link SmackDebugger}
+     * by setup the system property <code>smack.debuggerClass</code> to the implementation.
+     * 
+     * @throws IllegalStateException if the reader or writer isn't yet initialized.
+     * @throws IllegalArgumentException if the SmackDebugger can't be loaded.
+     */
+    protected void initDebugger() {
+        if (reader == null || writer == null) {
+            throw new NullPointerException("Reader or writer isn't initialized.");
+        }
+        // If debugging is enabled, we open a window and write out all network traffic.
+        if (config.isDebuggerEnabled()) {
+            if (debugger == null) {
+                // Detect the debugger class to use.
+                String className = null;
+                // Use try block since we may not have permission to get a system
+                // property (for example, when an applet).
+                try {
+                    className = System.getProperty("smack.debuggerClass");
+                }
+                catch (Throwable t) {
+                    // Ignore.
+                }
+                Class<?> debuggerClass = null;
+                if (className != null) {
+                    try {
+                        debuggerClass = Class.forName(className);
+                    }
+                    catch (Exception e) {
+                        LOGGER.warning("Unabled to instantiate debugger class " + className);
+                    }
+                }
+                if (debuggerClass == null) {
+                    try {
+                        debuggerClass =
+                                Class.forName("org.jivesoftware.smackx.debugger.EnhancedDebugger");
+                    }
+                    catch (Exception ex) {
+                        try {
+                            debuggerClass =
+                                    Class.forName("org.jivesoftware.smack.debugger.LiteDebugger");
+                        }
+                        catch (Exception ex2) {
+                            LOGGER.warning("Unabled to instantiate either Smack debugger class");
+                        }
+                    }
+                }
+                // Create a new debugger instance. If an exception occurs then disable the debugging
+                // option
+                try {
+                    Constructor<?> constructor = debuggerClass
+                            .getConstructor(XMPPConnection.class, Writer.class, Reader.class);
+                    debugger = (SmackDebugger) constructor.newInstance(this, writer, reader);
+                    reader = debugger.getReader();
+                    writer = debugger.getWriter();
+                }
+                catch (Exception e) {
+                    throw new IllegalArgumentException("Can't initialize the configured debugger!", e);
+                }
+            }
+            else {
+                // Obtain new reader and writer from the existing debugger
+                reader = debugger.newConnectionReader(reader);
+                writer = debugger.newConnectionWriter(writer);
+            }
+        }
+    }
+
+    /**
+     * Set the servers Entity Caps node
+     * 
+     * XMPPConnection holds this information in order to avoid a dependency to
+     * smack-extensions where EntityCapsManager lives from smack.
+     * 
+     * @param node
+     */
+    protected void setServiceCapsNode(String node) {
+        serviceCapsNode = node;
+    }
+
+    @Override
+    public String getServiceCapsNode() {
+        return serviceCapsNode;
+    }
+
+    @Override
+    public boolean isRosterVersioningSupported() {
+        return rosterVersioningSupported;
+    }
+
+    /**
+     * Indicates that the server supports roster versioning as defined in XEP-0237.
+     */
+    protected void setRosterVersioningSupported() {
+        rosterVersioningSupported = true;
+    }
+
+    @Override
+    public long getPacketReplyTimeout() {
+        return packetReplyTimeout;
+    }
+
+    @Override
+    public void setPacketReplyTimeout(long timeout) {
+        packetReplyTimeout = timeout;
+    }
+
+    /**
+     * Processes a packet after it's been fully parsed by looping through the installed
+     * packet collectors and listeners and letting them examine the packet to see if
+     * they are a match with the filter.
+     *
+     * @param packet the packet to process.
+     */
+    protected void processPacket(Packet packet) {
+        if (packet == null) {
+            return;
+        }
+
+        // Loop through all collectors and notify the appropriate ones.
+        for (PacketCollector collector: getPacketCollectors()) {
+            collector.processPacket(packet);
+        }
+
+        // Deliver the incoming packet to listeners.
+        executorService.submit(new ListenerNotification(packet));
+    }
+
+    /**
+     * A runnable to notify all listeners of a packet.
+     */
+    private class ListenerNotification implements Runnable {
+
+        private Packet packet;
+
+        public ListenerNotification(Packet packet) {
+            this.packet = packet;
+        }
+
+        public void run() {
+            for (ListenerWrapper listenerWrapper : recvListeners.values()) {
+                try {
+                    listenerWrapper.notifyListener(packet);
+                } catch(NotConnectedException e) {
+                    LOGGER.log(Level.WARNING, "Got not connected exception, aborting", e);
+                    break;
+                } catch (Exception e) {
+                    LOGGER.log(Level.SEVERE, "Exception in packet listener", e);
+                }
+            }
+        }
+    }
+
+    /**
+     * Sets whether the connection has already logged in the server. This method assures that the
+     * {@link #wasAuthenticated} flag is never reset once it has ever been set.
+     * 
+     * @param authenticated true if the connection has already been authenticated.
+     */
+    protected void setWasAuthenticated(boolean authenticated) {
+        // Never reset the flag if the connection has ever been authenticated
+        if (!wasAuthenticated) {
+            wasAuthenticated = authenticated;
+        }
+    }
+
+    protected void callConnectionConnectedListener() {
+        for (ConnectionListener listener : getConnectionListeners()) {
+            listener.connected(this);
+        }
+    }
+
+    protected void callConnectionAuthenticatedListener() {
+        for (ConnectionListener listener : getConnectionListeners()) {
+            listener.authenticated(this);
+        }
+    }
+
+    void callConnectionClosedListener() {
+        for (ConnectionListener listener : getConnectionListeners()) {
+            try {
+                listener.connectionClosed();
+            }
+            catch (Exception e) {
+                // Catch and print any exception so we can recover
+                // from a faulty listener and finish the shutdown process
+                LOGGER.log(Level.SEVERE, "Error in listener while closing connection", e);
+            }
+        }
+    }
+
+    protected void callConnectionClosedOnErrorListener(Exception e) {
+        LOGGER.log(Level.WARNING, "Connection closed with error", e);
+        for (ConnectionListener listener : getConnectionListeners()) {
+            try {
+                listener.connectionClosedOnError(e);
+            }
+            catch (Exception e2) {
+                // Catch and print any exception so we can recover
+                // from a faulty listener
+                LOGGER.log(Level.SEVERE, "Error in listener while closing connection", e2);
+            }
+        }
+    }
+
+    /**
+     * A wrapper class to associate a packet filter with a listener.
+     */
+    protected static class ListenerWrapper {
+
+        private PacketListener packetListener;
+        private PacketFilter packetFilter;
+
+        /**
+         * Create a class which associates a packet filter with a listener.
+         * 
+         * @param packetListener the packet listener.
+         * @param packetFilter the associated filter or null if it listen for all packets.
+         */
+        public ListenerWrapper(PacketListener packetListener, PacketFilter packetFilter) {
+            this.packetListener = packetListener;
+            this.packetFilter = packetFilter;
+        }
+
+        /**
+         * Notify and process the packet listener if the filter matches the packet.
+         * 
+         * @param packet the packet which was sent or received.
+         * @throws NotConnectedException 
+         */
+        public void notifyListener(Packet packet) throws NotConnectedException {
+            if (packetFilter == null || packetFilter.accept(packet)) {
+                packetListener.processPacket(packet);
+            }
+        }
+    }
+
+    /**
+     * A wrapper class to associate a packet filter with an interceptor.
+     */
+    protected static class InterceptorWrapper {
+
+        private PacketInterceptor packetInterceptor;
+        private PacketFilter packetFilter;
+
+        /**
+         * Create a class which associates a packet filter with an interceptor.
+         * 
+         * @param packetInterceptor the interceptor.
+         * @param packetFilter the associated filter or null if it intercepts all packets.
+         */
+        public InterceptorWrapper(PacketInterceptor packetInterceptor, PacketFilter packetFilter) {
+            this.packetInterceptor = packetInterceptor;
+            this.packetFilter = packetFilter;
+        }
+
+        public boolean equals(Object object) {
+            if (object == null) {
+                return false;
+            }
+            if (object instanceof InterceptorWrapper) {
+                return ((InterceptorWrapper) object).packetInterceptor
+                        .equals(this.packetInterceptor);
+            }
+            else if (object instanceof PacketInterceptor) {
+                return object.equals(this.packetInterceptor);
+            }
+            return false;
+        }
+
+        /**
+         * Notify and process the packet interceptor if the filter matches the packet.
+         * 
+         * @param packet the packet which will be sent.
+         */
+        public void notifyListener(Packet packet) {
+            if (packetFilter == null || packetFilter.accept(packet)) {
+                packetInterceptor.interceptPacket(packet);
+            }
+        }
+    }
+
+    @Override
+    public ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit) {
+        return executorService.schedule(command, delay, unit);
+    }
+
+    @Override
+    public int getConnectionCounter() {
+        return connectionCounterValue;
+    }
+
+    @Override
+    public void setFromMode(FromMode fromMode) {
+        this.fromMode = fromMode;
+    }
+
+    @Override
+    public FromMode getFromMode() {
+        return this.fromMode;
+    }
+
+    @Override
+    protected void finalize() throws Throwable {
+        try {
+            // It's usually not a good idea to rely on finalize. But this is the easiest way to
+            // avoid the "Smack Listener Processor" leaking. The thread(s) of the executor have a
+            // reference to their ExecutorService which prevents the ExecutorService from being
+            // gc'ed. It is possible that the XMPPConnection instance is gc'ed while the
+            // listenerExecutor ExecutorService call not be gc'ed until it got shut down.
+            executorService.shutdownNow();
+        }
+        finally {
+            super.finalize();
+        }
+    }
+}
diff --git a/smack-core/src/main/java/org/jivesoftware/smack/ConnectionCreationListener.java b/smack-core/src/main/java/org/jivesoftware/smack/ConnectionCreationListener.java
index 0a04bc00c..5b724078f 100644
--- a/smack-core/src/main/java/org/jivesoftware/smack/ConnectionCreationListener.java
+++ b/smack-core/src/main/java/org/jivesoftware/smack/ConnectionCreationListener.java
@@ -20,7 +20,7 @@ package org.jivesoftware.smack;
 /**
  * Implementors of this interface will be notified when a new {@link XMPPConnection}
  * has been created. The newly created connection will not be actually connected to
- * the server. Use {@link XMPPConnection#addConnectionCreationListener(ConnectionCreationListener)}
+ * the server. Use {@link XMPPConnectionRegistry#addConnectionCreationListener(ConnectionCreationListener)}
  * to add new listeners.
  *
  * @author Gaston Dombiak
diff --git a/smack-core/src/main/java/org/jivesoftware/smack/Manager.java b/smack-core/src/main/java/org/jivesoftware/smack/Manager.java
index da00235f0..0b6d1315d 100644
--- a/smack-core/src/main/java/org/jivesoftware/smack/Manager.java
+++ b/smack-core/src/main/java/org/jivesoftware/smack/Manager.java
@@ -17,8 +17,6 @@
 package org.jivesoftware.smack;
 
 import java.lang.ref.WeakReference;
-import java.util.concurrent.ScheduledFuture;
-import java.util.concurrent.TimeUnit;
 
 public abstract class Manager {
 
@@ -31,8 +29,4 @@ public abstract class Manager {
     protected final XMPPConnection connection() {
         return weakConnection.get();
     }
-
-    protected ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit) {
-        return connection().schedule(command, delay, unit);
-    }
 }
diff --git a/smack-core/src/main/java/org/jivesoftware/smack/ReconnectionManager.java b/smack-core/src/main/java/org/jivesoftware/smack/ReconnectionManager.java
index 683b86d0c..ae256f10b 100644
--- a/smack-core/src/main/java/org/jivesoftware/smack/ReconnectionManager.java
+++ b/smack-core/src/main/java/org/jivesoftware/smack/ReconnectionManager.java
@@ -39,7 +39,7 @@ public class ReconnectionManager extends AbstractConnectionListener {
     private static final Logger LOGGER = Logger.getLogger(ReconnectionManager.class.getName());
     
     // Holds the connection to the server
-    private XMPPConnection connection;
+    private final AbstractXMPPConnection connection;
     private Thread reconnectionThread;
     private int randomBase = new Random().nextInt(11) + 5; // between 5 and 15 seconds
     
@@ -50,14 +50,16 @@ public class ReconnectionManager extends AbstractConnectionListener {
         // Create a new PrivacyListManager on every established connection. In the init()
         // method of PrivacyListManager, we'll add a listener that will delete the
         // instance when the connection is closed.
-        XMPPConnection.addConnectionCreationListener(new ConnectionCreationListener() {
+        XMPPConnectionRegistry.addConnectionCreationListener(new ConnectionCreationListener() {
             public void connectionCreated(XMPPConnection connection) {
-                connection.addConnectionListener(new ReconnectionManager(connection));
+                if (connection instanceof AbstractXMPPConnection) {
+                    connection.addConnectionListener(new ReconnectionManager((AbstractXMPPConnection) connection));
+                }
             }
         });
     }
 
-    private ReconnectionManager(XMPPConnection connection) {
+    private ReconnectionManager(AbstractXMPPConnection connection) {
         this.connection = connection;
     }
 
diff --git a/smack-core/src/main/java/org/jivesoftware/smack/XMPPConnection.java b/smack-core/src/main/java/org/jivesoftware/smack/XMPPConnection.java
index 6f47e5d47..6d9e75ad1 100644
--- a/smack-core/src/main/java/org/jivesoftware/smack/XMPPConnection.java
+++ b/smack-core/src/main/java/org/jivesoftware/smack/XMPPConnection.java
@@ -16,44 +16,15 @@
  */
 package org.jivesoftware.smack;
 
-import java.io.IOException;
-import java.io.Reader;
-import java.io.Writer;
-import java.lang.reflect.Constructor;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.Map;
-import java.util.Set;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ConcurrentLinkedQueue;
-import java.util.concurrent.CopyOnWriteArrayList;
-import java.util.concurrent.CopyOnWriteArraySet;
-import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.ScheduledFuture;
-import java.util.concurrent.ScheduledThreadPoolExecutor;
-import java.util.concurrent.ThreadFactory;
 import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.concurrent.atomic.AtomicInteger;
-import java.util.logging.Level;
-import java.util.logging.Logger;
-
-import javax.security.sasl.SaslException;
 
 import org.jivesoftware.smack.SmackException.NoResponseException;
 import org.jivesoftware.smack.SmackException.NotConnectedException;
-import org.jivesoftware.smack.SmackException.ConnectionException;
-import org.jivesoftware.smack.SmackException.ResourceBindingNotOfferedException;
-import org.jivesoftware.smack.XMPPException.XMPPErrorException;
-import org.jivesoftware.smack.compression.XMPPInputOutputStream;
-import org.jivesoftware.smack.debugger.SmackDebugger;
 import org.jivesoftware.smack.filter.IQReplyFilter;
 import org.jivesoftware.smack.filter.PacketFilter;
-import org.jivesoftware.smack.packet.Bind;
 import org.jivesoftware.smack.packet.IQ;
 import org.jivesoftware.smack.packet.Packet;
-import org.jivesoftware.smack.packet.Presence;
-import org.jivesoftware.smack.packet.Session;
 
 /**
  * The abstract XMPPConnection class provides an interface for connections to a XMPP server and
@@ -82,204 +53,14 @@ import org.jivesoftware.smack.packet.Session;
  * </pre>
  * <p>
  * Connections can be reused between connections. This means that an Connection may be connected,
- * disconnected and then connected again. Listeners of the Connection will be retained accross
+ * disconnected and then connected again. Listeners of the Connection will be retained across
  * connections.
- * <p>
- * If a connected XMPPConnection gets disconnected abruptly and automatic reconnection is enabled (
- * {@link ConnectionConfiguration#isReconnectionAllowed()}, the default), then it will try to
- * reconnect again. To stop the reconnection process, use {@link #disconnect()}. Once stopped you
- * can use {@link #connect()} to manually connect to the server.
  * 
  * @author Matt Tucker
  * @author Guenther Niess
  */
 @SuppressWarnings("javadoc")
-public abstract class XMPPConnection {
-    private static final Logger LOGGER = Logger.getLogger(XMPPConnection.class.getName());
-    
-    /** 
-     * Counter to uniquely identify connections that are created.
-     */
-    private final static AtomicInteger connectionCounter = new AtomicInteger(0);
-
-    /**
-     * A set of listeners which will be invoked if a new connection is created.
-     */
-    private final static Set<ConnectionCreationListener> connectionEstablishedListeners =
-            new CopyOnWriteArraySet<ConnectionCreationListener>();
-
-    static {
-        // Ensure the SmackConfiguration class is loaded by calling a method in it.
-        SmackConfiguration.getVersion();
-    }
-
-    /**
-     * A collection of ConnectionListeners which listen for connection closing
-     * and reconnection events.
-     */
-    protected final Collection<ConnectionListener> connectionListeners =
-            new CopyOnWriteArrayList<ConnectionListener>();
-
-    /**
-     * A collection of PacketCollectors which collects packets for a specified filter
-     * and perform blocking and polling operations on the result queue.
-     */
-    protected final Collection<PacketCollector> collectors = new ConcurrentLinkedQueue<PacketCollector>();
-
-    /**
-     * List of PacketListeners that will be notified when a new packet was received.
-     */
-    protected final Map<PacketListener, ListenerWrapper> recvListeners =
-            new ConcurrentHashMap<PacketListener, ListenerWrapper>();
-
-    /**
-     * List of PacketListeners that will be notified when a new packet was sent.
-     */
-    protected final Map<PacketListener, ListenerWrapper> sendListeners =
-            new ConcurrentHashMap<PacketListener, ListenerWrapper>();
-
-    /**
-     * List of PacketInterceptors that will be notified when a new packet is about to be
-     * sent to the server. These interceptors may modify the packet before it is being
-     * actually sent to the server.
-     */
-    protected final Map<PacketInterceptor, InterceptorWrapper> interceptors =
-            new ConcurrentHashMap<PacketInterceptor, InterceptorWrapper>();
-
-    /**
-     * 
-     */
-    private long packetReplyTimeout = SmackConfiguration.getDefaultPacketReplyTimeout();
-
-    /**
-     * The SmackDebugger allows to log and debug XML traffic.
-     */
-    protected SmackDebugger debugger = null;
-
-    /**
-     * The Reader which is used for the debugger.
-     */
-    protected Reader reader;
-
-    /**
-     * The Writer which is used for the debugger.
-     */
-    protected Writer writer;
-
-
-    /**
-     * The SASLAuthentication manager that is responsible for authenticating with the server.
-     */
-    protected SASLAuthentication saslAuthentication = new SASLAuthentication(this);
-
-    /**
-     * A number to uniquely identify connections that are created. This is distinct from the
-     * connection ID, which is a value sent by the server once a connection is made.
-     */
-    protected final int connectionCounterValue = connectionCounter.getAndIncrement();
-
-    /**
-     * Holds the initial configuration used while creating the connection.
-     */
-    protected final ConnectionConfiguration config;
-
-    /**
-     * Holds the Caps Node information for the used XMPP service (i.e. the XMPP server)
-     */
-    private String serviceCapsNode;
-
-    /**
-     * Defines how the from attribute of outgoing stanzas should be handled.
-     */
-    private FromMode fromMode = FromMode.OMITTED;
-
-    /**
-     * Stores whether the server supports rosterVersioning
-     */
-    private boolean rosterVersioningSupported = false;
-
-    protected XMPPInputOutputStream compressionHandler;
-
-    private final ScheduledExecutorService executorService = new ScheduledThreadPoolExecutor(2,
-                    new SmackExecutorThreadFactory(connectionCounterValue));
-
-    /**
-     * SmackExecutorThreadFactory is a *static* inner class of XMPPConnection. Note that we must not
-     * use anonymous classes in order to prevent threads from leaking.
-     */
-    private static final class SmackExecutorThreadFactory implements ThreadFactory {
-        private final int connectionCounterValue;
-        private int count = 0;
-
-        private SmackExecutorThreadFactory(int connectionCounterValue) {
-            this.connectionCounterValue = connectionCounterValue;
-        }
-
-        @Override
-        public Thread newThread(Runnable runnable) {
-            Thread thread = new Thread(runnable, "Smack Executor Service " + count++ + " ("
-                            + connectionCounterValue + ")");
-            thread.setDaemon(true);
-            return thread;
-        }
-    }
-
-    private Roster roster;
-
-    /**
-     * The used host to establish the connection to
-     */
-    private String host;
-
-    /**
-     * The used port to establish the connection to
-     */
-    private int port;
-
-    /**
-     * Set to true if the server requires the connection to be binded in order to continue.
-     * <p>
-     * Note that we use AtomicBoolean here because it allows us to set the Boolean *object*, which
-     * we also use as synchronization object. A plain non-atomic Boolean object would be newly created
-     * for every change of the boolean value, which makes it useless as object for wait()/notify().
-     */
-    private AtomicBoolean bindingRequired = new AtomicBoolean(false);
-
-    private boolean sessionSupported;
-
-    /**
-     * 
-     */
-    private IOException connectionException;
-
-    /**
-     * Flag that indicates if the user is currently authenticated with the server.
-     */
-    protected boolean authenticated = false;
-
-    /**
-     * Flag that indicates if the user was authenticated with the server when the connection
-     * to the server was closed (abruptly or not).
-     */
-    protected boolean wasAuthenticated = false;
-
-    /**
-     * Create a new XMPPConnection to a XMPP server.
-     * 
-     * @param configuration The configuration which is used to establish the connection.
-     */
-    protected XMPPConnection(ConnectionConfiguration configuration) {
-        config = configuration;
-    }
-
-    /**
-     * Returns the configuration used to connect to the server.
-     * 
-     * @return the configuration used to connect to the server.
-     */
-    protected ConnectionConfiguration getConfiguration() {
-        return config;
-    }
+public interface XMPPConnection {
 
     /**
      * Returns the name of the service provided by the XMPP server for this connection.
@@ -288,9 +69,7 @@ public abstract class XMPPConnection {
      * 
      * @return the name of the service provided by the XMPP server.
      */
-    public String getServiceName() {
-        return config.getServiceName();
-    }
+    public String getServiceName();
 
     /**
      * Returns the host name of the server where the XMPP server is running. This would be the
@@ -298,9 +77,7 @@ public abstract class XMPPConnection {
      * 
      * @return the host name of the server where the XMPP server is running or null if not yet connected.
      */
-    public String getHost() {
-        return host;
-    }
+    public String getHost();
 
     /**
      * Returns the port number of the XMPP server for this connection. The default port
@@ -308,9 +85,7 @@ public abstract class XMPPConnection {
      * 
      * @return the port number of the XMPP server or 0 if not yet connected.
      */
-    public int getPort() {
-        return port;
-    }
+    public int getPort();
 
     /**
      * Returns the full XMPP address of the user that is logged in to the connection or
@@ -319,7 +94,7 @@ public abstract class XMPPConnection {
      * 
      * @return the full XMPP address of the user logged in.
      */
-    public abstract String getUser();
+    public String getUser();
 
     /**
      * Returns the connection ID for this connection, which is the value set by the server
@@ -329,37 +104,35 @@ public abstract class XMPPConnection {
      * @return the ID of this connection returned from the XMPP server or <tt>null</tt> if
      *      not connected to the server.
      */
-    public abstract String getConnectionID();
+    public String getConnectionID();
 
     /**
      * Returns true if currently connected to the XMPP server.
      * 
      * @return true if connected.
      */
-    public abstract boolean isConnected();
+    public boolean isConnected();
 
     /**
      * Returns true if currently authenticated by successfully calling the login method.
      * 
      * @return true if authenticated.
      */
-    public abstract boolean isAuthenticated();
+    public boolean isAuthenticated();
 
     /**
      * Returns true if currently authenticated anonymously.
      * 
      * @return true if authenticated anonymously.
      */
-    public abstract boolean isAnonymous();
+    public boolean isAnonymous();
 
     /**
      * Returns true if the connection to the server has successfully negotiated encryption. 
      * 
      * @return true if a secure connection to the server.
      */
-    public abstract boolean isSecureConnection();
-
-    protected abstract void sendPacketInternal(Packet packet) throws NotConnectedException;
+    public boolean isSecureConnection();
 
     /**
      * Returns true if network traffic is being compressed. When using stream compression network
@@ -369,204 +142,14 @@ public abstract class XMPPConnection {
      * 
      * @return true if network traffic is being compressed.
      */
-    public abstract boolean isUsingCompression();
+    public boolean isUsingCompression();
 
     /**
-     * Establishes a connection to the XMPP server and performs an automatic login
-     * only if the previous connection state was logged (authenticated). It basically
-     * creates and maintains a connection to the server.
-     * <p>
-     * Listeners will be preserved from a previous connection.
+     * Returns the configuration used to connect to the server.
      * 
-     * @throws XMPPException if an error occurs on the XMPP protocol level.
-     * @throws SmackException if an error occurs somewhere else besides XMPP protocol level.
-     * @throws IOException 
-     * @throws ConnectionException with detailed information about the failed connection.
+     * @return the configuration used to connect to the server.
      */
-    public void connect() throws SmackException, IOException, XMPPException {
-        saslAuthentication.init();
-        bindingRequired.set(false);
-        sessionSupported = false;
-        connectionException = null;
-        connectInternal();
-    }
-
-    /**
-     * Abstract method that concrete subclasses of XMPPConnection need to implement to perform their
-     * way of XMPP connection establishment. Implementations must guarantee that this method will
-     * block until the last features stanzas has been parsed and the features have been reported
-     * back to XMPPConnection (e.g. by calling @{link {@link XMPPConnection#serverRequiresBinding()}
-     * and such).
-     * <p>
-     * Also implementations are required to perform an automatic login if the previous connection
-     * state was logged (authenticated).
-     *
-     * @throws SmackException
-     * @throws IOException
-     * @throws XMPPException
-     */
-    protected abstract void connectInternal() throws SmackException, IOException, XMPPException;
-
-    /**
-     * Logs in to the server using the strongest authentication mode supported by
-     * the server, then sets presence to available. If the server supports SASL authentication 
-     * then the user will be authenticated using SASL if not Non-SASL authentication will 
-     * be tried. If more than five seconds (default timeout) elapses in each step of the 
-     * authentication process without a response from the server, or if an error occurs, a 
-     * XMPPException will be thrown.<p>
-     * 
-     * Before logging in (i.e. authenticate) to the server the connection must be connected.
-     * 
-     * It is possible to log in without sending an initial available presence by using
-     * {@link ConnectionConfiguration#setSendPresence(boolean)}. If this connection is
-     * not interested in loading its roster upon login then use
-     * {@link ConnectionConfiguration#setRosterLoadedAtLogin(boolean)}.
-     * Finally, if you want to not pass a password and instead use a more advanced mechanism
-     * while using SASL then you may be interested in using
-     * {@link ConnectionConfiguration#setCallbackHandler(javax.security.auth.callback.CallbackHandler)}.
-     * For more advanced login settings see {@link ConnectionConfiguration}.
-     * 
-     * @param username the username.
-     * @param password the password or <tt>null</tt> if using a CallbackHandler.
-     * @throws XMPPException if an error occurs on the XMPP protocol level.
-     * @throws SmackException if an error occurs somehwere else besides XMPP protocol level.
-     * @throws IOException 
-     * @throws SaslException 
-     */
-    public void login(String username, String password) throws XMPPException, SmackException, SaslException, IOException {
-        login(username, password, "Smack");
-    }
-
-    /**
-     * Logs in to the server using the strongest authentication mode supported by
-     * the server, then sets presence to available. If the server supports SASL authentication 
-     * then the user will be authenticated using SASL if not Non-SASL authentication will 
-     * be tried. If more than five seconds (default timeout) elapses in each step of the 
-     * authentication process without a response from the server, or if an error occurs, a 
-     * XMPPException will be thrown.<p>
-     * 
-     * Before logging in (i.e. authenticate) to the server the connection must be connected.
-     * 
-     * It is possible to log in without sending an initial available presence by using
-     * {@link ConnectionConfiguration#setSendPresence(boolean)}. If this connection is
-     * not interested in loading its roster upon login then use
-     * {@link ConnectionConfiguration#setRosterLoadedAtLogin(boolean)}.
-     * Finally, if you want to not pass a password and instead use a more advanced mechanism
-     * while using SASL then you may be interested in using
-     * {@link ConnectionConfiguration#setCallbackHandler(javax.security.auth.callback.CallbackHandler)}.
-     * For more advanced login settings see {@link ConnectionConfiguration}.
-     * 
-     * @param username the username.
-     * @param password the password or <tt>null</tt> if using a CallbackHandler.
-     * @param resource the resource.
-     * @throws XMPPException if an error occurs on the XMPP protocol level.
-     * @throws SmackException if an error occurs somehwere else besides XMPP protocol level.
-     * @throws IOException 
-     * @throws SaslException 
-     */
-    public abstract void login(String username, String password, String resource) throws XMPPException, SmackException, SaslException, IOException;
-
-    /**
-     * Logs in to the server anonymously. Very few servers are configured to support anonymous
-     * authentication, so it's fairly likely logging in anonymously will fail. If anonymous login
-     * does succeed, your XMPP address will likely be in the form "123ABC@server/789XYZ" or
-     * "server/123ABC" (where "123ABC" and "789XYZ" is a random value generated by the server).
-     * 
-     * @throws XMPPException if an error occurs on the XMPP protocol level.
-     * @throws SmackException if an error occurs somehwere else besides XMPP protocol level.
-     * @throws IOException 
-     * @throws SaslException 
-     */
-    public abstract void loginAnonymously() throws XMPPException, SmackException, SaslException, IOException;
-
-    /**
-     * Notification message saying that the server requires the client to bind a
-     * resource to the stream.
-     */
-    protected void serverRequiresBinding() {
-        synchronized (bindingRequired) {
-            bindingRequired.set(true);
-            bindingRequired.notify();
-        }
-    }
-
-    /**
-     * Notification message saying that the server supports sessions. When a server supports
-     * sessions the client needs to send a Session packet after successfully binding a resource
-     * for the session.
-     */
-    protected void serverSupportsSession() {
-        sessionSupported = true;
-    }
-
-    protected String bindResourceAndEstablishSession(String resource) throws XMPPErrorException,
-                    ResourceBindingNotOfferedException, NoResponseException, NotConnectedException {
-
-        synchronized (bindingRequired) {
-            if (!bindingRequired.get()) {
-                try {
-                    bindingRequired.wait(getPacketReplyTimeout());
-                }
-                catch (InterruptedException e) {
-                    // Ignore
-                }
-                if (!bindingRequired.get()) {
-                    // Server never offered resource binding, which is REQURIED in XMPP client and
-                    // server
-                    // implementations as per RFC6120 7.2
-                    throw new ResourceBindingNotOfferedException();
-                }
-            }
-        }
-
-        Bind bindResource = new Bind();
-        bindResource.setResource(resource);
-
-        Bind response = (Bind) createPacketCollectorAndSend(bindResource).nextResultOrThrow();
-        String userJID = response.getJid();
-
-        if (sessionSupported && !getConfiguration().isLegacySessionDisabled()) {
-            Session session = new Session();
-            createPacketCollectorAndSend(session).nextResultOrThrow();
-        }
-        return userJID;
-    }
-
-    protected void setConnectionException(IOException exception) {
-        connectionException = exception;
-    }
-
-    protected void throwConnectionExceptionOrNoResponse() throws IOException, NoResponseException {
-        if (connectionException != null) {
-            throw connectionException;
-        } else {
-            throw new NoResponseException();
-        }
-    }
-
-    protected Reader getReader() {
-        return reader;
-    }
-
-    protected Writer getWriter() {
-        return writer;
-    }
-
-    protected void setServiceName(String serviceName) {
-        config.setServiceName(serviceName);
-    }
-    
-    protected void setLoginInfo(String username, String password, String resource) {
-        config.setLoginInfo(username, password, resource);
-    }
-    
-    protected void serverSupportsAccountCreation() {
-        AccountManager.getInstance(this).setSupportsAccountCreation(true);
-    }
-
-    protected void maybeResolveDns() throws Exception {
-        config.maybeResolveDns();
-    }
+    public ConnectionConfiguration getConfiguration();
 
     /**
      * Sends the specified packet to the server.
@@ -574,32 +157,7 @@ public abstract class XMPPConnection {
      * @param packet the packet to send.
      * @throws NotConnectedException 
      */
-    public void sendPacket(Packet packet) throws NotConnectedException {
-        if (!isConnected()) {
-            throw new NotConnectedException();
-        }
-        if (packet == null) {
-            throw new NullPointerException("Packet is null.");
-        }
-        switch (fromMode) {
-        case OMITTED:
-            packet.setFrom(null);
-            break;
-        case USER:
-            packet.setFrom(getUser());
-            break;
-        case UNCHANGED:
-        default:
-            break;
-        }
-        // Invoke interceptors for the new packet that is about to be sent. Interceptors may modify
-        // the content of the packet.
-        firePacketInterceptors(packet);
-        sendPacketInternal(packet);
-        // Process packet writer listeners. Note that we're using the sending thread so it's
-        // expected that listeners are fast.
-        firePacketSendingListeners(packet);
-    }
+    public void sendPacket(Packet packet) throws NotConnectedException;
 
     /**
      * Returns the roster for the user.
@@ -613,129 +171,7 @@ public abstract class XMPPConnection {
      * @return the user's roster.
      * @throws IllegalStateException if the connection is anonymous
      */
-    public Roster getRoster() {
-        if (isAnonymous()) {
-            throw new IllegalStateException("Anonymous users can't have a roster");
-        }
-        // synchronize against login()
-        synchronized(this) {
-            if (roster == null) {
-                roster = new Roster(this);
-            }
-            if (!isAuthenticated()) {
-                return roster;
-            }
-        }
-
-        // If this is the first time the user has asked for the roster after calling
-        // login, we want to wait for the server to send back the user's roster. This
-        // behavior shields API users from having to worry about the fact that roster
-        // operations are asynchronous, although they'll still have to listen for
-        // changes to the roster. Note: because of this waiting logic, internal
-        // Smack code should be wary about calling the getRoster method, and may need to
-        // access the roster object directly.
-        // Also only check for rosterInitalized is isRosterLoadedAtLogin is set, otherwise the user
-        // has to manually call Roster.reload() before he can expect a initialized roster.
-        if (!roster.rosterInitialized && config.isRosterLoadedAtLogin()) {
-            try {
-                synchronized (roster) {
-                    long waitTime = getPacketReplyTimeout();
-                    long start = System.currentTimeMillis();
-                    while (!roster.rosterInitialized) {
-                        if (waitTime <= 0) {
-                            break;
-                        }
-                        roster.wait(waitTime);
-                        long now = System.currentTimeMillis();
-                        waitTime -= now - start;
-                        start = now;
-                    }
-                }
-            }
-            catch (InterruptedException ie) {
-                // Ignore.
-            }
-        }
-        return roster;
-    }
-
-    /**
-     * Returns the SASLAuthentication manager that is responsible for authenticating with
-     * the server.
-     * 
-     * @return the SASLAuthentication manager that is responsible for authenticating with
-     *         the server.
-     */
-    protected SASLAuthentication getSASLAuthentication() {
-        return saslAuthentication;
-    }
-
-    /**
-     * Closes the connection by setting presence to unavailable then closing the connection to
-     * the XMPP server. The XMPPConnection can still be used for connecting to the server
-     * again.
-     *
-     * @throws NotConnectedException 
-     */
-    public void disconnect() throws NotConnectedException {
-        disconnect(new Presence(Presence.Type.unavailable));
-    }
-
-    /**
-     * Closes the connection. A custom unavailable presence is sent to the server, followed
-     * by closing the stream. The XMPPConnection can still be used for connecting to the server
-     * again. A custom unavailable presence is useful for communicating offline presence
-     * information such as "On vacation". Typically, just the status text of the presence
-     * packet is set with online information, but most XMPP servers will deliver the full
-     * presence packet with whatever data is set.
-     * 
-     * @param unavailablePresence the presence packet to send during shutdown.
-     * @throws NotConnectedException 
-     */
-    public synchronized void disconnect(Presence unavailablePresence) throws NotConnectedException {
-        if (!isConnected()) {
-            return;
-        }
-
-        sendPacket(unavailablePresence);
-        shutdown();
-        callConnectionClosedListener();
-    };
-
-    /**
-     * Shuts the current connection down.
-     */
-    protected abstract void shutdown();
-
-    /**
-     * Adds a new listener that will be notified when new Connections are created. Note
-     * that newly created connections will not be actually connected to the server.
-     * 
-     * @param connectionCreationListener a listener interested on new connections.
-     */
-    public static void addConnectionCreationListener(
-            ConnectionCreationListener connectionCreationListener) {
-        connectionEstablishedListeners.add(connectionCreationListener);
-    }
-
-    /**
-     * Removes a listener that was interested in connection creation events.
-     * 
-     * @param connectionCreationListener a listener interested on new connections.
-     */
-    public static void removeConnectionCreationListener(
-            ConnectionCreationListener connectionCreationListener) {
-        connectionEstablishedListeners.remove(connectionCreationListener);
-    }
-
-    /**
-     * Get the collection of listeners that are interested in connection creation events.
-     * 
-     * @return a collection of listeners interested on new connections.
-     */
-    protected static Collection<ConnectionCreationListener> getConnectionCreationListeners() {
-        return Collections.unmodifiableCollection(connectionEstablishedListeners);
-    }
+    public Roster getRoster();
 
     /**
      * Adds a connection listener to this connection that will be notified when
@@ -743,32 +179,14 @@ public abstract class XMPPConnection {
      * 
      * @param connectionListener a connection listener.
      */
-    public void addConnectionListener(ConnectionListener connectionListener) {
-        if (connectionListener == null) {
-            return;
-        }
-        if (!connectionListeners.contains(connectionListener)) {
-            connectionListeners.add(connectionListener);
-        }
-    }
+    public void addConnectionListener(ConnectionListener connectionListener);
 
     /**
      * Removes a connection listener from this connection.
      * 
      * @param connectionListener a connection listener.
      */
-    public void removeConnectionListener(ConnectionListener connectionListener) {
-        connectionListeners.remove(connectionListener);
-    }
-
-    /**
-     * Get the collection of listeners that are interested in connection events.
-     * 
-     * @return a collection of listeners interested on connection events.
-     */
-    protected Collection<ConnectionListener> getConnectionListeners() {
-        return connectionListeners;
-    }
+    public void removeConnectionListener(ConnectionListener connectionListener);
 
     /**
      * Creates a new packet collector collecting packets that are replies to <code>packet</code>.
@@ -780,14 +198,7 @@ public abstract class XMPPConnection {
      * @return a new packet collector.
      * @throws NotConnectedException 
      */
-    public PacketCollector createPacketCollectorAndSend(IQ packet) throws NotConnectedException {
-        PacketFilter packetFilter = new IQReplyFilter(packet, this);
-        // Create the packet collector before sending the packet
-        PacketCollector packetCollector = createPacketCollector(packetFilter);
-        // Now we can send the packet as the collector has been created
-        sendPacket(packet);
-        return packetCollector;
-    }
+    public PacketCollector createPacketCollectorAndSend(IQ packet) throws NotConnectedException;
 
     /**
      * Creates a new packet collector for this connection. A packet filter determines
@@ -798,30 +209,14 @@ public abstract class XMPPConnection {
      * @param packetFilter the packet filter to use.
      * @return a new packet collector.
      */
-    public PacketCollector createPacketCollector(PacketFilter packetFilter) {
-        PacketCollector collector = new PacketCollector(this, packetFilter);
-        // Add the collector to the list of active collectors.
-        collectors.add(collector);
-        return collector;
-    }
+    public PacketCollector createPacketCollector(PacketFilter packetFilter);
 
     /**
      * Remove a packet collector of this connection.
      * 
      * @param collector a packet collectors which was created for this connection.
      */
-    protected void removePacketCollector(PacketCollector collector) {
-        collectors.remove(collector);
-    }
-
-    /**
-     * Get the collection of all packet collectors for this connection.
-     * 
-     * @return a collection of packet collectors for this connection.
-     */
-    protected Collection<PacketCollector> getPacketCollectors() {
-        return collectors;
-    }
+    public void removePacketCollector(PacketCollector collector);
 
     /**
      * Registers a packet listener with this connection. A packet listener will be invoked only
@@ -829,37 +224,19 @@ public abstract class XMPPConnection {
      * which packets will be delivered to the listener. If the same packet listener
      * is added again with a different filter, only the new filter will be used.
      * 
-     * <p>
      * NOTE: If you want get a similar callback for outgoing packets, see {@link #addPacketInterceptor(PacketInterceptor, PacketFilter)}.
      * 
      * @param packetListener the packet listener to notify of new received packets.
      * @param packetFilter   the packet filter to use.
      */
-    public void addPacketListener(PacketListener packetListener, PacketFilter packetFilter) {
-        if (packetListener == null) {
-            throw new NullPointerException("Packet listener is null.");
-        }
-        ListenerWrapper wrapper = new ListenerWrapper(packetListener, packetFilter);
-        recvListeners.put(packetListener, wrapper);
-    }
+    public void addPacketListener(PacketListener packetListener, PacketFilter packetFilter);
 
     /**
      * Removes a packet listener for received packets from this connection.
      * 
      * @param packetListener the packet listener to remove.
      */
-    public void removePacketListener(PacketListener packetListener) {
-        recvListeners.remove(packetListener);
-    }
-
-    /**
-     * Get a map of all packet listeners for received packets of this connection.
-     * 
-     * @return a map of all packet listeners for received packets.
-     */
-    protected Map<PacketListener, ListenerWrapper> getPacketListeners() {
-        return recvListeners;
-    }
+    public void removePacketListener(PacketListener packetListener);
 
     /**
      * Registers a packet listener with this connection. The listener will be
@@ -872,50 +249,14 @@ public abstract class XMPPConnection {
      * @param packetListener the packet listener to notify of sent packets.
      * @param packetFilter   the packet filter to use.
      */
-    public void addPacketSendingListener(PacketListener packetListener, PacketFilter packetFilter) {
-        if (packetListener == null) {
-            throw new NullPointerException("Packet listener is null.");
-        }
-        ListenerWrapper wrapper = new ListenerWrapper(packetListener, packetFilter);
-        sendListeners.put(packetListener, wrapper);
-    }
+    public void addPacketSendingListener(PacketListener packetListener, PacketFilter packetFilter);
 
     /**
      * Removes a packet listener for sending packets from this connection.
      * 
      * @param packetListener the packet listener to remove.
      */
-    public void removePacketSendingListener(PacketListener packetListener) {
-        sendListeners.remove(packetListener);
-    }
-
-    /**
-     * Get a map of all packet listeners for sending packets of this connection.
-     * 
-     * @return a map of all packet listeners for sent packets.
-     */
-    protected Map<PacketListener, ListenerWrapper> getPacketSendingListeners() {
-        return sendListeners;
-    }
-
-
-    /**
-     * Process all packet listeners for sending packets.
-     * 
-     * @param packet the packet to process.
-     */
-    private void firePacketSendingListeners(Packet packet) {
-        // Notify the listeners of the new sent packet
-        for (ListenerWrapper listenerWrapper : sendListeners.values()) {
-            try {
-                listenerWrapper.notifyListener(packet);
-            }
-            catch (NotConnectedException e) {
-                LOGGER.log(Level.WARNING, "Got not connected exception, aborting");
-                break;
-            }
-        }
-    }
+    public void removePacketSendingListener(PacketListener packetListener);
 
     /**
      * Registers a packet interceptor with this connection. The interceptor will be
@@ -929,128 +270,14 @@ public abstract class XMPPConnection {
      * @param packetInterceptor the packet interceptor to notify of packets about to be sent.
      * @param packetFilter      the packet filter to use.
      */
-    public void addPacketInterceptor(PacketInterceptor packetInterceptor,
-            PacketFilter packetFilter) {
-        if (packetInterceptor == null) {
-            throw new NullPointerException("Packet interceptor is null.");
-        }
-        interceptors.put(packetInterceptor, new InterceptorWrapper(packetInterceptor, packetFilter));
-    }
-
+    public void addPacketInterceptor(PacketInterceptor packetInterceptor, PacketFilter packetFilter);
+ 
     /**
      * Removes a packet interceptor.
      *
      * @param packetInterceptor the packet interceptor to remove.
      */
-    public void removePacketInterceptor(PacketInterceptor packetInterceptor) {
-        interceptors.remove(packetInterceptor);
-    }
-
-    /**
-     * Get a map of all packet interceptors for sending packets of this connection.
-     * 
-     * @return a map of all packet interceptors for sending packets.
-     */
-    protected Map<PacketInterceptor, InterceptorWrapper> getPacketInterceptors() {
-        return interceptors;
-    }
-
-    /**
-     * Process interceptors. Interceptors may modify the packet that is about to be sent.
-     * Since the thread that requested to send the packet will invoke all interceptors, it
-     * is important that interceptors perform their work as soon as possible so that the
-     * thread does not remain blocked for a long period.
-     * 
-     * @param packet the packet that is going to be sent to the server
-     */
-    private void firePacketInterceptors(Packet packet) {
-        if (packet != null) {
-            for (InterceptorWrapper interceptorWrapper : interceptors.values()) {
-                interceptorWrapper.notifyListener(packet);
-            }
-        }
-    }
-
-    /**
-     * Initialize the {@link #debugger}. You can specify a customized {@link SmackDebugger}
-     * by setup the system property <code>smack.debuggerClass</code> to the implementation.
-     * 
-     * @throws IllegalStateException if the reader or writer isn't yet initialized.
-     * @throws IllegalArgumentException if the SmackDebugger can't be loaded.
-     */
-    protected void initDebugger() {
-        if (reader == null || writer == null) {
-            throw new NullPointerException("Reader or writer isn't initialized.");
-        }
-        // If debugging is enabled, we open a window and write out all network traffic.
-        if (config.isDebuggerEnabled()) {
-            if (debugger == null) {
-                // Detect the debugger class to use.
-                String className = null;
-                // Use try block since we may not have permission to get a system
-                // property (for example, when an applet).
-                try {
-                    className = System.getProperty("smack.debuggerClass");
-                }
-                catch (Throwable t) {
-                    // Ignore.
-                }
-                Class<?> debuggerClass = null;
-                if (className != null) {
-                    try {
-                        debuggerClass = Class.forName(className);
-                    }
-                    catch (Exception e) {
-                        LOGGER.warning("Unabled to instantiate debugger class " + className);
-                    }
-                }
-                if (debuggerClass == null) {
-                    try {
-                        debuggerClass =
-                                Class.forName("org.jivesoftware.smackx.debugger.EnhancedDebugger");
-                    }
-                    catch (Exception ex) {
-                        try {
-                            debuggerClass =
-                                    Class.forName("org.jivesoftware.smack.debugger.LiteDebugger");
-                        }
-                        catch (Exception ex2) {
-                            LOGGER.warning("Unabled to instantiate either Smack debugger class");
-                        }
-                    }
-                }
-                // Create a new debugger instance. If an exception occurs then disable the debugging
-                // option
-                try {
-                    Constructor<?> constructor = debuggerClass
-                            .getConstructor(XMPPConnection.class, Writer.class, Reader.class);
-                    debugger = (SmackDebugger) constructor.newInstance(this, writer, reader);
-                    reader = debugger.getReader();
-                    writer = debugger.getWriter();
-                }
-                catch (Exception e) {
-                    throw new IllegalArgumentException("Can't initialize the configured debugger!", e);
-                }
-            }
-            else {
-                // Obtain new reader and writer from the existing debugger
-                reader = debugger.newConnectionReader(reader);
-                writer = debugger.newConnectionWriter(writer);
-            }
-        }
-    }
-
-    /**
-     * Set the servers Entity Caps node
-     * 
-     * XMPPConnection holds this information in order to avoid a dependency to
-     * smackx where EntityCapsManager lives from smack.
-     * 
-     * @param node
-     */
-    protected void setServiceCapsNode(String node) {
-        serviceCapsNode = node;
-    }
+    public void removePacketInterceptor(PacketInterceptor packetInterceptor);
 
     /**
      * Retrieve the servers Entity Caps node
@@ -1060,25 +287,14 @@ public abstract class XMPPConnection {
      * 
      * @return the servers entity caps node
      */
-    public String getServiceCapsNode() {
-        return serviceCapsNode;
-    }
+    public String getServiceCapsNode();
 
     /**
      * Returns true if the server supports roster versioning as defined in XEP-0237.
      *
      * @return true if the server supports roster versioning
      */
-    public boolean isRosterVersioningSupported() {
-        return rosterVersioningSupported;
-    }
-
-    /**
-     * Indicates that the server supports roster versioning as defined in XEP-0237.
-     */
-    protected void setRosterVersioningSupported() {
-        rosterVersioningSupported = true;
-    }
+    public boolean isRosterVersioningSupported();
 
     /**
      * Returns the current value of the reply timeout in milliseconds for request for this
@@ -1086,9 +302,7 @@ public abstract class XMPPConnection {
      *
      * @return the packet reply timeout in milliseconds
      */
-    public long getPacketReplyTimeout() {
-        return packetReplyTimeout;
-    }
+    public long getPacketReplyTimeout();
 
     /**
      * Set the packet reply timeout in milliseconds. In most cases, Smack will throw a
@@ -1096,188 +310,7 @@ public abstract class XMPPConnection {
      *
      * @param timeout the packet reply timeout in milliseconds
      */
-    public void setPacketReplyTimeout(long timeout) {
-        packetReplyTimeout = timeout;
-    }
-
-    /**
-     * Processes a packet after it's been fully parsed by looping through the installed
-     * packet collectors and listeners and letting them examine the packet to see if
-     * they are a match with the filter.
-     *
-     * @param packet the packet to process.
-     */
-    protected void processPacket(Packet packet) {
-        if (packet == null) {
-            return;
-        }
-
-        // Loop through all collectors and notify the appropriate ones.
-        for (PacketCollector collector: getPacketCollectors()) {
-            collector.processPacket(packet);
-        }
-
-        // Deliver the incoming packet to listeners.
-        executorService.submit(new ListenerNotification(packet));
-    }
-
-    /**
-     * A runnable to notify all listeners of a packet.
-     */
-    private class ListenerNotification implements Runnable {
-
-        private Packet packet;
-
-        public ListenerNotification(Packet packet) {
-            this.packet = packet;
-        }
-
-        public void run() {
-            for (ListenerWrapper listenerWrapper : recvListeners.values()) {
-                try {
-                    listenerWrapper.notifyListener(packet);
-                } catch(NotConnectedException e) {
-                    LOGGER.log(Level.WARNING, "Got not connected exception, aborting", e);
-                    break;
-                } catch (Exception e) {
-                    LOGGER.log(Level.SEVERE, "Exception in packet listener", e);
-                }
-            }
-        }
-    }
-
-    /**
-     * Sets whether the connection has already logged in the server. This method assures that the
-     * {@link #wasAuthenticated} flag is never reset once it has ever been set.
-     * 
-     * @param authenticated true if the connection has already been authenticated.
-     */
-    protected void setWasAuthenticated(boolean authenticated) {
-        // Never reset the flag if the connection has ever been authenticated
-        if (!wasAuthenticated) {
-            wasAuthenticated = authenticated;
-        }
-    }
-
-    protected void callConnectionConnectedListener() {
-        for (ConnectionListener listener : getConnectionListeners()) {
-            listener.connected(this);
-        }
-    }
-
-    protected void callConnectionAuthenticatedListener() {
-        for (ConnectionListener listener : getConnectionListeners()) {
-            listener.authenticated(this);
-        }
-    }
-
-    void callConnectionClosedListener() {
-        for (ConnectionListener listener : getConnectionListeners()) {
-            try {
-                listener.connectionClosed();
-            }
-            catch (Exception e) {
-                // Catch and print any exception so we can recover
-                // from a faulty listener and finish the shutdown process
-                LOGGER.log(Level.SEVERE, "Error in listener while closing connection", e);
-            }
-        }
-    }
-
-    protected void callConnectionClosedOnErrorListener(Exception e) {
-        LOGGER.log(Level.WARNING, "Connection closed with error", e);
-        for (ConnectionListener listener : getConnectionListeners()) {
-            try {
-                listener.connectionClosedOnError(e);
-            }
-            catch (Exception e2) {
-                // Catch and print any exception so we can recover
-                // from a faulty listener
-                LOGGER.log(Level.SEVERE, "Error in listener while closing connection", e2);
-            }
-        }
-    }
-
-    /**
-     * A wrapper class to associate a packet filter with a listener.
-     */
-    protected static class ListenerWrapper {
-
-        private PacketListener packetListener;
-        private PacketFilter packetFilter;
-
-        /**
-         * Create a class which associates a packet filter with a listener.
-         * 
-         * @param packetListener the packet listener.
-         * @param packetFilter the associated filter or null if it listen for all packets.
-         */
-        public ListenerWrapper(PacketListener packetListener, PacketFilter packetFilter) {
-            this.packetListener = packetListener;
-            this.packetFilter = packetFilter;
-        }
-
-        /**
-         * Notify and process the packet listener if the filter matches the packet.
-         * 
-         * @param packet the packet which was sent or received.
-         * @throws NotConnectedException 
-         */
-        public void notifyListener(Packet packet) throws NotConnectedException {
-            if (packetFilter == null || packetFilter.accept(packet)) {
-                packetListener.processPacket(packet);
-            }
-        }
-    }
-
-    /**
-     * A wrapper class to associate a packet filter with an interceptor.
-     */
-    protected static class InterceptorWrapper {
-
-        private PacketInterceptor packetInterceptor;
-        private PacketFilter packetFilter;
-
-        /**
-         * Create a class which associates a packet filter with an interceptor.
-         * 
-         * @param packetInterceptor the interceptor.
-         * @param packetFilter the associated filter or null if it intercepts all packets.
-         */
-        public InterceptorWrapper(PacketInterceptor packetInterceptor, PacketFilter packetFilter) {
-            this.packetInterceptor = packetInterceptor;
-            this.packetFilter = packetFilter;
-        }
-
-        public boolean equals(Object object) {
-            if (object == null) {
-                return false;
-            }
-            if (object instanceof InterceptorWrapper) {
-                return ((InterceptorWrapper) object).packetInterceptor
-                        .equals(this.packetInterceptor);
-            }
-            else if (object instanceof PacketInterceptor) {
-                return object.equals(this.packetInterceptor);
-            }
-            return false;
-        }
-
-        /**
-         * Notify and process the packet interceptor if the filter matches the packet.
-         * 
-         * @param packet the packet which will be sent.
-         */
-        public void notifyListener(Packet packet) {
-            if (packetFilter == null || packetFilter.accept(packet)) {
-                packetInterceptor.interceptPacket(packet);
-            }
-        }
-    }
-
-    protected ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit) {
-        return executorService.schedule(command, delay, unit);
-    }
+    public void setPacketReplyTimeout(long timeout);
 
     /**
      * Get the connection counter of this XMPPConnection instance. Those can be used as ID to
@@ -1286,9 +319,7 @@ public abstract class XMPPConnection {
      *
      * @return the connection counter of this XMPPConnection
      */
-    public int getConnectionCounter() {
-        return connectionCounterValue;
-    }
+    public int getConnectionCounter();
 
     public static enum FromMode {
         /**
@@ -1313,31 +344,26 @@ public abstract class XMPPConnection {
      * 
      * @param fromMode
      */
-    public void setFromMode(FromMode fromMode) {
-        this.fromMode = fromMode;
-    }
+    public void setFromMode(FromMode fromMode);
 
     /**
      * Get the currently active FromMode.
      *
      * @return the currently active {@link FromMode}
      */
-    public FromMode getFromMode() {
-        return this.fromMode;
-    }
+    public FromMode getFromMode();
 
-    @Override
-    protected void finalize() throws Throwable {
-        try {
-            // It's usually not a good idea to rely on finalize. But this is the easiest way to
-            // avoid the "Smack Listener Processor" leaking. The thread(s) of the executor have a
-            // reference to their ExecutorService which prevents the ExecutorService from being
-            // gc'ed. It is possible that the XMPPConnection instance is gc'ed while the
-            // listenerExecutor ExecutorService call not be gc'ed until it got shut down.
-            executorService.shutdownNow();
-        }
-        finally {
-            super.finalize();
-        }
-    }
+    /**
+     * Schedule a Runnable related to this connection.
+     * <p>
+     * It is possible that the connection is blocked if the Runnable takes a considerably long
+     * amount to complete. So either make sure that it always finishes within a reasonably fast or
+     * use your own ScheduledExecutorService.
+     * 
+     * @param command
+     * @param delay
+     * @param unit
+     * @return the ScheduldedFuture
+     */
+    public ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit);
 }
diff --git a/smack-core/src/main/java/org/jivesoftware/smack/XMPPConnectionRegistry.java b/smack-core/src/main/java/org/jivesoftware/smack/XMPPConnectionRegistry.java
new file mode 100644
index 000000000..c40c23b05
--- /dev/null
+++ b/smack-core/src/main/java/org/jivesoftware/smack/XMPPConnectionRegistry.java
@@ -0,0 +1,64 @@
+/**
+ *
+ * Copyright 2014 Florian Schmaus
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.jivesoftware.smack;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Set;
+import java.util.concurrent.CopyOnWriteArraySet;
+
+public class XMPPConnectionRegistry {
+
+    /**
+     * A set of listeners which will be invoked if a new connection is created.
+     */
+    private final static Set<ConnectionCreationListener> connectionEstablishedListeners =
+            new CopyOnWriteArraySet<ConnectionCreationListener>();
+
+    /**
+     * Adds a new listener that will be notified when new Connections are created. Note
+     * that newly created connections will not be actually connected to the server.
+     * 
+     * @param connectionCreationListener a listener interested on new connections.
+     */
+    public static void addConnectionCreationListener(
+            ConnectionCreationListener connectionCreationListener) {
+        connectionEstablishedListeners.add(connectionCreationListener);
+    }
+    
+    /**
+     * Removes a listener that was interested in connection creation events.
+     * 
+     * @param connectionCreationListener a listener interested on new connections.
+     */
+    public static void removeConnectionCreationListener(
+            ConnectionCreationListener connectionCreationListener) {
+        connectionEstablishedListeners.remove(connectionCreationListener);
+    }
+    
+
+
+    /**
+     * Get the collection of listeners that are interested in connection creation events.
+     * 
+     * @return a collection of listeners interested on new connections.
+     */
+    protected static Collection<ConnectionCreationListener> getConnectionCreationListeners() {
+        return Collections.unmodifiableCollection(connectionEstablishedListeners);
+    }
+
+}
diff --git a/smack-core/src/test/java/org/jivesoftware/smack/DummyConnection.java b/smack-core/src/test/java/org/jivesoftware/smack/DummyConnection.java
index 22db8f32f..ff4a09188 100644
--- a/smack-core/src/test/java/org/jivesoftware/smack/DummyConnection.java
+++ b/smack-core/src/test/java/org/jivesoftware/smack/DummyConnection.java
@@ -49,7 +49,7 @@ import org.jivesoftware.smack.packet.Packet;
  * @see XMPPConnection
  * @author Guenther Niess
  */
-public class DummyConnection extends XMPPConnection {
+public class DummyConnection extends AbstractXMPPConnection {
 
     private boolean authenticated = false;
     private boolean anonymous = false;
@@ -68,9 +68,9 @@ public class DummyConnection extends XMPPConnection {
     public DummyConnection(ConnectionConfiguration configuration) {
         super(configuration);
 
-	for (ConnectionCreationListener listener : getConnectionCreationListeners()) {
-	    listener.connectionCreated(this);
-	}
+        for (ConnectionCreationListener listener : XMPPConnectionRegistry.getConnectionCreationListeners()) {
+            listener.connectionCreated(this);
+        }
     }
 
     @Override
diff --git a/smack-experimental/src/main/java/org/jivesoftware/smackx/carbons/CarbonManager.java b/smack-experimental/src/main/java/org/jivesoftware/smackx/carbons/CarbonManager.java
index ec0476d49..8625db54a 100644
--- a/smack-experimental/src/main/java/org/jivesoftware/smackx/carbons/CarbonManager.java
+++ b/smack-experimental/src/main/java/org/jivesoftware/smackx/carbons/CarbonManager.java
@@ -27,6 +27,7 @@ import org.jivesoftware.smack.XMPPConnection;
 import org.jivesoftware.smack.ConnectionCreationListener;
 import org.jivesoftware.smack.Manager;
 import org.jivesoftware.smack.PacketListener;
+import org.jivesoftware.smack.XMPPConnectionRegistry;
 import org.jivesoftware.smack.XMPPException;
 import org.jivesoftware.smack.XMPPException.XMPPErrorException;
 import org.jivesoftware.smack.filter.IQReplyFilter;
@@ -52,7 +53,7 @@ public class CarbonManager extends Manager {
             Collections.synchronizedMap(new WeakHashMap<XMPPConnection, CarbonManager>());
 
     static {
-        XMPPConnection.addConnectionCreationListener(new ConnectionCreationListener() {
+        XMPPConnectionRegistry.addConnectionCreationListener(new ConnectionCreationListener() {
             public void connectionCreated(XMPPConnection connection) {
                 getInstanceFor(connection);
             }
diff --git a/smack-experimental/src/main/java/org/jivesoftware/smackx/hoxt/HOXTManager.java b/smack-experimental/src/main/java/org/jivesoftware/smackx/hoxt/HOXTManager.java
index 17c23f078..fd24deeee 100644
--- a/smack-experimental/src/main/java/org/jivesoftware/smackx/hoxt/HOXTManager.java
+++ b/smack-experimental/src/main/java/org/jivesoftware/smackx/hoxt/HOXTManager.java
@@ -19,6 +19,7 @@ package org.jivesoftware.smackx.hoxt;
 import org.jivesoftware.smack.ConnectionCreationListener;
 import org.jivesoftware.smack.SmackException.NoResponseException;
 import org.jivesoftware.smack.XMPPConnection;
+import org.jivesoftware.smack.XMPPConnectionRegistry;
 import org.jivesoftware.smack.XMPPException.XMPPErrorException;
 import org.jivesoftware.smack.SmackException.NotConnectedException;
 import org.jivesoftware.smackx.disco.ServiceDiscoveryManager;
@@ -37,7 +38,7 @@ public class HOXTManager {
     public static final String NAMESPACE = "urn:xmpp:http";
 
     static {
-        XMPPConnection.addConnectionCreationListener(new ConnectionCreationListener() {
+        XMPPConnectionRegistry.addConnectionCreationListener(new ConnectionCreationListener() {
             @Override
             public void connectionCreated(XMPPConnection connection) {
                 ServiceDiscoveryManager.getInstanceFor(connection).addFeature(NAMESPACE);
diff --git a/smack-extensions/src/main/java/org/jivesoftware/smackx/amp/AMPManager.java b/smack-extensions/src/main/java/org/jivesoftware/smackx/amp/AMPManager.java
index a1d887400..bfd169295 100644
--- a/smack-extensions/src/main/java/org/jivesoftware/smackx/amp/AMPManager.java
+++ b/smack-extensions/src/main/java/org/jivesoftware/smackx/amp/AMPManager.java
@@ -20,6 +20,7 @@ import org.jivesoftware.smack.SmackException.NoResponseException;
 import org.jivesoftware.smack.SmackException.NotConnectedException;
 import org.jivesoftware.smack.XMPPConnection;
 import org.jivesoftware.smack.ConnectionCreationListener;
+import org.jivesoftware.smack.XMPPConnectionRegistry;
 import org.jivesoftware.smack.XMPPException.XMPPErrorException;
 import org.jivesoftware.smackx.amp.packet.AMPExtension;
 import org.jivesoftware.smackx.disco.ServiceDiscoveryManager;
@@ -39,7 +40,7 @@ public class AMPManager {
     // Enable the AMP support on every established connection
     // The ServiceDiscoveryManager class should have been already initialized
     static {
-        XMPPConnection.addConnectionCreationListener(new ConnectionCreationListener() {
+        XMPPConnectionRegistry.addConnectionCreationListener(new ConnectionCreationListener() {
             public void connectionCreated(XMPPConnection connection) {
                 AMPManager.setServiceEnabled(connection, true);
             }
diff --git a/smack-extensions/src/main/java/org/jivesoftware/smackx/bytestreams/ibb/InBandBytestreamManager.java b/smack-extensions/src/main/java/org/jivesoftware/smackx/bytestreams/ibb/InBandBytestreamManager.java
index 1e95de0f3..cf9cdb2d3 100644
--- a/smack-extensions/src/main/java/org/jivesoftware/smackx/bytestreams/ibb/InBandBytestreamManager.java
+++ b/smack-extensions/src/main/java/org/jivesoftware/smackx/bytestreams/ibb/InBandBytestreamManager.java
@@ -30,6 +30,7 @@ import org.jivesoftware.smack.SmackException.NoResponseException;
 import org.jivesoftware.smack.SmackException.NotConnectedException;
 import org.jivesoftware.smack.XMPPConnection;
 import org.jivesoftware.smack.ConnectionCreationListener;
+import org.jivesoftware.smack.XMPPConnectionRegistry;
 import org.jivesoftware.smack.XMPPException;
 import org.jivesoftware.smack.XMPPException.XMPPErrorException;
 import org.jivesoftware.smack.packet.IQ;
@@ -100,7 +101,7 @@ public class InBandBytestreamManager implements BytestreamManager {
      * connection
      */
     static {
-        XMPPConnection.addConnectionCreationListener(new ConnectionCreationListener() {
+        XMPPConnectionRegistry.addConnectionCreationListener(new ConnectionCreationListener() {
             public void connectionCreated(final XMPPConnection connection) {
                 // create the manager for this connection
                 InBandBytestreamManager.getByteStreamManager(connection);
diff --git a/smack-extensions/src/main/java/org/jivesoftware/smackx/bytestreams/socks5/Socks5BytestreamManager.java b/smack-extensions/src/main/java/org/jivesoftware/smackx/bytestreams/socks5/Socks5BytestreamManager.java
index 7f16950e5..46483f85b 100644
--- a/smack-extensions/src/main/java/org/jivesoftware/smackx/bytestreams/socks5/Socks5BytestreamManager.java
+++ b/smack-extensions/src/main/java/org/jivesoftware/smackx/bytestreams/socks5/Socks5BytestreamManager.java
@@ -35,6 +35,7 @@ import org.jivesoftware.smack.SmackException.FeatureNotSupportedException;
 import org.jivesoftware.smack.SmackException.NotConnectedException;
 import org.jivesoftware.smack.XMPPConnection;
 import org.jivesoftware.smack.ConnectionCreationListener;
+import org.jivesoftware.smack.XMPPConnectionRegistry;
 import org.jivesoftware.smack.XMPPException;
 import org.jivesoftware.smack.XMPPException.XMPPErrorException;
 import org.jivesoftware.smack.packet.IQ;
@@ -93,7 +94,7 @@ public final class Socks5BytestreamManager implements BytestreamManager {
      * connection
      */
     static {
-        XMPPConnection.addConnectionCreationListener(new ConnectionCreationListener() {
+        XMPPConnectionRegistry.addConnectionCreationListener(new ConnectionCreationListener() {
 
             public void connectionCreated(final XMPPConnection connection) {
                 // create the manager for this connection
diff --git a/smack-extensions/src/main/java/org/jivesoftware/smackx/caps/EntityCapsManager.java b/smack-extensions/src/main/java/org/jivesoftware/smackx/caps/EntityCapsManager.java
index 2bcb4ccbe..c3cb99ceb 100644
--- a/smack-extensions/src/main/java/org/jivesoftware/smackx/caps/EntityCapsManager.java
+++ b/smack-extensions/src/main/java/org/jivesoftware/smackx/caps/EntityCapsManager.java
@@ -24,6 +24,7 @@ import org.jivesoftware.smack.ConnectionCreationListener;
 import org.jivesoftware.smack.Manager;
 import org.jivesoftware.smack.PacketInterceptor;
 import org.jivesoftware.smack.PacketListener;
+import org.jivesoftware.smack.XMPPConnectionRegistry;
 import org.jivesoftware.smack.XMPPException.XMPPErrorException;
 import org.jivesoftware.smack.packet.IQ;
 import org.jivesoftware.smack.packet.Packet;
@@ -107,7 +108,7 @@ public class EntityCapsManager extends Manager {
     private static final Cache<String, NodeVerHash> JID_TO_NODEVER_CACHE = new Cache<String, NodeVerHash>(10000, -1);
 
     static {
-        XMPPConnection.addConnectionCreationListener(new ConnectionCreationListener() {
+        XMPPConnectionRegistry.addConnectionCreationListener(new ConnectionCreationListener() {
             public void connectionCreated(XMPPConnection connection) {
                 getInstanceFor(connection);
             }
diff --git a/smack-extensions/src/main/java/org/jivesoftware/smackx/commands/AdHocCommandManager.java b/smack-extensions/src/main/java/org/jivesoftware/smackx/commands/AdHocCommandManager.java
index c5e900dc4..064266797 100755
--- a/smack-extensions/src/main/java/org/jivesoftware/smackx/commands/AdHocCommandManager.java
+++ b/smack-extensions/src/main/java/org/jivesoftware/smackx/commands/AdHocCommandManager.java
@@ -76,7 +76,7 @@ public class AdHocCommandManager extends Manager {
      * related to that connection.
      */
     static {
-        XMPPConnection.addConnectionCreationListener(new ConnectionCreationListener() {
+        XMPPConnectionRegistry.addConnectionCreationListener(new ConnectionCreationListener() {
             public void connectionCreated(XMPPConnection connection) {
                 getAddHocCommandsManager(connection);
             }
diff --git a/smack-extensions/src/main/java/org/jivesoftware/smackx/disco/ServiceDiscoveryManager.java b/smack-extensions/src/main/java/org/jivesoftware/smackx/disco/ServiceDiscoveryManager.java
index 8e31230f8..3d0472a73 100644
--- a/smack-extensions/src/main/java/org/jivesoftware/smackx/disco/ServiceDiscoveryManager.java
+++ b/smack-extensions/src/main/java/org/jivesoftware/smackx/disco/ServiceDiscoveryManager.java
@@ -22,6 +22,7 @@ import org.jivesoftware.smack.XMPPConnection;
 import org.jivesoftware.smack.ConnectionCreationListener;
 import org.jivesoftware.smack.Manager;
 import org.jivesoftware.smack.PacketListener;
+import org.jivesoftware.smack.XMPPConnectionRegistry;
 import org.jivesoftware.smack.XMPPException.XMPPErrorException;
 import org.jivesoftware.smack.filter.PacketFilter;
 import org.jivesoftware.smack.filter.PacketTypeFilter;
@@ -79,7 +80,7 @@ public class ServiceDiscoveryManager extends Manager {
 
     // Create a new ServiceDiscoveryManager on every established connection
     static {
-        XMPPConnection.addConnectionCreationListener(new ConnectionCreationListener() {
+        XMPPConnectionRegistry.addConnectionCreationListener(new ConnectionCreationListener() {
             public void connectionCreated(XMPPConnection connection) {
                 getInstanceFor(connection);
             }
diff --git a/smack-extensions/src/main/java/org/jivesoftware/smackx/iqlast/LastActivityManager.java b/smack-extensions/src/main/java/org/jivesoftware/smackx/iqlast/LastActivityManager.java
index 6d4b38b03..f12bf0651 100644
--- a/smack-extensions/src/main/java/org/jivesoftware/smackx/iqlast/LastActivityManager.java
+++ b/smack-extensions/src/main/java/org/jivesoftware/smackx/iqlast/LastActivityManager.java
@@ -26,6 +26,7 @@ import org.jivesoftware.smack.XMPPConnection;
 import org.jivesoftware.smack.ConnectionCreationListener;
 import org.jivesoftware.smack.PacketListener;
 import org.jivesoftware.smack.Manager;
+import org.jivesoftware.smack.XMPPConnectionRegistry;
 import org.jivesoftware.smack.XMPPException.XMPPErrorException;
 import org.jivesoftware.smack.filter.AndFilter;
 import org.jivesoftware.smack.filter.IQTypeFilter;
@@ -104,7 +105,7 @@ public class LastActivityManager extends Manager {
 
     // Enable the LastActivity support on every established connection
     static {
-        XMPPConnection.addConnectionCreationListener(new ConnectionCreationListener() {
+        XMPPConnectionRegistry.addConnectionCreationListener(new ConnectionCreationListener() {
             public void connectionCreated(XMPPConnection connection) {
                 LastActivityManager.getInstanceFor(connection);
             }
diff --git a/smack-extensions/src/main/java/org/jivesoftware/smackx/muc/MultiUserChat.java b/smack-extensions/src/main/java/org/jivesoftware/smackx/muc/MultiUserChat.java
index 00143c3bc..e8a6198b4 100644
--- a/smack-extensions/src/main/java/org/jivesoftware/smackx/muc/MultiUserChat.java
+++ b/smack-extensions/src/main/java/org/jivesoftware/smackx/muc/MultiUserChat.java
@@ -44,6 +44,7 @@ import org.jivesoftware.smack.SmackException;
 import org.jivesoftware.smack.SmackException.NoResponseException;
 import org.jivesoftware.smack.SmackException.NotConnectedException;
 import org.jivesoftware.smack.XMPPConnection;
+import org.jivesoftware.smack.XMPPConnectionRegistry;
 import org.jivesoftware.smack.XMPPException;
 import org.jivesoftware.smack.XMPPException.XMPPErrorException;
 import org.jivesoftware.smack.filter.AndFilter;
@@ -112,7 +113,7 @@ public class MultiUserChat {
     private List<PacketListener> connectionListeners = new ArrayList<PacketListener>();
 
     static {
-        XMPPConnection.addConnectionCreationListener(new ConnectionCreationListener() {
+        XMPPConnectionRegistry.addConnectionCreationListener(new ConnectionCreationListener() {
             public void connectionCreated(final XMPPConnection connection) {
                 // Set on every established connection that this client supports the Multi-User
                 // Chat protocol. This information will be used when another client tries to
diff --git a/smack-extensions/src/main/java/org/jivesoftware/smackx/ping/PingManager.java b/smack-extensions/src/main/java/org/jivesoftware/smackx/ping/PingManager.java
index af201ff32..6d0af7c2f 100644
--- a/smack-extensions/src/main/java/org/jivesoftware/smackx/ping/PingManager.java
+++ b/smack-extensions/src/main/java/org/jivesoftware/smackx/ping/PingManager.java
@@ -34,6 +34,7 @@ import org.jivesoftware.smack.XMPPConnection;
 import org.jivesoftware.smack.ConnectionCreationListener;
 import org.jivesoftware.smack.Manager;
 import org.jivesoftware.smack.PacketListener;
+import org.jivesoftware.smack.XMPPConnectionRegistry;
 import org.jivesoftware.smack.XMPPException;
 import org.jivesoftware.smack.XMPPException.XMPPErrorException;
 import org.jivesoftware.smack.filter.AndFilter;
@@ -69,7 +70,7 @@ public class PingManager extends Manager {
                     Pong.class), new IQTypeFilter(Type.RESULT));
 
     static {
-        XMPPConnection.addConnectionCreationListener(new ConnectionCreationListener() {
+        XMPPConnectionRegistry.addConnectionCreationListener(new ConnectionCreationListener() {
             public void connectionCreated(XMPPConnection connection) {
                 getInstanceFor(connection);
             }
@@ -308,7 +309,7 @@ public class PingManager extends Manager {
             int nextPingIn = pingInterval - delta;
             LOGGER.fine("Scheduling ServerPingTask in " + nextPingIn + " seconds (pingInterval="
                             + pingInterval + ", delta=" + delta + ")");
-            nextAutomaticPing = schedule(pingServerRunnable, pingInterval, TimeUnit.SECONDS);
+            nextAutomaticPing = connection().schedule(pingServerRunnable, pingInterval, TimeUnit.SECONDS);
         }
     }
 
diff --git a/smack-extensions/src/main/java/org/jivesoftware/smackx/privacy/PrivacyListManager.java b/smack-extensions/src/main/java/org/jivesoftware/smackx/privacy/PrivacyListManager.java
index e222a7e97..31fe7def2 100644
--- a/smack-extensions/src/main/java/org/jivesoftware/smackx/privacy/PrivacyListManager.java
+++ b/smack-extensions/src/main/java/org/jivesoftware/smackx/privacy/PrivacyListManager.java
@@ -29,6 +29,7 @@ import org.jivesoftware.smack.XMPPConnection;
 import org.jivesoftware.smack.ConnectionCreationListener;
 import org.jivesoftware.smack.Manager;
 import org.jivesoftware.smack.PacketListener;
+import org.jivesoftware.smack.XMPPConnectionRegistry;
 import org.jivesoftware.smack.XMPPException.XMPPErrorException;
 import org.jivesoftware.smack.filter.AndFilter;
 import org.jivesoftware.smack.filter.IQTypeFilter;
@@ -68,7 +69,7 @@ public class PrivacyListManager extends Manager {
 
     static {
         // Create a new PrivacyListManager on every established connection.
-        XMPPConnection.addConnectionCreationListener(new ConnectionCreationListener() {
+        XMPPConnectionRegistry.addConnectionCreationListener(new ConnectionCreationListener() {
             public void connectionCreated(XMPPConnection connection) {
                 getInstanceFor(connection);
             }
diff --git a/smack-extensions/src/main/java/org/jivesoftware/smackx/receipts/DeliveryReceiptManager.java b/smack-extensions/src/main/java/org/jivesoftware/smackx/receipts/DeliveryReceiptManager.java
index ba3633ddd..f3e035adb 100644
--- a/smack-extensions/src/main/java/org/jivesoftware/smackx/receipts/DeliveryReceiptManager.java
+++ b/smack-extensions/src/main/java/org/jivesoftware/smackx/receipts/DeliveryReceiptManager.java
@@ -28,6 +28,7 @@ import org.jivesoftware.smack.XMPPConnection;
 import org.jivesoftware.smack.ConnectionCreationListener;
 import org.jivesoftware.smack.Manager;
 import org.jivesoftware.smack.PacketListener;
+import org.jivesoftware.smack.XMPPConnectionRegistry;
 import org.jivesoftware.smack.XMPPException;
 import org.jivesoftware.smack.filter.PacketExtensionFilter;
 import org.jivesoftware.smack.packet.Message;
@@ -47,7 +48,7 @@ public class DeliveryReceiptManager extends Manager implements PacketListener {
             Collections.synchronizedMap(new WeakHashMap<XMPPConnection, DeliveryReceiptManager>());
 
     static {
-        XMPPConnection.addConnectionCreationListener(new ConnectionCreationListener() {
+        XMPPConnectionRegistry.addConnectionCreationListener(new ConnectionCreationListener() {
             public void connectionCreated(XMPPConnection connection) {
                 getInstanceFor(connection);
             }
diff --git a/smack-extensions/src/main/java/org/jivesoftware/smackx/time/EntityTimeManager.java b/smack-extensions/src/main/java/org/jivesoftware/smackx/time/EntityTimeManager.java
index d4c5e19a5..ca8dc81a1 100644
--- a/smack-extensions/src/main/java/org/jivesoftware/smackx/time/EntityTimeManager.java
+++ b/smack-extensions/src/main/java/org/jivesoftware/smackx/time/EntityTimeManager.java
@@ -25,6 +25,7 @@ import org.jivesoftware.smack.XMPPConnection;
 import org.jivesoftware.smack.ConnectionCreationListener;
 import org.jivesoftware.smack.Manager;
 import org.jivesoftware.smack.PacketListener;
+import org.jivesoftware.smack.XMPPConnectionRegistry;
 import org.jivesoftware.smack.XMPPException.XMPPErrorException;
 import org.jivesoftware.smack.filter.AndFilter;
 import org.jivesoftware.smack.filter.IQTypeFilter;
@@ -45,7 +46,7 @@ public class EntityTimeManager extends Manager {
     private static boolean autoEnable = true;
 
     static {
-        XMPPConnection.addConnectionCreationListener(new ConnectionCreationListener() {
+        XMPPConnectionRegistry.addConnectionCreationListener(new ConnectionCreationListener() {
             public void connectionCreated(XMPPConnection connection) {
                 getInstanceFor(connection);
             }
diff --git a/smack-extensions/src/main/java/org/jivesoftware/smackx/vcardtemp/VCardManager.java b/smack-extensions/src/main/java/org/jivesoftware/smackx/vcardtemp/VCardManager.java
index b85992507..82dded328 100644
--- a/smack-extensions/src/main/java/org/jivesoftware/smackx/vcardtemp/VCardManager.java
+++ b/smack-extensions/src/main/java/org/jivesoftware/smackx/vcardtemp/VCardManager.java
@@ -20,6 +20,7 @@ import org.jivesoftware.smack.ConnectionCreationListener;
 import org.jivesoftware.smack.SmackException.NoResponseException;
 import org.jivesoftware.smack.SmackException.NotConnectedException;
 import org.jivesoftware.smack.XMPPConnection;
+import org.jivesoftware.smack.XMPPConnectionRegistry;
 import org.jivesoftware.smack.XMPPException.XMPPErrorException;
 import org.jivesoftware.smackx.disco.ServiceDiscoveryManager;
 
@@ -28,7 +29,7 @@ public class VCardManager {
     public static final String ELEMENT = "vCard";
 
     static {
-        XMPPConnection.addConnectionCreationListener(new ConnectionCreationListener() {
+        XMPPConnectionRegistry.addConnectionCreationListener(new ConnectionCreationListener() {
             @Override
             public void connectionCreated(XMPPConnection connection) {
                 ServiceDiscoveryManager.getInstanceFor(connection).addFeature(NAMESPACE);
diff --git a/smack-extensions/src/main/java/org/jivesoftware/smackx/xhtmlim/XHTMLManager.java b/smack-extensions/src/main/java/org/jivesoftware/smackx/xhtmlim/XHTMLManager.java
index 51340145b..69db186c3 100644
--- a/smack-extensions/src/main/java/org/jivesoftware/smackx/xhtmlim/XHTMLManager.java
+++ b/smack-extensions/src/main/java/org/jivesoftware/smackx/xhtmlim/XHTMLManager.java
@@ -21,6 +21,7 @@ import org.jivesoftware.smack.ConnectionCreationListener;
 import org.jivesoftware.smack.SmackException.NoResponseException;
 import org.jivesoftware.smack.SmackException.NotConnectedException;
 import org.jivesoftware.smack.XMPPConnection;
+import org.jivesoftware.smack.XMPPConnectionRegistry;
 import org.jivesoftware.smack.XMPPException.XMPPErrorException;
 import org.jivesoftware.smack.packet.Message;
 import org.jivesoftware.smackx.disco.ServiceDiscoveryManager;
@@ -41,7 +42,7 @@ public class XHTMLManager {
     // Enable the XHTML support on every established connection
     // The ServiceDiscoveryManager class should have been already initialized
     static {
-        XMPPConnection.addConnectionCreationListener(new ConnectionCreationListener() {
+        XMPPConnectionRegistry.addConnectionCreationListener(new ConnectionCreationListener() {
             public void connectionCreated(XMPPConnection connection) {
                 XHTMLManager.setServiceEnabled(connection, true);
             }
diff --git a/smack-jingle/src/main/java/org/jivesoftware/smackx/jingle/JingleManager.java b/smack-jingle/src/main/java/org/jivesoftware/smackx/jingle/JingleManager.java
index 9b5310ca3..7e9068157 100644
--- a/smack-jingle/src/main/java/org/jivesoftware/smackx/jingle/JingleManager.java
+++ b/smack-jingle/src/main/java/org/jivesoftware/smackx/jingle/JingleManager.java
@@ -26,6 +26,7 @@ import org.jivesoftware.smack.PacketListener;
 import org.jivesoftware.smack.RosterListener;
 import org.jivesoftware.smack.SmackException;
 import org.jivesoftware.smack.XMPPConnection;
+import org.jivesoftware.smack.XMPPConnectionRegistry;
 import org.jivesoftware.smack.XMPPException;
 import org.jivesoftware.smack.filter.PacketFilter;
 import org.jivesoftware.smack.packet.IQ;
@@ -258,7 +259,7 @@ public class JingleManager implements JingleSessionListener {
         // Enable the Jingle support on every established connection
         // The ServiceDiscoveryManager class should have been already
         // initialized
-        XMPPConnection.addConnectionCreationListener(new ConnectionCreationListener() {
+        XMPPConnectionRegistry.addConnectionCreationListener(new ConnectionCreationListener() {
             public void connectionCreated(XMPPConnection connection) {
                 JingleManager.setServiceEnabled(connection, true);
             }
diff --git a/smack-tcp/src/main/java/org/jivesoftware/smack/tcp/XMPPTCPConnection.java b/smack-tcp/src/main/java/org/jivesoftware/smack/tcp/XMPPTCPConnection.java
index 10a11054f..a5ec7eac7 100644
--- a/smack-tcp/src/main/java/org/jivesoftware/smack/tcp/XMPPTCPConnection.java
+++ b/smack-tcp/src/main/java/org/jivesoftware/smack/tcp/XMPPTCPConnection.java
@@ -16,6 +16,7 @@
  */
 package org.jivesoftware.smack.tcp;
 
+import org.jivesoftware.smack.AbstractXMPPConnection;
 import org.jivesoftware.smack.ConnectionConfiguration;
 import org.jivesoftware.smack.ConnectionCreationListener;
 import org.jivesoftware.smack.ConnectionListener;
@@ -76,7 +77,7 @@ import java.util.logging.Logger;
  * @see XMPPConnection
  * @author Matt Tucker
  */
-public class XMPPTCPConnection extends XMPPConnection {
+public class XMPPTCPConnection extends AbstractXMPPConnection {
 
     private static final Logger LOGGER = Logger.getLogger(XMPPTCPConnection.class.getName());
 
@@ -890,11 +891,6 @@ public class XMPPTCPConnection extends XMPPConnection {
         return super.getSASLAuthentication();
     }
 
-    @Override
-    protected ConnectionConfiguration getConfiguration() {
-        return super.getConfiguration();
-    }
-
     /**
      * Sends a notification indicating that the connection was reconnected successfully.
      */
diff --git a/smack-tcp/src/test/java/org/jivesoftware/smack/tcp/RosterOfflineTest.java b/smack-tcp/src/test/java/org/jivesoftware/smack/tcp/RosterOfflineTest.java
index ca3b2f1c6..ad27c17ed 100644
--- a/smack-tcp/src/test/java/org/jivesoftware/smack/tcp/RosterOfflineTest.java
+++ b/smack-tcp/src/test/java/org/jivesoftware/smack/tcp/RosterOfflineTest.java
@@ -20,7 +20,6 @@ import static org.junit.Assert.*;
 
 import org.jivesoftware.smack.Roster;
 import org.jivesoftware.smack.SmackException;
-import org.jivesoftware.smack.XMPPConnection;
 import org.jivesoftware.smack.XMPPException;
 import org.junit.Before;
 import org.junit.Test;
@@ -32,7 +31,7 @@ import org.junit.Test;
  */
 public class RosterOfflineTest {
 
-    XMPPConnection connection;
+    XMPPTCPConnection connection;
 
     Roster roster;