AbstractXMPPConnection (Smack 4.1.4 API)

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

All Implemented Interfaces:

XMPPConnection

Direct Known Subclasses:

XMPPBOSHConnection, XMPPTCPConnection
```
public abstract class AbstractXMPPConnection
extends Object
implements XMPPConnection
```

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`protected static class`	`AbstractXMPPConnection.InterceptorWrapper` A wrapper class to associate a stanza(/packet) filter with an interceptor.
`protected static class`	`AbstractXMPPConnection.ListenerWrapper` A wrapper class to associate a stanza(/packet) filter with a listener.

Nested classes/interfaces inherited from interface org.jivesoftware.smack.XMPPConnection
XMPPConnection.FromMode

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 XMPPInputOutputStream`	`compressionHandler`
`protected ConnectionConfiguration`	`config` Holds the initial configuration used while creating the connection.
`protected boolean`	`connected`
`protected int`	`connectionCounterValue` A number to uniquely identify connections that are created.
`protected Set<ConnectionListener>`	`connectionListeners` A collection of ConnectionListeners which listen for connection closing and reconnection events.
`protected Lock`	`connectionLock`
`protected SmackDebugger`	`debugger` The SmackDebugger allows to log and debug XML traffic.
`protected String`	`host` The used host to establish the connection to
`protected List<HostAddress>`	`hostAddresses`
`protected SynchronizationPoint<Exception>`	`lastFeaturesReceived` Set to success if the last features stanza from the server has been parsed.
`protected int`	`port` The used port to establish the connection to
`protected Reader`	`reader` The Reader which is used for the debugger.
`protected SASLAuthentication`	`saslAuthentication` The SASLAuthentication manager that is responsible for authenticating with the server.
`protected SynchronizationPoint<SmackException>`	`saslFeatureReceived` Set to success if the sasl feature has been received.
`protected Map<String,ExtensionElement>`	`streamFeatures`
`protected String`	`streamId` The stream ID, see RFC 6120 § 4.7.3
`protected String`	`user` The full JID of the authenticated user, as returned by the resource binding response of the server.
`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 Writer`	`writer` The Writer which is used for the debugger.

Constructor Summary

Constructors
Modifier Constructor and Description

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

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

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`addAsyncStanzaListener(StanzaListener packetListener, StanzaFilter packetFilter)` Registers an asynchronous stanza(/packet) listener with this connection.
`void`	`addConnectionListener(ConnectionListener connectionListener)` Adds a connection listener to this connection that will be notified when the connection closes or fails.
`void`	`addOneTimeSyncCallback(StanzaListener callback, StanzaFilter packetFilter)` Add a callback that is called exactly once and synchronously with the incoming stanza that matches the given stanza(/packet) filter.
`void`	`addPacketInterceptor(StanzaListener packetInterceptor, StanzaFilter packetFilter)` Registers a stanza(/packet) interceptor with this connection.
`void`	`addPacketListener(StanzaListener packetListener, StanzaFilter packetFilter)` Deprecated.
`void`	`addPacketSendingListener(StanzaListener packetListener, StanzaFilter packetFilter)` Registers a stanza(/packet) listener with this connection.
`void`	`addSyncStanzaListener(StanzaListener packetListener, StanzaFilter packetFilter)` Registers a synchronous stanza(/packet) listener with this connection.
`protected void`	`afterFeaturesReceived()`
`protected void`	`afterSuccessfulLogin(boolean resumed)`
`protected void`	`asyncGo(Runnable runnable)`
`protected void`	`bindResourceAndEstablishSession(String resource)`
`protected void`	`callConnectionAuthenticatedListener(boolean resumed)`
`protected void`	`callConnectionClosedOnErrorListener(Exception e)`
`protected void`	`callConnectionConnectedListener()`
`AbstractXMPPConnection`	`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(PacketCollector.Configuration configuration)` Create a new stanza(/packet) collector with the given stanza(/packet) collector configuration.
`PacketCollector`	`createPacketCollector(StanzaFilter packetFilter)` Creates a new stanza(/packet) collector for this connection.
`PacketCollector`	`createPacketCollectorAndSend(IQ packet)` Creates a new stanza(/packet) collector collecting packets that are replies to `packet`.
`PacketCollector`	`createPacketCollectorAndSend(StanzaFilter packetFilter, Stanza packet)` Creates a new stanza(/packet) collector for this connection.
`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 void`	`firePacketSendingListeners(Stanza packet)` Process all stanza(/packet) listeners for sending packets.
`ConnectionConfiguration`	`getConfiguration()` Get the connection configuration used by this connection.
`int`	`getConnectionCounter()` Get the connection counter of this XMPPConnection instance.
`protected static Collection<ConnectionCreationListener>`	`getConnectionCreationListeners()` Get the collection of listeners that are interested in connection creation events.
`protected Lock`	`getConnectionLock()`
`<F extends ExtensionElement> F`	`getFeature(String element, String namespace)` Get the feature stanza(/packet) extensions for a given stream feature of the server, or `null` if the server doesn't support that feature.
`XMPPConnection.FromMode`	`getFromMode()` Get the currently active FromMode.
`String`	`getHost()` Returns the host name of the server where the XMPP server is running.
`long`	`getLastStanzaReceived()` Returns the timestamp in milliseconds when the last stanza was received.
`long`	`getPacketReplyTimeout()` Returns the current value of the reply timeout in milliseconds for request for this XMPPConnection instance.
`ParsingExceptionCallback`	`getParsingExceptionCallback()` Get the current active parsing exception callback.
`int`	`getPort()` Returns the port number of the XMPP server for this connection.
`protected SASLAuthentication`	`getSASLAuthentication()` Returns the SASLAuthentication manager that is responsible for authenticating with the server.
`String`	`getServiceName()` Returns the name of the service provided by the XMPP server for this connection.
`String`	`getStreamId()` Returns the stream ID for this connection, which is the value set by the server when opening an XMPP stream.
`String`	`getUser()` Returns the full XMPP address of the user that is logged in to the connection or `null` if not logged in yet.
`boolean`	`hasFeature(String element, String namespace)` Return true if the server supports the given stream feature.
`protected void`	`initDebugger()` Initialize the `debugger`.
`protected void`	`invokePacketCollectorsAndNotifyRecvListeners(Stanza packet)` Invoke `PacketCollector.processPacket(Stanza)` for every PacketCollector with the given packet.
`boolean`	`isAnonymous()` Returns true if currently authenticated anonymously.
`boolean`	`isAuthenticated()` Returns true if currently authenticated by successfully calling the login method.
`boolean`	`isConnected()` Returns true if currently connected to the XMPP server.
`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()` Logs in to the server using the strongest SASL mechanism supported by the server.
`void`	`login(CharSequence username, String password)` Same as `login(CharSequence, String, String)`, but takes the resource from the connection configuration.
`void`	`login(CharSequence username, String password, String resource)` Login with the given username (authorization identity).
`protected abstract void`	`loginAnonymously()`
`protected abstract void`	`loginNonAnonymously(String username, String password, String resource)`
`protected void`	`notifyReconnection()` Sends a notification indicating that the connection was reconnected successfully.
`protected void`	`parseAndProcessStanza(org.xmlpull.v1.XmlPullParser parser)`
`protected void`	`parseFeatures(org.xmlpull.v1.XmlPullParser parser)`
`protected List<HostAddress>`	`populateHostAddresses()` Populates `hostAddresses` with at least one host address.
`protected void`	`processPacket(Stanza packet)` Processes a stanza(/packet) after it's been fully parsed by looping through the installed stanza(/packet) collectors and listeners and letting them examine the stanza(/packet) to see if they are a match with the filter.
`IQRequestHandler`	`registerIQRequestHandler(IQRequestHandler iqRequestHandler)` Register an IQ request handler with this connection.
`boolean`	`removeAsyncStanzaListener(StanzaListener packetListener)` Removes an asynchronous stanza(/packet) listener for received packets from this connection.
`void`	`removeConnectionListener(ConnectionListener connectionListener)` Removes a connection listener from this connection.
`void`	`removePacketCollector(PacketCollector collector)` Remove a stanza(/packet) collector of this connection.
`void`	`removePacketInterceptor(StanzaListener packetInterceptor)` Removes a stanza(/packet) interceptor.
`boolean`	`removePacketListener(StanzaListener packetListener)` Deprecated.
`void`	`removePacketSendingListener(StanzaListener packetListener)` Removes a stanza(/packet) listener for sending packets from this connection.
`boolean`	`removeSyncStanzaListener(StanzaListener packetListener)` Removes a stanza(/packet) listener for received packets from this connection.
`protected ScheduledFuture<?>`	`schedule(Runnable runnable, long delay, TimeUnit unit)`
`abstract void`	`send(PlainStreamElement element)` Send a PlainStreamElement.
`void`	`sendIqWithResponseCallback(IQ iqRequest, StanzaListener callback)` Send a IQ stanza and invoke `callback` if there is a result of `IQ.Type.result` with that result IQ.
`void`	`sendIqWithResponseCallback(IQ iqRequest, StanzaListener callback, ExceptionCallback exceptionCallback)` Send a IQ stanza and invoke `callback` if there is a result of `IQ.Type.result` with that result IQ.
`void`	`sendIqWithResponseCallback(IQ iqRequest, StanzaListener callback, ExceptionCallback exceptionCallback, long timeout)` Send a IQ stanza and invoke `callback` if there is a result of `IQ.Type.result` with that result IQ.
`void`	`sendPacket(Stanza packet)` Deprecated.
`void`	`sendStanza(Stanza packet)` Sends the specified stanza to the server.
`protected abstract void`	`sendStanzaInternal(Stanza packet)`
`void`	`sendStanzaWithResponseCallback(Stanza stanza, StanzaFilter replyFilter, StanzaListener callback)` Send a stanza and wait asynchronously for a response by using `replyFilter`.
`void`	`sendStanzaWithResponseCallback(Stanza stanza, StanzaFilter replyFilter, StanzaListener callback, ExceptionCallback exceptionCallback)` Send a stanza and wait asynchronously for a response by using `replyFilter`.
`void`	`sendStanzaWithResponseCallback(Stanza stanza, StanzaFilter replyFilter, StanzaListener callback, ExceptionCallback exceptionCallback, long timeout)` Send a stanza and wait asynchronously for a response by using `replyFilter`.
`void`	`setFromMode(XMPPConnection.FromMode fromMode)` Set the FromMode for this connection instance.
`void`	`setPacketReplyTimeout(long timeout)` Set the stanza(/packet) reply timeout in milliseconds.
`void`	`setParsingExceptionCallback(ParsingExceptionCallback callback)` Install a parsing exception callback, which will be invoked once an exception is encountered while parsing a stanza
`void`	`setReplyToUnknownIq(boolean replyToUnknownIq)` Set if Smack will automatically send `XMPPError.Condition.feature_not_implemented` when a request IQ without a registered `IQRequestHandler` is received.
`static void`	`setReplyToUnknownIqDefault(boolean replyToUnkownIqDefault)` Set the default value used to determine if new connection will reply to unknown IQ requests.
`protected void`	`setWasAuthenticated()` Sets whether the connection has already logged in the server.
`protected abstract void`	`shutdown()` Shuts the current connection down.
`protected void`	`throwAlreadyConnectedExceptionIfAppropriate()`
`protected void`	`throwAlreadyLoggedInExceptionIfAppropriate()`
`protected void`	`throwNotConnectedExceptionIfAppropriate()`
`protected void`	`throwNotConnectedExceptionIfAppropriate(String optionalHint)`
`IQRequestHandler`	`unregisterIQRequestHandler(IQRequestHandler iqRequestHandler)` Convenience method for `XMPPConnection.unregisterIQRequestHandler(String, String, org.jivesoftware.smack.packet.IQ.Type)`.
`IQRequestHandler`	`unregisterIQRequestHandler(String element, String namespace, IQ.Type type)` Unregister an IQ request handler with this connection.

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

- Field Detail
  - connectionListeners
```
protected final Set<ConnectionListener> connectionListeners
```
    A collection of ConnectionListeners which listen for connection closing and reconnection events.
  - connectionLock
```
protected final Lock connectionLock
```
  - streamFeatures
```
protected final Map<String,ExtensionElement> streamFeatures
```
  - user
```
protected String user
```
    The full JID of the authenticated user, as returned by the resource binding response of the server.
    It is important that we don't infer the user from the login() arguments and the configurations service name, as, for example, when SASL External is used, the username is not given to login but taken from the 'external' certificate.
  - connected
```
protected boolean connected
```
  - streamId
```
protected String streamId
```
    The stream ID, see RFC 6120 § 4.7.3
  - debugger
```
protected SmackDebugger debugger
```
    The SmackDebugger allows to log and debug XML traffic.
  - reader
```
protected Reader reader
```
    The Reader which is used for the debugger.
  - writer
```
protected Writer writer
```
    The Writer which is used for the debugger.
  - lastFeaturesReceived
```
protected final SynchronizationPoint<Exception> lastFeaturesReceived
```
    Set to success if the last features stanza from the server has been parsed. A XMPP connection handshake can invoke multiple features stanzas, e.g. when TLS is activated a second feature stanza is send by the server. This is set to true once the last feature stanza has been parsed.
  - saslFeatureReceived
```
protected final SynchronizationPoint<SmackException> saslFeatureReceived
```
    Set to success if the sasl feature has been received.
  - 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
```
  - host
