ie.omk.smpp
Class Connection

java.lang.Object
  extended by ie.omk.smpp.Connection
All Implemented Interfaces:
Runnable

public class Connection
extends Object
implements Runnable

SMPP client connection (ESME). An SMPP Connection represents any kind of connection to the SMSC, be it a transmitter, receiver or transceiver. It also supports both synchronous and asynchronous modes of communication. Synchronous mode is only useful for very simple applications that use single-threading. Asynchronous mode is recommended for more complex applications, especially those that will be running many threads.

Important Note : if you wish to use synchronous mode in a multi-threaded environment, it is the application's responsiblity to ensure there is only one thread executing a call to either or both of the sendRequest and readNextPacket methods. If there are concurrent calls to these methods executing, there is a strong possibility of the incorrect packet being returned in a particular thread and both the API and the application getting confused. These are the only methods that contain such a race condition.

Version:
$Id: Connection.java 467 2009-06-16 13:38:16Z orank $
Author:
Oran Kelly

Field Summary
protected  boolean ackDeliverSm
          Automatically acknowledge incoming deliver_sm messages.
protected  boolean ackQryLinks
          Specify whether the listener thread will automatically ack enquire_link primitives received from the Smsc
protected  boolean asyncComms
          Is the user using synchronous are async communication?.
static int BINDING
          Connection state: waiting for successful acknowledgement to bind request.
static int BOUND
          Connection state: bound to the SMSC.
protected  AlphabetEncoding defaultAlphabet
          The default alphabet to use for this connection.
protected  SMPPVersion interfaceVersion
          SMPP protocol version number.
static int RECEIVER
          SMPP Receiver connection type.
protected  boolean supportOptionalParams
          Does the remote end support optional parameters? According to the SMPPv3.4 specification, if the SMSC does not return the sc_interface_version optional parameter in its bind response packet, then we must assume it does not support optional parameters.
static int TRANSCEIVER
          SMPP Transciever connection type.
static int TRANSMITTER
          SMPP Transmitter connection type.
static int UNBINDING
          Connection state: waiting for successful acknowledgement to unbind request or waiting for application to respond to unbind request.
static int UNBOUND
          Connection state: not bound to the SMSC.
 
Constructor Summary
Connection(SmscLink link)
          Initialise a new SMPP connection object.
Connection(SmscLink link, boolean async)
          Initialise a new SMPP connection object, specifying the type of communication desired.
Connection(String host, int port)
          Initialise a new SMPP connection object.
Connection(String host, int port, boolean async)
          Initialise a new SMPP connection object.
 
Method Summary
 void ackDeliverSm(DeliverSM rq)
          Acknowledge a DeliverSM command received from the Smsc.
 void ackEnquireLink(EnquireLink rq)
          Acknowledge an EnquireLink received from the Smsc
 void ackLinkQuery(EnquireLink el)
          Deprecated. #ackEnquireLink
 void addObserver(ConnectionObserver ob)
          Add a connection observer to receive SMPP events from this connection.
 void autoAckLink(boolean b)
          Set the behaviour of automatically acking ENQUIRE_LINK's from the SMSC (only valid in asynchronous mode).
 void autoAckMessages(boolean b)
          Set the behaviour of automatically acking Deliver_Sm's from the Smsc (only valid in asynchronous mode).
 BindResp bind(int type, String systemID, String password, String systemType)
          Bind this connection to the SMSC.
 BindResp bind(int type, String systemID, String password, String systemType, int typeOfNum, int numberPlan, String addrRange)
          Bind this connection to the SMSC.
 void closeLink()
          Close the underlying network link to the SMSC.
 EnquireLinkResp enquireLink()
          Do a confidence check on the SMPP link to the SMSC.
 void force_unbind()
          Force the SMPP connection down.
 int getConnectionType()
          Get the type of this SMPP connection.
 AlphabetEncoding getDefaultAlphabet()
          Get the current alphabet this Connection is using as its default.
 SMPPVersion getInterfaceVersion()
          Get the interface version.
 SequenceNumberScheme getSeqNumScheme()
          Get the current sequence numbering scheme object being used by this connection.
 int getState()
          Get the current state of the ESME.
 SMPPVersion getVersion()
          Get the SMPP version in use by this connection.
 boolean isAckingLinks()
          Check is this connection automatically acking Enquire link requests in asynchronous mode.
 boolean isAckingMessages()
          Check is this connection automatically acking delivered messages
 boolean isBound()
          Report whether the connection is bound or not.
 SMPPPacket newInstance(int commandId)
          Get a new instance of an SMPP packet.
