AbstractXMPPConnection (smack-core 4.4.0-alpha2 API)

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

All Implemented Interfaces:

XMPPConnection

Direct Known Subclasses:

AbstractXmppStateMachineConnection
```
public abstract class AbstractXMPPConnection
extends java.lang.Object
implements XMPPConnection
```
This abstract class is commonly used as super class for XMPP connection mechanisms like TCP and BOSH. Hence it provides the methods for connection state management, like connect(), login() and disconnect() (which are deliberately not provided by the XMPPConnection interface).
Note: The default entry point to Smack's documentation is XMPPConnection. If you are getting started with Smack, then head over to XMPPConnection and the come back here.

Parsing Exceptions

In case a Smack parser (Provider) throws those exceptions are handled over to the ParsingExceptionCallback. A common cause for a provider throwing is illegal input, for example a non-numeric String where only Integers are allowed. Smack's default behavior follows the "fail-hard per default" principle leading to a termination of the connection on parsing exceptions. This default was chosen to make users eventually aware that they should configure their own callback and handle those exceptions to prevent the disconnect. Handle a parsing exception could be as simple as using a non-throwing no-op callback, which would cause the faulty stream element to be taken out of the stream, i.e., Smack behaves like that element was never received.

If the parsing exception is because Smack received illegal input, then please consider informing the authors of the originating entity about that. If it was thrown because of an bug in a Smack parser, then please consider filling a bug with Smack.

Managing the parsing exception callback

The "fail-hard per default" behavior is achieved by using the ExceptionThrowingCallbackWithHint as default parsing exception callback. You can change the behavior using setParsingExceptionCallback(ParsingExceptionCallback) to set a new callback. Use SmackConfiguration.setDefaultParsingExceptionCallback(ParsingExceptionCallback) to set the default callback.

Nested Class Summary

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

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

Field Summary

