public Transport(Session session,
    URLName urlname) 
{
	super(session, urlname);
}

Constructor.

Parameters:

session - Session object for this Transport.

urlname - URLName object to be used for this Transport

 public synchronized  void addTransportListener(TransportListener l) 
{
                                                           
	if (transportListeners == null)
	    transportListeners = new Vector();
	transportListeners.addElement(l);
}

Add a listener for Transport events.

The default implementation provided here adds this listener to an internal list of TransportListeners.

 protected  void notifyTransportListeners(int type,
    Address[] validSent,
    Address[] validUnsent,
    Address[] invalid,
    Message msg) 
{
	if (transportListeners == null)
	    return;
	TransportEvent e = new TransportEvent(this, type, validSent, 
					      validUnsent, invalid, msg);
	queueEvent(e, transportListeners);
}

Notify all TransportListeners. Transport implementations are expected to use this method to broadcast TransportEvents.

The provided default implementation queues the event into an internal event queue. An event dispatcher thread dequeues events from the queue and dispatches them to the registered TransportListeners. Note that the event dispatching occurs in a separate thread, thus avoiding potential deadlock problems.

 public synchronized  void removeTransportListener(TransportListener l) 
{
	if (transportListeners != null)
	    transportListeners.removeElement(l);
}

Remove a listener for Transport events.

The default implementation provided here removes this listener from the internal list of TransportListeners.

 public static  void send(Message msg) throws MessagingException 
{
	msg.saveChanges(); // do this first
	send0(msg, msg.getAllRecipients());
}

Send a message. The message will be sent to all recipient addresses specified in the message (as returned from the Message method getAllRecipients), using message transports appropriate to each address. The send method calls the saveChanges method on the message before sending it.

If any of the recipient addresses is detected to be invalid by the Transport during message submission, a SendFailedException is thrown. Clients can get more detail about the failure by examining the exception. Whether or not the message is still sent succesfully to any valid addresses depends on the Transport implementation. See SendFailedException for more details. Note also that success does not imply that the message was delivered to the ultimate recipient, as failures may occur in later stages of delivery. Once a Transport accepts a message for delivery to a recipient, failures that occur later should be reported to the user via another mechanism, such as returning the undeliverable message.

Note that send is a static method that creates and manages its own connection. Any connection associated with any Transport instance used to invoke this method is ignored and not used. This method should only be invoked using the form Transport.send(msg);, and should never be invoked using an instance variable.

 public static  void send(Message msg,
    Address[] addresses) throws MessagingException 
{
	msg.saveChanges();
	send0(msg, addresses);
}

Send the message to the specified addresses, ignoring any recipients specified in the message itself. The send method calls the saveChanges method on the message before sending it.

 abstract public  void sendMessage(Message msg,
    Address[] addresses) throws MessagingException
Send the Message to the specified list of addresses. An appropriate
TransportEvent indicating the delivery status is delivered to any
TransportListener registered on this Transport. Also, if any of
the addresses is invalid, a SendFailedException is thrown.
Whether or not the message is still sent succesfully to
any valid addresses depends on the Transport implementation. 


Unlike the static send method, the sendMessage
method does not call the saveChanges method on
the message; the caller should do so.