Cisco Cisco Computer Telephony Integration Option 8.5 Developer's Guide

Page of 508
   
4-81
CTI OS Developer’s Guide for Cisco Unified ICM/Contact Center Enterprise & Hosted
Release 8.0(1)
Chapter 4      Building Your Application
Building Supervisor Applications
Upon successfully calling this method, the application will receive many events since this method not 
only changes the state of the monitored call, but also delivers a call to the supervisor which changes the 
supervisor’s state.  When a OnButtonEnablementChange event is received, be sure to check the 
monitored flag.  If the flag does not exist or exists and is set to false, apply the event to any application 
specific logic or UI to control the supervisor’s state.  This is illustrated in SoftphoneForm.OnEvent().  
Notice that this method discards any event that is monitored.
One or more OnSupervisorButtonChange events will be received by the application.  These events notify 
the application that it is now possible to intercept the agent’s call.
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.
Table 4-11
Agent.SuperviseCall Parameter
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.
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