JCAT
v0.3.1

javax.jcat
Interface JcatCall

All Superinterfaces:
JccCall

public interface JcatCall
extends JccCall

A JcatCall object extends the JccCall object . It provides advanced features such as transfer, conference etc. The JcatCall object has the same finite state machine as the JccCall object.

Since:
1.0

Field Summary
 
Fields inherited from interface javax.csapi.cc.jcc.JccCall
ACTIVE, IDLE, INVALID
 
Method Summary
 void addTerminalConnectionListener(JcatTerminalConnectionListener termconnlistener)
          Adds a JcatTerminalConnectionListener to the call.
 JcatConnection blindTransfer(java.lang.String dialledDigits)
          This method transfers all participants currently on this Call, with the exception of the transfer controller participant, to another telephone address.
 void conference(JcatCall othercall)
          Merges two JcatCalls together, resulting in the union of the participants of both calls being placed on a single JcatCall.
 JcatConnection[] connect(JcatTerminal term, JcatAddress addr, java.lang.String dialedDigits)
          Places a telephone call from an originating endpoint to a destination address string.
 JcatConnection[] consult(JcatTerminalConnection termconn, java.lang.String dialedDigits)
          Creates a consultation between this idle JcatCall and an active JcatCall.
 void consultTransfer(JcatCall otherCall)
          This method moves all participants from one JcatCall to another, with the exception of a selected common participant.
 JcatTerminalConnection getConferenceController()
          Returns the JcatTerminalConnection which currently acts as the conference controller.
 boolean getConferenceEnable()
          Return true if conferencing is enabled, false otherwise.
 JcatTerminalConnection getTransferController()
          Returns the JcatTerminalConnection which currently acts as the transfer controller.
 boolean getTransferEnable()
          Return true if transferring is enabled, false otherwise.
 void removeTerminalConnectionListener(JcatTerminalConnectionListener terminalConnectionListener)
          Removes the terminal connection listener.
 void setConferenceController(JcatTerminalConnection tc)
          Sets the JcatTerminalConnection which acts as the conference controller for the JcatCall.
 void setConferenceEnable(boolean enabled)
          Controls whether the JcatCall is permitted or able to perform the conferencing feature.
 void setTransferController(JcatTerminalConnection termconn)
          Sets the JcatTerminalConnection which acts as the transfer controller for the JcatCall.
 void setTransferEnable(boolean enable)
          Controls whether the JcatCall is permitted or able to perform the transferring feature.
 
Methods inherited from interface javax.csapi.cc.jcc.JccCall
addCallListener, addConnectionListener, connect, createConnection, getConnections, getProvider, getState, release, removeCallListener, removeConnectionListener, routeCall, superviseCall
 

Method Detail

addTerminalConnectionListener

public void addTerminalConnectionListener(JcatTerminalConnectionListener termconnlistener)
                                   throws MethodNotSupportedException,
                                          ResourceUnavailableException
Adds a JcatTerminalConnectionListener to the call.

Parameters:
termconnlistener - the JcatTerminalConnectionListener to be added to the call.
Throws:
MethodNotSupportedException - The implementation does not support this method.
ResourceUnavailableException - The resource limit for the number of listeners has been exceeded.

blindTransfer

public JcatConnection blindTransfer(java.lang.String dialledDigits)
                             throws InvalidArgumentException,
                                    InvalidStateException,
                                    InvalidPartyException,
                                    MethodNotSupportedException,
                                    PrivilegeViolationException,
                                    ResourceUnavailableException
This method transfers all participants currently on this Call, with the exception of the transfer controller participant, to another telephone address. This is often called a "single-step transfer" because the transfer feature places another telephone call and performs the transfer at one time. The telephone address string given as the argument to this method must be valid and complete.

The Transfer Controller

The transfer controller for this version of this method represents the participant on this JcatCall around which the transfer is taking place and who drops off the call once the transfer feature has completed. The transfer controller is a JcatTerminalConnection which must be in the JcatTerminalConnection.TALKING state. Applications may control which JcatTerminalConnection acts as the transfer controller via the setTransferController(JcatTerminalConnection) method. If no transfer controller is set, the implementation chooses a suitable JcatTerminalConnection when the transfer feature is invoked. When the transfer feature is invoked, the transfer controller moves into the JcatTerminalConnection.DROPPED state. If it is the only JcatTerminalConnection associated with its JcatConnection, then its JcatConnection moves into the JccConnection.DISCONNECTED state as well.

