J2ME

1
J2ME

• JAVA 2 Micro Edition

2
JAVA editions

J2Enterprise Edition
J2 Standard Edition
J2 Micro Edition
3
Architectures
Desktop
machines
Java 2 Enterprise Edition (J2EE)
Smart- cards
Java 2 Standard Edition (J2SE)
Personal Profile
Foundation Profile
MIDP
Java Card APIs
CDC
CLDC
KVM
Java Virtual Machine
4
KVM

• The device requires the Java virtual machine
  named KVM
• minimal amount of Java application programming
  interface
• (Java API) libraries included it.
• K means kilo, indicating that the J2ME
  runnable
• environment virtual machine size is measured in
  kilobytes,
• not in megabytes

5
J2ME Configurations CDC and CLDC
Sun has split the J2ME into configurations. Config
urations define virtual machine features and Java
language features API classes exist for each
configuration environment
6
CDC - Connected Device Configuration

• This covers devices with large interface
  capabilities
• Such as TV set top boxes
• A large API is likely to be needed

7
Connected Limited Device Configuration (CLDC)

• For devices which have simple user interfaces
• and low memory
• Devices like cellular phones and PDAs
• The CLDC requires 160 kB to 512 kB of total
  memory
• Virtual machine the interpreter that runs
  applications
• plus java.io, java.lang, java.util

8
Outside CLDC Scope

• Specified in Profiles to be implemented
• on top of the CLDC
• User interface support
• Event handling
• High-level application model
• Persistence support
• remaining APIs MIDP

9
Profiles

• The Mobile Information device Profile (MIDP) is a
  further set of APIs for mobile devices
• javax.microedition.midlet (MIDlet lifecycle),
  javax.microedition.lcdui (interface development),
  javax.microdedition.rms(storage
  facilities)
• You can find more information about
• MIDP and CLDC at the following URLs
• http//java.sun.com/products/midp
• http//java.sun.com/products/cldc

10
MIDlets

• A MIDlet is a Mobile Information Device
  application that runs on a MIDP device
• The name is similar to servlet and applet and it
  shares similar characteristics
• They have a lifecycle and occupy various states
  during program execution

11
MIDlets continued

• Servlet container loads the servlet into memory
• MIDlets are loaded in a similar fashion MIDP
  developers store several MIDlets in a jar file
  called a MIDlet suite
• The MIDP device contains a program called the
  application management software (AMS)

12
Application Management Software (AMS)

• MIDlet suite is held on the server
• The AMS downloads the MIDlet suite from the server

Application descriptor file
Server MIDlet suite
.jad
AMS
13
Lifecycle of a MIDlet

• AMS calls MIDlets constructor
• AMS calls startApp (now activated)
• If AMS calls method pauseApp then MIDlet is
  paused
• A call of destroyApp terminates the MIDlets
  execution

14
Midlet package

• MIDlets are packaged in a JAR file including
• Class files of the MIDlet(s)
• Resource files
• Manifest with application properties
• Application Descriptors (JAD files) accompany
• MIDlet JARs and provide deployment
• information (name, version, size, etc.)

15
Wireless Toolkit

• The J2ME Wireless Toolkit supports the
  development of Java
• applications that run on devices compliant with
  the Mobile Information
• Device Profile (MIDP), such as cellular phones.
• The J2ME Wireless Toolkit supports a number of
  ways to develop
• MIDP Applications
• - running the tools from the command line
  yourself
• - relying on development environments
• The toolkit provides a basic UI called KToolBar.

16
Mobile information device characteristics(minimum)
96 pixel wide 54 pixel height display Touch
screen, keypad or keyboard Wireless connection of
limited bandwidth 128k non volatile memory to
store MIDP components 8k for persistent data 32k
of volatile memory for Java run time
17
MIDP summary
Defines and controls applications, handles
graphics and user events, storage,networking,
scheduling
JAVA application
MIDP
CLDC
Uses KVM, data types, io, util
18
Base UI Class Displayable

• The screen in MIDP is of a fixed size
  represented
• by the displayable object
• Displayable can be considered to be similar to a
  WAP card
• It has two abstract subclasses
• Screen
• Canvas