Fields
Modifier and Type	Field and Description
`protected static AsyncButOrdered<AbstractXMPPConnection>`	`ASYNC_BUT_ORDERED`
`protected boolean`	`authenticated` Flag that indicates if the user is currently authenticated with the server.
`protected long`	`authenticatedConnectionInitiallyEstablishedTimestamp`
`protected SynchronizationPoint<java.lang.Exception>`	`closingStreamReceived` A synchronization point which is successful if this connection has received the closing stream element from the remote end-point, i.e.
`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 java.util.Set<ConnectionListener>`	`connectionListeners` A collection of ConnectionListeners which listen for connection closing and reconnection events.
`protected java.util.concurrent.locks.Lock`	`connectionLock`
`protected java.lang.Exception`	`currentConnectionException`
`protected SmackDebugger`	`debugger` The SmackDebugger allows to log and debug XML traffic.
`protected java.lang.String`	`host` The used host to establish the connection to
`protected java.util.List<HostAddress>`	`hostAddresses`
`protected AsyncButOrdered<StanzaListener>`	`inOrderListeners`
`protected SynchronizationPoint<SmackException>`	`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 java.io.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<XMPPException>`	`saslFeatureReceived` Set to success if the SASL feature has been received.
`protected static SmackReactor`	`SMACK_REACTOR`
`protected java.util.Map<javax.xml.namespace.QName,FullyQualifiedElement>`	`streamFeatures`
`protected java.lang.String`	`streamId` The stream ID, see RFC 6120 § 4.7.3
`protected SynchronizationPoint<SmackException>`	`tlsHandled`
`protected org.jxmpp.jid.EntityFullJid`	`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 java.io.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

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addAsyncStanzaListener(StanzaListener packetListener, StanzaFilter packetFilter)` Registers an asynchronous stanza 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 filter.
`void`	`addStanzaInterceptor(StanzaListener packetInterceptor, StanzaFilter packetFilter)` Registers a stanza interceptor with this connection.
`void`	`addStanzaListener(StanzaListener stanzaListener, StanzaFilter stanzaFilter)` Registers a stanza listener with this connection.
`void`	`addStanzaSendingListener(StanzaListener packetListener, StanzaFilter packetFilter)` Registers a stanza listener with this connection.
`protected void`	`addStreamFeature(FullyQualifiedElement feature)`
`void`	`addSyncStanzaListener(StanzaListener packetListener, StanzaFilter packetFilter)` Registers a synchronous stanza listener with this connection.
`protected void`	`afterFeaturesReceived()`
`protected void`	`afterSuccessfulLogin(boolean resumed)`
`protected static void`	`asyncGo(java.lang.Runnable runnable)`
`protected void`	`asyncGoLimited(java.lang.Runnable runnable)`
`protected org.jxmpp.jid.parts.Resourcepart`	`bindResourceAndEstablishSession(org.jxmpp.jid.parts.Resourcepart resource)`
`protected NonzaCallback.Builder`	`buildNonzaCallback()`
`protected void`	`callConnectionAuthenticatedListener(boolean resumed)`
`protected void`	`callConnectionConnectedListener()`
`AbstractXMPPConnection`	`connect()` Establishes a connection to the XMPP server.
`protected abstract void`	`connectInternal()` Abstract method that concrete subclasses of XMPPConnection need to implement to perform their way of XMPP connection establishment.
`StanzaCollector`	`createStanzaCollector(StanzaCollector.Configuration configuration)` Create a new stanza collector with the given stanza collector configuration.
`StanzaCollector`	`createStanzaCollector(StanzaFilter packetFilter)` Creates a new stanza collector for this connection.
`StanzaCollector`	`createStanzaCollectorAndSend(IQ packet)` Creates a new stanza collector collecting IQ responses that are replies to the IQ `request`.
`StanzaCollector`	`createStanzaCollectorAndSend(StanzaFilter packetFilter, Stanza packet)` Creates a new stanza 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`	`firePacketSendingListeners(TopLevelStreamElement sendTopLevelStreamElement)` Process all stanza listeners for sending stanzas.
`long`	`getAuthenticatedConnectionInitiallyEstablishedTimestamp()` Get the timestamp when the connection was the first time authenticated, i.e., when the first successful login was performed.
`ConnectionConfiguration`	`getConfiguration()` Get the connection configuration used by this connection.
`int`	`getConnectionCounter()` Get the connection counter of this XMPPConnection instance.
`protected java.util.concurrent.locks.Lock`	`getConnectionLock()`
`<F extends FullyQualifiedElement> F`	`getFeature(java.lang.String element, java.lang.String namespace)` Get the feature stanza 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.
`java.lang.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.
`ParsingExceptionCallback`	`getParsingExceptionCallback()` Get the current active parsing exception callback.
`int`	`getPort()` Returns the port number of the XMPP server for this connection.
`long`	`getReplyTimeout()` Returns the current value of the reply timeout in milliseconds for request for this XMPPConnection instance.
`protected SASLAuthentication`	`getSASLAuthentication()` Returns the SASLAuthentication manager that is responsible for authenticating with the server.
`protected AbstractXMPPConnection.SmackTlsContext`	`getSmackTlsContext()`
`java.lang.String`	`getStreamId()` Returns the stream ID for this connection, which is the value set by the server when opening an XMPP stream.
`java.lang.String`	`getUsedSaslMechansism()` Get the name of the SASL mechanism that was used to authenticate this connection.
`org.jxmpp.jid.EntityFullJid`	`getUser()` Returns the full XMPP address of the user that is logged in to the connection or `null` if not logged in yet.
`org.jxmpp.jid.DomainBareJid`	`getXMPPServiceDomain()` Returns the XMPP Domain of the service provided by the XMPP server and used for this connection.
`boolean`	`hasFeature(java.lang.String element, java.lang.String namespace)` Return true if the server supports the given stream feature.
`protected void`	`initDebugger()` Initialize the `debugger`.
`protected void`	`initState()`
`abstract void`	`instantShutdown()` Performs an unclean disconnect and shutdown of the connection.
`protected void`	`invokeStanzaCollectorsAndNotifyRecvListeners(Stanza packet)` Invoke `StanzaCollector.processStanza(Stanza)` for every StanzaCollector 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(java.lang.CharSequence username, java.lang.String password)` Same as `login(CharSequence, String, Resourcepart)`, but takes the resource from the connection configuration.
`void`	`login(java.lang.CharSequence username, java.lang.String password, org.jxmpp.jid.parts.Resourcepart resource)` Login with the given username (authorization identity).
`protected abstract void`	`loginInternal(java.lang.String username, java.lang.String password, org.jxmpp.jid.parts.Resourcepart resource)`
`protected void`	`notifyConnectionError(java.lang.Exception exception)` Sends out a notification that there was an error with the connection and closes the connection.
`protected void`	`onStreamOpen(org.jivesoftware.smack.xml.XmlPullParser parser)`
`protected void`	`parseAndProcessNonza(org.jivesoftware.smack.xml.XmlPullParser parser)`
`protected void`	`parseAndProcessStanza(org.jivesoftware.smack.xml.XmlPullParser parser)`
`protected void`	`parseFeatures(org.jivesoftware.smack.xml.XmlPullParser parser)`
`protected void`	`parseFeaturesAndNotify(org.jivesoftware.smack.xml.XmlPullParser parser)`
`protected java.util.List<HostAddress>`	`populateHostAddresses()` Populates `hostAddresses` with the resolved addresses or with the configured host address.
`protected void`	`processStanza(Stanza stanza)` Processes a stanza after it's been fully parsed by looping through the installed stanza collectors and listeners and letting them examine the stanza 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 listener for received stanzas from this connection.
`void`	`removeConnectionListener(ConnectionListener connectionListener)` Removes a connection listener from this connection.
`void`	`removeStanzaCollector(StanzaCollector collector)` Remove a stanza collector of this connection.
`void`	`removeStanzaInterceptor(StanzaListener packetInterceptor)` Removes a stanza interceptor.
`boolean`	`removeStanzaListener(StanzaListener stanzaListener)` Removes a stanza listener for received stanzas from this connection.
`void`	`removeStanzaSendingListener(StanzaListener packetListener)` Removes a stanza listener for sending stanzas from this connection.
`boolean`	`removeSyncStanzaListener(StanzaListener packetListener)` Removes a stanza listener for received stanzas from this connection.
`protected static ScheduledAction`	`schedule(java.lang.Runnable runnable, long delay, java.util.concurrent.TimeUnit unit)`
`protected <SN extends Nonza,FN extends Nonza> SN`	`sendAndWaitForResponse(Nonza nonza, java.lang.Class<SN> successNonzaClass, java.lang.Class<FN> failedNonzaClass)`
`<S extends Stanza> SmackFuture<S,java.lang.Exception>`	`sendAsync(S stanza, StanzaFilter replyFilter)` Send a stanza asynchronously, waiting for exactly one response stanza using the given reply filter.
`<S extends Stanza> SmackFuture<S,java.lang.Exception>`	`sendAsync(S stanza, StanzaFilter replyFilter, long timeout)` Send a stanza asynchronously, waiting for exactly one response stanza using the given reply filter.
`<I extends IQ> I`	`sendIqRequestAndWaitForResponse(IQ request)` Send an IQ request and wait for the response.
`SmackFuture<IQ,java.lang.Exception>`	`sendIqRequestAsync(IQ request)` Send an IQ request asynchronously.
`SmackFuture<IQ,java.lang.Exception>`	`sendIqRequestAsync(IQ request, long timeout)` Send an IQ request asynchronously.
`abstract void`	`sendNonza(Nonza element)` Send a Nonza.
`void`	`sendStanza(Stanza stanza)` Sends the specified stanza to the server.
`protected abstract void`	`sendStanzaInternal(Stanza packet)`
`protected void`	`sendStreamOpen()`
`void`	`setFromMode(XMPPConnection.FromMode fromMode)` Set the FromMode for this connection instance.
`void`	`setMaxAsyncOperations(int maxAsyncOperations)`
`void`	`setParsingExceptionCallback(ParsingExceptionCallback callback)` Install a parsing exception callback, which will be invoked once an exception is encountered while parsing a stanza.
`void`	`setReplyTimeout(long timeout)` Set the stanza reply timeout in milliseconds.
`void`	`setUnknownIqRequestReplyMode(SmackConfiguration.UnknownIqRequestReplyMode unknownIqRequestReplyMode)` Set how Smack behaves when an unknown IQ request has been received.
`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(java.lang.String optionalHint)`
`java.lang.String`	`toString()`
`boolean`	`trySendStanza(Stanza stanza)` Try to send the given stanza.
`boolean`	`trySendStanza(Stanza stanza, long timeout, java.util.concurrent.TimeUnit unit)` Try to send the given stanza.
`IQRequestHandler`	`unregisterIQRequestHandler(IQRequestHandler iqRequestHandler)` Convenience method for `XMPPConnection.unregisterIQRequestHandler(String, String, org.jivesoftware.smack.packet.IQ.Type)`.
`IQRequestHandler`	`unregisterIQRequestHandler(java.lang.String element, java.lang.String namespace, IQ.Type type)` Unregister an IQ request handler with this connection.
`protected boolean`	`waitForClosingStreamTagFromServer()`

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

- Field Detail
  - SMACK_REACTOR
```
protected static final SmackReactor SMACK_REACTOR
```
  - connectionListeners
```
protected final java.util.Set<ConnectionListener> connectionListeners
```
    A collection of ConnectionListeners which listen for connection closing and reconnection events.
  - connectionLock
```
protected final java.util.concurrent.locks.Lock connectionLock
```
  - streamFeatures
```
protected final java.util.Map<javax.xml.namespace.QName,FullyQualifiedElement> streamFeatures
```
  - user
```
protected org.jxmpp.jid.EntityFullJid 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 java.lang.String streamId
```
    The stream ID, see RFC 6120 § 4.7.3
  - debugger
```
protected final 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.
  - tlsHandled