protected  void openLink()
          Method to open the link to the SMSC.
 int packetAvailable()
          Determine if there are packets available for reading using readNextPacket.
 SMPPPacket readNextPacket()
          Read in the next packet from the SMSC link.
 void removeObserver(ConnectionObserver ob)
          Remove a connection observer from this Connection.
 void reset()
          Reset this connection's sequence numbering to the beginning.
 void run()
          Listener thread method for asynchronous communication.
 SMPPResponse sendRequest(SMPPRequest request)
          Send an smpp request to the SMSC.
protected  SMPPResponse sendRequestInternal(SMPPRequest r)
          Send a request to the SMSC.
 void sendResponse(SMPPResponse resp)
          Send an smpp response packet to the SMSC
 void setDefaultAlphabet(AlphabetEncoding alphabet)
          Set the default alphabet of the SMSC this Connection is communicating with.
 void setEventDispatcher(EventDispatcher eventDispatcher)
          Set the event dispatcher for this connection object.
 void setInterfaceVersion(SMPPVersion interfaceVersion)
          Set the desired interface version for this connection.
 void setSeqNumScheme(SequenceNumberScheme scheme)
          Set the sequence numbering scheme for this connection.
 void setVersion(SMPPVersion version)
          Set the SMPP version this connection will use.
 UnbindResp unbind()
          Unbind from the SMSC.
 void unbind(UnbindResp ubr)
          Unbind from the SMSC.
protected  SMPPResponse waitForResponsePacket(SMPPPacket req)
          Wait for a response packet from the SMSC.
 
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 

Field Detail

TRANSMITTER

public static final int TRANSMITTER
SMPP Transmitter connection type.

See Also:
Constant Field Values

RECEIVER

public static final int RECEIVER
SMPP Receiver connection type.

See Also:
Constant Field Values

TRANSCEIVER

public static final int TRANSCEIVER
SMPP Transciever connection type.

See Also:
Constant Field Values

UNBOUND

public static final int UNBOUND
Connection state: not bound to the SMSC.

See Also:
Constant Field Values

BINDING

public static final int BINDING
Connection state: waiting for successful acknowledgement to bind request.

See Also:
Constant Field Values

BOUND

public static final int BOUND
Connection state: bound to the SMSC.

See Also:
Constant Field Values

UNBINDING

public static final int UNBINDING
Connection state: waiting for successful acknowledgement to unbind request or waiting for application to respond to unbind request.

See Also:
Constant Field Values

interfaceVersion

protected SMPPVersion interfaceVersion
SMPP protocol version number.


supportOptionalParams

protected boolean supportOptionalParams
Does the remote end support optional parameters? According to the SMPPv3.4 specification, if the SMSC does not return the sc_interface_version optional parameter in its bind response packet, then we must assume it does not support optional parameters.


ackQryLinks

protected boolean ackQryLinks
Specify whether the listener thread will automatically ack enquire_link primitives received from the Smsc


ackDeliverSm

protected boolean ackDeliverSm
Automatically acknowledge incoming deliver_sm messages. Only valid for the Receiver


asyncComms

protected boolean asyncComms
Is the user using synchronous are async communication?.


defaultAlphabet

protected AlphabetEncoding defaultAlphabet
The default alphabet to use for this connection.

Constructor Detail

Connection

public Connection(String host,
                  int port)
           throws UnknownHostException
Initialise a new SMPP connection object. This is a convenience constructor that will create a new TcpLinkobject using the host name and port provided. The connection created will use synchronous communications.

Parameters:
host - the hostname of the SMSC.
port - the port to connect to. If 0, use the default SMPP port number.
Throws:
UnknownHostException

Connection

public Connection(String host,
                  int port,
                  boolean async)
           throws UnknownHostException
Initialise a new SMPP connection object. This is a convenience constructor that will create a new TcpLinkobject using the host name and port provided.

Parameters:
host - the hostname of the SMSC.
port - the port to connect to. If 0, use the default SMPP port number.
async - true for asyncronous communication, false for synchronous.
Throws:
UnknownHostException