19
Screens and events
A MIDlet uses screens for output. Only one screen
at a time is visible Predefined screen
types Alert List TextBox
20
A reference to the device's display can be
obtained by providing a MIDlet reference to the
static getDisplay( ) method public static
Display getDisplay(MIDlet c) This is typically
done in the startApp( ) method of a MIDlet, as
follows public class MyMIDlet extends MIDlet
Display display null public MyMIDlet( )
// constructor public void startApp( )
display Display.getDisplay(this)
// other methods
21
Alert
A pre defined screen providing information but
with An associated timeout. It can also be
modal. The purpose is to provide a signal for
exceptional circumstances and errors
22
Two constructors for the Alert class public
Alert(String title) public Alert(String title,
String alertText, Image alertImage, AlertType
alertType)
Alert alert new Alert("title") alert.setTimeout
(4000)
Alert timedAlert new Alert("Confirmation",
"Your message has been sent!", null,
AlertType.CONFIRMATION) TimedAlert.setTimeout(500
0) Display display Display.getDisplay(this)
23
List
A list of choices. List implements the Choice
interface Three types - Multiple -
Exclusive - Implicit (fires a Command)
24
Display display Display.getDisplay(this) List
menu new List("Edit", Choice.EXCLUSIVE) menu.ap
pend("Save") menu.append("Move
to") menu.append("delete") display.setCurrent(me
nu) Set up a command handler to listen for
selection then Execute the necessary function
associated with that selection see tutorial
25
TextBox
TextBox mytext new TextBox(Introduction,
Welcome, 256, TextField.ANY) Di
fferent types of input are defined within the
TextField class
26
Form class

• User interface controls can be grouped together
  on a screen called a Form
• The Form class is a subclass of screen
• Form items can be Choicegroup(list),
• Datefield, Gauge (bar graph), ImageItem,
  StringItem, TextField

27
ChoiceGroup
A choice group is very similar to a List, but
used for embedding in a FORM ChoiceGroup mycg
new ChoiceGroup(Courses, Choice.MULTIPLE) my
cg.append(Maths,null) mycg.append(Science,nul
l)
28
MIDP Class Hierarchy
Displayable
Interface Choice
Screen
Canvas
Form
Alert
TextBox
List
29
MIDP Class Hierarchy
Item
Interface Choice
ChoiceGroup
Guage
TextField
StringItem
ImageItem
DateField
30
Events

• Actions and commands
• A Command has a label, type and priority
• Examples of Command types are
• BACK, CANCEL, EXIT, HELP, ITEM, OK, SCREEN and
  STOP

31
Command Class

• A Command represents an action a user can select.
  Keys displayed on a screen are called soft
  keys.
• Selecting a soft key causes a Command to be
  selected
• Typically a MIDlet can be made to listen for a
  Command and then execute some code in response

32
Soft keys being set up
// create soft button commands
selectCommand new Command( "Select",
Command.OK, 0 ) nextCommand new Command(
"Next", Command.OK, 0 ) backCommand new
Command( "Back", Command.BACK, 1 )
33
import javax.microedition.lcdui. import
javax.microedition.midlet. public class
HelloWorld extends MIDlet implements
CommandListener private final static
String a1 "HelloWorld" private final static
String a2 "Bye" private Command
exitCommand private Command backCommand
private Display display private TextBox t
public HelloWorld() display
Display.getDisplay(this) exitCommand new
Command("Exit", Command.EXIT, 1) backCommand
new Command("Back", Command.BACK, 1)
34
public void startApp() List l new
List("Choose", Choice.IMPLICIT) l.append(a1,
null) l.append(a2, null)
l.addCommand(exitCommand) l.setCommandListene
r(this) display.setCurrent(l)
35
public void helloWorld() t new
TextBox(a1, "Hello World", 256, TextField.ANY)
t.addCommand(exitCommand)
t.addCommand(backCommand) t.setCommandListene
r(this) display.setCurrent(t)
36
public void commandAction(Command c, Displayable
s) if (c List.SELECT_COMMAND)
List l (List) s String choice
l.getString(l.getSelectedIndex()) if
(choice.equals(a1))
helloWorld() else if
(choice.equals(a2))
notifyDestroyed() int
commandType c.getCommandType() if
(commandType Command.BACK)
startApp() else if (commandType
Command.EXIT) notifyDestroyed()
37
Exercise use JBuilder to develop a MIDlet
Carry out the instructions in tutorials
38
Low level API

• The high-level API requires you to use
  task-oriented abstractions to define what the
  user interface does.