```
protected String host
```
    The used host to establish the connection to
  - port
```
protected int port
```
    The used port to establish the connection to
  - 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).
  - hostAddresses
```
protected List<HostAddress> hostAddresses
```
- Constructor Detail
  - AbstractXMPPConnection
```
protected AbstractXMPPConnection(ConnectionConfiguration configuration)
```
    Create a new XMPPConnection to an XMPP server.
    
    Parameters:
    configuration - The configuration which is used to establish the connection.
- Method Detail
  - getConnectionCreationListeners
```
protected static Collection<ConnectionCreationListener> getConnectionCreationListeners()
```
    Get the collection of listeners that are interested in connection creation events.
    
    Returns:
    a collection of listeners interested on new connections.
  - getConfiguration
```
public ConnectionConfiguration getConfiguration()
```
    Get the connection configuration used by this connection.
    
    Returns:
    the connection configuration.
  - getServiceName
```
public String getServiceName()
```
    Description copied from interface: XMPPConnection
    
    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.
    
    Specified by:
    
    getServiceName in interface XMPPConnection
    
    Returns:
    the name of the service provided by the XMPP server.
  - getHost
```
public String getHost()
```
    Description copied from interface: XMPPConnection
    
    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.
    
    Specified by:
    
    getHost in interface XMPPConnection
    
    Returns:
    the host name of the server where the XMPP server is running or null if not yet connected.
  - getPort