Connection

public Connection(SmscLink link)
Initialise a new SMPP connection object. The connection will use synchronous communications.

Parameters:
link - The network link object to the Smsc (cannot be null)

Connection

public Connection(SmscLink link,
                  boolean async)
Initialise a new SMPP connection object, specifying the type of communication desired. See the Connectionclass description for some required knowledge on using the Connection in syncrhonous mode.

Parameters:
link - The network link object to the Smsc (cannot be null)
async - true for asyncronous communication, false for synchronous.
Method Detail

setDefaultAlphabet

public void setDefaultAlphabet(AlphabetEncoding alphabet)
Set the default alphabet of the SMSC this Connection is communicating with. Each SMSC has its own default alphabet it uses. When messages arrive and announce themselves with a data coding value of zero, that means the message is encoded in the SMSC's default alphabet. The smppapi assumes the GSM default alphabet as it's default alphabet. By setting the default alphabet on the Connection all packets returned by newInstance(int)will use the Connection's default alphabet plus any packets read from the wire with a data coding value of zero will have their default alphabet initialised appropriately.

Parameters:
alphabet - the alphabet to use as the default for this connection (may be null in which case the API falls back to using its own internal default).

getDefaultAlphabet

public AlphabetEncoding getDefaultAlphabet()
Get the current alphabet this Connection is using as its default.

Returns:
the default alphabet for this Connection.

setVersion

public void setVersion(SMPPVersion version)
                throws VersionException
Set the SMPP version this connection will use. Setting the version is only a valid operation before the connection is bound. Any attempt to set the version after binding to the SMSC will result in an exception being thrown.

Parameters:
version - the SMPP version to use.
Throws:
VersionException - if an attempt is made to set the version of the connection after binding to the SMSC.
See Also:
SMPPVersion

getVersion

public SMPPVersion getVersion()
Get the SMPP version in use by this connection. The version in use by the connection may be different to that specified before the bind operation as binding to the SMSC may result in an alternative SMPP version being negotiated. For instance, if the client sends a bind packet to the SMSC specifying that it supports SMPP version 3.4 but the SMSC returns a bind_resp stating it supports version 3.3, the Connection automatically sets it's internal version to use down to 3.3.


getState

public int getState()
Get the current state of the ESME. One of UNBOUND, BINDING, BOUND or UNBINDING.


openLink

protected void openLink()
                 throws IOException
Method to open the link to the SMSC. This method will connect the underlying SmscLink object if necessary and reset the sequence numbering scheme to the beginning.

Throws:
IOException - if an i/o error occurs while opening the connection.

closeLink

public void closeLink()
               throws IOException
Close the underlying network link to the SMSC. This method calls the underlying link's close method to actually shutdown the network connection to the SMSC.

Throws:
ie.omk.smpp.IllegalStateException - if an attempt is made to close the connection while bound to the SMSC.
IOException - if an I/O exception occurs while trying to close the link.
See Also:
SmscLink.close()

getInterfaceVersion

public SMPPVersion getInterfaceVersion()
Get the interface version.

See Also:
setInterfaceVersion(SMPPVersion)

setInterfaceVersion

public void setInterfaceVersion(SMPPVersion interfaceVersion)
Set the desired interface version for this connection. The default version is 3.4. The bind operation may negotiate an eariler version of the protocol if the SC does not understand the version sent by the ESME. This API will not support any version eariler than SMPP v3.3. The interface version is encoded as follows:
SMPP version Version value
v3.4 0x34
v3.3 0x33
All other values reserved.


autoAckLink

public void autoAckLink(boolean b)
Set the behaviour of automatically acking ENQUIRE_LINK's from the SMSC (only valid in asynchronous mode). By default, the listener thread will automatically ack an enquire_link message from the Smsc so as not to lose the connection. This can be turned off with this method.

Any attempt to enable this setting in synchronous mode will be silently ignored.

Parameters:
b - true to activate automatic acknowledgment, false to disable

autoAckMessages

public void autoAckMessages(boolean b)
Set the behaviour of automatically acking Deliver_Sm's from the Smsc (only valid in asynchronous mode). By default the listener thread will not acknowledge a message. Applications which are using the synchronous mode of communication will always have to handle enquire link requests themselves.

Any attempt to enable this setting in synchronous mode will be silently ignored.

