JAVATM ACCESSIBILITY API GOES TO MARKET Leading Assistive Technologies Spring to Life

by Steven Meloan

March 22, 2000 -- What a difference a year makes in the fast-paced world of Java^TM technology! At the 1999 CSUN event, Cal State Northridge's annual conference on "Technology and Persons With Disabilities," the Java 2 Platform had just recently been released -- and with it, the Java Accessibility API (JAAPI) became a core part of the platform. Prior to JAAPI, the accepted norm in accessibility technology (screen readers, screen magnifiers, and so on) had been add-ons after the fact and easy-to-break proprietary hacks -- with the result that assistive technology developers were forced into in an endless mad scramble to tap into newly released software packages by any means available. But Java technology changed all that. The Java Accessibility API broke new ground by offering extensible, full-featured, fine-grained accessibility, built in at the actual component level.

Also at the 1999 CSUN conference, accessibility industry leaders such as IBM and Henter-Joyce (maker of the world's most popular screen reader) had already introduced pre-release versions of products that leveraged the object-driven power of the Java Accessibility API. This year, at CSUN 2000 (March 20 - 25), the API is clearly coming into its own, with new products shipping, and corporate customers lining up to test their Java technology-based applications against them.

Bridging the Platform Gap

Sun's Java Access Bridge is a particularly important new element in providing increased accessibility to the Java platform. Users of assistive technologies generally live on proprietary platforms -- Windows, Mac, and so on. As a result, they are often already using an assistive technology specific to their native platform. But to make use of the information offered by the Java Accessibility API, a given assistive technology must have access to the Java virtual machine. In most cases, it doesn't make sense to have separate assistive technologies -- a screen reader for Windows, and a separate screen reader for Java applications. With the aid of the Java Access Bridge, a single assistive technology can effectively live in both worlds.

The Java Access Bridge (on a Windows platform) consists of a pair of Windows DLLs (DLL stands for "Dynamic Link Library") that expose a subset of the JAAPI as functions on a Windows DLL. With these, the Windows-based assistive technology can effectively live with one foot in Windows, and the other in the Java virtual machine, seamlessly extracting necessary information from the application or applet. "Using the Java Access Bridge," says Peter Korn, of Sun's Accessibility Team, "a screen reader can look at an application written in the Java language and know that the word beneath the caret is in Bold, Times Roman, and 14 Point. That's a level of information that would be hard, if not impossible, to get from the Windows platform itself."

For more on the Java Access Bridge, see Bridging the Gap.

The Real World

While theory and possibility are all well and good, for accessibility users the real proof is in the pudding.

At the 1999 CSUN gathering, only months after the release of the Java 2 Platform, IBM had already showcased their Java technology-specific screen reader using the Java Accessibility API, and the IBM Self Voicing Kit for speech synthesis (an implicit testament to the rapid time-to-market nature of the component-driven development world of Java technology). Now, for CSUN 2000, Henter-Joyce, the maker of JAWS for Windows, the most popular and widely used screen reader on the market, is showcasing the just released version 3.5 of their flagship product -- with support for Java technology-based applications via Sun's Java Access Bridge. With over 40,000 users of JAWS worldwide, in 700+ universities, and by such prestige customers as Honeywell, Federal Express, AT&T-Bell Labs, USA Today, McDonnell-Douglas, and Hughes Aircraft, a large and diverse assistive technology user base will now have access to applications based on Java technology. And Henter-Joyce's screen magnifier product, MAGic, will soon follow suit, offering support for Java technology-based applications using the Java Access Bridge.

"From a technological viewpoint," says Eric Damery, vice president of Business Development at Henter-Joyce, "the Java Accessibility API has been a great accomplishment. Sun built accessibility into the Java 2 Platform while it was being developed. The result is a robust API that covers many of the elements that we as assistive technology developers need for our products."

Major corporate clients (currently constrained by non-disclosure agreements) are lining up to test the accessibility features of their under-development applications via the newly Java technology-enabled version of JAWS. "I think there's going to be a great response when people see some of the major companies out there that are implementing the Java Accessibility API," says Damery.

Evaluation versions of Henter-Joyce's products can be downloaded from the company's Web site (see below).

Future Features

Looking toward the future, the Java Accessibility API has no intention of resting on its laurels. As a core element of the Java 2 Platform, extensibility lies at the API's very heart. As a result, several new features will be built into the upcoming 1.3 release of the Java 2 platform, offering even greater degrees of informational granularity to assistive technologies.

Three important additions to the Accessibility API are in store: Accessible Icon, Accessible Table, and Accessible Relations.

The Accessible Icon feature provides information about an icon's description and dimension. "It's a way of making sure that icons themselves have text labels associated with them," says Korn, "separate from the object that contains the icon. Previously, if a programmer got lazy and didn't set an accessible name for a graphic-only button, it wouldn't be there. But now, if you're using one of the common Java Foundation Classes icon objects with that button, you'll get text from the icon."

Meanwhile, the Accessible Table feature provides information about tables -- the first and last row and column of the table, the total number of rows and columns, the text of captions and headers, and a variety of other descriptions concerning content and format. "There was really no way before this to get detailed information about the 2D structure of a table component," says Korn. "With Accessible Table, you can walk through the cells of the table linearly, and you can find out what the row headers and column headers are. It makes it a lot easier to navigate through applications like spreadsheets."

Perhaps most important in the upcoming features of the Java Accessibility API are the Accessible Relation and the Accessible Relation Set facilities, which provide information about the ways user-interface objects are related to one another. Individual relations are captured by an AccessibileRelation object, while the full set of relations that describe any user-interface object are expressed by that object's AccessibleRelationSet. "This is really ground-breaking," says Korn. "A great deal of information about a user interface comes not when you look at individual objects, but when you look at how they interrelate with one another. These relationships are often obvious to you or me, because we can see them with our eyes. But there's nothing necessarily encoded into the program to tell us about that relationship."

The Accessible Relation facility serves to quantify these all too important implicit nuggets of information -- the fact that cell "C1" of a spreadsheet contains Quarter 1 profits, which contributes to an annual total in cell "C5." "If a blind person is going to have the same quality of experience using software as a sighted person, they need to know that information," says Korn. "With Accessible Relation, and a spreadsheet that fully implements it, a user can arrow over to a cell and be told -- 'cell B4, Q1, Expense, $450, contributing to Q1, Profit, $50, contributing to TTL, Expense, $2,230.'"

Gaining Ground

Most recently, Oracle Corporation has announced that they're implementing the Java Accessibility API on two of their GUI toolkits. "That's a tremendous endorsement," says Korn. "It solidifies the Java Accessibility API as the way to express accessibility information, and greatly broadens the set of tools that developers can use to build accessible applets and Java technology-based applications."

See Also

Overview of Java Accessibility Features
(http://java.sun.com/products/jfc/jaccess-1.2/doc/guide.html)

Java Accessibility FAQ
(http://java.sun.com/products/jfc/jaccess-1.2/doc/FAQ.html)

The Sun Microsystems Accessibility Page
(http://www.sun.com/access)

Java Foundation Classes version 1.1 (containing the Java Accessibility API)
(http://java.sun.com/products/jfc/)

Java 2 SDK (containing the Java Accessibility API)
(http://java.sun.com/products/jdk/1.2/)

Previous Feature Article on the Java Accessibility API
(http://java.sun.com/features/1999/03/access.html)

Bridging the Gap: Java^TM Access Bridge Links Windows-based Assistive Technologies to the Java Platform
(http://java.sun.com/features/2000/03/accessbridge.html)

Java Accessibility Utilities (download)
(http://java.sun.com/products/jfc/index.html#download-access)

Guidelines for Writing Accessible Applications in the Java Programming Language
(http://www.austin.ibm.com/sns/snsjavag.htm)

Accessing the Java Accessibility API with IBM's Self Voicing Kit
(http://www.austin.ibm.com/sns/svkalphapress.htm)

Henter-Joyce, Inc.
(http://www.hj.com/)

The National Center for Accessible Media's "CD-ROM Access Project"
(http://www.wgbh.org/wgbh/pages/ncam/cdrom/)

The Americans with Disabilities Act
(http://www.usdoj.gov/crt/ada/adahom1.htm)

Video Demo of "Photosynthesis Explorer" from Java One '99
(http://www.sun.com/webcast/javaone99/keynote5.html)

Books Covering the Java Accessibility API in Depth:

• "The JFC Swing Tutorial," by Mary Campione and Kathy Walrath
• "Java Look And Feel Design Guidelines," by Sun Microsystems
• "Java Foundation Classes," by Matthew T. Nelson
• "Programming with JFC," by Scott R. Weiner and Stephen Asbury
• "Using Java 1.2," by Mike Morgan
• "Java Swing," by Robert Eckstein, Marc Loy, and Dave Wood

To contact the Sun Accessibility team:

access@sun.com

[ This page was updated: 27-Mar-00 ]