XMPPConnection (smack-core 4.0.0 API)

java.lang.Object
- org.jivesoftware.smack.XMPPConnection

```
public abstract class XMPPConnection
extends java.lang.Object
```
The abstract XMPPConnection class provides an interface for connections to a XMPP server and implements shared methods which are used by the different types of connections (e.g. XMPPTCPConnection or XMPPBOSHConnection). To create a connection to a XMPP server a simple usage of this API might look like the following:
```
 // Create a connection to the igniterealtime.org XMPP server.
 XMPPConnection con = new XMPPTCPConnection("igniterealtime.org");
 // Connect to the server
 con.connect();
 // Most servers require you to login before performing other tasks.
 con.login("jsmith", "mypass");
 // Start a new conversation with John Doe and send him a message.
 Chat chat = ChatManager.getInstanceFor(con).createChat("[email protected]", new MessageListener() {
     public void processMessage(Chat chat, Message message) {
         // Print out any messages we get back to standard out.
         System.out.println("Received message: " + message);
     }
 });
 chat.sendMessage("Howdy!");
 // Disconnect from the server
 con.disconnect();
 
```
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 connections.
If a connected XMPPConnection gets disconnected abruptly and automatic reconnection is enabled ( ConnectionConfiguration.isReconnectionAllowed(), the default), then it will try to reconnect again. To stop the reconnection process, use disconnect(). Once stopped you can use connect() to manually connect to the server.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`XMPPConnection.FromMode`
`protected static class`	`XMPPConnection.InterceptorWrapper` A wrapper class to associate a packet filter with an interceptor.
`protected static class`	`XMPPConnection.ListenerWrapper` A wrapper class to associate a packet filter with a listener.

Field Summary

Fields
Modifier and Type	Field and Description
`protected boolean`	`authenticated` Flag that indicates if the user is currently authenticated with the server.
`protected java.util.Collection<PacketCollector>`	`collectors` A collection of PacketCollectors which collects packets for a specified filter and perform blocking and polling operations on the result queue.
`protected XMPPInputOutputStream`	`compressionHandler`
`protected ConnectionConfiguration`	`config` Holds the initial configuration used while creating the connection.
`protected int`	`connectionCounterValue` A number to uniquely identify connections that are created.
`protected java.util.Collection<ConnectionListener>`	`connectionListeners` A collection of ConnectionListeners which listen for connection closing and reconnection events.
`protected SmackDebugger`	`debugger` The SmackDebugger allows to log and debug XML traffic.
`protected java.util.Map<PacketInterceptor,XMPPConnection.InterceptorWrapper>`	`interceptors` List of PacketInterceptors that will be notified when a new packet is about to be sent to the server.
`protected java.io.Reader`	`reader` The Reader which is used for the debugger.
`protected java.util.Map<PacketListener,XMPPConnection.ListenerWrapper>`	`recvListeners` List of PacketListeners that will be notified when a new packet was received.
`protected SASLAuthentication`	`saslAuthentication` The SASLAuthentication manager that is responsible for authenticating with the server.
`protected java.util.Map<PacketListener,XMPPConnection.ListenerWrapper>`	`sendListeners` List of PacketListeners that will be notified when a new packet was sent.
`protected boolean`	`wasAuthenticated` Flag that indicates if the user was authenticated with the server when the connection to the server was closed (abruptly or not).
`protected java.io.Writer`	`writer` The Writer which is used for the debugger.

Constructor Summary

Constructors
Modifier Constructor and Description

protected XMPPConnection(ConnectionConfiguration configuration)
Create a new XMPPConnection to a XMPP server.

Constructors
Modifier	Constructor and Description
`protected`	`XMPPConnection(ConnectionConfiguration configuration)` Create a new XMPPConnection to a XMPP server.

Method Summary