Parameters:
b - true to activate this function, false to deactivate.

isAckingLinks

public boolean isAckingLinks()
Check is this connection automatically acking Enquire link requests in asynchronous mode.


isAckingMessages

public boolean isAckingMessages()
Check is this connection automatically acking delivered messages


ackDeliverSm

public void ackDeliverSm(DeliverSM rq)
                  throws IOException
Acknowledge a DeliverSM command received from the Smsc.

Parameters:
rq - The deliver_sm request to respond to.
Throws:
IOException - If an I/O error occurs writing the response packet to the network connection.

sendRequest

public SMPPResponse sendRequest(SMPPRequest request)
                         throws SocketTimeoutException,
                                IOException,
                                AlreadyBoundException,
                                VersionException,
                                SMPPProtocolException,
                                UnsupportedOperationException
Send an smpp request to the SMSC. No fields in the SMPPRequest packet will be altered except possibly the sequence number. The sequence number will be assigned the next number as defined by this Connection's sequence numbering scheme. If the sequence numbering scheme class is null for this Connection, no number will be assigned. By default, the DefaultSequenceSchemeclass is used to assign sequence numbers to packets.
IMPORTANT : You must use the bind and unbind methods to carry out those operations. Attempting to send an bind or unbind packet using this method will result in an UnsupportedOperationException being thrown.

Parameters:
request - The request packet to send to the SMSC
Returns:
The response packet returned by the SMSC, or null if asynchronous communication is being used.
Throws:
NullPointerException - if r is null.
SocketTimeoutException - If a socket timeout occurs while waiting for a response packet. (Only in synchronized mode).
IOException - If an I/O error occurs while writing the request packet to the network connection.
UnsupportedOperationException - If this connection type does not support operation r. For example, a receiver link does not support the submit_sm operation.
AlreadyBoundException - If the request type is a bind packet and this connection is already bound.
SMPPProtocolException - If synchronous communications is in use and the incoming response packet violates the SMPP specification, this exception will be thrown.
VersionException
See Also:
setSeqNumScheme(ie.omk.smpp.util.SequenceNumberScheme)

sendRequestInternal

protected SMPPResponse sendRequestInternal(SMPPRequest r)
                                    throws SocketTimeoutException,
                                           IOException,
                                           AlreadyBoundException,
                                           VersionException,
                                           SMPPProtocolException
Send a request to the SMSC.

Throws:
VersionException - if the version in use does not support the request being sent.
SocketTimeoutException
IOException
AlreadyBoundException
SMPPProtocolException

waitForResponsePacket

protected SMPPResponse waitForResponsePacket(SMPPPacket req)
                                      throws SocketTimeoutException,
                                             IOException,
                                             SMPPProtocolException
Wait for a response packet from the SMSC. A response packet with the same sequence number as req will be waited for from the SMSC. If an unexpected packet arrives, either a response packet with a different sequence number or a request packet, it will be queued for later retrieval by the application via readNextPacket.

Parameters:
req - the request packet to wait for a response to.
Returns:
A response packet with the same sequence number as req.
Throws:
SocketTimeoutException - if the read on the socket times out.
IOException
SMPPProtocolException
See Also:
readNextPacket(), SocketTimeoutException

packetAvailable

public int packetAvailable()
Determine if there are packets available for reading using readNextPacket. This method is only valid for synchronous communications...it will always return 0 if asynchronous mode is in use.

Returns:
0 if there is no packet available for reading, 1 if there is data available but the call to readNextPacket may block or 2 if there is a full packet available.

sendResponse

public void sendResponse(SMPPResponse resp)
                  throws IOException
Send an smpp response packet to the SMSC

Parameters:
resp - The response packet to send to the SMSC
Throws:
IOException - If an I/O error occurs while writing the response packet to the output stream.

bind

public BindResp bind(int type,
                     String systemID,
                     String password,
                     String systemType)
              throws IOException,
                     InvalidParameterValueException,
                     IllegalArgumentException,
                     AlreadyBoundException,
                     VersionException,
                     SMPPProtocolException
Bind this connection to the SMSC. Calling this method is the equivalent of calling
bind(type, systemID, password, systemType, 0, 0, null);.

Throws:
IOException
InvalidParameterValueException
IllegalArgumentException
AlreadyBoundException
VersionException
SMPPProtocolException
See Also:
bind(int, String, String, String, int, int, String)

