Contents

About Interaction Designer

Interaction Designer is a visual programming environment for Customer Interaction Center that makes it easy to create sophisticated server applications without writing code. Interaction Designer is powerful. CIC's default event-processing behaviors were created using Interaction Designer. Interaction Designer empowers any trained entry-level programmer to change the functionality of a CIC system.

Electronic interactions between customers and businesses can take many forms. For example:

Sending and receiving email
Sending and receiving faxes
Sending and receiving voice mail
Simple and multi-party telephone calls
Internet-based calls and chat sessions
Remote access to voice mail, email, and faxes
Intelligent call routing (ACD)

Each interaction is triggered by an event detected by CIC, which, in turn uses an initiator to launch a handler to respond to the event and process it appropriately.

A handler is a logical flow of actions authored by an administrator or developer using Interaction Designer (ID). These actions are composed of small steps that do work of some sort. The author of a handler creates steps by dragging them from tool palette. Tools are template definitions of steps.

CIC includes predefined initiators to cover all the most-common events detected in business interactions. Interaction Designer, the premier development tool bundled with CIC, makes it easy to create seamlessly integrated telephony applications.

Interaction Designer uses a visual programming metaphor. Traditional programming tools require developers to construct statements in a programming language. Interaction Designer permits developers to visually lay out logic needed to respond to a given event, by arranging and connecting graphical objects on the screen. Each object performs a specific task, such as sending a fax, e-mail, or routing a call.

Telephony applications are created in Interaction Designer by arranging tools steps in a logical sequence.

Interaction Designer creates event-processing programs called handlers. Handlers encapsulate program logic within graphically connected nodes, called steps, for events processed by the CIC server. Each step is created by dragging a tool (a template definition of each step) from a palette, pasting it in the workspace, and editing the tool's properties. Interaction Designer provides an extensible palette of tools that serve as building blocks for building handlers.

The first step in each handler is an initiator. An Initiator identifies the event that starts a handler. An example of an event might be Incoming Call. When the Interaction Processor receives a notification that an Incoming Call event occurred, it starts the handler whose initiator is configured for Incoming Call.

When you finish building a handler, you can elect to have Interaction Designer publish it. Publishing a handler converts your visual design to Java source code. (Absolutely no knowledge of Java is required. Visually designed logic is automatically converted to Java program code that is compiled to create a highly efficient server application.)

The process of building handlers can be broken down into these six steps.

Research. Start by becoming familiar with the handlers and subroutines currently running on your CIC system.
Design. Map out the functionality of the handler you plan to build, and figure out how it might interact with the other handlers and subroutines.
Build. Create and link steps to define new functionality, using Interaction Designer.
Publish. The automated Publish process compiles your handler and moves it to the server.
Test. Test the handler on your live system or on a second system you've set up for testing purposes. We highly recommend the latter.
Activate. If you are not already using the handler on your live system, activate the handler.

When you publish a handler, events configured for its initiator are registered with the Interaction Processor. Interaction Processor then instructs the Notifier that it wants to be notified any time that event occurs. Whenever the event occurs, Notifier tells the Interaction Processor, and Interaction Processor starts a new instance of the handler. The active lifetime of a handler is very short, since handlers terminate after processing an event.

Sometimes, modifying an existing handler is the best way to implement new functionality. For example, you might want to add a new key-press option for callers using your IVR (Interactive Voice Response) system. In this case, adding new functionality involves recording a new prompt, adding a condition to a Selection step, and adding additional steps to your existing IVR handler. You don't need to write a new subroutine or handler to add simple functionality. To make minor changes or additions to CIC, it is often best to modify existing handlers or subroutines. For more information about Information Designer, refer to Interaction Designer Help.