```
protected final SynchronizationPoint<SmackException> tlsHandled
```
  - lastFeaturesReceived
```
protected final SynchronizationPoint<SmackException> 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<XMPPException> saslFeatureReceived
```
    Set to success if the SASL feature has been received.
  - closingStreamReceived
```
protected final SynchronizationPoint<java.lang.Exception> closingStreamReceived
```
    A synchronization point which is successful if this connection has received the closing stream element from the remote end-point, i.e. the server.
  - saslAuthentication
```
protected final 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
```
  - ASYNC_BUT_ORDERED
```
protected static final AsyncButOrdered<AbstractXMPPConnection> ASYNC_BUT_ORDERED
```
  - inOrderListeners
```
protected final AsyncButOrdered<StanzaListener> inOrderListeners
```
  - host
```
protected java.lang.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.
  - authenticatedConnectionInitiallyEstablishedTimestamp
```
protected long authenticatedConnectionInitiallyEstablishedTimestamp
```
  - 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).
  - currentConnectionException
```
protected java.lang.Exception currentConnectionException
```
  - hostAddresses
```
protected java.util.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
  - getConfiguration
```
public ConnectionConfiguration getConfiguration()
```
    Get the connection configuration used by this connection.
    
    Returns:
    
    the connection configuration.
  - getXMPPServiceDomain
```
public org.jxmpp.jid.DomainBareJid getXMPPServiceDomain()
```
    Description copied from interface: XMPPConnection
    
    Returns the XMPP Domain of the service provided by the XMPP server and used for this connection. After authenticating with the server the returned value may be different.
    
    Specified by:
    
    getXMPPServiceDomain in interface XMPPConnection
    
    Returns:
    
    the XMPP domain of this XMPP session.
  - getHost
```
public java.lang.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,
                                           java.lang.InterruptedException
```
    Throws:
    
    SmackException.NotConnectedException
    
    java.lang.InterruptedException
  - trySendStanza
```
public boolean trySendStanza(Stanza stanza)
                      throws SmackException.NotConnectedException
```
    Description copied from interface: XMPPConnection
    
    Try to send the given stanza. Returns true if the stanza was successfully put into the outgoing stanza queue, otherwise, if false is returned, the stanza could not be scheduled for sending (for example because the outgoing element queue is full). Note that this means that the stanza possibly was not put onto the wire, even if true is returned, it just has been successfully scheduled for sending.
    Note: Implementations are not required to provide that functionality. In that case this method is mapped to XMPPConnection.sendStanza(Stanza) and will possibly block until the stanza could be scheduled for sending.
    
    Specified by:
    
    trySendStanza in interface XMPPConnection
    
    Parameters:
    
    stanza - the stanza to send.
    
    Returns:
    
    true if the stanza was successfully scheduled to be send, false otherwise.
    
    Throws:
    
    SmackException.NotConnectedException - if the connection is not connected.
  - trySendStanza