The New Connection

This method creates and returns a new JcatConnection representing the party to which the JcatCall was transferred. If the JcatConnection state progressed beyond JccConnection.IDLE before this method returns, appropriate events should reflect this. This new JcatConnection will progress as any normal destination JcatConnection on a telephone call.

Pre-Conditions:

  1. Let tc be the transfer controller on this Call
  2. (this.getProvider()).getState() == JccProvider.IN_SERVICE
  3. this.getState() == JccCall.ACTIVE
  4. tc.getState() == JcatTerminalConnection.TALKING

Post-Conditions:

  1. Let newconnection be the JcatConnection created and returned
  2. Let connection = tc.getConnection()
  3. (this.getProvider()).getState() == JccProvider.IN_SERVICE
  4. this.getState() == JccCall.ACTIVE
  5. tc.getState() == JcatTerminalConnection.DROPPED
  6. If connection.getTerminalConnections().size() == 1, then connection.getState() == JccConnection.DISCONNECTED
  7. newconnection is an element of this.getConnections().
  8. newconnection.getState() at least JccConnection.IDLE.
  9. JccConnectionEvent.CONNECTION_CREATED is delivered for newconnection
  10. JcatTerminalConnectionEevent.TERMINAL_DROPPED is delivered for tc

Parameters:
dialledDigits - The destination telephone address string to where the Call is being transferred.
Returns:
The new JcatConnection associated with the destination.
Throws:
InvalidArgumentException - The JcatTerminalConnection provided as controlling the transfer is not valid or part of this JcatCall.
InvalidStateException - Either the JcatProvider is not JccProvider.IN_SERVICE, the JcatCall is not JccCall.ACTIVE, or the transfer controller is not JcatTerminalConnection.TALKING.
InvalidPartyException - The destination address is not valid and/or complete.
MethodNotSupportedException - This method is not supported by the implementation.
PrivilegeViolationException - The application does not have the proper authority to invoke this method.
ResourceUnavailableException - An internal resource necessary for the successful invocation of this method is not available.

conference

public void conference(JcatCall othercall)
                throws InvalidArgumentException,
                       InvalidStateException,
                       MethodNotSupportedException,
                       PrivilegeViolationException,
                       ResourceUnavailableException
Merges two JcatCalls together, resulting in the union of the participants of both calls being placed on a single JcatCall. This method takes a call as an argument, referred to hereafter as the "second" call. All of the participants from the second call are moved to the call on which this method is invoked.

The Conference Controller

In order for the conferencing feature to happen, there must be a common participant to both calls, as represented by a single JcatTerminal and two JcatTerminalConnections, one on each of the two JcatCalls. These two JcatTerminalConnections are known as the conference controllers. In the real-world, one of the two calls must be on hold with respect to the controlling Terminal, and hence, the JcatTerminalConnection on the second JcatCall must be in the JcatTerminalConnection.HELD state. The two conference controlling JcatTerminalConnections are merged into one as a result of this method. Applications may control which JcatTerminalConnection acts as the conference controller via the setConferenceController(JcatTerminalConnection) method. If no conference controller is set, the implementation chooses a suitable JcatTerminalConnection when the conferencing feature is invoked.

The Telephone Call Argument

All of the participants from the second JcatCall, passed as the argument to this method, are "moved" to the JcatCall on which this method was invoked. That is, new JcatConnections and JcatTerminalConnections are created on this JcatCall which are found on the second JcatCall. Those JcatConnections and JcatTerminalConnections on the second JcatCall are removed from the JcatCall and the JcatCall moves into the JccCall.INVALID state. The conference controller terminalConnections are merged into one on this JcatCall. That is, the existing terminalConnection controller on this JcatCall is left unchanged, while the terminalConnection on the second JcatCall is removed from that JcatCall.

Other Shared Participant

There may exist JcatAddress and JcatTerminals which are part of both telephone calls in addition to the designated conference controller. In these instances, those participants which are shared between both JcatCalls are merged into one. That is, the JcatConnections and JcatTerminalConnections on this JcatCall are left unchanged. The corresponding JcatConnections and JcatTerminalConnections on the second JcatCall are removed from that JcatCall.