```
public int getPort()
```
    Description copied from interface: XMPPConnection
    
    Returns the port number of the XMPP server for this connection. The default port for normal connections is 5222.
    
    Specified by:
    
    getPort in interface XMPPConnection
    
    Returns:
    the port number of the XMPP server or 0 if not yet connected.
  - isSecureConnection
```
public abstract boolean isSecureConnection()
```
    Description copied from interface: XMPPConnection
    
    Returns true if the connection to the server has successfully negotiated encryption.
    
    Specified by:
    
    isSecureConnection in interface XMPPConnection
    
    Returns:
    true if a secure connection to the server.
  - sendStanzaInternal
```
protected abstract void sendStanzaInternal(Stanza packet)
                                    throws SmackException.NotConnectedException
```
    Throws:
    
    SmackException.NotConnectedException
  - send
```
public abstract void send(PlainStreamElement element)
                   throws SmackException.NotConnectedException
```
    Description copied from interface: XMPPConnection
    
    Send a PlainStreamElement.
    This method is not meant for end-user usage! It allows sending plain stream elements, which should not be done by a user manually. Doing so may result in a unstable or unusable connection. Certain Smack APIs use this method to send plain stream elements.
    
    Specified by:
    
    send in interface XMPPConnection
    
    Throws:
    
    SmackException.NotConnectedException
  - isUsingCompression
```
public abstract boolean isUsingCompression()
```
    Description copied from interface: XMPPConnection
    
    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.
    
    Specified by:
    
    isUsingCompression in interface XMPPConnection
    
    Returns:
    true if network traffic is being compressed.
  - connect
```
public AbstractXMPPConnection connect()
                               throws SmackException,
                                      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.
    
    Returns:
    a reference to this object, to chain connect() with login().
    
    Throws:
    
    XMPPException - if an error occurs on the XMPP protocol level.
    
    SmackException - if an error occurs somewhere else besides XMPP protocol level.
    
    IOException
    
    SmackException.ConnectionException - with detailed information about the failed connection.
  - connectInternal
```
protected abstract void connectInternal()
                                 throws SmackException,
                                        IOException,
                                        XMPPException
```
    Abstract method that concrete subclasses of XMPPConnection need to implement to perform their way of XMPP connection establishment. Implementations are required to perform an automatic login if the previous connection state was logged (authenticated).
    
    Throws:
    
    SmackException
    
    IOException
    
    XMPPException
  - login
```
public void login()
           throws XMPPException,
                  SmackException,
                  IOException
```
    Logs in to the server using the strongest SASL mechanism supported by the server. If more than the connection's default stanza(/packet) timeout elapses in each step of the authentication process without a response from the server, a SmackException.NoResponseException will be thrown.
    Before logging in (i.e. authenticate) to the server the connection must be connected by calling connect().
    
    It is possible to log in without sending an initial available presence by using ConnectionConfiguration.Builder.setSendPresence(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.Builder.setCallbackHandler(javax.security.auth.callback.CallbackHandler). For more advanced login settings see ConnectionConfiguration.
    
    Throws:
    
    XMPPException - if an error occurs on the XMPP protocol level.
    
    SmackException - if an error occurs somewhere else besides XMPP protocol level.
    
    IOException - if an I/O error occurs during login.
  - login
```
public void login(CharSequence username,
         String password)
           throws XMPPException,
                  SmackException,
                  IOException
```
    Same as login(CharSequence, String, String), but takes the resource from the connection configuration.
    
    Parameters:
    username -
    password -
    
    Throws:
    
    XMPPException
    
    SmackException
    
    IOException
    See Also:
    login()
  - login
```
public void login(CharSequence username,
         String password,
         String resource)
           throws XMPPException,
                  SmackException,
                  IOException
```
    Login with the given username (authorization identity). You may omit the password if a callback handler is used. If resource is null, then the server will generate one.
    
    Parameters:
    username -
    password -
    resource -
    
    Throws:
    
    XMPPException
    
    SmackException
    
    IOException
    See Also:
    login()
  - loginNonAnonymously
```
protected abstract void loginNonAnonymously(String username,
                       String password,
                       String resource)
                                     throws XMPPException,
                                            SmackException,
                                            IOException