Methods
Modifier and Type	Method and Description
`static void`	`addConnectionCreationListener(ConnectionCreationListener connectionCreationListener)` Adds a new listener that will be notified when new Connections are created.
`void`	`addConnectionListener(ConnectionListener connectionListener)` Adds a connection listener to this connection that will be notified when the connection closes or fails.
`void`	`addPacketInterceptor(PacketInterceptor packetInterceptor, PacketFilter packetFilter)` Registers a packet interceptor with this connection.
`void`	`addPacketListener(PacketListener packetListener, PacketFilter packetFilter)` Registers a packet listener with this connection.
`void`	`addPacketSendingListener(PacketListener packetListener, PacketFilter packetFilter)` Registers a packet listener with this connection.
`protected java.lang.String`	`bindResourceAndEstablishSession(java.lang.String resource)`
`protected void`	`callConnectionAuthenticatedListener()`
`protected void`	`callConnectionClosedOnErrorListener(java.lang.Exception e)`
`protected void`	`callConnectionConnectedListener()`
`void`	`connect()` Establishes a connection to the XMPP server and performs an automatic login only if the previous connection state was logged (authenticated).
`protected abstract void`	`connectInternal()` Abstract method that concrete subclasses of XMPPConnection need to implement to perform their way of XMPP connection establishment.
`PacketCollector`	`createPacketCollector(PacketFilter packetFilter)` Creates a new packet collector for this connection.
`PacketCollector`	`createPacketCollectorAndSend(IQ packet)` Creates a new packet collector collecting packets that are replies to `packet`.
`void`	`disconnect()` Closes the connection by setting presence to unavailable then closing the connection to the XMPP server.
`void`	`disconnect(Presence unavailablePresence)` Closes the connection.
`protected void`	`finalize()`
`protected ConnectionConfiguration`	`getConfiguration()` Returns the configuration used to connect to the server.
`int`	`getConnectionCounter()` Get the connection counter of this XMPPConnection instance.
`protected static java.util.Collection<ConnectionCreationListener>`	`getConnectionCreationListeners()` Get the collection of listeners that are interested in connection creation events.
`abstract java.lang.String`	`getConnectionID()` Returns the connection ID for this connection, which is the value set by the server when opening a XMPP stream.
`protected java.util.Collection<ConnectionListener>`	`getConnectionListeners()` Get the collection of listeners that are interested in connection events.
`XMPPConnection.FromMode`	`getFromMode()` Get the currently active FromMode.
`java.lang.String`	`getHost()` Returns the host name of the server where the XMPP server is running.
`protected java.util.Collection<PacketCollector>`	`getPacketCollectors()` Get the collection of all packet collectors for this connection.
`protected java.util.Map<PacketInterceptor,XMPPConnection.InterceptorWrapper>`	`getPacketInterceptors()` Get a map of all packet interceptors for sending packets of this connection.
`protected java.util.Map<PacketListener,XMPPConnection.ListenerWrapper>`	`getPacketListeners()` Get a map of all packet listeners for received packets of this connection.
`long`	`getPacketReplyTimeout()` Returns the current value of the reply timeout in milliseconds for request for this XMPPConnection instance.
`protected java.util.Map<PacketListener,XMPPConnection.ListenerWrapper>`	`getPacketSendingListeners()` Get a map of all packet listeners for sending packets of this connection.
`int`	`getPort()` Returns the port number of the XMPP server for this connection.
`protected java.io.Reader`	`getReader()`
`Roster`	`getRoster()` Returns the roster for the user.
`protected SASLAuthentication`	`getSASLAuthentication()` Returns the SASLAuthentication manager that is responsible for authenticating with the server.
`java.lang.String`	`getServiceCapsNode()` Retrieve the servers Entity Caps node XMPPConnection holds this information in order to avoid a dependency to smackx where EntityCapsManager lives from smack.
`java.lang.String`	`getServiceName()` Returns the name of the service provided by the XMPP server for this connection.
`abstract java.lang.String`	`getUser()` Returns the full XMPP address of the user that is logged in to the connection or `null` if not logged in yet.
`protected java.io.Writer`	`getWriter()`
`protected void`	`initDebugger()` Initialize the `debugger`.
`abstract boolean`	`isAnonymous()` Returns true if currently authenticated anonymously.
`abstract boolean`	`isAuthenticated()` Returns true if currently authenticated by successfully calling the login method.
`abstract boolean`	`isConnected()` Returns true if currently connected to the XMPP server.
`boolean`	`isRosterVersioningSupported()` Returns true if the server supports roster versioning as defined in XEP-0237.
`abstract boolean`	`isSecureConnection()` Returns true if the connection to the server has successfully negotiated encryption.
`abstract boolean`	`isUsingCompression()` Returns true if network traffic is being compressed.
`void`	`login(java.lang.String username, java.lang.String password)` Logs in to the server using the strongest authentication mode supported by the server, then sets presence to available.
`abstract void`	`login(java.lang.String username, java.lang.String password, java.lang.String resource)` Logs in to the server using the strongest authentication mode supported by the server, then sets presence to available.
`abstract void`	`loginAnonymously()` Logs in to the server anonymously.
`protected void`	`maybeResolveDns()`
`protected void`	`processPacket(Packet packet)` 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.
`static void`	`removeConnectionCreationListener(ConnectionCreationListener connectionCreationListener)` Removes a listener that was interested in connection creation events.
`void`	`removeConnectionListener(ConnectionListener connectionListener)` Removes a connection listener from this connection.
`protected void`	`removePacketCollector(PacketCollector collector)` Remove a packet collector of this connection.
`void`	`removePacketInterceptor(PacketInterceptor packetInterceptor)` Removes a packet interceptor.
`void`	`removePacketListener(PacketListener packetListener)` Removes a packet listener for received packets from this connection.
`void`	`removePacketSendingListener(PacketListener packetListener)` Removes a packet listener for sending packets from this connection.
`protected java.util.concurrent.ScheduledFuture<?>`	`schedule(java.lang.Runnable command, long delay, java.util.concurrent.TimeUnit unit)`
`void`	`sendPacket(Packet packet)` Sends the specified packet to the server.
`protected abstract void`	`sendPacketInternal(Packet packet)`
`protected void`	`serverRequiresBinding()` Notification message saying that the server requires the client to bind a resource to the stream.
`protected void`	`serverSupportsAccountCreation()`
`protected void`	`serverSupportsSession()` Notification message saying that the server supports sessions.
`protected void`	`setConnectionException(java.io.IOException exception)`
`void`	`setFromMode(XMPPConnection.FromMode fromMode)` Set the FromMode for this connection instance.
`protected void`	`setLoginInfo(java.lang.String username, java.lang.String password, java.lang.String resource)`
`void`	`setPacketReplyTimeout(long timeout)` Set the packet reply timeout in milliseconds.
`protected void`	`setRosterVersioningSupported()` Indicates that the server supports roster versioning as defined in XEP-0237.
`protected void`	`setServiceCapsNode(java.lang.String node)` Set the servers Entity Caps node XMPPConnection holds this information in order to avoid a dependency to smackx where EntityCapsManager lives from smack.
`protected void`	`setServiceName(java.lang.String serviceName)`
`protected void`	`setWasAuthenticated(boolean authenticated)` Sets whether the connection has already logged in the server.
`protected abstract void`	`shutdown()` Shuts the current connection down.
`protected void`	`throwConnectionExceptionOrNoResponse()`

