Habanero^® is a framework or API for sharing Java objects with other remote colleagues through the Internet. Included are all the networking facilities, routing, arbitration and synchronization mechanisms necessary to accomplish the sharing of state data and key events between collaborator's copies of a software tool.

Habanero framework is built to facilitate adding internet-distributed collaborative capability to diverse applications. These applications could be either new applications designed to fit into habanero framework or existing applications or applets which have to be modified a bit to integrate the new collaborative functionalities.

The goal of this paper is to give some guidelines to the developers who want to design from scratch a collaborative application or modify an existing application or applet into a collaborative one.

Defining what kind of collaborative actions are needed

The first thing a developer needs to decide is what will be shared in the new collaborative application.

Things to consider:

• some actions should only be seen by the user who is performing the action.
• other actions should be propagated to all the users working on the same tool

To help you decide, you should determine what kind of feedback all the participants need to see when a user performs an action or changes a data value. For instance, all copies of a toggle button should change when one of the participant selects a value. But local mouse movements could be limited to each individual user.

All these solutions have to be defined according to the nature of the application and the nature of the collaborative interactions between users.

Impact on the application's design

More than in a traditional application, the design of a collaborative application means the decomposition of the design into abstraction, control, and presentation parts. The abstraction level will be in charge of the domain of the application (i.e., accessing to the database, performing the calculation or other computations, etc..). The control part communicates between the abstraction and the presentation level. The presentation level processes the display and the user events.

This is short explanation is based on several well known models of architecture like MVC (Model View Controller) or PAC (Presentation Abstraction Control). If you are not familiar with this kind of architecture you might take some time to read about them. It will save you time later in the realization phase.

In a collaborative application, the user actions and the performed actions must be separated. Because of this a collaborative kernel is added to propagate an action to all the other participants or determine if it is to be kept local.

That means in the design of the application you have to carefully distinguish :

The reception of an user event on his own tool and how to handle it.

The handling of this event should make all the verification to determine what does this event means in the current context, and what action(s) should be performed by the tool.

The propagation of this action to everyone through the habanero framework.

The propagation of this action could be made by:

• forcing the Java system to pass the event to the Habanero Frame of the application. With the Java 1.1 event model this is performed by calling the Habanero.sendEvent(AWTEvent evt) method.

• OR specifying which type of event should be shared using the Habanero.addSharedEventType method.

How to port an application into the Habanero Framework

This process is facilitated with the Habanero framework which takes care of all the collaborative mechanisms such as routing, arbitrating, synchronizing, and networking mechanisms. Nevertheless, you still need to do few things to make your own collaborative application:

Turning an Applet into a Hablet:

plugging it into the Habanero Framework

• The constructor of the new Hablet must take no arguments. If your Applet took arguments then create one that uses default or static variables and if necessary add a way for the user to set them.

  For example:

  public CollabDraw() {
  	somevariable = true;
  }

• Make your application extend the Habanero Hablet class.

  For example:

  public class TicTacToe extends ncsa.habanero.Hablet

The differences between an Applet and a Hablet:

When your applet was running under a browser, you were able to call some functions that are not available to it as an application. For example:

• the applet.getDocument() method is not available to applications. Instead, you have to declare a String variable to set it to the URL of the location where you want to connect.

• the applet.getImage(URL) method is no longer available and is replaced with the method Toolkit.getDefaultToolkit().getImage(URL)

• Be aware that all the methods used to display an HTML page are no longer available because your applet is no longer connected with an browser. With this in mind, you can't access or display them so all of these actions should be disabled.

• If you want to extend the behavior of different kinds of UI objects, you can extend them taking full advantage OO programming, but don't forget to modify the constructor before they are created.

Initial and Current States

During a collaborative session, a new user can join a session at any time and it is important to be able to know the state of a tool at any time during its instantiation. It is also important to be able to load the current state as an initial state for anyone joining the session while the tool is in use. Thus, each collaborative tool needs the ability to get the state of the user interface (UI) object(s) and the ability to set them during the course of loading the tool.

To send the state of a tool over the network, you need to make sure that it implements the Serializable interface. For example:

	
	public class myUIClass implements Serializable {


	}

The Differences when Comparing Objects

In a collaborative application, you can't compare two objects in the same way you do it in a single user application. That means, if you want to retreive a specific object in each instance of the collaborative tool, you can't deal with the object (pointers) themselves. But you need to have a property to identify them, like a name or a key, and then retrieve the right object by comparing the identificator. For example, with a button, the identifyer is its label and you can retrieve it with method getLabel().

[ Download ] [ User Docs ] [ FAQs ] [ Home ] [ Dev API ] [ Tools ] [ License ]

Habanero^® is a registered trademark owned by The Board of Trustees of the University of Illinois. Copyright 1996-1998. All rights reserved.   Java^(TM) is a proprietary trademark owned by Sun Microsystems, Inc.