```
    Throws:
    
    XMPPException
    
    SmackException
    
    IOException
  - loginAnonymously
```
protected abstract void loginAnonymously()
                                  throws XMPPException,
                                         SmackException,
                                         IOException
```
    Throws:
    
    XMPPException
    
    SmackException
    
    IOException
  - isConnected
```
public final boolean isConnected()
```
    Description copied from interface: XMPPConnection
    
    Returns true if currently connected to the XMPP server.
    
    Specified by:
    
    isConnected in interface XMPPConnection
    
    Returns:
    true if connected.
  - isAuthenticated
```
public final boolean isAuthenticated()
```
    Description copied from interface: XMPPConnection
    
    Returns true if currently authenticated by successfully calling the login method.
    
    Specified by:
    
    isAuthenticated in interface XMPPConnection
    
    Returns:
    true if authenticated.
  - getUser
```
public final String getUser()
```
    Description copied from interface: XMPPConnection
    
    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.
    
    Specified by:
    
    getUser in interface XMPPConnection
    
    Returns:
    the full XMPP address of the user logged in.
  - getStreamId
```
public String getStreamId()
```
    Description copied from interface: XMPPConnection
    
    Returns the stream ID for this connection, which is the value set by the server when opening an XMPP stream. This value will be null if not connected to the server.
    
    Specified by:
    
    getStreamId in interface XMPPConnection
    
    Returns:
    the ID of this connection returned from the XMPP server or null if not connected to the server.
    See Also:
    RFC 6120 § 4.7.3. id
  - bindResourceAndEstablishSession
```
protected void bindResourceAndEstablishSession(String resource)
                                        throws XMPPException.XMPPErrorException,
                                               IOException,
                                               SmackException
```
    Throws:
    
    XMPPException.XMPPErrorException
    
    IOException
    
    SmackException
  - afterSuccessfulLogin
```
protected void afterSuccessfulLogin(boolean resumed)
                             throws SmackException.NotConnectedException
```
    Throws:
    
    SmackException.NotConnectedException
  - isAnonymous
```
public final boolean isAnonymous()
```
    Description copied from interface: XMPPConnection
    
    Returns true if currently authenticated anonymously.
    
    Specified by:
    
    isAnonymous in interface XMPPConnection
    
    Returns:
    true if authenticated anonymously.
  - populateHostAddresses
```
protected List<HostAddress> populateHostAddresses()
```
    Populates hostAddresses with at least one host address.
    
    Returns:
    a list of host addresses where DNS (SRV) RR resolution failed.
  - getConnectionLock
```
protected Lock getConnectionLock()
```
  - throwNotConnectedExceptionIfAppropriate
```
protected void throwNotConnectedExceptionIfAppropriate()
                                                throws SmackException.NotConnectedException
```
    Throws:
    
    SmackException.NotConnectedException
  - throwNotConnectedExceptionIfAppropriate
```
protected void throwNotConnectedExceptionIfAppropriate(String optionalHint)
                                                throws SmackException.NotConnectedException
```
    Throws:
    
    SmackException.NotConnectedException
  - throwAlreadyConnectedExceptionIfAppropriate
```
protected void throwAlreadyConnectedExceptionIfAppropriate()
                                                    throws SmackException.AlreadyConnectedException
```
    Throws:
    
    SmackException.AlreadyConnectedException
  - throwAlreadyLoggedInExceptionIfAppropriate
```
protected void throwAlreadyLoggedInExceptionIfAppropriate()
                                                   throws SmackException.AlreadyLoggedInException
```
    Throws:
    
    SmackException.AlreadyLoggedInException
  - sendPacket
```
@Deprecated
public void sendPacket(Stanza packet)
                throws SmackException.NotConnectedException
```
    Deprecated.
    
    Description copied from interface: XMPPConnection
    
    Sends the specified stanza(/packet) to the server.
    
    Specified by:
    
    sendPacket in interface XMPPConnection
    
    Parameters:
    packet - the stanza(/packet) to send.
    
    Throws:
    
    SmackException.NotConnectedException
  - sendStanza
```
public void sendStanza(Stanza packet)
                throws SmackException.NotConnectedException
```
    Description copied from interface: XMPPConnection
    
    Sends the specified stanza to the server.
    
    Specified by:
    
    sendStanza in interface XMPPConnection
    
    Parameters:
    packet - the stanza to send.
    
    Throws:
    
    SmackException.NotConnectedException - if the connection is not connected.
  - 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()
```
    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.
  - 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 stanza(/packet) is set with online information, but most XMPP servers will deliver the full presence stanza(/packet) with whatever data is set.
    
    Parameters:
    unavailablePresence - the presence stanza(/packet) to send during shutdown.
    
    Throws:
    
    SmackException.NotConnectedException
  - shutdown
```
protected abstract void shutdown()
```
    Shuts the current connection down.
  - addConnectionListener
```
public void addConnectionListener(ConnectionListener connectionListener)
```
    Description copied from interface: XMPPConnection
    
    Adds a connection listener to this connection that will be notified when the connection closes or fails.
    
    Specified by:
    
    addConnectionListener in interface XMPPConnection
    
    Parameters:
    connectionListener - a connection listener.
  - removeConnectionListener
```
public void removeConnectionListener(ConnectionListener connectionListener)
```
    Description copied from interface: XMPPConnection
    
    Removes a connection listener from this connection.
    
    Specified by:
    
    removeConnectionListener in interface XMPPConnection
    
    Parameters:
    connectionListener - a connection listener.
  - createPacketCollectorAndSend
```
public PacketCollector createPacketCollectorAndSend(IQ packet)
                                             throws SmackException.NotConnectedException
```
    Description copied from interface: XMPPConnection
    
    Creates a new stanza(/packet) collector collecting packets that are replies to packet. Does also send packet. The stanza(/packet) filter for the collector is an IQReplyFilter, guaranteeing that stanza(/packet) id and JID in the 'from' address have expected values.
    
    Specified by:
    
    createPacketCollectorAndSend in interface XMPPConnection
    
    Parameters:
    packet - the stanza(/packet) to filter responses from
    
    Returns:
    a new stanza(/packet) collector.
    
    Throws:
    
    SmackException.NotConnectedException
  - createPacketCollectorAndSend