Pre-Conditions:

  1. Let tc1 be the conference controller on this Call
  2. Let connection1 = tc1.getConnection()
  3. Let tc2 be the conference controller on otherCall
  4. (this.getProvider()).getState() == JccProvider.IN_SERVICE
  5. this.getState() == JccCall.ACTIVE
  6. tc1.getTerminal() == tc2.getTerminal()
  7. tc1.getState() == JcatTerminalConnection.TALKING
  8. tc2.getState() == JcatTerminalConnection.HELD
  9. this != otherCall

Post-Conditions:

  1. (this.getProvider()).getState() == JccProvider.IN_SERVICE
  2. this.getState() == JccCall.ACTIVE
  3. otherCall.getState() == JccCall.INVALID
  4. Let c[] be the JccConnections to be merged from otherCall
  5. Let tc[] be the JcatTerminalConnections to be merged from otherCall
  6. Let new_c be the set of new JccConnections created on this Call
  7. Let new_tc be the set of new JcatTerminalConnections created on this Call
  8. new_c element of this.getConnections()
  9. new_c.getState() == c.getState()
  10. new_tc element of (this.getConnections()).getTerminalConnections()
  11. new_tc.getState() == tc.getState()
  12. c[i].getState() == JccConnection.DISCONNECTED for all i
  13. tc[i].getState() == JcatTerminalConnection.DROPPED for all i
  14. Appropriate events are delivered for all new_c and new_tc

Parameters:
othercall - - The JcatCall which is to be merged with the existing JcatCall.
Throws:
InvalidArgumentException - - The JcatTerminalConnection provided (implicitly) as controlling the transfer is not valid or part of this Call.
InvalidStateException - - One of the objects is not in the prescribed state.
MethodNotSupportedException - - This method is not supported by the implementation.
PrivilegeViolationException - - The application does not have the proper authority to invoke this method.
ResourceUnavailableException - - An internal resource necessary for the successful invocation of this method is not available.

connect

public JcatConnection[] connect(JcatTerminal term,
                                JcatAddress addr,
                                java.lang.String dialedDigits)
                         throws ResourceUnavailableException,
                                PrivilegeViolationException,
                                InvalidPartyException,
                                InvalidStateException,
                                MethodNotSupportedException
