A New Protocol in the Offing

The Java Telephony API

(JTAPI) is a recently introduced, portable, object-oriented Application Programming

Interface (API) for Java-based Computer Telephony Applications (CTI). JTAPI serves a broad

audience, from call centre application developers to Web page designers. JTAPI supports

both first-party and third-party CTI application needs. API is designed to make the

development of simple applications easy, while providing the feature functionality

necessary for advanced telephony applications.

Market Drivers SIZE="2" COLOR="#000000">

JTAPI specification was debuted on 1

October 1996 and the specification was in its third revision as of November 1997.

Lucent’s support for JTAPI could not be more perfectly timed as many Chief

Information Officers (CIOs) and Information Technology (IT) managers are challenged with

developing their enterprise-wide strategies for integrating computing and communications

infrastructure. Certainly, Internet and intranets are playing large roles in this arena. SIZE="2">

With the growth of enterprise intranets,

CIOs and IT managers are looking for ways to link telephones, computers, and other devices

with this common underlying enterprise infrastructure.

A leading candidate for this

infrastructure will most probably be the World Wide Web. The goals of JTAPI are to enable

the integration of computing and telephony resources using the powerful Java programming

language, thus enabling this integration through Internet/intranet. JTAPI is an API for

computer telephony applications in the Java environment. JTAPI applications will be able

to run on any hardware/operating system platform that contains a Java Virtual Machine (VM)

and a JTAPI-compliant telephony sub-system. It is important to note that the leading web

browsers, such as Microsoft Internet Explorer and Netscape Navigator, come with Java VMs,

thus allowing JTAPI applets embedded in HTML pages to run whenever the page is viewed.

This allows Internet and intranet JTAPI applications to run on virtually any platform,

anywhere, including the emerging Network Computers.

By leveraging the inherent strengths of

the Java platform, JTAPI delivers the Sun concept of "Write Once, Run Anywhere"

to everyone from web page designers to telephony service providers to enterprise call

centre application developers. As a result, platform-independent Java applications and

applets can be created and deployed to provide telephony-enabled solutions for a wide

range of environments including customer sales and service, Internet telephony,

Interactive Voice Response (IVR), directory services, and PBXes.

JTAPI is still relatively new. As best as

we know, Lucent Technologies has delivered the first real implementation of JTAPI to the

market-place. It appears that with the steam that Sun’s Java has brewed up, JTAPI

will be embraced by the industry. Undoubtedly, JTAPI will influence the call centre

industry in a big way just like CTI, IVR, the World Wide Web and Java have already

impacted this dynamic market-place known to be populated with "early adopters".

Planned extensions to JTAPI to support IVR and other media capabilities will further

contribute to call centre opportunities.

A brief overview of JTAPI and Lucent

Technologies’ implementation of its JTAPI provider, which became generally available

on 27 October 1997. Additional information about JTAPI implementation and PassageWay

Telephony Services product can be found at this URL:

http://www.lucent.com/enterprise/passageway.

Detailed information about the actual

JTAPI reference specification can be found at this URL: href="http://java.sun.com/products/jtapi/">http://java.sun.com/products/jtapi/. SIZE="4" COLOR="#016077">

History of JTAPI SIZE="2" COLOR="#000000">

The JTAPI specification represents the

combined efforts of design teams from Sun, Lucent, Nortel, Novell, Intel, and IBM,

operating under the direction of JavaSoft. The JTAPI version 1.0 specification was

released to the public on 1 November 1996. Version 1.1 was released to the public on 1

February 1997. As of November 1997, the JTAPI specification is in its third revision,

Version 1.3.

JavaSoft and the design team decided to

contribute the JTAPI specification to the Enterprise Computer Telephony Forum (ECTF) in

February 1997. Lucent is an active member of ECTF and is continuing to work within ECTF on

this API. ECTF is evaluating JTAPI for use as a "Portable API" for CTI

applications and is working to extend JTAPI with multimedia and voice processing

capabilities.

This talented design team of key industry

players is composed of solid CTI API experts. Several of these companies have already been

very active in helping to develop CTI API standards over the years. For example, Lucent

and Novell were instrumental in the CSTA-based Telephony Services, TSAPI-based upon

third-party call control architecture. Meanwhile, Intel, along with Microsoft, developed

the Telephony API (TAPI) designed with a first-party call control functionality in mind.

JTAPI does not compete with other call

control specifications directly. In the JTAPI model, industry vendors will implement their

JTAPI classes by invoking telephony functionality using TSAPI, IBM’s CallPath, TAPI,

or any other standard or proprietary call control mechanism. The idea is that

implementations of JTAPI will be available for existing CTI platforms such as TSAPI,

SunXTL, TAPI, and CallPath. Independent hardware vendors may choose to provide

implementations of JTAPI on top of their own proprietary hardware. It is also important to

note that Java applications written using one of these JTAPI implementations (assuming the

implementation adheres to the official specification) are portable across these CTI

servers (TSAPI, CallPath, etc.) as well as being computing-platform (hardware and

operating system) and telephone-system independent. COLOR="#016077">

Overview of JTAPI SIZE="2" COLOR="#000000">

Why Java?

Java is a new object-oriented,

component-based computer programming language. These architectural characteristics make