```
public PacketCollector createPacketCollectorAndSend(StanzaFilter packetFilter,
                                           Stanza packet)
                                             throws SmackException.NotConnectedException
```
    Description copied from interface: XMPPConnection
    
    Creates a new stanza(/packet) collector for this connection. A stanza(/packet) filter determines which packets will be accumulated by the collector. A PacketCollector is more suitable to use than a StanzaListener when you need to wait for a specific result.
    
    Specified by:
    
    createPacketCollectorAndSend in interface XMPPConnection
    
    Parameters:
    packetFilter - the stanza(/packet) filter to use.
    packet - the stanza(/packet) to send right after the collector got created
    
    Returns:
    a new stanza(/packet) collector.
    
    Throws:
    
    SmackException.NotConnectedException
  - createPacketCollector
```
public PacketCollector createPacketCollector(StanzaFilter packetFilter)
```
    Description copied from interface: XMPPConnection
    
    Creates a new stanza(/packet) collector for this connection. A stanza(/packet) filter determines which packets will be accumulated by the collector. A PacketCollector is more suitable to use than a StanzaListener when you need to wait for a specific result.
    Note: If you send a Stanza(/Packet) right after using this method, then consider using XMPPConnection.createPacketCollectorAndSend(StanzaFilter, Stanza) instead. Otherwise make sure cancel the PacketCollector in every case, e.g. even if an exception is thrown, or otherwise you may leak the PacketCollector.
    
    Specified by:
    
    createPacketCollector in interface XMPPConnection
    
    Parameters:
    packetFilter - the stanza(/packet) filter to use.
    
    Returns:
    a new stanza(/packet) collector.
  - createPacketCollector
```
public PacketCollector createPacketCollector(PacketCollector.Configuration configuration)
```
    Description copied from interface: XMPPConnection
    
    Create a new stanza(/packet) collector with the given stanza(/packet) collector configuration.
    Please make sure to cancel the collector when it is no longer required. See also XMPPConnection.createPacketCollector(StanzaFilter).
    
    Specified by:
    
    createPacketCollector in interface XMPPConnection
    
    Parameters:
    configuration - the stanza(/packet) collector configuration.
    
    Returns:
    a new stanza(/packet) collector.
  - removePacketCollector
```
public void removePacketCollector(PacketCollector collector)
```
    Description copied from interface: XMPPConnection
    
    Remove a stanza(/packet) collector of this connection.
    
    Specified by:
    
    removePacketCollector in interface XMPPConnection
    
    Parameters:
    collector - a stanza(/packet) collectors which was created for this connection.
  - addPacketListener
```
@Deprecated
public void addPacketListener(StanzaListener packetListener,
                                StanzaFilter packetFilter)
```
    Deprecated.
    
    Description copied from interface: XMPPConnection
    
    Registers a stanza(/packet) listener with this connection.
    This method has been deprecated. It is important to differentiate between using an asynchronous stanza(/packet) listener (preferred where possible) and a synchronous stanza(/packet) lister. Refer XMPPConnection.addAsyncStanzaListener(StanzaListener, StanzaFilter) and XMPPConnection.addSyncStanzaListener(StanzaListener, StanzaFilter) for more information.
    
    Specified by:
    
    addPacketListener in interface XMPPConnection
    
    Parameters:
    packetListener - the stanza(/packet) listener to notify of new received packets.
    packetFilter - the stanza(/packet) filter to use.
  - removePacketListener
```
@Deprecated
public boolean removePacketListener(StanzaListener packetListener)
```
    Deprecated.
    
    Description copied from interface: XMPPConnection
    
    Removes a stanza(/packet) listener for received packets from this connection.
    
    Specified by:
    
    removePacketListener in interface XMPPConnection
    
    Parameters:
    packetListener - the stanza(/packet) listener to remove.
    
    Returns:
    true if the stanza(/packet) listener was removed
  - addSyncStanzaListener
```
public void addSyncStanzaListener(StanzaListener packetListener,
                         StanzaFilter packetFilter)
```
    Description copied from interface: XMPPConnection
    
    Registers a synchronous stanza(/packet) listener with this connection. A stanza(/packet) listener will be invoked only when an incoming stanza(/packet) is received. A stanza(/packet) filter determines which packets will be delivered to the listener. If the same stanza(/packet) listener is added again with a different filter, only the new filter will be used.
    Important: This stanza(/packet) listeners will be called in the same single thread that processes all incoming stanzas. Only use this kind of stanza(/packet) filter if it does not perform any XMPP activity that waits for a response. Consider using XMPPConnection.addAsyncStanzaListener(StanzaListener, StanzaFilter) when possible, i.e. when the invocation order doesn't have to be the same as the order of the arriving packets. If the order of the arriving packets, consider using a PacketCollector when possible.
    
    Specified by:
    
    addSyncStanzaListener in interface XMPPConnection
    
    Parameters:
    packetListener - the stanza(/packet) listener to notify of new received packets.
    packetFilter - the stanza(/packet) filter to use.
    See Also:
    XMPPConnection.addPacketInterceptor(StanzaListener, StanzaFilter)
  - removeSyncStanzaListener
```
public boolean removeSyncStanzaListener(StanzaListener packetListener)
```
    Description copied from interface: XMPPConnection
    
    Removes a stanza(/packet) listener for received packets from this connection.
    
    Specified by:
    
    removeSyncStanzaListener in interface XMPPConnection
    
    Parameters:
    packetListener - the stanza(/packet) listener to remove.
    
    Returns:
    true if the stanza(/packet) listener was removed
  - addAsyncStanzaListener
```
public void addAsyncStanzaListener(StanzaListener packetListener,
                          StanzaFilter packetFilter)
```
    Description copied from interface: XMPPConnection
    
    Registers an asynchronous stanza(/packet) listener with this connection. A stanza(/packet) listener will be invoked only when an incoming stanza(/packet) is received. A stanza(/packet) filter determines which packets will be delivered to the listener. If the same stanza(/packet) listener is added again with a different filter, only the new filter will be used.
    Unlike XMPPConnection.addAsyncStanzaListener(StanzaListener, StanzaFilter) stanza(/packet) listeners added with this method will be invoked asynchronously in their own thread. Use this method if the order of the stanza(/packet) listeners must not depend on the order how the stanzas where received.
    
    Specified by:
    
    addAsyncStanzaListener in interface XMPPConnection
    
    Parameters:
    packetListener - the stanza(/packet) listener to notify of new received packets.
    packetFilter - the stanza(/packet) filter to use.
    See Also:
    XMPPConnection.addPacketInterceptor(StanzaListener, StanzaFilter)
  - removeAsyncStanzaListener