bind

public BindResp bind(int type,
                     String systemID,
                     String password,
                     String systemType,
                     int typeOfNum,
                     int numberPlan,
                     String addrRange)
              throws IOException,
                     InvalidParameterValueException,
                     IllegalArgumentException,
                     AlreadyBoundException,
                     VersionException,
                     SMPPProtocolException
Bind this connection to the SMSC. An application must bind to an SMSC as one of transmitter, receiver or transceiver. Binding as transmitter allows general manipulation of messages at the SMSC including submitting messages for delivery, cancelling, replacing and querying the state of previously submitted messages. Binding as a receiver allows an application to receive all messages previously queued for delivery to it's address. The transceiver mode, which was added in version 3.4 of the SMPP protocol, combines the functionality of both transmitter and receiver into one connection type.

The connection object will negotiate the appropriate version for the protocol link at bind time. If the SMSC returns the SC_INTERFACE_VERSION optional parameter in its bind response packet, the Connection will read it. If the version stated by the SMSC is older than the current version setting of the Connection then the Connection's version will be downgraded to that of the SMSC's. Otherwise, the current version will be left alone.

If an SMSC does not supply the SC_INTERFACE_VERSION in its bind response, then the Connection object will assume that the SMSC does not support optional parameters. This behaviour is required by the SMPP v3.4 specification.

Note that it is only necessary to supply values for type, systemID and password. The other arguments may be left at null (or zero, as applicable) and the SMSC will use default values for them.

Parameters:
type - connection type to use, either TRANSMITTER, RECEIVERor TRANSCEIVER.
systemID - the system ID to identify as to the SMSC.
password - password to use to authenticate to the SMSC.
systemType - the system type to bind as.
Returns:
the bind response packet.
Throws:
IllegalArgumentException - if a bad type value is supplied.
ie.omk.smpp.VersionException - if an attempt is made to bind as transceiver while using SMPP version 3.3.
ie.omk.smpp.InvalidParameterValueException - If any of systemID, password, system type or address range are outside allowed bounds or the TON or NPI is invalid.
IOException - If an I/O error occurs while writing the bind packet to the output stream.
AlreadyBoundException - If the Connection is already bound.
ie.omk.smpp.SMPPProtocolExcpetion - if synchronous communication is in use and the incoming response packet violates the SMPP protocol.
InvalidParameterValueException
VersionException
SMPPProtocolException

unbind

public UnbindResp unbind()
                  throws IOException,
                         NotBoundException,
                         SMPPProtocolException
Unbind from the SMSC. This method will unbind the SMPP protocol connection from the SMSC. No further SMPP operations will be possible once unbound. If the calling application is using sync mode, it should be sure there are no incoming packets awaiting a response (check using packetAvailable()), otherwise an IllegalStateException may be thrown. Note that this method will not close the underlying network connection.

Returns:
The Unbind response packet, or null if asynchronous communication is being used.
Throws:
NotBoundException - if the connection is not yet bound.
SMPPProtocolException - If synchronous comms is in use and the incoming unbind_resp packet violates the SMPP specification, this exception is thrown.
IOException - If an I/O error occurs while writing the unbind request or reading the unbind response.

unbind

public void unbind(UnbindResp ubr)
            throws IOException,
                   SMPPException
Unbind from the SMSC. This method is used to acknowledge an unbind request from the SMSC.

Throws:
NotBoundException - if the connection is not currently bound.
AlreadyBoundException - if no unbind request has been received from the SMSC.
IOException - If an I/O error occurs while writing the response packet to the network connection.
SMPPException

force_unbind

public void force_unbind()
Force the SMPP connection down. Only use this method once it's full sure that graceful unbinding and disconnection isn't going to work. This method cleans up it's internal state, forcing the network connection closed and terminating the receiver thread if necessary.

If you end up having to use this method to terminate a Connection, it is advisable not to attempt to reuse the connection at all. Create a new object and start from scratch. Use of this method indicates something seriously wrong!


ackEnquireLink

public void ackEnquireLink(EnquireLink rq)
                    throws IOException
Acknowledge an EnquireLink received from the Smsc

Throws:
IOException - If an I/O error occurs while writing to the network connection.

enquireLink

public EnquireLinkResp enquireLink()
                            throws IOException,
                                   SMPPProtocolException
