J.E.N.I.

Chapter 2
Starting Mobile Programming
2.1 Objectives
In this section, we will be delving into writing, building, using the emulator and
packaging J2ME applications. The Integrated Programming Environment that we will use
is NetBeans 4.1 (www.netbeans.org) and NetBeans Mobility Pack.

At the end of the lesson, the student should be able to:

Create a simple MIDlet

Create a Project in Netbeans

Create a MIDlet in Netbeans Mobility Pack

Run a MIDlet on the emulator

2.2 Getting Started

IDE (Integrated Development Environment) is a programming environment (programming
environment) that has a GUI builder, text or code editor, compiler and / or interpreter and
debugger. In this case, NetBeans Mobility Pack also has device emulator. This facility can
make us see our program on the device indeed.

2.3 "Hello, world!" MIDlet

We have learned in the previous section about the life cycle of a MIDlet (MIDlet's life
cycle). MIDlet began life when the MIDlet created by the Application Management System
(AMS) on the device.

Pengembangan Perangkat Mobile

So that we can create a MIDlet, we must create a subclass of the MIDlet class of
javax.microedition.midlet package. We also need to override or implement the method:
startApp (), destroyApp () and pauseApp (). Those methods are is the method required
by AMS to run and control the MIDlet.

new
destroyApp()

startApp()

Paused
Destroyed
pauseApp()

Active

destroyApp()

Unlike the Java program in general where the method main () is only used once in the
course of the program, method startApp () may be called more than once in the MIDlet
life cycle. So you are required to not make one initialization code in the method startApp
(). Instead, you can create a MIDlet consturctor and initializing there.

Here is our first MIDP program code

/*
* HelloMidlet.java
*
* Created on July 8, 2000, 9:00 AM
*/

import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
/**
*

* @author

JEDI Apprentice

* @version
*/
public class HelloMidlet extends MIDlet implements CommandListener {
Display display;
Command exitCommand = new Command("Exit", Command.EXIT, 1);
Alert helloAlert;
public HelloMidlet(){
helloAlert = new Alert(
"Hello MIDlet", "Hello, world!",
null, AlertType.INFO
);

helloAlert.setTimeout(Alert.FOREVER);
helloAlert.addCommand(exitCommand);
helloAlert.setCommandListener(this);
}
public void startApp() {
if (display == null){
display = Display.getDisplay(this);
}

display.setCurrent(helloAlert);
}

public void pauseApp() {

}

public void destroyApp(boolean unconditional) {

}

public void commandAction(Command c, Displayable d){

if (c == exitCommand){
destroyApp(true);
notifyDestroyed(); // Exit
}

}
}

Next we will learn our first MIDlet, focused on line importance of the code above:

public class HelloMidlet extends MIDlet implements CommandListener {

As we have said before, we have to create a subclass of MIDlet to make MIDP program.
In this line, we've made a subclass of MIDlet by giving the parent class derivative and
named HelloMIDlet.

Display display;
Command exitCommand = new Command("Exit", Command.EXIT, 1);
Alert helloAlert;
The above line is the variable properties of the MIDlet. We need an object Display (only
one diplay per MIDlet) to perform the function of drawing on the screen. exitCommand is
a command that will we put on the screen so that we can get out of the program. If we
do not have the orders out, then we have no way to exit the MIDlet properly.

public HelloMidlet(){
helloAlert = new Alert(
"Hello MIDlet", "Hello, world!",
null, AlertType.INFO
);
helloAlert.setTimeout(Alert.FOREVER);
helloAlert.addCommand(exitCommand);
helloAlert.setCommandListener(this);
}

Constructor perform initialization of object Alert. We will learn more from the class Alert in
the next chapter. Method addCommand () on the object Alert giving the command "Exit"
on the screen. Method setCommandListener () provides information to the system to
provide all the command events to the MIDlet.

public class HelloMidlet extends MIDlet implements CommandListener {

Code "implements CommandListener" is to command / key presses, so program we are

able to handle the "command" events. If we do implement CommandListener, we must
create a method commandAction ().

public void commandAction(Command c, Displayable d){

if (c == exitCommand){
destroyApp(true);
notifyDestroyed(); // Exit
}
}

commandAction() only to handle the request for the command "Exit". method above will
stop the program using notifyDestroyed () if the command "Exit" executed or suppressed.

public void startApp() {

if (display == null){
display = Display.getDisplay(this);
}

display.setCurrent(helloAlert);
}

The code above is the first part of our program when we are ready to program displayed
by AMS. Keep in mind that the method startApp () may / can entered more than once as
the MIDlet lifecycle. If the MIDlet stop / terminated, such as when a call comes in, the
program will go to state stops (pausedApp). If the call has been completed AMS will
return to the program and startApp invoke () again. Method display.setCurrent () provides
information to the system that we want the Alert object to appear on the screen. We can
got tampilah object by calling the static method Display.getDisplay ().

NetBeans Mobility Pack automatically creates a Java Application Descriptor (JAD) for
your program. NetBeans Mobility Pack put the JAD file in the folder "dist" from project
folder. Here is an example of the JAD file created by the NetBeans Mobility Pack:

MIDlet-1: HelloMidlet, , HelloMidlet

MIDlet-Jar-Size: 1415
MIDlet-Jar-URL: ProjectHello.jar

MIDlet-Name: ProjectHello
MIDlet-Vendor: Vendor
MIDlet-Version: 1.0
MicroEdition-Configuration: CLDC-1.1
MicroEdition-Profile: MIDP-2.0
Now we are ready to compile, do packaging (package) on the application Our first MIDlet.

2.4 Compilation and Packaging MIDlets

Before we use integrated tools to compile and perform packaging the MIDlet application
(MIDlet suite), we will try to use the command line.

MIDlet applications are typically bundled into a file that is a JAR file. This file is
compressed files, such as ZIP files. On implementation, you can open the JAR file using a
ZIP file decompressor program.

MIDlet application consists of:

File JAR

File Java Application Descriptor (JAD)

JAR files have:

File class

Manifest file describing the contents of the archive

The manifest file that describes the contents of the archive

Source: image / icon, video, data, etc. Used by applications

The manifest file, MANIFEST.MF is like a JAD file. This file is used by appication manager of
the device. Some fields that are required by the manifest file is:

MIDlet-Name

MIDlet-Version

MIDlet-Vendor

MIDlet-<n> (where n is a number from 1, for each MIDlet in the JAR file)

MicroEdition-Profile

MicroEdition-Configuration

Furthermore, we are to compile Java source files:

javac -bootclasspath C:\WTK23\lib\cldcapi11.jar;C:\WTK23\lib\midpapi20.jar

*.java
Java Compiler program, "javac", must be on your path. If you see an error like "can not
find the file" or "not an executable", you can consult with installation guide for the
distribution of the Java development kit you about how enter the executable PATH of
location tools in Java.

Furthermore, we conduct pre-verify from the class file:

preverify
-classpath C:\WTK23\lib\cldcapi11.jar;C:\WTK23\lib\midpapi20.jar;.
-d . HelloMidlet

Preverify've been in the wireless toolkit from java.sun.com. Enter this command on a row.

The final step is to create the JAR fil:

jar cvfm HelloMidlet.jar manifest.txt HelloMidlet.class

Program jar was already in the Java Development Kit, and its location must be entered
the executable path. This command creates a JAR file with the file name HelloMidlet.jar.
Manifest.txt file name was changed to the MANIFEST.MF in the JAR file.

2.5 Using the Sun Wireless Toolkit

Now we are using Sun Wireless Toolkit for clicking compile and bundle application MIDlet /
MIDlet suite (containing one MIDlet)

Open ktoolbar (Wireless Toolkit distribution)):

Create a project:

In the Settings window, you can change many options of several options configuration for
your project. You can choose the configuration that will work, package / API required,
configuration Push Registry and others. For our purposes this time, we will use the default
configuration of the project. Click "OK" to finish making project.

Copy HelloMidlet.java to a directory "src": In this window is in the directory: C: \ WTK23 \

apps \ HelloMidlet \ src (where C: \ WTK23 is where you are installing the wireless
toolkit). Click "Build" and "Run"

Pengembangan Perangkat Mobile

1
0

2.6 Using NetBeans Mobility Pack

As described earlier in this chapter about the necessary things, NetBeans Mobility Pack 4.1
and must have been installed on your computer.

Step 1: Create a new project

Step 2: Choose the category "Mobile"

Step 3: Choose the "Mobile Application"

Step 4: Name the project and specify its location

(Uncheck the "Create Hello MIDlet", we will make our own MIDlet later)

Step 5: Select Platform (optional)

Figure 1: newly created Mobile Project (NetBeans Mobility Pack)

Step 6: Create a new MIDlet

Step 7: Choose MIDP "Category" and MIDlet "File Type"

Step 8: Name the MIDlet

Step 9

Figure 2: Creating a MIDlet. MIDlet automatically create the required method

Pengembangan Perangkat Mobile

2
0

Step 10: Replace the code that is created automatically by our program code.

Step 11: Compile and Run (Run) MIDlet in Emulator

Step 12: Running MIDlet us in Emulator

Figure 3: Hello World MIDlet

2.7 Exercises
2.7.1 Multiple MIDlets within a MIDlet suite
Add a new MIDlet in the project "ProjectHello". You need to note that NetBeans Mobility
Pack automatically add new MIDlet application file JAD when you use the "New File ..."
Wizard.

2.7.2Multiple MIDlets in the MIDlet suite using Wireless Toolkit

Use the Sun Wireless Toolkit to add a new MIDlet in the MIDlet application you.