Methods inherited from class java.lang.Object
clone, equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - connectionListeners
```
protected final java.util.Collection<ConnectionListener> connectionListeners
```
    A collection of ConnectionListeners which listen for connection closing and reconnection events.
  - collectors
```
protected final java.util.Collection<PacketCollector> collectors
```
    A collection of PacketCollectors which collects packets for a specified filter and perform blocking and polling operations on the result queue.
  - recvListeners
```
protected final java.util.Map<PacketListener,XMPPConnection.ListenerWrapper> recvListeners
```
    List of PacketListeners that will be notified when a new packet was received.
  - sendListeners
```
protected final java.util.Map<PacketListener,XMPPConnection.ListenerWrapper> sendListeners
```
    List of PacketListeners that will be notified when a new packet was sent.
  - interceptors
```
protected final java.util.Map<PacketInterceptor,XMPPConnection.InterceptorWrapper> interceptors
```
    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.
  - debugger
```
protected SmackDebugger debugger
```
    The SmackDebugger allows to log and debug XML traffic.
  - reader
```
protected java.io.Reader reader
```
    The Reader which is used for the debugger.
  - writer
```
protected java.io.Writer writer
```
    The Writer which is used for the debugger.
  - saslAuthentication
```
protected SASLAuthentication saslAuthentication
```
    The SASLAuthentication manager that is responsible for authenticating with the server.
  - connectionCounterValue