```
public boolean trySendStanza(Stanza stanza,
                             long timeout,
                             java.util.concurrent.TimeUnit unit)
                      throws SmackException.NotConnectedException,
                             java.lang.InterruptedException
```
    Description copied from interface: XMPPConnection
    
    Try to send the given stanza. Returns true if the stanza was successfully put into the outgoing stanza queue within the given timeout period, otherwise, if false is returned, the stanza could not be scheduled for sending (for example because the outgoing element queue is full). Note that this means that the stanza possibly was not put onto the wire, even if true is returned, it just has been successfully scheduled for sending.
    Note: Implementations are not required to provide that functionality. In that case this method is mapped to XMPPConnection.sendStanza(Stanza) and will possibly block until the stanza could be scheduled for sending.
    
    Specified by:
    
    trySendStanza in interface XMPPConnection
    
    Parameters:
    
    stanza - the stanza to send.
    
    timeout - how long to wait before giving up, in units of unit.
    
    unit - a TimeUnit determining how to interpret the timeout parameter.
    
    Returns:
    
    true if the stanza was successfully scheduled to be send, false otherwise.
    
    Throws:
    
    SmackException.NotConnectedException - if the connection is not connected.
    
    java.lang.InterruptedException - if the calling thread was interrupted.
  - sendNonza
```
public abstract void sendNonza(Nonza element)
                        throws SmackException.NotConnectedException,
                               java.lang.InterruptedException
```
    Description copied from interface: XMPPConnection
    
    Send a Nonza.
    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:
    
    sendNonza in interface XMPPConnection
    
    Parameters:
    
    element - the Nonza to send.
    
    Throws:
    
    SmackException.NotConnectedException
    
    java.lang.InterruptedException
  - 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.
  - initState
```
protected void initState()
```
  - connect
```
public AbstractXMPPConnection connect()
                               throws SmackException,
                                      java.io.IOException,
                                      XMPPException,
                                      java.lang.InterruptedException
```
    Establishes a connection to the XMPP server. 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.
    
    java.io.IOException
    
    java.lang.InterruptedException
  - connectInternal
```
protected abstract void connectInternal()
                                 throws SmackException,
                                        java.io.IOException,
                                        XMPPException,
                                        java.lang.InterruptedException
```
    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
    
    java.io.IOException
    
    XMPPException
    
    java.lang.InterruptedException
  - login
```
public void login()
           throws XMPPException,
                  SmackException,
                  java.io.IOException,
                  java.lang.InterruptedException
```
    Logs in to the server using the strongest SASL mechanism supported by the server. If more than the connection's default stanza 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.
    
    java.io.IOException - if an I/O error occurs during login.
    
    java.lang.InterruptedException
  - login
```
public void login(java.lang.CharSequence username,
                  java.lang.String password)
           throws XMPPException,
                  SmackException,
                  java.io.IOException,
                  java.lang.InterruptedException
```
    Same as login(CharSequence, String, Resourcepart), but takes the resource from the connection configuration.
    
    Parameters:
    
    username -
    
    password -
    
    Throws:
    
    XMPPException
    
    SmackException
    
    java.io.IOException
    
    java.lang.InterruptedException
    
    See Also:
    
    login()
  - login
```
public void login(java.lang.CharSequence username,
                  java.lang.String password,
                  org.jxmpp.jid.parts.Resourcepart resource)
           throws XMPPException,
                  SmackException,
                  java.io.IOException,
                  java.lang.InterruptedException
```
    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
    
    java.io.IOException
    
    java.lang.InterruptedException
    
    See Also:
    
    login()
  - loginInternal
```
protected abstract void loginInternal(java.lang.String username,
                                      java.lang.String password,
                                      org.jxmpp.jid.parts.Resourcepart resource)
                               throws XMPPException,
                                      SmackException,
                                      java.io.IOException,
                                      java.lang.InterruptedException
```
    Throws:
    
    XMPPException
    
    SmackException
    
    java.io.IOException
    
    java.lang.InterruptedException
  - 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 org.jxmpp.jid.EntityFullJid 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 java.lang.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 org.jxmpp.jid.parts.Resourcepart bindResourceAndEstablishSession(org.jxmpp.jid.parts.Resourcepart resource)
                                                                    throws XMPPException.XMPPErrorException,
                                                                           SmackException,
                                                                           java.lang.InterruptedException
```
    Throws:
    
    XMPPException.XMPPErrorException
    
    SmackException
    
    java.lang.InterruptedException
  - afterSuccessfulLogin
```
protected void afterSuccessfulLogin(boolean resumed)
                             throws SmackException.NotConnectedException,
                                    java.lang.InterruptedException
```
    Throws:
    
    SmackException.NotConnectedException
    
    java.lang.InterruptedException
  - 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.
  - getUsedSaslMechansism
```
public final java.lang.String getUsedSaslMechansism()
```
    Get the name of the SASL mechanism that was used to authenticate this connection. This returns the name of mechanism which was used the last time this connection was authenticated, and will return null if this connection was not authenticated before.
    
    Returns:
    
    the name of the used SASL mechanism.
    
    Since:
    
    4.2
  - populateHostAddresses
```
protected java.util.List<HostAddress> populateHostAddresses()
```
    Populates hostAddresses with the resolved addresses or with the configured host address. If no host address was configured and all lookups failed, for example with NX_DOMAIN, then hostAddresses will be populated with the empty list.
    
    Returns:
    
    a list of host addresses where DNS (SRV) RR resolution failed.
  - getConnectionLock
```
protected java.util.concurrent.locks.Lock getConnectionLock()
```
  - throwNotConnectedExceptionIfAppropriate
```
protected void throwNotConnectedExceptionIfAppropriate()
                                                throws SmackException.NotConnectedException
