Cisco Cisco Computer Telephony Integration Option 9.0 Developer's Guide

Page of 500
   
4-80
CTI OS Developer’s Guide for Cisco Unified ICM/Contact Center Enterprise & Hosted
Release 7.5(1)
Chapter 4      Building Your Application
Building Supervisor Applications
The trickiest piece of handling the events that result from a successful call to Agent.SuperviseCall() is 
handing the resulting Call and MonitoredCall events.  All CallEvents should be applied to whatever 
application specific object and/or UI element is managing calls directly connected to the supervisor’s 
device (SoftphoneForm in the combo desktop).  All MonitoredCallEvents should be applied to whatever 
application specific object and/or UI element is managing calls connected to the supervisor’s team 
members/monitored agents (SupervisorUIManager in the combo desktop).
Calling SuperviseCall() with the SupervisoryAction set to barge-in, essentially initiates a consultative 
conference between the caller, agent, and supervisor.  This means that whatever UI elements and/or 
objects that handle monitored calls has to be able to handle the set of events that setup a consultative 
conference.    In general, this is not too difficult.  The consultative call is joined to the conference call 
by sending a MonitoredCallEndEvent to end the consultative call.  Then a 
MonitoredCallDataUpdateEvent is used to change the ID of the call to the conference. The 
MonitoredCallEndEvent will take care of cleaning up the consultative call.  The trick is to check 
OnMonitoredCallDataUpdateEvents for the OldUniqueObjectID key.  If this key exists, it means that the 
UniqueObjectID of a call has changed.  OldUniqueObjectID stores the old/obsolete ID of the call.  
UniqueObjectID stores the new ID of the call. This new ID will be carried in all future events for the 
call.  Application logic must be updated based on this information or new events for the call will not be 
tracked correctly. 
Intercepting Calls
Once a supervisor has barged into an agent’s call, the supervisor can intercept the call.  This can be done 
by calling the Agent.SuperviseCall() method.    The target of the SuperviseCall() method is the current 
agent (the agent object that represents the supervisor).  The parameter to the method is an Arguments 
object with the following key/value pairs. 
Calling this method will remove the agent from the call.  This means that OnMonitoredEndCall events 
will be received for the agent.  Also, OnSupervisorButtonChange events will be sent to reflect the current 
state of the monitored agent.
Updating Monitored Call Data
Setting monitored call data is very similar to setting call data on an agent’s call.  The only difference is 
that the monitored call is the target of the Call.SetCallData() method.  The currently monitored call can 
be retrieved by calling Agent.GetMonitoredCall() where the current agent (the agent object that 
represents the supervisor) is the target of the Agent.GetMonitoredCall() method.
Key
Value
AgentReference
The UniqueObjectID of the currently 
monitored agent
CallReference
The UniqueObjectID of the currently 
monitored call
SupervisoryAction
The value 4.  For the .NET CIL, this is 
SupervisoryAction.eSupervisorIntercept