```
protected final int connectionCounterValue
```
    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.
  - config
```
protected final ConnectionConfiguration config
```
    Holds the initial configuration used while creating the connection.
  - compressionHandler
```
protected XMPPInputOutputStream compressionHandler
```
  - authenticated
```
protected boolean authenticated
```
    Flag that indicates if the user is currently authenticated with the server.
  - wasAuthenticated
```
protected boolean wasAuthenticated
```
    Flag that indicates if the user was authenticated with the server when the connection to the server was closed (abruptly or not).
- Constructor Detail
  - XMPPConnection
```
protected XMPPConnection(ConnectionConfiguration configuration)
```
    Create a new XMPPConnection to a XMPP server.
    
    Parameters:
    configuration - The configuration which is used to establish the connection.
- Method Detail
  - getConfiguration
```
protected ConnectionConfiguration getConfiguration()
```
    Returns the configuration used to connect to the server.
    
    Returns:
    the configuration used to connect to the server.
  - getServiceName
```
public java.lang.String getServiceName()
```
    Returns the name of the service provided by the XMPP server for this connection. This is also called XMPP domain of the connected server. After authenticating with the server the returned value may be different.
    
    Returns:
    the name of the service provided by the XMPP server.
  - getHost
```
public java.lang.String getHost()
```
    Returns the host name of the server where the XMPP server is running. This would be the IP address of the server or a name that may be resolved by a DNS server.
    
    Returns:
    the host name of the server where the XMPP server is running or null if not yet connected.
  - getPort
```
public int getPort()
```
    Returns the port number of the XMPP server for this connection. The default port for normal connections is 5222.
    
    Returns:
    the port number of the XMPP server or 0 if not yet connected.
  - getUser
```
public abstract java.lang.String getUser()
```
    Returns the full XMPP address of the user that is logged in to the connection or null if not logged in yet. An XMPP address is in the form username@server/resource.
    
    Returns:
    the full XMPP address of the user logged in.
  - getConnectionID
```
public abstract java.lang.String getConnectionID()
```
    Returns the connection ID for this connection, which is the value set by the server when opening a XMPP stream. If the server does not set a connection ID, this value will be null. This value will be null if not connected to the server.
    
    Returns:
    the ID of this connection returned from the XMPP server or null if not connected to the server.
  - isConnected
```
public abstract boolean isConnected()
```
    Returns true if currently connected to the XMPP server.
    
    Returns:
    true if connected.
  - isAuthenticated
```
public abstract boolean isAuthenticated()
```
    Returns true if currently authenticated by successfully calling the login method.
    
    Returns:
    true if authenticated.
  - isAnonymous
```
public abstract boolean isAnonymous()
```
    Returns true if currently authenticated anonymously.
    
    Returns:
    true if authenticated anonymously.
  - isSecureConnection
```
public abstract boolean isSecureConnection()
```
    Returns true if the connection to the server has successfully negotiated encryption.
    
    Returns:
    true if a secure connection to the server.
  - sendPacketInternal
```
protected abstract void sendPacketInternal(Packet packet)
                                    throws SmackException.NotConnectedException
```
    Throws:
    
    SmackException.NotConnectedException
  - isUsingCompression
```
public abstract boolean isUsingCompression()
```
    Returns true if network traffic is being compressed. When using stream compression network traffic can be reduced up to 90%. Therefore, stream compression is ideal when using a slow speed network connection. However, the server will need to use more CPU time in order to un/compress network data so under high load the server performance might be affected.
    
    Returns:
    true if network traffic is being compressed.
  - connect
```
public void connect()
             throws SmackException,
                    java.io.IOException,
                    XMPPException
```
    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.
    Listeners will be preserved from a previous connection.
    
    Throws:
    
    XMPPException - if an error occurs on the XMPP protocol level.
    
    SmackException - if an error occurs somewhere else besides XMPP protocol level.
    
    java.io.IOException
    
    SmackException.ConnectionException - with detailed information about the failed connection.
  - connectInternal
