Introduction to J2ME
Java 2 Platform Micro Edition
(J2ME)
Java platform for small devices
A subset of J2SE
Released mid June 1999
Target devices:
– Two-way pagers
– Mobile phones, smart phones
– PDAs (inc PocketPCs)
– TVs, VCRs, CD players
Almost every mobile phone support J2ME
Introduction to J2ME 2
J2ME Phones
Introduction to J2ME 3
3 Java Platforms
Java 2 Platform
Java2 Java2 Java2
Standard Edition Enterprise Edition Micro Edition
(J2SE) (J2EE) (J2ME)
Standard desktop & Heavy duty server Small & memory
Workstation Applications systems Constrained devices
Introduction to J2ME 4
Introduction to J2ME 5
J2ME Architecture
To increase the flexibility of design, the J2ME
consists of two distinct layers:
Configurations and Profiles
Configuration
– Defines the minimum Java technology for a broad
range of devices with similar capabilities
Profile
– Provides capabilities, on top of configuration, for a
specific device type
Introduction to J2ME 6
J2ME Architecture
Two types of J2ME
configurations J2ME Profile
Profile
1. Connected Device
Configuration
2. Connected Limited
Device Configuration
Configuration
J2ME
Libraries CDC, or
CLDC
Java
Virtual Machine
Introduction to J2ME 7
CLDC vs CDC
CLDC
160 Kbytes to 512 Kbytes of total memory
available
16-bit or 32-bit processor
Low power consumption and often operating
with battery power
Connectivity with limited bandwidth.
CDC
2Mbytes or more memory for Java platform
32-bit processor
High bandwidth network connection, most
often using TCP/IP
Introduction to J2ME 8
CLDC
Introduction to J2ME 9
Mobile Information Device Profile
(MIDP)
Is a set of APIs that allow developers to control
mobile device-specific problems
– i.e. user interfaces, local storage and client
application lifecycles etc.
MIDlets minimum requirements
– 96 x 54 pixels mono screen
– two-way wireless network
– input device (i.e. keypad)
– 128 KB for CLDC/MIDP class and another 32 KB
for the KVM
Midlets are the most important and popular
applications in the J2ME family.
Introduction to J2ME 10
MIDP
Introduction to J2ME 11
Building J2ME Apps- Tool
We will use Sun Java Wireless Toolkit 2.x for
CLDC (The newest version is 2.5.2 in Jan 2008)
which can be downloaded from
http://java.sun.com/j2me/download.html
Introduction to J2ME 12
J2ME Wireless Toolkit Demo
Launch the Wireless Toolkit:
– Start > Programs > Sun Java(TM) Wireless Toolkit
2.5.2 for CLDC
WTK already includes a set of demo programs ready
to run.
Introduction to J2ME 13
J2ME Wireless Toolkit Demo
Select menu item
File > Open Project ...
Select UIDemo and
click Open Project.
The projects can be used as the templates of your
applications.
Introduction to J2ME 14
J2ME Wireless Toolkit Demo
Click the Build and then the Run buttons.
Introduction to J2ME 15
J2ME Wireless Toolkit Demo
The main menu screen is shown up. You can choose
a program and select Launch to start the program.
Introduction to J2ME 16
MIDlet Programming
Any MIDP application must extend MIDlet
This is the MIDP equivalent of an applet, where
starting/stopping is under the control of the
environment
Like Java applets, MIDlets have an application life
cycle while running on a mobile device.
Introduction to J2ME 17
MIDlet Transition States
Specifically, a MIDlet can be in one of three states as
shown:
Why do we need
a Paused state?
Introduction to J2ME 18
Midlet Skeleton
import javax.microedition.midlet.*; Note that startApp(), pauseApp()
import javax.microedition.lcdui.*; and destroyApp() are abstract
methods.
public class MyApp extends MIDlet {
public void startApp() { You Midlet program must
// start up code override these 3 methods even
} though you are not doing
anything in it.
public void pauseApp() {
// we aren't showing any more
}
public void destroyApp(boolean unconditional) {
// clean up
}
}
Introduction to J2ME 19
Two Level API
There are two levels of the API
– the high and low-level API.
High-Level Provides input elements such as,
– text fields, choices, and form
Low-level is for drawing on Canvases and capturing
keyed events
All MIDlet applications need to import the necessary
midlet and lcdui packages:
– import javax.microedition.midlet.*;
– import javax.microedition.lcdui.*;
Introduction to J2ME 20
Displaying Objects
High-level Screens have a base class called
Displayable.
To show something on a MIDP device, you need to
obtain the device’s display
– javax.microedition.lcdui.Display class.
This Display class is the one and only display
manager for each active MIDlet and provides
information about the device’s display capability.
Subclassed Displayable classes will fill the whole
screen
Introduction to J2ME 21
Displaying Objects
To show a Displayable object you must use the
setCurrent() method on the Display object.
Form mainForm = new Form ("First Program ");
Display display = Display.getDisplay(this);
display.setCurrent (mainForm);
Note that Form is a Displayable subclass.
Introduction to J2ME 22
First Example - HelloWorld
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
public class HelloWorld extends MIDlet {
public HelloWorld() {
}
public void startApp() {
Form form = new Form( "First Program" );
form.append( "Hello World" );
Display.getDisplay(this).setCurrent( form );
}
public void pauseApp() {
}
public void destroyApp( boolean unconditional ) {
}
} Introduction to J2ME 23
Introduction to J2ME 24
Building the MIDlet
After pressing the Create Project Button, a directory
tree will be created for the project:
Introduction to J2ME 25
Building the MIDlet
Use TextPad to create a source file HelloWorld.java
and save it under the directory src.
Introduction to J2ME 26
Building and Run the MIDlet
Click the Build and then the Run buttons.
Introduction to J2ME 27
How can the program exit?
The program can not exit unless you close the
emulator.
To provide a way to exit the program, you need to
use Commands.
A command is like a button, it has a title, like "OK" or
"Cancel," and your application can respond
appropriately when the user invokes the command.
Introduction to J2ME 28
Event Handling with Commands
Displayable, the parent of all screen displays,
supports Commands.
The device determines how the commands are
shown on the screen or invoked by user.
Every Displayable keeps a list of its Commands. You
can add and remove Commands using the following
methods:
– public void addCommand(Command cmd)
– public void removeCommand(Command cmd)
Introduction to J2ME 29
Command Objects
In J2ME, commands are commonly represented with
soft-buttons on the device. The following diagram
shows two Command objects, one with the label
"Exit" and one with label "View."
soft-buttons
Introduction to J2ME 30
Command Objects
If there are too many commands to be shown on the
display, a device will create a menu to hold multiple
commands. The following diagram shows how this
might look.
Introduction to J2ME 31
Use Command objects
The basic steps to process events with a Command
object are as follows:
1. Create a Command object.
2. Add the Command to a Form (or other GUI
objects TextBox, List, or Canvas).
3. Create and set a listener for the Form.
Upon detection of an event, the listener will call the
method commandAction().
Introduction to J2ME 32
Create a Command
To create a Command, you need to supply a label, a
type, and a priority.
The type is used to signify a commonly used
command. It helps device to arrange the commands.
Command Meaning
BACK returns to the previous screen.
CANCEL standard negative answer to a dialog
EXIT for exiting from the application.
HELP a request for on-line help.
ITEM specific to the items of the Screen or the elements of a
Choice.
OK standard positive answer to a dialog
SCREEN an application-defined command
STOP A command that will stop some currently running
process, operation, etc.
Introduction to J2ME 33
Create a Command
To create a standard OK command, for example, you
would do this:
Command c = new Command("OK", Command.OK, 0);
label
type priority
To create a command specific to your application,
you might do this:
Command c = new Command(
"Launch", Command.SCREEN, 0);
Introduction to J2ME 34
Priority and Long Label
Every command has a priority.
Lower numbers indicate a higher priority.
If you add a command with priority 0, then several
more with priority 1, the priority 0 command will show
up on the screen directly. The other commands will
most likely end up in a secondary menu.
MIDP also supports for long labels on commands.
You can create a command with a short and long
label like this:
Command c = new Command("Run", "Run simulation",
Command.SCREEN, 0);
The device decides which label it will use based on
the available screen space and the size of the labels.
Introduction to J2ME 35
Responding to Commands
Commands show up on the screen, but nothing
happens automatically when a user invokes a
command.
You need to write an object called a listener which
will be called when the user invokes any command in
a Displayable.
The listener is an object that implements the
CommandListener interface.
To register the listener with a Displayable, use the
following method:
– public void setListener(CommandListener l)
Note it is one Listener per Displayable, NOT one
Listener per one Command.
Introduction to J2ME 36
Example
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
public class Commander extends MIDlet implements CommandListener {
public void startApp() {
Displayable d = new Form( "Test Command" );
Command c = new Command("Exit", Command.EXIT, 0);
d.addCommand(c);
d.setCommandListener(this);
Display.getDisplay(this).setCurrent(d);
}
public void pauseApp() { }
public void destroyApp(boolean unconditional) { }
public void commandAction(Command c, Displayable s) {
notifyDestroyed();
}
} Abstract method of CommandListener. Will
be called when any command in the Form is
selected.
Introduction to J2ME 37
Introduction to J2ME 38
Another Command Example
(Two Forms)
Launch
Exit
2nd Form
Exit
Go to First Form
Introduction to J2ME 39
Another Command Example (Two
Forms)
import javax.microedition.lcdui.*;
import javax.microedition.midlet.*;
public class Commander2 extends MIDlet implements CommandListener {
Display display = null;
Form f1 = null;
Form f2 = null;
// command
Command firstFormCommand =
new Command("1st Form", "Go to First Form", Command.SCREEN, 0);
Command secondFormCommand =
new Command("2nd Form", "Go to Second Form", Command.SCREEN, 0);
Command exitCommand =
new Command("Exit", Command.EXIT, 1);
Introduction to J2ME 40
Another Command Example (Two
Forms)
public void startApp() {
display = Display.getDisplay(this);
f1 = new Form( "Form 1" );
f1.append( "This is Form No. 1" );
f1.addCommand(secondFormCommand);
f1.addCommand(exitCommand);
f1.setCommandListener(this);
f2 = new Form( "Form 2" );
f2.append( "This is Form No. 2" );
f2.addCommand(firstFormCommand);
f2.addCommand(exitCommand);
f2.setCommandListener(this);
display.setCurrent( f1 );
}
Introduction to J2ME 41
Another Command Example (Two
Forms)
public void pauseApp() {
}
public void destroyApp(boolean unconditional) {
}
public void commandAction(Command c, Displayable d) {
String label = c.getLabel();
if (label.equals("Exit")) {
notifyDestroyed();
} else if (label.equals("1st Form")) {
Display.getDisplay(this).setCurrent( f1 );
} else {
Display.getDisplay(this).setCurrent( f2 );
}
}
}
Introduction to J2ME 42
Simple Debugging
System.out.print and System.out.println can be used
for debugging.
When run in the simulator, the output is put on the
console, not the phone.
public void commandAction(Command c, Displayable d) {
String label = c.getLabel();
if (label.equals("Exit")) {
notifyDestroyed();
} else if (label.equals("1st Form")) {
System.out.println("1st Form is called");
display.setCurrent( f1 );
} else {
System.out.println("2nd Form is called");
display.setCurrent( f2 );
}
Introduction to J2ME 43
J2ME User Interface I
Major classes in the lcdui
package
To be discussed in
this lecture
Introduction to J2ME 45
TextBox
The simplest type of screen is the TextBox.
TextBox allows the user to enter a string.
Text input is a difficult task on mobile phones. Many
devices only have a numeric keypad, so entering a
single character is a matter of one, two, three or four
button presses.
A good MIDlet requires minimal user input.
an email TextBox
Introduction to J2ME 46
TextBox
A TextBox is created by specifying four parameters:
public TextBox(String title, String text, int maxSize, int
constraints)
The title is used as the screen title
The text and maxSize determine the initial text and maximum
size of the text box.
The constraints are used to restrict the user's input.
– ANY : allows any type of input.
– NUMERIC : restricts the input to integers.
– DECIMAL : allows numbers with fractional parts.
– PHONENUMBER : requires a telephone number.
– EMAILADDR : input must be an e-mail address.
– URL : input must be a web address.
Introduction to J2ME 47
TextBox Constraints
The devices don't allow invalid input; for example, a NUMERIC
TextBox doesn't allow you to enter alphabetic characters.
Constraints may be combined with the flags listed below.
Constraints limit the behavior of users, while flags define the
behavior of the TextBox.
The available flags are:
PASSWORD : characters are not shown when entered;
generally, they are represented by
asterisks.
UNEDITABLE : indicates text that cannot be edited.
Introduction to J2ME 48
TextBox Flags
SENSITIVE : indicates that text should not be stored. Some input
schemes store input from the user for later use in
autocompletion. This flag indicates that the text
should not be saved or cached.
NON_PREDICTIVE : indicates that you are expecting the user to
enter text that any text-predicting input scheme will
probably not be able to guess. For example, if
you're expecting the user to enter an order number
like Z51002S, you would use this flag to tell the
input scheme to not bother trying to predict the
input.
INITIAL_CAPS_WORD : is used for input where each word
should be capitalized.
INITIAL_CAPS_SENTENCE indicates input where the first
character of each sentence should be capitalized.
NOT all of these settings may be functional in all
devices.
Introduction to J2ME 49
TextBox Flags
The flags may be combined with any of the other
constraints using the OR operator ( | ).
For example, to create a TextBox that asks the user
to enter a number password, you would do
something like this:
Displayable d = new TextBox( "PIN", "", 8,
TextField.NUMERIC | TextField.PASSWORD);
Introduction to J2ME 50
Password
Be careful in using PASSWORD.
For every character you enter, the password field
shows an asterisk or some other symbol.
On mobile phones and other small devices, security
is less of a concern because the screens are smaller
and much more difficult to read than a typical
desktop monitor.
Introduction to J2ME 51
Example: Accept a string from
TextBox and echo it
One TextBox
Two Commands
- Exit and Greet
One CommandListener
Introduction to J2ME 52
Example
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
public class TextBoxTest extends MIDlet implements
CommandListener {
private Display display;
private TextBox tbClip;
private Command cmExit;
private Command cmGreet;
public TextBoxTest() {
cmExit = new Command("Exit", Command.EXIT, 0);
cmGreet = new Command("Greet", Command.SCREEN, 1);
tbClip = new TextBox("Textbox Test", "", 20,
TextField.ANY);
tbClip.addCommand(cmExit);
tbClip.addCommand(cmGreet);
tbClip.setCommandListener(this);
}
Introduction to J2ME 53
Example
public void startApp() {
display = Display.getDisplay(this);
display.setCurrent(tbClip);
}
public void pauseApp() {
}
public void destroyApp(boolean unconditional) {
}
public void commandAction(Command c, Displayable s) {
if (c == cmExit)
notifyDestroyed();
else if (c == cmGreet)
System.out.println("Hello " + tbClip.getString());
}
}
Introduction to J2ME 54
Alerts
An Alert is essentially a simple dialog box. There are
two types of Alert:
– modal, which displays the dialog until
acknowledged by the user, and
– timed, which is displayed for a specified number of
seconds.
The constructors for an Alert are shown below:
Alert(String title)
Alert(String title, String alertText, Image alertImage,
AlertType alertType)
Introduction to J2ME 55
Alerts
The AlertType class provides five types: ALARM,
CONFIRMATION, ERROR, INFO, and WARNING.
The AlertType component uses sound, rather than an image, to
notify the user of an event.
By default, timed Alerts are created using a default timeout
value; you can find out the default value by calling
getDefaultTimeout().
To set the timeout value to five seconds, you could do this:
alert.setTimeout(5000);
If you want a modal alert, use the special value FOREVER:
alert.setTimeout(Alert.FOREVER);
Introduction to J2ME 56
Example Five Alerts
The following example, FiveAlerts, shows all types of alert.
The display has six commands (5 Alerts + 1 Exit).
The default timeout value is 2000ms = 2 seconds. i.e. The Alert
screen will dismiss after 2 seconds.
Introduction to J2ME 57
Example - Five Alerts
The Error Alert will stay until the user dismiss it.
The Info Alert will stay for on the screen for 4
seconds.
After the alert dismisses, the display will return to the
previous screen
public void setCurrent(Alert alert)
or go to next screen if the following setCurrent is
used:
public void setCurrent(Alert alert, Displayable nextDisplayable)
Introduction to J2ME 58
Example - Five Alerts
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
public class FiveAlerts extends MIDlet implements CommandListener {
private Display disp;
private Form f;
private Alert alarm;
private Alert confirm;
private Alert error;
private Alert info;
private Alert warning;
private Command alarmCommand, confCommand, errCommand,
infoCommand, warnCommand, exitCommand;
public FiveAlerts() {
alarmCommand = new Command("Alarm", Command.SCREEN, 1);
confCommand = new Command("Confirm", Command.SCREEN, 1);
errCommand = new Command("Error", Command.SCREEN, 1);
infoCommand = new Command("Info", Command.SCREEN, 1);
warnCommand = new Command("Warning", Command.SCREEN, 1);
exitCommand = new Command("Exit", Command.EXIT, 0);
Introduction to J2ME 59
f = new Form("Five Alerts");
f.addCommand(alarmCommand);
f.addCommand(confCommand);
f.addCommand(errCommand);
f.addCommand(infoCommand);
f.addCommand(warnCommand);
f.addCommand(exitCommand);
f.setCommandListener(this);
alarm = new Alert("Alarm",
"Your payment is due today.",
null,
AlertType.ALARM);
confirm = new Alert("Confirmation",
"Do you want to proceed?",
null,
AlertType.CONFIRMATION);
error = new Alert("Network error",
"A network error occurred. Please try again.",
null,
AlertType.ERROR);
Introduction to J2ME 60
info = new Alert("About",
"This program is used to demonstrate use of Alert."
+ " It will displayed for 4 seconds",
null,
AlertType.INFO);
warning = new Alert("Warning",
"Memory is low.",
null,
AlertType.WARNING);
System.out.println("DefultTimeout = "
+ alarm.getDefaultTimeout());
error.setTimeout(Alert.FOREVER);
info.setTimeout(4000); // display for 4 seconds
}
public void startApp() {
disp = Display.getDisplay(this);
disp.setCurrent(f);
}
Introduction to J2ME 61
public void pauseApp() {
}
public void destroyApp(boolean unconditional) {}
public void commandAction(Command c, Displayable s) {
if (c == alarmCommand)
disp.setCurrent(alarm);
else if (c == confCommand)
disp.setCurrent(confirm);
else if (c == errCommand)
disp.setCurrent(error, f);
else if (c == infoCommand)
disp.setCurrent(info, f);
else if (c == warnCommand)
disp.setCurrent(warning, f);
else if (c == exitCommand)
notifyDestroyed();
}
}
Introduction to J2ME 62
DISMISS_COMMAND - Done
MIDP implementation automatically supply a
DISMISS_COMMAND to dismiss a modal alert.
For example, the Sun's emulator provides a Done command
mapped to a soft button.
You can replace the default DISMISS_COMMAND by using the
addCommand() method.
When the application first adds a command to an Alert,
DISMISS_COMMAND is implicitly removed.
Introduction to J2ME 63