Some of the major parameters within the ADF file are detailed in Table 22.1.

For example, a sample JAM file named MySample.jam might look like this:

AppName = MYSampleApp
AppClass = MySample
AppVer = 1.0
PackageURL = http://www.sample.com/MySample.jar
AppSize = 1014
AppParam = argl arg2 arg3
LastModified = Fri, 3 Mar 2002 11:11:11

The provisioning process works as follows:

All iAppli applications can also operate as standalone apps. For example, a user can enjoy a single-player action game without connecting to the network and incurring network fees of any kind.

After an iAppli program has been downloaded, users can activate it directly from the original cHTML i-mode page.

Each JAM file has a LastModified entry. If the key is out of date, then the new JAR file will be downloaded and installed. After everything is installed properly, the old JAR file will be deleted. All data in the ScratchPad, however, will remain intact.

To drop an iAppli program within an i-mode cHTML page, you can use the <OBJECT> tag as follows:

<OBJECT declare id="application.declaration" data="MySampleApp.jam" type="application/x-jam">
Here's a Sample IAppli Java Application
</OBJECT>

Point to the JAM file using the data attribute. You can then have the user download the iAppli as follows:

<A ijam="#application.declaration" href="fail.html">Download The Sample App!</A>

Note that the href attribute points to a URL that will only come up if the application's download fails. This is a good place to put an error or help page.

Low-level API is based on the com.nttdocomo.ui.Canvas class. Methods in this class include the following:

A low-level implementation of iAppli Canvas is almost identical to the way you would do it with the MIDP standard. Basically, all the action happens in the paint() method.

You could create a simple Canvas class as follows:

import com.nttdocomo.ui.*;

public class MyCanvas extends Canvas(){

    MyCanvas(){
    }

    public void paint(Graphics g){
        g.lock();
        g.clearRect(0, 0, 200, 200);
        g.drawString("Hello", 10, 10);
        g.drawRect(5,5, 195, 195);
        g.unlock(true);
    }
}

Note the g.lock() and g.unlock() methods. You should always surround all drawing routines with these functions to draw to an offscreen buffer and create flicker-free graphics.

You could bring the canvas to life by creating an iAppli as follows:

import com.nttdocomo.ui.IApplication;

public class HelloIAppli extends IApplication{
    public void start() {
        MyCanvas myCanvas = new MyCanvas();
              Display.setCurrent(myCanvas);
    }
}

The com.nttdocomo.ui.Graphics class is very similar to the MIDP's Graphics class. There are some interesting additions and omissions, however:

All high-level UI is achieved by creating a Panel. First off, you can set the title of the panel as follows:

setTitle("My Panel");

You can then add various user interface elements. Elements will appear in the panel according to the order you add them. You can adjust elements using standard component methods such as setEnabled(), setVisible(), and so on.

Some of the user interface elements are discussed in the following sections.

Label lab = new Label("Username:", Label.LEFT);
add(lab);

TextBox name = new TextBox("Henry", 50, 1, TextBox.DISPLAY_ANY);
TextBox pass = new TextBox(null, 50, 1, TextBox.DISPLAY_PASSWORD);
name.setInputMode(TextBox.KANA);
pass.setInputMode(TextBox.NUMBER);

ListBox lb = new ListBox(ListBox.RADIO_BUTTON);
String items[] = new String[3];
items[0] = "Choice 1";
items[1] = "Choice 2";
items[2] = "Choice 3";
lb.setItems(items);
add(lb);

Ticker tick = new Ticker();
tick.setBackground(Graphics.getColorOfName(Graphics.LIME));
tick.setText("This text will scroll and scroll forever!");
add(tick);

VisualPresenter vp = new VisualPresenter();
add(vp);
vp.setAttribute(VisualPresenter.IMAGE_XPOS, 0);
vp.setAttribute(VisualPresenter.IMAGE_YPOS, 0);
MediaImage mediaImage = MediaManager.getImage("resource:///myimage.gif");
try {
 mediaImage.use();
}  catch (Exception e) {  }
Image img = mediaImage.getImage();
int imgWidth = img.getWidth();
int imgHeight = img.getHeight();
vp.setImage(mediaImage);
vp.setSize(Display.getWidth()/2, Display.getHeight()/2); 
vp.play();

Button but = new Button("Hit Me!");
add(but);

Dialog dialog = new Dialog(DIALOG_INFORMATION,"Hello");
dialog.setText("Hello sir.");
dialog.show();

The event model for iAppli programs is similar to the listener-delegation model used in JDK 1.1.

If you are drawing a bunch of widgets using high-level user interface classes, listeners might not be registered within a component—but only in the container or panel that holds the component.