```
protected abstract void connectInternal()
                                 throws SmackException,
                                        java.io.IOException,
                                        XMPPException
```
    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 serverRequiresBinding() and such).
    Also implementations are required to perform an automatic login if the previous connection state was logged (authenticated).
    
    Throws:
    
    SmackException
    
    java.io.IOException
    
    XMPPException
  - login
```
public void login(java.lang.String username,
         java.lang.String password)
           throws XMPPException,
                  SmackException,
                  javax.security.sasl.SaslException,
                  java.io.IOException
```
    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.
    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 ConnectionConfiguration.setSendPresence(boolean). If this connection is not interested in loading its roster upon login then use 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 ConnectionConfiguration.setCallbackHandler(javax.security.auth.callback.CallbackHandler). For more advanced login settings see ConnectionConfiguration.
    
    Parameters:
    username - the username.
    password - the password or null if using a CallbackHandler.
    
    Throws:
    
    XMPPException - if an error occurs on the XMPP protocol level.
    
    SmackException - if an error occurs somehwere else besides XMPP protocol level.
    
    java.io.IOException
    
    javax.security.sasl.SaslException
  - login
```
public abstract void login(java.lang.String username,
         java.lang.String password,
         java.lang.String resource)
                    throws XMPPException,
                           SmackException,
                           javax.security.sasl.SaslException,
                           java.io.IOException
```
    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.
    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 ConnectionConfiguration.setSendPresence(boolean). If this connection is not interested in loading its roster upon login then use 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 ConnectionConfiguration.setCallbackHandler(javax.security.auth.callback.CallbackHandler). For more advanced login settings see ConnectionConfiguration.
    
    Parameters:
    username - the username.
    password - the password or null if using a CallbackHandler.
    resource - the resource.
    
    Throws:
    
    XMPPException - if an error occurs on the XMPP protocol level.
    
    SmackException - if an error occurs somehwere else besides XMPP protocol level.
    
    java.io.IOException
    
    javax.security.sasl.SaslException
  - loginAnonymously
```
public abstract void loginAnonymously()
                               throws XMPPException,
                                      SmackException,
                                      javax.security.sasl.SaslException,
                                      java.io.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.
    
    SmackException - if an error occurs somehwere else besides XMPP protocol level.
    
    java.io.IOException
    
    javax.security.sasl.SaslException
  - serverRequiresBinding
```
protected void serverRequiresBinding()
```
    Notification message saying that the server requires the client to bind a resource to the stream.
  - serverSupportsSession
```
protected void serverSupportsSession()
```
    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.
  - bindResourceAndEstablishSession
```
protected java.lang.String bindResourceAndEstablishSession(java.lang.String resource)
                                                    throws XMPPException.XMPPErrorException,
                                                           SmackException.ResourceBindingNotOfferedException,
                                                           SmackException.NoResponseException,
                                                           SmackException.NotConnectedException
```
    Throws:
    
    XMPPException.XMPPErrorException
    
    SmackException.ResourceBindingNotOfferedException
    
    SmackException.NoResponseException
    
    SmackException.NotConnectedException
  - setConnectionException
```
protected void setConnectionException(java.io.IOException exception)
```
  - throwConnectionExceptionOrNoResponse
```
protected void throwConnectionExceptionOrNoResponse()
                                             throws java.io.IOException,
                                                    SmackException.NoResponseException
```
    Throws:
    
    java.io.IOException
    
    SmackException.NoResponseException
  - getReader
```
protected java.io.Reader getReader()
```
  - getWriter
```
protected java.io.Writer getWriter()
```
  - setServiceName
```
protected void setServiceName(java.lang.String serviceName)
```
  - setLoginInfo
```
protected void setLoginInfo(java.lang.String username,
                java.lang.String password,
                java.lang.String resource)
```
  - serverSupportsAccountCreation
```
protected void serverSupportsAccountCreation()
```
  - maybeResolveDns
```
protected void maybeResolveDns()
                        throws java.lang.Exception