programming easier and more flexible by supporting modular, reusable components (logical

code with specific functions) that enable plug-and-play design.

Furthermore, Java Beans component

technology allows developers to use application builder tools to easily employ components

to create new applications. Computing hardware platform and operating system independence

is achieved by the concept of a Java VM. A Java VM emulates a computer in software,

allowing Java applications to execute and behave as if they were computers. Sun promotes

the Java promise of "Write Once, Run Anywhere". As a result, no modifications

are needed to the application to run on different platforms. Applications are written once

and can run on Windows, UNIX, OS/2, Macintosh, etc.

Java can be used to write programs that

can be downloaded and executed on any computer. For example, you can create Java-based

programs to make web pages more interactive. Java applications can run standalone as Java

programs or they can run inside a browser, such as Microsoft Internet Explorer and

Netscape Navigator, as Java applets imbedded in web pages.

In the market-place, we are seeing a move

towards web-based computing, where networked personal computers are linked to server-based

applications. Companies around the globe are providing access to enterprise applications

and tools through web browsers on their enterprise intranets. This is in contrast to the

Eighties trend of putting more and more applications resident on the desktop. Network

computers and "thin clients" are emerging to fit this new architecture. The cost

of the desktop throughout corporate enterprises and call centres can be lessened by such

network computers.

The network computer is typically

configured with only a display, keyboard, processor, and some limited memory. It accesses

network resources, making use of a centralized server for common administration and

maintenance of shared applications. There can be significant cost savings associated with

this model. Network computers are ideal for the call-centre agent where most of the

activity is accessing and inputing information, with no need for intense number crunching

or graphics creation.

Why JTAPI?

The goals for JTAPI are simple: to create

a TAPI that allows applications to run on a variety of operating systems and hardware

platforms, against a variety of telephony networks.

Leveraging the promise of Java, JTAPI is

portable in that it provides software, operating system, and hardware platform

independence. Applications can run on a wide range of configurations wherever Java

run-time can be used. Applications can be written once, with less work and re-writes. This

means faster time to market for application developers and investment protection for

customers as they grow and change their computing environments.

JTAPI is intended to be a simple API as

well. JTAPI still requires application developers to be knowledgeable about telephony, but

reduces the amount of implementation-specific knowledge required to develop applications.

The "target markets" for JTAPI

ranges from the largest call centres, to desktop systems, to network computers, to network

telephones. This range is the reason for the "core plus extensions" organization

of JTAPI. (See the JTAPI specification for details about the set of modularly-designed

JTAPI packages: Core API plus extensions.)

JTAPI spans borders. It spans across

first-party and third-party call control and it ultimately will span across call control

and media control, blurring the distinction. The next release of the JTAPI specification

will add a media extension package supporting robust IVR applications fully integrated

with JTAPI call control. Lucent is a primary contributor to this effort.

JTAPI is not "just another telephony

API". It was also designed to allow implementers to build on top of existing TAPIs,

such as TSAPI.

What is JTAPI? SIZE="2" COLOR="#000000">

JTAPI specifies the standard telephony API

for computer-telephone applications running under Java. It defines a reusable set of call

control objects that bring cross-platform and cross-implementation portability to

telephony applications. It is a simple, modularly designed, object-oriented model that

addresses a broad range of computer-telephony functions. Applications written using JTAPI

are portable across various computer platforms and telephone systems, and even JTAPI

implementations.

JTAPI is a specification that enables the

integration of computing and telephony using the Java programming language. It is an

industry specification that defines telephony objects that allow application developers to

write Java-based programs that integrate the telephony/voice systems with their data

systems. Two important characteristics are:

• Operating system-independent
  
  programming language (Java).

• Telephony object definition
  
  (i.e., it is an object-oriented TAPI).

The JTAPI call model describes the objects

that correspond to the actual entities in the real telephony world. Examples of such

objects are the Provider, Call, Connection, Terminal connection, Terminal, and Address.

The Provider object represents the telephony sub-system.

This could be a fax/voice card in a

desktop computer where the JTAPI application is running on the desktop itself and

controlling the fax/voice card. As an alternative, the Provider object could be a PBX

switch or an ACD where the JTAPI application is running somewhere in the

"network" and has access to the switch using CTI links. Call objects are

associated with a Provider object. Call objects represent telephone calls. Address objects

represent telephone numbers. An address object represents the logical endpoint of a call.

Connection object represents the link between a call object and an address object. (For

detailed information about the actual JTAPI reference specification, go to the JTAPI

specification URL, http://java.sun.com/products/jtapi/.

)

Here are some of the JTAPI design goals: SIZE="1">

• Support both third-party and
  
  first-party call control scenarios.

• Compliment existing call
  
  control specifications and applications programming interfaces such as TSAPI and TAPI.

• Simplicity, one of the basic
  
  themes of the Java language.

• Compatibility with the Java
  
  Media framework (multimedia interoperability at application level).

• Extensibility of core
  
  functionality (Core JTAPI API + extensions for call centre, media, etc.).

• Support for wide variety of
  
  telephony applications and systems.

• Support for all environments
  
  capable of running a Java VM.

• Support for call control, media
  
  stream management, physical phone control, and switch-specific communication. SIZE="1" COLOR="#ff0000">

This article is a

white paper



by Lucent Technologies,


dated 27 October 1997.