If you are drawing directly to the screen using the low-level APIs, all events are automatically passed to the processEvent() method of the Canvas drawing area. This method can be overridden and all events can thus be handled. You do not need to add a special listener.

class HelloCanvas extends Canvas {

    // Put all drawing here, in the paint() method...

    public void processEvent(int type, int param)
        {
        if(type == Display.KEY_PRESSED_EVENT)
              {
                      int key = getKeypadState();
                      if (param == Display.KEY_RIGHT)
                          // The right cursor key was pressed.
            else if(param == Display.KEY_SOFT1)
                // Softkey 1 was pressed.
            else if(param == Display.KEY_SOFT2)
                // Softkey 2 was pressed.
            else if
        }
    }
}

setKeyListener(this);

public class ButtonTest extends Panel implements ComponentListener
{
 Button btn;

 ButtonTest() {
 btn = new Button("Button");
 this.add(btn);
 setComponentListener(this);

 public void componentAction(Component source, int type, int param)
 {
    if (source instanceof Button && type == BUTTON_PRESSED)
        // Do something!
 }
}

setSoftKeyListener(this);

setSoftLabel(Frame.SOFT_KEY_1, "Exit");

public void softKeyPressed(int key)
{
    if (key == Frame.SOFT_KEY_1)
        MainApp.terminate();
}

public void softKeyReleased(int key) {}

iAppli can handle the following formats:

Images and sounds can be loaded using the com.nttdocomo.ui.MediaManager's methods:

There are two main locations you can read media from:

MediaImage mi = MediaManager.getImage("resource:///sample.gif");

try{
 mi.use();
}
catch(ConnectionException ce){
    // Could not connect.
} catch(UIException ui){
          // Other exception.
}
Image img = mi.getImage();

AudioPresenter ap;
MediaSound ms;
ap = AudioPresenter.getAudioPresenter();
ms = MediaManager.getSound("resouce:///audio/test.mld");
try {
 ms.use();
}
catch (Exception e) {  }
ap.setSound(ms);

ap.play();

ap.setMediaListener(this);

public void mediaAction(MediaPresenter source, int type, int param)
{
 switch (type) {
 case AudioPresenter.AUDIO_PLAYING:
  break;
 case AudioPresenter.AUDIO_COMPLETE:
  break;
 case AudioPresenter.AUDIO_STOPPED:
  break;
}

In order to use HTTP communications, you have to add the "UseNetwork = http" line to your application's ADF (JAM) file.

Basically, HTTP communications work the same with iApplis as they do with MIDlets. For example, to read data from a servlet on the network (http://www.myhost.com/myservlet) and put it into a byte array called data you would use the following code:

HttpConnection http = null;
InputStream in = null;
byte[] data = null;
String URL = "http://www.myhost.com/myservlet";

try
{
 http = (HttpConnection)Connector.open(URL,Connector.READ);
 http.setRequestMethod(HttpConnection.GET);
 http.connect();

 int contentLength = (int)http.getLength();
 in = http.openInputStream();

 data = new byte[contentLength];
 in.read(data);
}
catch(ConnectionException ce)
{
 // Handle a connection exception.
}
catch(Exception e)
{
 // Handle other type of exception
}
finally
{
 try
 {
  if(in!=null)
  {
  in.close();
  in = null;
  }
  if(http!=null)
  {
  http.close();
  http = null;
  }
 }
 catch(Exception e)
 {
  http = null;
  in = null;
 }
}

To write to the server you would use code similar to the following:

http = (HttpConnection)Connector.open(URL, Connector.WRITE);
http.setRequestMethod(HttpConnection.POST);
http.setRequestProperty("Content-Type","application/octet-stream");
DataOutputStream stream = http.openDataOutputStream();
stream.write(data,0,data.length);
stream.close();
http.close();

Writing and reading to the ScratchPad is really easy. Simply use "scratchpad:///0" as the URL protocol. For example, to write four Unicode characters to the ScratchPad, use the following code:

try
{
 OutputStream out = Connector.openOutputStream("scratchpad:///0");
 out.write(0xfe);
 out.write(0xff);
 out.write(0x100);
 out.write(0x101);
 out.close();
}
catch (IOException e)
{
System.out.println("IOException in save");
}

And to read those bytes back in

try
{
 InputStream in= Connector.openInputStream("scratchpad:///0");
 for(int i=0; i<4; i++)
 {
  System.out.println(in.read());
 }
 in.close();
}
catch (IOException e)
{
 System.out.println("IOException in read");}
}

You could also read or write several bytes at a time using OutputStream's write(String data,int offset,int length) method. Then read in using the read(String data,int offset, int length) method.