Places a telephone call from an originating endpoint to a destination address string. The call must be in the JccCall.IDLE state (and therefore have no existing associated connections. The successful effect of this method is to place the telephone call and create and return at most two connections associated with this call.

Method input Arguments

This method has three arguments. The first input argument is the originating terminal for the telephone call. The second argument is the originating address for the telephone Call. This terminal/address pair must reference one another. That is, the originating address must appear on the terminal (via JcatAddress.getTerminals() and the originating terminal must appear on the address (via JcatTerminal.getAddresses()). If not, an InvalidArgumentException is thrown. The third argument is a destination string whose value represents the address to which the telephone call is placed.

Parameters:
term - originating terminal for the telephone call.
addr - The originating Address for this call.
dialedDigits - The destination address string for this call.
Returns:
An array of JcatConnection.
Throws:
ResourceUnavailableException - An internal resource necessary for placing the call is unavailable.
PrivilegeViolationException - The application does not have the proper authority to place a call.
InvalidPartyException - Either the originator or the destination does not represent a valid party required to place a call.
InvalidStateException - Some object required by this method is not in a valid state as designated by the pre-conditions for this method.
MethodNotSupportedException - The implementation does not support this method.

consult

public JcatConnection[] consult(JcatTerminalConnection termconn,
                                java.lang.String dialedDigits)
                         throws InvalidArgumentException,
                                InvalidPartyException,
                                InvalidStateException,
                                MethodNotSupportedException,
                                PrivilegeViolationException,
                                ResourceUnavailableException
Creates a consultation between this idle JcatCall and an active JcatCall. A consultation JcatCall must be in the JccCall.IDLE state which is associated with a particular existing JcatCall and often created for a particular purpose. For example, the consultation JcatCall may be used simply to "consult" with another party or to conference or transfer with its associated JcatCall. This method establishes a special relationship between the two JcatCalls which extends down to the telephony platform level. Most often, this feature is directly provided by the underlying telephony platform.

This Call Object

The instance on which this method is invoked is used as the JcatCall on which the consultation takes place and must be in the JccCall.IDLE state.

The TerminalConnection Argument

The JcatTerminalConnection argument provides two pieces of information. The first piece of information is the other active JcatCall to which this idle JcatCall is associated. The call associated with the JcatTerminalConnection argument must be in the JccCall.ACTIVE state. The second piece of information given by the JcatTerminalConnection argument is the originating endpoint from which to place a telephone call on this idle JcatCall. In other words, the JcatAddress and JcatTerminal associated with the JcatTerminalConnection argument are used as the originating endpoint for the telephone call. The state of the JcatTerminalConnection must be JcatTerminalConnection.TALKING and this method first moves it into the JcatTerminalConnection.HELD in order to place a telephone call on this idle call.

The Destination Address String

A telephone call is placed to the destination telephone address string given as the second argument to this method.

The Telephone Call

A telephone call is placed on this JcatCall and an array of two JcatConnections are returned representing the originating and destination participants of the JcatCall. The JcatCall progresses in the same way as if the JcatCall was placed using the connect(JcatTerminal,JcatAddress,String) method.

Parameters:
termconn - originating terminal for the telephone call.
dialedDigits - The destination address string for this call.
Returns:
An array of JcatConnection.
Throws:
InvalidArgumentException - The JcatTerminalConnection provided as controlling the transfer is not valid or part of this call.
InvalidStateException - Some object required by this method is not in a valid state as designated by the pre-conditions for this method.
InvalidPartyException
MethodNotSupportedException - This method is not supported by the implementation.
PrivilegeViolationException - The application does not have the proper authority to invoke this method.
ResourceUnavailableException - An internal resource necessary for the successful invocation of this method is not available.

consultTransfer

public void consultTransfer(JcatCall otherCall)
                     throws InvalidArgumentException,
                            InvalidPartyException,
                            InvalidStateException,
                            MethodNotSupportedException,
                            PrivilegeViolationException,
                            ResourceUnavailableException
This method moves all participants from one JcatCall to another, with the exception of a selected common participant. This method takes a JcatCall as an argument, referred to hereafter as the "second" JcatCall. All of the participants, with the exception for the selected common participant, from the second call are moved to the JcatCall on which this method is invoked.

The Transfer Controller

In order for the transfer feature to happen, there must be a participant that acts as the transfer controller. The transfer controller is a JcatTerminalConnection around which the transfer is placed. This transfer controller must be present on each of the two JcatCalls and share a common JcatTerminal. The transfer controller participant is no longer part of any JcatCall once this transfer feature is complete. The transfer controllers on each of the two JcatCalls must be in either of the JcatTerminalConnection.TALKING or JcatTerminalConnection.HELD state. Applications may control which JcatTerminalConnection acts as the transfer controller via the setTransferController(JcatTerminalConnection) method. If no transfer controller is set, the implementation chooses a suitable JcatTerminalConnection when the transfer feature is invoked.

The Telephone Call Argument

All of the participants from the second JcatCall, passed as the argument to this method, are "moved" to the JcatCall on which this method is invoked, with the exception of the transfer controller. That is, new connections and terminal connections are created on this JcatCall which are found on the second JcatCall. Those JcatConnections and JcatTerminalConnections on the second JcatCall are removed from the JcatCall and the JcatCall moves into the JccCall.INVALID state. The transfer controller JcatTerminalConnections are dropped from both Calls. They move into the JcatTerminalConnection.DROPPED state.

Other Shared Participants

There may exist JcatAddress and JcatTerminals which are part of both JcatCalls in addition to the designated transfer controller. In these instances, those participants which are shared between both JcatCalls are merged into one. That is, the JcatConnections and JcatTerminalConnections on this JcatCall are left unchanged. The corresponding JcatConnections and JcatTerminalConnections on the second JcatCall are removed from that JcatCall.

Pre-Conditions:

  1. JcatTerminalConnection tc1=this.getTransferController()
  2. JcatTerminalConnection tc2=otherCall.getTransferController()
  3. this != otherCall
  4. (this.getProvider()).getState() == JccProvider.IN_SERVICE
  5. this.getState() == JcatCall.ACTIVE
  6. otherCall.getState() == JcatCall.ACTIVE
  7. tc1.getState() == JcatTerminalConnection.TALKING or JcatTerminalConnection.HELD
  8. tc2.getState() == JcatTerminalConnection.TALKING or JcatTerminalConnection.HELD

Post-Conditions:

  1. (this.getProvider()).getState() == JcatProvider.IN_SERVICE
  2. this.getState() == JcatCall.ACTIVE
  3. otherCall.getState() == JcatCall.INVALID
  4. tc1.getState() == JcatTerminalConnection.DROPPED
  5. tc2.getState() == JcatTerminalConnection.DROPPED
  6. Let c[] be the JcatConnections to be transferred from otherCall
  7. Let tc[] be the JcatTerminalConnections to be transferred from otherCall
  8. Let new_c[] be the new JcatConnections created on this JcatCall and for all i, new_c[i].getAddress() == c[i].getAddress()
  9. Let new_tc[] be the new JcatTerminalConnections created on this JcatCall and for all i, new_tc[i].getName() == tc[i].getName()
  10. for all i, new_c[i].getCall().getState() == c[i].getCall().getState()
  11. for all i, new_tc[i].getConnection().getCall().getState() == tc[i].getConnection().getCall().getState()
  12. for all i, c[i].getState() == JccConnection.DISCONNECTED
  13. for all i, tc[i].getState() == JcatTerminalConnection.DROPPED
  14. let JccCallEvent ce be delivered, where ce.getID() == JccCallEvent.CALL_INVALID and ce.getCall() == otherCall
  15. let JcatTerminalConnectionEvent tce1,tce2 be delivered, where tce1.getID() == tce2.getID() == JcatTerminalConnectionEvent.TERMINALCONNECTION_DROPPED and tce1.getTerminalConnection() == tc1 and tce2.getTerminalConnection() == tc2
  16. for all i, new_c[i].getState() == JccConnection.IDLE or beyond
  17. for all i, new_tc[i].getState() == JcatTerminalConnection.IDLE or beyond

Parameters:
otherCall - - The other JcatCall which to transfer to this JcatCall.
Throws:
InvalidArgumentException - The JcatTerminalConnection controlling the transfer is not valid or does not exist or the other call is not valid.
InvalidStateException - Either the provider is not "in service", the Call is not "active", or the transfer controllers are not "talking" or "held".
InvalidPartyException - The other Call given as the argument is not a valid Call to conference with.
MethodNotSupportedException - This method is not supported by the implementation.
PrivilegeViolationException - The application does not have the proper authority to invoke this method.
ResourceUnavailableException - An internal resource necessary for the successful invocation of this method is not available.

getConferenceController

public JcatTerminalConnection getConferenceController()
Returns the JcatTerminalConnection which currently acts as the conference controller. The conference controller represents the participant in the telephone around which a conference takes place.

When a JcatCall is initially created, the conference controller is set to null. This method returns non-null only if the application has previously set the conference controller. If the current conference controller leaves the JcatCall, the conference controller is reset to null.

Returns:
JcatTerminalConnection which acts as the conference controller.

getConferenceEnable

public boolean getConferenceEnable()
Return true if conferencing is enabled, false otherwise. Applications may use this method initially to obtain the default value set by the implementation and may attempt to change this value using the setConferenceEnable(boolean) method.

Returns:
true/false depending on whether conferencing is enabled.

getTransferController

public JcatTerminalConnection getTransferController()
Returns the JcatTerminalConnection which currently acts as the transfer controller. The transfer controller represents the participant in the JcatCall around which a transfer takes place.

When a JcatCall is initially created, the transfer controller is set to null. This method returns non-null only if the application has previously set the transfer controller. If the current transfer controller leaves the telephone call, the transfer controller is reset to null.

Returns:
the JcatTerminalConnection which acts as the transfer controller.

getTransferEnable

public boolean getTransferEnable()
Return true if transferring is enabled, false otherwise. Applications may use this method initially to obtain the default value set by the implementation and may attempt to change this value using the JcatCall.setTransferEnable() method.

Returns:
true/false depending on whether transfer is enabled.

removeTerminalConnectionListener

public void removeTerminalConnectionListener(JcatTerminalConnectionListener terminalConnectionListener)
Removes the terminal connection listener. Removes a TerminalConnectionlistener from this call. If the listener is not part of the Call for the given address(es), then this method fails silently.JcatTerminalConnectionEvent.TERMINALCONNECTION_EVENT_TRANSMISSION_ENDED is the last event sent on this listener.

Parameters:
terminalConnectionListener - listener to be added

setConferenceController

public void setConferenceController(JcatTerminalConnection tc)
                             throws InvalidArgumentException,
                                    InvalidStateException,
                                    MethodNotSupportedException,
                                    ResourceUnavailableException
Sets the JcatTerminalConnection which acts as the conference controller for the JcatCall. The conference controller represents the participant in the JcatCall around which a conference takes place. Typically, when two JcatCalls are conferenced together, a single participant is part of both JcatCalls. This participant is represented by a JcatTerminalConnection on each JcatCall, each of which shares the same JcatTerminal. If the designated JcatTerminalConnection is not part of this JcatCall, exception InvalidArgumentException is thrown. If the JcatTerminalConnection leaves the JcatCall in the future, the implementation resets the conference controller to null.

Parameters:
tc - the JcatTerminalConnection to set as the conference controller.
Throws:
InvalidArgumentException - The TerminalConnection controlling the transfer is not valid or does not exist or the other Call is not valid.
InvalidStateException - Either the Provider is not "in service", the Call is not "active", or the transfer controllers are not "talking" or "held".
MethodNotSupportedException - This method is not supported by the implementation.
ResourceUnavailableException - An internal resource necessary for the successful invocation of this method is not available.

setConferenceEnable

public void setConferenceEnable(boolean enabled)
                         throws InvalidArgumentException,
                                InvalidStateException,
                                MethodNotSupportedException,
                                ResourceUnavailableException
Controls whether the JcatCall is permitted or able to perform the conferencing feature. The boolean argument provided indicates whether conferencing should be turned on (true) or off (false). This method throws an exception if the boolean argument is true and the implementation does not support the conferencing feature. This method must be invoked when the JcatCall is in the JccCall.IDLE state.

Setting this parameter is a "request"; the call will be routed such that a resource capable of conferencing is part of the path. Note that this does not mean that three party calls are not supported if ConferenceEnable=false since we consider a conference to be call with more than three parties.

Parameters:
enabled - set to true or false depending on whether conferencing feature is enabled or not.
Throws:
InvalidArgumentException - - The TerminalConnection controlling the transfer is not valid or does not exist or the other Call is not valid.
InvalidStateException - - Either the Provider is not "in service", the Call is not "active", or the transfer controllers are not "talking" or "held".
MethodNotSupportedException - - This method is not supported by the implementation.
ResourceUnavailableException - - An internal resource necessary for the successful invocation of this method is not available.

setTransferController

public void setTransferController(JcatTerminalConnection termconn)
                           throws InvalidArgumentException,
                                  InvalidStateException,
                                  MethodNotSupportedException,
                                  ResourceUnavailableException
Sets the JcatTerminalConnection which acts as the transfer controller for the JcatCall. The transfer controller represents the participant in the JcatCall around which a transfer takes place. If the designated JcatTerminalConnection is not part of this JcatCall, an exception is thrown. If the JcatTerminalConnection leaves the JcatCall in the future, the implementation resets the transfer controller to null.

Parameters:
termconn - JcatTerminalConnection to set as the transfer controller.
Throws:
InvalidArgumentException - - The TerminalConnection controlling the transfer is not valid or does not exist or the other Call is not valid.
InvalidStateException - - Either the Provider is not "in service", the Call is not "active", or the transfer controllers are not "talking" or "held".
MethodNotSupportedException - - This method is not supported by the implementation.
ResourceUnavailableException - - An internal resource necessary for the successful invocation of this method is not available.

setTransferEnable

public void setTransferEnable(boolean enable)
                       throws InvalidArgumentException,
                              InvalidStateException,
                              MethodNotSupportedException,
                              ResourceUnavailableException
Controls whether the JcatCall is permitted or able to perform the transferring feature. The boolean argument provided indicates whether transferring should be turned on (true) or off (false). This method throws an exception if the boolean argument is true and the implementation does not support the transferring feature. This method must be invoked when the JcatCall is in the JccCall.IDLE state.

Parameters:
enable - true/false depending on whether transferring feature is enabled.
Throws:
InvalidArgumentException - - The TerminalConnection controlling the transfer is not valid or does not exist or the other Call is not valid.
InvalidStateException - - Either the Provider is not "in service", the Call is not "active", or the transfer controllers are not "talking" or "held".
MethodNotSupportedException - - This method is not supported by the implementation.
ResourceUnavailableException - - An internal resource necessary for the successful invocation of this method is not available.

JCAT
v0.3.1

August, 2003
If you have any comments or queries, please mail them to JSR-122-EG@JCP.ORG

Copyright - 2001, 2003 Sun Microsystems