```
    Throws:
    
    java.lang.Exception
  - sendPacket
```
public void sendPacket(Packet packet)
                throws SmackException.NotConnectedException
```
    Sends the specified packet to the server.
    
    Parameters:
    packet - the packet to send.
    
    Throws:
    
    SmackException.NotConnectedException
  - getRoster
```
public Roster getRoster()
```
    Returns the roster for the user.
    This method will never return null, instead if the user has not yet logged into the server or is logged in anonymously all modifying methods of the returned roster object like Roster.createEntry(String, String, String[]), Roster.removeEntry(RosterEntry) , etc. except adding or removing RosterListeners will throw an IllegalStateException.
    
    Returns:
    the user's roster.
    
    Throws:
    
    java.lang.IllegalStateException - if the connection is anonymous
  - getSASLAuthentication
```
protected SASLAuthentication getSASLAuthentication()
```
    Returns the SASLAuthentication manager that is responsible for authenticating with the server.
    
    Returns:
    the SASLAuthentication manager that is responsible for authenticating with the server.
  - disconnect
```
public void disconnect()
                throws SmackException.NotConnectedException
```
    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:
    
    SmackException.NotConnectedException
  - disconnect
```
public void disconnect(Presence unavailablePresence)
                throws SmackException.NotConnectedException