```
    Throws:
    
    SmackException.NotConnectedException
  - throwNotConnectedExceptionIfAppropriate
```
protected void throwNotConnectedExceptionIfAppropriate(java.lang.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
  - sendStanza
```
public final void sendStanza(Stanza stanza)
                      throws SmackException.NotConnectedException,
                             java.lang.InterruptedException
```
    Description copied from interface: XMPPConnection
    
    Sends the specified stanza to the server.
    
    Specified by:
    
    sendStanza in interface XMPPConnection
    
    Parameters:
    
    stanza - the stanza to send.
    
    Throws:
    
    SmackException.NotConnectedException - if the connection is not connected.
    
    java.lang.InterruptedException
  - 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 is set with online information, but most XMPP servers will deliver the full presence stanza with whatever data is set.
    
    Parameters:
    
    unavailablePresence - the optional presence stanza to send during shutdown.
    
    Throws:
    
    SmackException.NotConnectedException
  - notifyConnectionError
```
protected final void notifyConnectionError(java.lang.Exception exception)
```
    Sends out a notification that there was an error with the connection and closes the connection.
    
    Parameters:
    
    exception - the exception that causes the connection close event.
  - instantShutdown
```
public abstract void instantShutdown()
```
    Performs an unclean disconnect and shutdown of the connection. Does not send a closing stream stanza.
  - shutdown
```
protected abstract void shutdown()
```
    Shuts the current connection down.
  - waitForClosingStreamTagFromServer
```
protected final boolean waitForClosingStreamTagFromServer()
```
  - 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.
  - sendIqRequestAndWaitForResponse
```
public <I extends IQ> I sendIqRequestAndWaitForResponse(IQ request)
                                                 throws SmackException.NoResponseException,
                                                        XMPPException.XMPPErrorException,
                                                        SmackException.NotConnectedException,
                                                        java.lang.InterruptedException
```
    Description copied from interface: XMPPConnection
    
    Send an IQ request and wait for the response.
    
    Specified by:
    
    sendIqRequestAndWaitForResponse in interface XMPPConnection
    
    Parameters:
    
    request - the IQ request
    
    Returns:
    
    an IQ with type 'result'
    
    Throws:
    
    SmackException.NoResponseException
    
    XMPPException.XMPPErrorException
    
    SmackException.NotConnectedException
    
    java.lang.InterruptedException
  - createStanzaCollectorAndSend
```
public StanzaCollector createStanzaCollectorAndSend(IQ packet)
                                             throws SmackException.NotConnectedException,
                                                    java.lang.InterruptedException
```
    Description copied from interface: XMPPConnection
    
    Creates a new stanza collector collecting IQ responses that are replies to the IQ request. Does also send the request IQ. The stanza filter for the collector is an IQReplyFilter, guaranteeing that stanza id and JID in the 'from' address have expected values.
    
    Specified by:
    
    createStanzaCollectorAndSend in interface XMPPConnection
    
    Parameters:
    
    packet - the IQ request to filter responses from
    
    Returns:
    
    a new stanza collector.
    
    Throws:
    
    SmackException.NotConnectedException
    
    java.lang.InterruptedException
  - createStanzaCollectorAndSend
```
public StanzaCollector createStanzaCollectorAndSend(StanzaFilter packetFilter,
                                                    Stanza packet)
                                             throws SmackException.NotConnectedException,
                                                    java.lang.InterruptedException
```
    Description copied from interface: XMPPConnection
    
    Creates a new stanza collector for this connection. A stanza filter determines which stanzas will be accumulated by the collector. A StanzaCollector is more suitable to use than a StanzaListener when you need to wait for a specific result.
    
    Specified by:
    
    createStanzaCollectorAndSend in interface XMPPConnection
    
    Parameters:
    
    packetFilter - the stanza filter to use.
    
    packet - the stanza to send right after the collector got created
    
    Returns:
    
    a new stanza collector.
    
    Throws:
    
    SmackException.NotConnectedException
    
    java.lang.InterruptedException
  - createStanzaCollector
```
public StanzaCollector createStanzaCollector(StanzaFilter packetFilter)
```
    Description copied from interface: XMPPConnection
    
    Creates a new stanza collector for this connection. A stanza filter determines which stanzas will be accumulated by the collector. A StanzaCollector is more suitable to use than a StanzaListener when you need to wait for a specific result.
    Note: If you send a Stanza right after using this method, then consider using XMPPConnection.createStanzaCollectorAndSend(StanzaFilter, Stanza) instead. Otherwise make sure cancel the StanzaCollector in every case, e.g. even if an exception is thrown, or otherwise you may leak the StanzaCollector.
    
    Specified by:
    
    createStanzaCollector in interface XMPPConnection
    
    Parameters:
    
    packetFilter - the stanza filter to use.
    
    Returns:
    
    a new stanza collector.
  - createStanzaCollector
```
public StanzaCollector createStanzaCollector(StanzaCollector.Configuration configuration)
```
    Description copied from interface: XMPPConnection
    
    Create a new stanza collector with the given stanza collector configuration.
    Please make sure to cancel the collector when it is no longer required. See also XMPPConnection.createStanzaCollector(StanzaFilter).
    
    Specified by:
    
    createStanzaCollector in interface XMPPConnection
    
    Parameters:
    
    configuration - the stanza collector configuration.
    
    Returns:
    
    a new stanza collector.
  - removeStanzaCollector
```
public void removeStanzaCollector(StanzaCollector collector)
```
    Description copied from interface: XMPPConnection
    
    Remove a stanza collector of this connection.
    
    Specified by:
    
    removeStanzaCollector in interface XMPPConnection
    
    Parameters:
    
    collector - a stanza collectors which was created for this connection.
  - addStanzaListener
```
public final void addStanzaListener(StanzaListener stanzaListener,
                                    StanzaFilter stanzaFilter)
```
    Description copied from interface: XMPPConnection
    
    Registers a stanza listener with this connection. The listener will be invoked when a (matching) incoming stanza is received. The stanza filter determines which stanzas will be delivered to the listener. It is guaranteed that the same listener will not be invoked concurrently and the the order of invocation will reflect the order in which the stanzas have been received. If the same stanza listener is added again with a different filter, only the new filter will be used.
    
    Specified by:
    
    addStanzaListener in interface XMPPConnection
    
    Parameters:
    
    stanzaListener - the stanza listener to notify of new received stanzas.
    
    stanzaFilter - the stanza filter to use.
  - removeStanzaListener
```
public final boolean removeStanzaListener(StanzaListener stanzaListener)
```
    Description copied from interface: XMPPConnection
    
    Removes a stanza listener for received stanzas from this connection.
    
    Specified by:
    
    removeStanzaListener in interface XMPPConnection
    
    Parameters:
    
    stanzaListener - the stanza listener to remove.
    
    Returns:
    
    true if the stanza listener was removed.
  - addSyncStanzaListener
```
public void addSyncStanzaListener(StanzaListener packetListener,
                                  StanzaFilter packetFilter)
```
    Description copied from interface: XMPPConnection
    
    Registers a synchronous stanza listener with this connection. A stanza listener will be invoked only when an incoming stanza is received. A stanza filter determines which stanzas will be delivered to the listener. If the same stanza listener is added again with a different filter, only the new filter will be used.
    Important: This stanza listeners will be called in the same single thread that processes all incoming stanzas. Only use this kind of stanza 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 stanzas. If the order of the arriving stanzas, consider using a StanzaCollector when possible.
    
    Specified by:
    
    addSyncStanzaListener in interface XMPPConnection
    
    Parameters:
    
    packetListener - the stanza listener to notify of new received stanzas.
    
    packetFilter - the stanza filter to use.
    
    See Also:
    
    XMPPConnection.addStanzaInterceptor(StanzaListener, StanzaFilter)
  - removeSyncStanzaListener
```
public boolean removeSyncStanzaListener(StanzaListener packetListener)
```
    Description copied from interface: XMPPConnection
    
    Removes a stanza listener for received stanzas from this connection.
    
    Specified by:
    
    removeSyncStanzaListener in interface XMPPConnection
    
    Parameters:
    
    packetListener - the stanza listener to remove.
    
    Returns:
    
    true if the stanza listener was removed
  - addAsyncStanzaListener
```
public void addAsyncStanzaListener(StanzaListener packetListener,
                                   StanzaFilter packetFilter)
```
    Description copied from interface: XMPPConnection
    
    Registers an asynchronous stanza listener with this connection. A stanza listener will be invoked only when an incoming stanza is received. A stanza filter determines which stanzas will be delivered to the listener. If the same stanza listener is added again with a different filter, only the new filter will be used.
    Unlike XMPPConnection.addAsyncStanzaListener(StanzaListener, StanzaFilter) stanza listeners added with this method will be invoked asynchronously in their own thread. Use this method if the order of the stanza listeners must not depend on the order how the stanzas where received.
    
    Specified by:
    
    addAsyncStanzaListener in interface XMPPConnection
    
    Parameters:
    
    packetListener - the stanza listener to notify of new received stanzas.
    
    packetFilter - the stanza filter to use.
    
    See Also:
    
    XMPPConnection.addStanzaInterceptor(StanzaListener, StanzaFilter)
  - removeAsyncStanzaListener
```
public boolean removeAsyncStanzaListener(StanzaListener packetListener)
```
    Description copied from interface: XMPPConnection
    
    Removes an asynchronous stanza listener for received stanzas from this connection.
    
    Specified by:
    
    removeAsyncStanzaListener in interface XMPPConnection
    
    Parameters:
    
    packetListener - the stanza listener to remove.
    
    Returns:
    
    true if the stanza listener was removed
  - addStanzaSendingListener
```
public void addStanzaSendingListener(StanzaListener packetListener,
                                     StanzaFilter packetFilter)
```
    Description copied from interface: XMPPConnection
    
    Registers a stanza listener with this connection. The listener will be notified of every stanza that this connection sends. A stanza filter determines which stanzas will be delivered to the listener. Note that the thread that writes stanzas will be used to invoke the listeners. Therefore, each stanza listener should complete all operations quickly or use a different thread for processing.
    
    Specified by:
    
    addStanzaSendingListener in interface XMPPConnection
    
    Parameters:
    
    packetListener - the stanza listener to notify of sent stanzas.
    
    packetFilter - the stanza filter to use.
  - removeStanzaSendingListener
```
public void removeStanzaSendingListener(StanzaListener packetListener)
```
    Description copied from interface: XMPPConnection
    
    Removes a stanza listener for sending stanzas from this connection.
    
    Specified by:
    
    removeStanzaSendingListener in interface XMPPConnection
    
    Parameters:
    
    packetListener - the stanza listener to remove.
  - firePacketSendingListeners
```
protected void firePacketSendingListeners(TopLevelStreamElement sendTopLevelStreamElement)
```
    Process all stanza listeners for sending stanzas.
    Compared to firePacketInterceptors(Stanza), the listeners will be invoked in a new thread.
    
    Parameters:
    
    sendTopLevelStreamElement - the top level stream element which just got send.
  - addStanzaInterceptor
```
public void addStanzaInterceptor(StanzaListener packetInterceptor,
                                 StanzaFilter packetFilter)
```
    Description copied from interface: XMPPConnection
    
    Registers a stanza interceptor with this connection. The interceptor will be invoked every time a stanza is about to be sent by this connection. Interceptors may modify the stanza to be sent. A stanza filter determines which stanzas will be delivered to the interceptor.
    NOTE: For a similar functionality on incoming stanzas, see XMPPConnection.addAsyncStanzaListener(StanzaListener, StanzaFilter).
    
    Specified by:
    
    addStanzaInterceptor in interface XMPPConnection
    
    Parameters:
    
    packetInterceptor - the stanza interceptor to notify of stanzas about to be sent.
    
    packetFilter - the stanza filter to use.
  - removeStanzaInterceptor
```
public void removeStanzaInterceptor(StanzaListener packetInterceptor)
```
    Description copied from interface: XMPPConnection
    
    Removes a stanza interceptor.
    
    Specified by:
    
    removeStanzaInterceptor in interface XMPPConnection
    
    Parameters:
    
    packetInterceptor - the stanza 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:
    
    java.lang.IllegalStateException - if the reader or writer isn't yet initialized.
    
    java.lang.IllegalArgumentException - if the SmackDebugger can't be loaded.
  - getReplyTimeout
```
public long getReplyTimeout()
```
    Description copied from interface: XMPPConnection
    
    Returns the current value of the reply timeout in milliseconds for request for this XMPPConnection instance.
    
    Specified by:
    
    getReplyTimeout in interface XMPPConnection
    
    Returns:
    
    the reply timeout in milliseconds
  - setReplyTimeout
```
public void setReplyTimeout(long timeout)
```
    Description copied from interface: XMPPConnection
    
    Set the stanza 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:
    
    setReplyTimeout in interface XMPPConnection
    
    Parameters:
    
    timeout - for a reply in milliseconds
  - setUnknownIqRequestReplyMode
```
public void setUnknownIqRequestReplyMode(SmackConfiguration.UnknownIqRequestReplyMode unknownIqRequestReplyMode)
```
    Set how Smack behaves when an unknown IQ request has been received.
    
    Parameters:
    
    unknownIqRequestReplyMode - reply mode.
  - buildNonzaCallback
```
protected final NonzaCallback.Builder buildNonzaCallback()
```
  - sendAndWaitForResponse
```
protected <SN extends Nonza,FN extends Nonza> SN sendAndWaitForResponse(Nonza nonza,
                                                                        java.lang.Class<SN> successNonzaClass,
                                                                        java.lang.Class<FN> failedNonzaClass)
                                                                 throws SmackException.NoResponseException,
                                                                        SmackException.NotConnectedException,
                                                                        java.lang.InterruptedException,
                                                                        XMPPException.FailedNonzaException
```
    Throws:
    
    SmackException.NoResponseException
    
    SmackException.NotConnectedException
    
    java.lang.InterruptedException
    
    XMPPException.FailedNonzaException
  - parseAndProcessNonza
```
protected final void parseAndProcessNonza(org.jivesoftware.smack.xml.XmlPullParser parser)
                                   throws java.io.IOException,
                                          org.jivesoftware.smack.xml.XmlPullParserException,
                                          SmackParsingException
```
    Throws:
    
    java.io.IOException
    
    org.jivesoftware.smack.xml.XmlPullParserException
    
    SmackParsingException
  - parseAndProcessStanza
```
protected void parseAndProcessStanza(org.jivesoftware.smack.xml.XmlPullParser parser)
                              throws org.jivesoftware.smack.xml.XmlPullParserException,
                                     java.io.IOException,
                                     java.lang.InterruptedException
```
    Throws:
    
    org.jivesoftware.smack.xml.XmlPullParserException
    
    java.io.IOException
    
    java.lang.InterruptedException
  - processStanza
```
protected void processStanza(Stanza stanza)
                      throws java.lang.InterruptedException
```
    Processes a stanza after it's been fully parsed by looping through the installed stanza collectors and listeners and letting them examine the stanza to see if they are a match with the filter.
    
    Parameters:
    
    stanza - the stanza to process.
    
    Throws:
    
    java.lang.InterruptedException
  - invokeStanzaCollectorsAndNotifyRecvListeners
```
protected void invokeStanzaCollectorsAndNotifyRecvListeners(Stanza packet)
```
    Invoke StanzaCollector.processStanza(Stanza) for every StanzaCollector with the given packet. Also notify the receive listeners with a matching stanza filter about the packet.
    This method will be invoked by the connections incoming processing thread which may be shared across multiple connections and thus it is important that no user code, e.g. in form of a callback, is invoked by this method. For the same reason, this method must not block for an extended period of time.
    
    Parameters:
    
    packet - the stanza to notify the StanzaCollectors 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)