• You have no real control over what gets drawn on
  the screen -- the implementation selects the best
  approach for the device

39
Canvas class

• Unlike the high-level API, the low-level API
  gives you complete access to the screen and to
  input events
• You can use both the high-level and low-level
  APIs in the same application, but not at the same
  time
• To use the low-level API in a MIDlet, you must
  write a class that extends the Canvas class

40
Canvas Class

• Low level events such as key presses are only
  available on Canvases
• The low level API defines methods for drawing
  text and graphics on the display
• Such capabilities are only available for canvases
  all other screen types have painting automated
• Repaint occurs when the system calls the canvas
  paint method

41
import javax.microedition.lcdui. import
javax.microedition.midlet. public class
MyCanvas extends Canvas private MIDlet
midlet public MyCanvas( MIDlet midlet )
this.midlet midlet
42
protected void paint( Graphics g )
g.setColor( 255, 255, 255 )
g.fillRect( 0, 0, getWidth(), getHeight() )
g.setColor( 0, 0, 0 )
g.drawString( Low level API calls!",
getWidth()/2, 0, g.TOP g.HCENTER )

43
Calling the Canvas

• standard drawing primitives you would expect,
  such as drawArc, drawLine, drawRect, and
  drawString. Color is supported in the API using a
  24-bit RGB model, although the device might
  support less color than the API. The MyCanvas
  example simply erases the screen by painting it
  white and then draws a string (in black) at the
  center top of the screen.
• You activate a canvas by calling the setCurrent
  method on the MIDlet's Display object, usually in
  the startApp method of the application's MIDlet
  class

44
import javax.microedition.midlet. public class
MyMIDlet extends MIDlet private Display
display private MyCanvas canvas
public MyMIDlet() display
Display.getDisplay( this ) canvas
new MyCanvas( this ) protected
void startApp() display.setCurrent(
canvas ) protected void
pauseApp() protected void
destroyApp( boolean unconditional )
public void exit() destroyApp( true )
notifyDestroyed()
45
Input Events

• Pressing the keypad (keyPressed, keyRepeated, and
  keyReleased)
• Using the pointer (pointerPressed, pointerDragged
  and pointerReleased) if a pointer is available on
  the device
• Showing the canvas (showNotify, hideNotify).

46
public class MyCanvas extends GameCanvas
private String message "Press any key" int
fireKey int leftKey. public MyCanvas(
MIDlet midlet ) super( midlet )
protected void paint( Graphics g )
g.setColor( 255, 255, 255 )
g.fillRect( 0, 0, getWidth(), getHeight() )
g.setColor( 0, 0, 0 )
g.drawString( message, getWidth()/2, 0,
g.TOP g.HCENTER ) protected void
keyPressed( int keyCode ) if( keyCode
fireKey ) message "FIRE"
else if( keyCode leftKey )
message "LEFT" else if(
keyCode rightKey ) message
"RIGHT" else if( keyCode upKey
) message "UP"
else if( keyCode downKey )
message "DOWN" else
message getKeyName( keyCode )
repaint()
47
import javax.microedition.midlet. public class
MyMIDlet extends MIDlet implements
CommandListener private Display display
private MyCanvas canvas private Command
exitCommand new Command("Exit", Command.SCREEN,
1 ) public MyMIDlet() display
Display.getDisplay( this ) canvas new
MyCanvas( this ) canvas.addCommand(
exitCommand ) canvas.setListener( this
) protected void startApp()
display.setCurrent( canvas )
protected void pauseApp() protected
void destroyApp( boolean unconditional )
public void exit() destroyApp( true )
notifyDestroyed() public void
commandAction( Command c, Displayable d )
if( c exitCommand ) exit()
The CommandListener interface defines
a single method, commandAction, that is called
whenever a command is triggered

48
Summary
A MIDlet typically has a Constructor for
initialisation A starttApp() method which is
called whenever the MIDlet Becomes the devices
current process A pauseApp() A commandAction() A
destroyApp() The Wireless toolkit enables us to
build and run MIDlets It can be integrated into
an IDE.
49
The MIDlet Suite
MIDlets in a MIDlet suite can interact with each
other MIDlets are stored in the JAR file Other
files include The MIDlet Application Descriptor
file (JAD) The MIDlet Suite Manifest File
(describes the contents of the MIDlet Suite)