```
    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.
    
    Parameters:
    unavailablePresence - the presence packet to send during shutdown.
    
    Throws:
    
    SmackException.NotConnectedException
  - shutdown
```
protected abstract void shutdown()
```
    Shuts the current connection down.
  - addConnectionCreationListener
```
public static void addConnectionCreationListener(ConnectionCreationListener 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.
    
    Parameters:
    connectionCreationListener - a listener interested on new connections.
  - removeConnectionCreationListener
```
public static void removeConnectionCreationListener(ConnectionCreationListener connectionCreationListener)
```
    Removes a listener that was interested in connection creation events.
    
    Parameters:
    connectionCreationListener - a listener interested on new connections.
  - getConnectionCreationListeners
```
protected static java.util.Collection<ConnectionCreationListener> getConnectionCreationListeners()
```
    Get the collection of listeners that are interested in connection creation events.
    
    Returns:
    a collection of listeners interested on new connections.
  - addConnectionListener
```
public void addConnectionListener(ConnectionListener connectionListener)
```
    Adds a connection listener to this connection that will be notified when the connection closes or fails.
    
    Parameters:
    connectionListener - a connection listener.
  - removeConnectionListener
```
public void removeConnectionListener(ConnectionListener connectionListener)
```
    Removes a connection listener from this connection.
    
    Parameters:
    connectionListener - a connection listener.
  - getConnectionListeners
```
protected java.util.Collection<ConnectionListener> getConnectionListeners()
```
    Get the collection of listeners that are interested in connection events.
    
    Returns:
    a collection of listeners interested on connection events.
  - createPacketCollectorAndSend
```
public PacketCollector createPacketCollectorAndSend(IQ packet)
                                             throws SmackException.NotConnectedException
```
    Creates a new packet collector collecting packets that are replies to packet. Does also send packet. The packet filter for the collector is an IQReplyFilter, guaranteeing that packet id and JID in the 'from' address have expected values.
    
    Parameters:
    packet - the packet to filter responses from
    
    Returns:
    a new packet collector.
    
    Throws:
    
    SmackException.NotConnectedException
  - createPacketCollector
```
public PacketCollector createPacketCollector(PacketFilter packetFilter)
```
    Creates a new packet collector for this connection. A packet filter determines which packets will be accumulated by the collector. A PacketCollector is more suitable to use than a PacketListener when you need to wait for a specific result.
    
    Parameters:
    packetFilter - the packet filter to use.
    
    Returns:
    a new packet collector.
  - removePacketCollector
```
protected void removePacketCollector(PacketCollector collector)
```
    Remove a packet collector of this connection.
    
    Parameters:
    collector - a packet collectors which was created for this connection.
  - getPacketCollectors
```
protected java.util.Collection<PacketCollector> getPacketCollectors()
```
    Get the collection of all packet collectors for this connection.
    
    Returns:
    a collection of packet collectors for this connection.
  - addPacketListener
```
public void addPacketListener(PacketListener packetListener,
                     PacketFilter packetFilter)
```
    Registers a packet listener with this connection. A packet listener will be invoked only when an incoming packet is received. A packet filter determines 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.
    NOTE: If you want get a similar callback for outgoing packets, see addPacketInterceptor(PacketInterceptor, PacketFilter).
    
    Parameters:
    packetListener - the packet listener to notify of new received packets.
    packetFilter - the packet filter to use.
  - removePacketListener
```
public void removePacketListener(PacketListener packetListener)
```
    Removes a packet listener for received packets from this connection.
    
    Parameters:
    packetListener - the packet listener to remove.
  - getPacketListeners
```
protected java.util.Map<PacketListener,XMPPConnection.ListenerWrapper> getPacketListeners()
```
    Get a map of all packet listeners for received packets of this connection.
    
    Returns:
    a map of all packet listeners for received packets.
  - addPacketSendingListener
```
public void addPacketSendingListener(PacketListener packetListener,
                            PacketFilter packetFilter)
```
    Registers a packet listener with this connection. The listener will be notified of every packet that this connection sends. A packet filter determines which packets will be delivered to the listener. Note that the thread that writes packets will be used to invoke the listeners. Therefore, each packet listener should complete all operations quickly or use a different thread for processing.
    
    Parameters:
    packetListener - the packet listener to notify of sent packets.
    packetFilter - the packet filter to use.
  - removePacketSendingListener
```
public void removePacketSendingListener(PacketListener packetListener)
```
    Removes a packet listener for sending packets from this connection.
    
    Parameters:
    packetListener - the packet listener to remove.
  - getPacketSendingListeners
```
protected java.util.Map<PacketListener,XMPPConnection.ListenerWrapper> getPacketSendingListeners()
```
    Get a map of all packet listeners for sending packets of this connection.
    
    Returns:
    a map of all packet listeners for sent packets.
  - addPacketInterceptor
```
public void addPacketInterceptor(PacketInterceptor packetInterceptor,
                        PacketFilter packetFilter)
```
    Registers a packet interceptor with this connection. The interceptor will be invoked every time a packet is about to be sent by this connection. Interceptors may modify the packet to be sent. A packet filter determines which packets will be delivered to the interceptor.
    NOTE: For a similar functionality on incoming packets, see addPacketListener(PacketListener, PacketFilter).
    
    Parameters:
    packetInterceptor - the packet interceptor to notify of packets about to be sent.
    packetFilter - the packet filter to use.
  - removePacketInterceptor
```
public void removePacketInterceptor(PacketInterceptor packetInterceptor)
```
    Removes a packet interceptor.
    
    Parameters:
    packetInterceptor - the packet interceptor to remove.
  - getPacketInterceptors
```
protected java.util.Map<PacketInterceptor,XMPPConnection.InterceptorWrapper> getPacketInterceptors()
```
    Get a map of all packet interceptors for sending packets of this connection.
    
    Returns:
    a map of all packet interceptors for sending packets.
  - initDebugger
```
protected void initDebugger()
```
    Initialize the debugger. You can specify a customized SmackDebugger by setup the system property smack.debuggerClass to the implementation.
    
    Throws:
    
    java.lang.IllegalStateException - if the reader or writer isn't yet initialized.
    
    java.lang.IllegalArgumentException - if the SmackDebugger can't be loaded.
  - setServiceCapsNode
```
protected void setServiceCapsNode(java.lang.String node)
```
    Set the servers Entity Caps node XMPPConnection holds this information in order to avoid a dependency to smackx where EntityCapsManager lives from smack.
    
    Parameters:
    node -
  - getServiceCapsNode
```
public java.lang.String getServiceCapsNode()
```
    Retrieve the servers Entity Caps node XMPPConnection holds this information in order to avoid a dependency to smackx where EntityCapsManager lives from smack.
    
    Returns:
    the servers entity caps node
  - isRosterVersioningSupported
```
public boolean isRosterVersioningSupported()
```
    Returns true if the server supports roster versioning as defined in XEP-0237.
    
    Returns:
    true if the server supports roster versioning
  - setRosterVersioningSupported
```
protected void setRosterVersioningSupported()
```
    Indicates that the server supports roster versioning as defined in XEP-0237.
  - getPacketReplyTimeout
```
public long getPacketReplyTimeout()
```
    Returns the current value of the reply timeout in milliseconds for request for this XMPPConnection instance.
    
    Returns:
    the packet reply timeout in milliseconds
  - setPacketReplyTimeout
```
public void setPacketReplyTimeout(long timeout)
```
    Set the packet reply timeout in milliseconds. In most cases, Smack will throw a SmackException.NoResponseException if no reply to a request was received within the timeout period.
    
    Parameters:
    timeout - the packet reply timeout in milliseconds
  - processPacket
```
protected void processPacket(Packet packet)
```
    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.
    
    Parameters:
    packet - the packet to process.
  - setWasAuthenticated
```
protected void setWasAuthenticated(boolean authenticated)
```
    Sets whether the connection has already logged in the server. This method assures that the wasAuthenticated flag is never reset once it has ever been set.
    
    Parameters:
    authenticated - true if the connection has already been authenticated.
  - callConnectionConnectedListener
```
protected void callConnectionConnectedListener()
```
  - callConnectionAuthenticatedListener
```
protected void callConnectionAuthenticatedListener()
```
  - callConnectionClosedOnErrorListener
```
protected void callConnectionClosedOnErrorListener(java.lang.Exception e)
```
  - schedule
```
protected java.util.concurrent.ScheduledFuture<?> schedule(java.lang.Runnable command,
                                               long delay,
                                               java.util.concurrent.TimeUnit unit)
```
  - getConnectionCounter
```
public int getConnectionCounter()
```
    Get the connection counter of this XMPPConnection instance. Those can be used as ID to identify the connection, but beware that the ID may not be unique if you create more then 2*Integer.MAX_VALUE instances as the counter could wrap.
    
    Returns:
    the connection counter of this XMPPConnection
  - setFromMode
```
public void setFromMode(XMPPConnection.FromMode fromMode)
```
    Set the FromMode for this connection instance. Defines how the 'from' attribute of outgoing stanzas should be populated by Smack.
    
    Parameters:
    fromMode -
  - getFromMode
```
public XMPPConnection.FromMode getFromMode()
```
    Get the currently active FromMode.
    
    Returns:
    the currently active XMPPConnection.FromMode
  - finalize
```
protected void finalize()
                 throws java.lang.Throwable
```
    Overrides:
    
    finalize in class java.lang.Object
    
    Throws:
    
    java.lang.Throwable

Class XMPPConnection

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

connectionListeners

collectors

recvListeners

sendListeners

interceptors

debugger

reader

writer

saslAuthentication

connectionCounterValue

config

compressionHandler

authenticated

wasAuthenticated

Constructor Detail

XMPPConnection

Method Detail

getConfiguration

getServiceName

getHost

getPort

getUser

getConnectionID

isConnected

isAuthenticated

isAnonymous

isSecureConnection

sendPacketInternal

isUsingCompression

connect

connectInternal

login

login

loginAnonymously

serverRequiresBinding

serverSupportsSession

bindResourceAndEstablishSession

setConnectionException

throwConnectionExceptionOrNoResponse

getReader

getWriter

setServiceName

setLoginInfo

serverSupportsAccountCreation

maybeResolveDns

sendPacket

getRoster

getSASLAuthentication

disconnect

disconnect

shutdown

addConnectionCreationListener

removeConnectionCreationListener

getConnectionCreationListeners

addConnectionListener

removeConnectionListener

getConnectionListeners

createPacketCollectorAndSend

createPacketCollector

removePacketCollector

getPacketCollectors

addPacketListener

removePacketListener

getPacketListeners

addPacketSendingListener

removePacketSendingListener

getPacketSendingListeners

addPacketInterceptor

removePacketInterceptor

getPacketInterceptors

initDebugger

setServiceCapsNode

getServiceCapsNode