```
  - 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
  - parseFeatures
```
protected final void parseFeatures(org.jivesoftware.smack.xml.XmlPullParser parser)
                            throws org.jivesoftware.smack.xml.XmlPullParserException,
                                   java.io.IOException,
                                   SmackParsingException
```
    Throws:
    
    org.jivesoftware.smack.xml.XmlPullParserException
    
    java.io.IOException
    
    SmackParsingException
  - parseFeaturesAndNotify
```
protected final void parseFeaturesAndNotify(org.jivesoftware.smack.xml.XmlPullParser parser)
                                     throws java.lang.Exception
```
    Throws:
    
    java.lang.Exception
  - afterFeaturesReceived
```
protected void afterFeaturesReceived()
                              throws SmackException.SecurityRequiredException,
                                     SmackException.NotConnectedException,
                                     java.lang.InterruptedException
```
    Throws:
    
    SmackException.SecurityRequiredException
    
    SmackException.NotConnectedException
    
    java.lang.InterruptedException
  - getFeature
```
public <F extends FullyQualifiedElement> F getFeature(java.lang.String element,
                                                      java.lang.String namespace)
```
    Description copied from interface: XMPPConnection
    
    Get the feature stanza 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
    
    Type Parameters:
    
    F - ExtensionElement type of the feature.
    
    Returns:
    
    a stanza extensions of the feature or null
  - hasFeature
```
public boolean hasFeature(java.lang.String element,
                          java.lang.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.
  - addStreamFeature
```
protected void addStreamFeature(FullyQualifiedElement feature)
```
  - sendIqRequestAsync
```
public SmackFuture<IQ,java.lang.Exception> sendIqRequestAsync(IQ request)
```
    Description copied from interface: XMPPConnection
    
    Send an IQ request asynchronously. The connection's default reply timeout will be used.
    
    Specified by:
    
    sendIqRequestAsync in interface XMPPConnection
    
    Parameters:
    
    request - the IQ request to send.
    
    Returns:
    
    a SmackFuture for the response.
  - sendIqRequestAsync
```
public SmackFuture<IQ,java.lang.Exception> sendIqRequestAsync(IQ request,
                                                              long timeout)
```
    Description copied from interface: XMPPConnection
    
    Send an IQ request asynchronously.
    
    Specified by:
    
    sendIqRequestAsync in interface XMPPConnection
    
    Parameters:
    
    request - the IQ request to send.
    
    timeout - the reply timeout in milliseconds.
    
    Returns:
    
    a SmackFuture for the response.
  - sendAsync
```
public <S extends Stanza> SmackFuture<S,java.lang.Exception> sendAsync(S stanza,
                                                                       StanzaFilter replyFilter)
```
    Description copied from interface: XMPPConnection
    
    Send a stanza asynchronously, waiting for exactly one response stanza using the given reply filter. The connection's default reply timeout will be used.
    
    Specified by:
    
    sendAsync in interface XMPPConnection
    
    Parameters:
    
    stanza - the stanza to send.
    
    replyFilter - the filter used for the response stanza.
    
    Returns:
    
    a SmackFuture for the response.
  - sendAsync
```
public <S extends Stanza> SmackFuture<S,java.lang.Exception> sendAsync(S stanza,
                                                                       StanzaFilter replyFilter,
                                                                       long timeout)
```
    Description copied from interface: XMPPConnection
    
    Send a stanza asynchronously, waiting for exactly one response stanza using the given reply filter.
    
    Specified by:
    
    sendAsync in interface XMPPConnection
    
    Parameters:
    
    stanza - the stanza to send.
    
    replyFilter - the filter used for the response stanza.
    
    timeout - the reply timeout in milliseconds.
    
    Returns:
    
    a SmackFuture for the response.
  - 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 filter.
    
    Specified by:
    
    addOneTimeSyncCallback in interface XMPPConnection
    
    Parameters:
    
    callback - the callback invoked once the stanza 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(java.lang.String element,
                                                   java.lang.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
  - getAuthenticatedConnectionInitiallyEstablishedTimestamp
```
public final long getAuthenticatedConnectionInitiallyEstablishedTimestamp()
```
    Get the timestamp when the connection was the first time authenticated, i.e., when the first successful login was performed. Note that this value is not reset on disconnect, so it represents the timestamp from the last authenticated connection. The value is also not reset on stream resumption.
    
    Returns:
    
    the timestamp or null.
    
    Since:
    
    4.3.3
  - 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
  - toString
```
public final java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object
  - asyncGoLimited
```
protected void asyncGoLimited(java.lang.Runnable runnable)
```
  - setMaxAsyncOperations
```
public void setMaxAsyncOperations(int maxAsyncOperations)
```
  - asyncGo
```
protected static void asyncGo(java.lang.Runnable runnable)
```
  - schedule
```
protected static ScheduledAction schedule(java.lang.Runnable runnable,
                                          long delay,
                                          java.util.concurrent.TimeUnit unit)
```
  - onStreamOpen
```
protected void onStreamOpen(org.jivesoftware.smack.xml.XmlPullParser parser)
```
  - sendStreamOpen
```
protected void sendStreamOpen()
                       throws SmackException.NotConnectedException,
                              java.lang.InterruptedException
```
    Throws:
    
    SmackException.NotConnectedException
    
    java.lang.InterruptedException
  - getSmackTlsContext
```
protected final AbstractXMPPConnection.SmackTlsContext getSmackTlsContext()
                                                                   throws java.security.KeyManagementException,
                                                                          java.security.NoSuchAlgorithmException,
                                                                          java.security.cert.CertificateException,
                                                                          java.io.IOException,
                                                                          java.security.UnrecoverableKeyException,
                                                                          java.security.KeyStoreException,
                                                                          java.security.NoSuchProviderException
```
    Throws:
    
    java.security.KeyManagementException
    
    java.security.NoSuchAlgorithmException
    
    java.security.cert.CertificateException
    
    java.io.IOException
    
    java.security.UnrecoverableKeyException
    
    java.security.KeyStoreException
    
    java.security.NoSuchProviderException

Class AbstractXMPPConnection

Parsing Exceptions

Managing the parsing exception callback

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

SMACK_REACTOR

connectionListeners

connectionLock

streamFeatures

user

connected

streamId

debugger

reader

writer

tlsHandled

lastFeaturesReceived

saslFeatureReceived

closingStreamReceived

saslAuthentication

connectionCounterValue

config

compressionHandler

ASYNC_BUT_ORDERED

inOrderListeners

host

port

authenticated

authenticatedConnectionInitiallyEstablishedTimestamp

wasAuthenticated

currentConnectionException

hostAddresses

Constructor Detail

AbstractXMPPConnection

Method Detail

getConfiguration

getXMPPServiceDomain

getHost

getPort

isSecureConnection

sendStanzaInternal

trySendStanza

trySendStanza

sendNonza

isUsingCompression

initState

connect

connectInternal

login

login

login

loginInternal

isConnected

isAuthenticated

getUser

getStreamId

bindResourceAndEstablishSession

afterSuccessfulLogin

isAnonymous

getUsedSaslMechansism

populateHostAddresses

getConnectionLock

throwNotConnectedExceptionIfAppropriate

throwNotConnectedExceptionIfAppropriate

throwAlreadyConnectedExceptionIfAppropriate

throwAlreadyLoggedInExceptionIfAppropriate

sendStanza

getSASLAuthentication

disconnect

disconnect

notifyConnectionError

instantShutdown

shutdown

waitForClosingStreamTagFromServer

addConnectionListener