Do a confidence check on the SMPP link to the SMSC.

Returns:
The Enquire link response packet or null if asynchronous communication is in use.
Throws:
IOException - If an I/O error occurs while writing to the network connection.
SMPPProtocolException - If synchronous communications is in use and the incoming enquire_link_resp packet violates the SMPP specification, this exception is thrown.

getConnectionType

public int getConnectionType()
Get the type of this SMPP connection. The connection type is one of TRANSMITTER, RECEIVER or TRANSCEIVER.


isBound

public boolean isBound()
Report whether the connection is bound or not.

Returns:
true if the connection is bound.

reset

public void reset()
           throws AlreadyBoundException
Reset this connection's sequence numbering to the beginning. The underlying SequenceNumberScheme's reset method is called to start from that sequence's 'beginning'.

Throws:
AlreadyBoundException - if the connection is currently bound to the SMSC.

setSeqNumScheme

public void setSeqNumScheme(SequenceNumberScheme scheme)
Set the sequence numbering scheme for this connection. A sequence numbering scheme determines what sequence number each SMPP packet will have. By default, DefaultSequenceSchemeis used, which will begin with sequence number 1 and increase the number by 1 for each packet thereafter.

If the application sets the scheme to null, it is responsible for maintaining and setting the sequence number for each SMPP request it sends to the SMSC.

See Also:
SequenceNumberScheme, SMPPPacket.setSequenceNum(int)

getSeqNumScheme

public SequenceNumberScheme getSeqNumScheme()
Get the current sequence numbering scheme object being used by this connection.


readNextPacket

public SMPPPacket readNextPacket()
                          throws IOException,
                                 InvalidOperationException,
                                 SMPPProtocolException
Read in the next packet from the SMSC link. If asynchronous communications is in use, calling this method results in an SMPPException as the listener thread will be hogging the input stream of the socket connection.

Returns:
The next SMPP packet from the SMSC.
Throws:
IOException - If an I/O error occurs while reading from the network connection.
InvalidOperationException - If asynchronous comms is in use.
SMPPProtocolException - if the incoming data violates the SMPP protocol specifications.

setEventDispatcher

public void setEventDispatcher(EventDispatcher eventDispatcher)
Set the event dispatcher for this connection object. Before using the new event dispatcher, this method will call EventDispatcher.init()to initialise the dispatcher. It will then iterate through all the observers registered with the current event dispatcher and register them with the new one.

It is not a particularly good idea to set the event dispatcher after communications have begun. However, the observer copy is guarded against multi-threaded access to the current event dispatcher. During the copy, however, events will continue to be delievered via the current dispatcher. Only after the copy is complete will the new event dispatcher become the active one and events begin being delivered by it.

The caller of this method can be sure that, once this method returns, all new events will be handled by the new event dispatcher. However, there may be events that occurred before, or during the operation of, the call to this method which will be delivered by the old dispatcher. Once the new event dispatcher is in place, the EventDispatcher.destroy() method will be called on the old dispatcher.


addObserver

public void addObserver(ConnectionObserver ob)
Add a connection observer to receive SMPP events from this connection. If this connection is not using asynchronous communication, this method call has no effect.

Parameters:
ob - the ConnectionObserver implementation to add.

removeObserver

public void removeObserver(ConnectionObserver ob)
Remove a connection observer from this Connection.


run

public void run()
Listener thread method for asynchronous communication.

Specified by:
run in interface Runnable

ackLinkQuery

public void ackLinkQuery(EnquireLink el)
                  throws IOException
Deprecated. #ackEnquireLink

Throws:
IOException

newInstance

public SMPPPacket newInstance(int commandId)
                       throws BadCommandIDException,
                              VersionException
Get a new instance of an SMPP packet. The packet will be initialised so that it uses the same SMPP version as this connection and it's sequence number will be initialised to using this connection's sequence numbering scheme.

Parameters:
commandId - the SMPP command ID of the packet to retrieve.
Returns:
a subclass of SMPPPacket corresponding to SMPP command commandId.
Throws:
BadCommandIDException - if the command ID is not recognised.
ie.omk.smpp.NotSupportedException - if the Connection is currently using an SMPP version which does not support SMPP command commandId.
VersionException


Copyright © 2011 smppapi at Sourceforge. All Rights Reserved.