```
public boolean removeAsyncStanzaListener(StanzaListener packetListener)
```
    Description copied from interface: XMPPConnection
    
    Removes an asynchronous stanza(/packet) listener for received packets from this connection.
    
    Specified by:
    
    removeAsyncStanzaListener in interface XMPPConnection
    
    Parameters:
    packetListener - the stanza(/packet) listener to remove.
    
    Returns:
    true if the stanza(/packet) listener was removed
  - addPacketSendingListener
```
public void addPacketSendingListener(StanzaListener packetListener,
                            StanzaFilter packetFilter)
```
    Description copied from interface: XMPPConnection
    
    Registers a stanza(/packet) listener with this connection. The listener will be notified of every stanza(/packet) that this connection sends. A stanza(/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 stanza(/packet) listener should complete all operations quickly or use a different thread for processing.
    
    Specified by:
    
    addPacketSendingListener in interface XMPPConnection
    
    Parameters:
    packetListener - the stanza(/packet) listener to notify of sent packets.
    packetFilter - the stanza(/packet) filter to use.
  - removePacketSendingListener
```
public void removePacketSendingListener(StanzaListener packetListener)
```
    Description copied from interface: XMPPConnection
    
    Removes a stanza(/packet) listener for sending packets from this connection.
    
    Specified by:
    
    removePacketSendingListener in interface XMPPConnection
    
    Parameters:
    packetListener - the stanza(/packet) listener to remove.
  - firePacketSendingListeners
```
protected void firePacketSendingListeners(Stanza packet)
```
    Process all stanza(/packet) listeners for sending packets.
    Compared to firePacketInterceptors(Stanza), the listeners will be invoked in a new thread.
    
    Parameters:
    packet - the stanza(/packet) to process.
  - addPacketInterceptor
```
public void addPacketInterceptor(StanzaListener packetInterceptor,
                        StanzaFilter packetFilter)
```
    Description copied from interface: XMPPConnection
    
    Registers a stanza(/packet) interceptor with this connection. The interceptor will be invoked every time a stanza(/packet) is about to be sent by this connection. Interceptors may modify the stanza(/packet) to be sent. A stanza(/packet) filter determines which packets will be delivered to the interceptor.
    NOTE: For a similar functionality on incoming packets, see XMPPConnection.addAsyncStanzaListener(StanzaListener, StanzaFilter).
    
    Specified by:
    
    addPacketInterceptor in interface XMPPConnection
    
    Parameters:
    packetInterceptor - the stanza(/packet) interceptor to notify of packets about to be sent.
    packetFilter - the stanza(/packet) filter to use.
  - removePacketInterceptor
```
public void removePacketInterceptor(StanzaListener packetInterceptor)
```
    Description copied from interface: XMPPConnection
    
    Removes a stanza(/packet) interceptor.
    
    Specified by:
    
    removePacketInterceptor in interface XMPPConnection
    
    Parameters:
    packetInterceptor - the stanza(/packet) interceptor to remove.
  - initDebugger
```
protected void initDebugger()
```
    Initialize the debugger. You can specify a customized SmackDebugger by setup the system property smack.debuggerClass to the implementation.
    
    Throws:
    
    IllegalStateException - if the reader or writer isn't yet initialized.
    
    IllegalArgumentException - if the SmackDebugger can't be loaded.
  - getPacketReplyTimeout
```
public long getPacketReplyTimeout()
```
    Description copied from interface: XMPPConnection
    
    Returns the current value of the reply timeout in milliseconds for request for this XMPPConnection instance.
    
    Specified by:
    
    getPacketReplyTimeout in interface XMPPConnection
    
    Returns:
    the stanza(/packet) reply timeout in milliseconds
  - setPacketReplyTimeout
```
public void setPacketReplyTimeout(long timeout)
```
    Description copied from interface: XMPPConnection
    
    Set the stanza(/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.
    
    Specified by:
    
    setPacketReplyTimeout in interface XMPPConnection
    
    Parameters:
    timeout - the stanza(/packet) reply timeout in milliseconds
  - setReplyToUnknownIqDefault
```
public static void setReplyToUnknownIqDefault(boolean replyToUnkownIqDefault)
```
    Set the default value used to determine if new connection will reply to unknown IQ requests. The pre-configured default is 'true'.
    
    Parameters:
    replyToUnkownIqDefault -
    See Also:
    setReplyToUnknownIq(boolean)
  - setReplyToUnknownIq
```
public void setReplyToUnknownIq(boolean replyToUnknownIq)
```
    Set if Smack will automatically send XMPPError.Condition.feature_not_implemented when a request IQ without a registered IQRequestHandler is received.
    
    Parameters:
    replyToUnknownIq -
  - parseAndProcessStanza
```
protected void parseAndProcessStanza(org.xmlpull.v1.XmlPullParser parser)
                              throws Exception
```
    Throws:
    
    Exception
  - processPacket
```
protected void processPacket(Stanza packet)
```
    Processes a stanza(/packet) after it's been fully parsed by looping through the installed stanza(/packet) collectors and listeners and letting them examine the stanza(/packet) to see if they are a match with the filter.
    
    Parameters:
    packet - the stanza(/packet) to process.
  - invokePacketCollectorsAndNotifyRecvListeners
```
protected void invokePacketCollectorsAndNotifyRecvListeners(Stanza packet)
```
    Invoke PacketCollector.processPacket(Stanza) for every PacketCollector with the given packet. Also notify the receive listeners with a matching stanza(/packet) filter about the packet.
    
    Parameters:
    packet - the stanza(/packet) to notify the PacketCollectors and receive listeners about.
  - setWasAuthenticated
```
protected void setWasAuthenticated()
```
    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.
  - callConnectionConnectedListener
```
protected void callConnectionConnectedListener()
```
  - callConnectionAuthenticatedListener
```
protected void callConnectionAuthenticatedListener(boolean resumed)
```
  - callConnectionClosedOnErrorListener
```
protected void callConnectionClosedOnErrorListener(Exception e)
```
  - notifyReconnection
```
protected void notifyReconnection()
```
    Sends a notification indicating that the connection was reconnected successfully.
  - getConnectionCounter
```
public int getConnectionCounter()
```
    Description copied from interface: XMPPConnection
    
    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.
    
    Specified by:
    
    getConnectionCounter in interface XMPPConnection
    
    Returns:
    the connection counter of this XMPPConnection
  - setFromMode
```
public void setFromMode(XMPPConnection.FromMode fromMode)
```
    Description copied from interface: XMPPConnection
    
    Set the FromMode for this connection instance. Defines how the 'from' attribute of outgoing stanzas should be populated by Smack.
    
    Specified by:
    
    setFromMode in interface XMPPConnection
  - getFromMode
```
public XMPPConnection.FromMode getFromMode()
```
    Description copied from interface: XMPPConnection
    
    Get the currently active FromMode.
    
    Specified by:
    
    getFromMode in interface XMPPConnection
    
    Returns:
    the currently active XMPPConnection.FromMode
  - finalize
```
protected void finalize()
                 throws Throwable
```
    Overrides:
    
    finalize in class Object
    
    Throws:
    
    Throwable
  - parseFeatures
```
protected final void parseFeatures(org.xmlpull.v1.XmlPullParser parser)
                            throws org.xmlpull.v1.XmlPullParserException,
                                   IOException,
                                   SmackException
```
    Throws:
    
    org.xmlpull.v1.XmlPullParserException
    
    IOException
    
    SmackException
  - afterFeaturesReceived
```
protected void afterFeaturesReceived()
                              throws SmackException.SecurityRequiredException,
                                     SmackException.NotConnectedException
```
    Throws:
    
    SmackException.SecurityRequiredException
    
    SmackException.NotConnectedException
  - getFeature
```
public <F extends ExtensionElement> F getFeature(String element,
                                        String namespace)
```
    Description copied from interface: XMPPConnection
    
    Get the feature stanza(/packet) extensions for a given stream feature of the server, or null if the server doesn't support that feature.
    
    Specified by:
    
    getFeature in interface XMPPConnection
    
    Returns:
    a stanza(/packet) extensions of the feature or null
  - hasFeature
```
public boolean hasFeature(String element,
                 String namespace)
```
    Description copied from interface: XMPPConnection
    
    Return true if the server supports the given stream feature.
    
    Specified by:
    
    hasFeature in interface XMPPConnection
    
    Returns:
    true if the server supports the stream feature.
  - sendStanzaWithResponseCallback
```
public void sendStanzaWithResponseCallback(Stanza stanza,
                                  StanzaFilter replyFilter,
                                  StanzaListener callback)
                                    throws SmackException.NotConnectedException
```
    Description copied from interface: XMPPConnection
    
    Send a stanza and wait asynchronously for a response by using replyFilter.
    If there is a response, then callback will be invoked. The callback will be invoked at most once and it will be not invoked after the connections default reply timeout has been elapsed.
    
    Specified by:
    
    sendStanzaWithResponseCallback in interface XMPPConnection
    
    Parameters:
    stanza - the stanza to send (required)
    replyFilter - the filter used to determine response stanza (required)
    callback - the callback invoked if there is a response (required)
    
    Throws:
    
    SmackException.NotConnectedException
  - sendStanzaWithResponseCallback
```
public void sendStanzaWithResponseCallback(Stanza stanza,
                                  StanzaFilter replyFilter,
                                  StanzaListener callback,
                                  ExceptionCallback exceptionCallback)
                                    throws SmackException.NotConnectedException
```
    Description copied from interface: XMPPConnection
    
    Send a stanza and wait asynchronously for a response by using replyFilter.
    If there is a response, then callback will be invoked. If there is no response after the connections default reply timeout, then exceptionCallback will be invoked with a SmackException.NoResponseException. The callback will be invoked at most once.
    
    Specified by:
    
    sendStanzaWithResponseCallback in interface XMPPConnection
    
    Parameters:
    stanza - the stanza to send (required)
    replyFilter - the filter used to determine response stanza (required)
    callback - the callback invoked if there is a response (required)
    exceptionCallback - the callback invoked if there is an exception (optional)
    
    Throws:
    
    SmackException.NotConnectedException
  - sendStanzaWithResponseCallback
```
public void sendStanzaWithResponseCallback(Stanza stanza,
                                  StanzaFilter replyFilter,
                                  StanzaListener callback,
                                  ExceptionCallback exceptionCallback,
                                  long timeout)
                                    throws SmackException.NotConnectedException
```
    Description copied from interface: XMPPConnection
    
    Send a stanza and wait asynchronously for a response by using replyFilter.
    If there is a response, then callback will be invoked. If there is no response after timeout milliseconds, then exceptionCallback will be invoked with a SmackException.NoResponseException. The callback will be invoked at most once.
    
    Specified by:
    
    sendStanzaWithResponseCallback in interface XMPPConnection
    
    Parameters:
    stanza - the stanza to send (required)
    replyFilter - the filter used to determine response stanza (required)
    callback - the callback invoked if there is a response (required)
    exceptionCallback - the callback invoked if there is an exception (optional)
    timeout - the timeout in milliseconds to wait for a response
    
    Throws:
    
    SmackException.NotConnectedException
  - sendIqWithResponseCallback
```
public void sendIqWithResponseCallback(IQ iqRequest,
                              StanzaListener callback)
                                throws SmackException.NotConnectedException
```
    Description copied from interface: XMPPConnection
    
    Send a IQ stanza and invoke callback if there is a result of IQ.Type.result with that result IQ. The callback will not be invoked after the connections default reply timeout has been elapsed.
    
    Specified by:
    
    sendIqWithResponseCallback in interface XMPPConnection
    
    Parameters:
    iqRequest - the IQ stanza to send (required)
    callback - the callback invoked if there is result response (required)
    
    Throws:
    
    SmackException.NotConnectedException
  - sendIqWithResponseCallback
```
public void sendIqWithResponseCallback(IQ iqRequest,
                              StanzaListener callback,
                              ExceptionCallback exceptionCallback)
                                throws SmackException.NotConnectedException
```
    Description copied from interface: XMPPConnection
    
    Send a IQ stanza and invoke callback if there is a result of IQ.Type.result with that result IQ. If there is an error response exceptionCallback will be invoked, if not null, with the received error as XMPPException.XMPPErrorException. If there is no response after the connections default reply timeout, then exceptionCallback will be invoked with a SmackException.NoResponseException.
    
    Specified by:
    
    sendIqWithResponseCallback in interface XMPPConnection
    
    Parameters:
    iqRequest - the IQ stanza to send (required)
    callback - the callback invoked if there is result response (required)
    exceptionCallback - the callback invoked if there is an Exception optional
    
    Throws:
    
    SmackException.NotConnectedException
  - sendIqWithResponseCallback
```
public void sendIqWithResponseCallback(IQ iqRequest,
                              StanzaListener callback,
                              ExceptionCallback exceptionCallback,
                              long timeout)
                                throws SmackException.NotConnectedException
```
    Description copied from interface: XMPPConnection
    
    Send a IQ stanza and invoke callback if there is a result of IQ.Type.result with that result IQ. If there is an error response exceptionCallback will be invoked, if not null, with the received error as XMPPException.XMPPErrorException. If there is no response after timeout, then exceptionCallback will be invoked with a SmackException.NoResponseException.
    
    Specified by:
    
    sendIqWithResponseCallback in interface XMPPConnection
    
    Parameters:
    iqRequest - the IQ stanza to send (required)
    callback - the callback invoked if there is result response (required)
    exceptionCallback - the callback invoked if there is an Exception optional
    timeout - the timeout in milliseconds to wait for a response
    
    Throws:
    
    SmackException.NotConnectedException
  - addOneTimeSyncCallback
```
public void addOneTimeSyncCallback(StanzaListener callback,
                          StanzaFilter packetFilter)
```
    Description copied from interface: XMPPConnection
    
    Add a callback that is called exactly once and synchronously with the incoming stanza that matches the given stanza(/packet) filter.
    
    Specified by:
    
    addOneTimeSyncCallback in interface XMPPConnection
    
    Parameters:
    callback - the callback invoked once the stanza(/packet) filter matches a stanza.
    packetFilter - the filter to match stanzas or null to match all.
  - registerIQRequestHandler
```
public IQRequestHandler registerIQRequestHandler(IQRequestHandler iqRequestHandler)
```
    Description copied from interface: XMPPConnection
    
    Register an IQ request handler with this connection.
    IQ request handler process incoming IQ requests, i.e. incoming IQ stanzas of type 'get' or 'set', and return a result.
    
    Specified by:
    
    registerIQRequestHandler in interface XMPPConnection
    
    Parameters:
    iqRequestHandler - the IQ request handler to register.
    
    Returns:
    the previously registered IQ request handler or null.
  - unregisterIQRequestHandler
```
public final IQRequestHandler unregisterIQRequestHandler(IQRequestHandler iqRequestHandler)
```
    Description copied from interface: XMPPConnection
    
    Convenience method for XMPPConnection.unregisterIQRequestHandler(String, String, org.jivesoftware.smack.packet.IQ.Type).
    
    Specified by:
    
    unregisterIQRequestHandler in interface XMPPConnection
    
    Returns:
    the previously registered IQ request handler or null.
  - unregisterIQRequestHandler
```
public IQRequestHandler unregisterIQRequestHandler(String element,
                                          String namespace,
                                          IQ.Type type)
```
    Description copied from interface: XMPPConnection
    
    Unregister an IQ request handler with this connection.
    
    Specified by:
    
    unregisterIQRequestHandler in interface XMPPConnection
    
    Parameters:
    element - the IQ element the IQ request handler is responsible for.
    namespace - the IQ namespace the IQ request handler is responsible for.
    type - the IQ type the IQ request handler is responsible for.
    
    Returns:
    the previously registered IQ request handler or null.
  - getLastStanzaReceived
```
public long getLastStanzaReceived()
```
    Description copied from interface: XMPPConnection
    
    Returns the timestamp in milliseconds when the last stanza was received.
    
    Specified by:
    
    getLastStanzaReceived in interface XMPPConnection
    
    Returns:
    the timestamp in milliseconds
  - setParsingExceptionCallback
```
public void setParsingExceptionCallback(ParsingExceptionCallback callback)
```
    Install a parsing exception callback, which will be invoked once an exception is encountered while parsing a stanza
    
    Parameters:
    callback - the callback to install
  - getParsingExceptionCallback
```
public ParsingExceptionCallback getParsingExceptionCallback()
```
    Get the current active parsing exception callback.
    
    Returns:
    the active exception callback or null if there is none
  - asyncGo
```
protected final void asyncGo(Runnable runnable)
```
  - schedule
```
protected final ScheduledFuture<?> schedule(Runnable runnable,
                          long delay,
                          TimeUnit unit)
```

Class AbstractXMPPConnection

Nested Class Summary

Nested classes/interfaces inherited from interface org.jivesoftware.smack.XMPPConnection

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

connectionListeners

connectionLock

streamFeatures

user

connected

streamId

debugger

reader

writer

lastFeaturesReceived

saslFeatureReceived

saslAuthentication

connectionCounterValue

config

compressionHandler

host

port

authenticated

wasAuthenticated

hostAddresses

Constructor Detail

AbstractXMPPConnection

Method Detail

getConnectionCreationListeners

getConfiguration

getServiceName

getHost

getPort

isSecureConnection

sendStanzaInternal

send

isUsingCompression

connect

connectInternal

login

login

login

loginNonAnonymously

loginAnonymously

isConnected

isAuthenticated

getUser

getStreamId

bindResourceAndEstablishSession

afterSuccessfulLogin

isAnonymous

populateHostAddresses

getConnectionLock

throwNotConnectedExceptionIfAppropriate

throwNotConnectedExceptionIfAppropriate

throwAlreadyConnectedExceptionIfAppropriate

throwAlreadyLoggedInExceptionIfAppropriate

sendPacket

sendStanza

getSASLAuthentication

disconnect

disconnect

shutdown

addConnectionListener

removeConnectionListener

createPacketCollectorAndSend

createPacketCollectorAndSend

createPacketCollector

createPacketCollector

removePacketCollector

addPacketListener

removePacketListener

addSyncStanzaListener

removeSyncStanzaListener

addAsyncStanzaListener

removeAsyncStanzaListener

addPacketSendingListener