Java & Symbian Mobile Applications

Key Event Example 01(Event Demo)

2008-03-21T15:46:00.001+05:30

/*
* @(#)Tiles.java 1.6 00/05/24 Copyright (c) 2000 Sun Microsystems, Inc. All
* Rights Reserved.
*
* This software is the confidential and proprietary information of Sun
* Microsystems, Inc. ("Confidential Information"). You shall not disclose such
* Confidential Information and shall use it only in accordance with the terms
* of the license agreement you entered into with Sun.
*
* SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
* SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED
* WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR
* NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES SUFFERED BY
* LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING THIS SOFTWARE OR ITSDERIVATIVES.
*/

import javax.microedition.lcdui.Canvas;
import javax.microedition.lcdui.Command;
import javax.microedition.lcdui.CommandListener;
import javax.microedition.lcdui.Display;
import javax.microedition.lcdui.Displayable;
import javax.microedition.lcdui.Font;
import javax.microedition.lcdui.Graphics;
import javax.microedition.midlet.MIDlet;

public class Tiles extends MIDlet {

Board b;

public Tiles() {
b = new Board(this);
}

public void startApp() {
Display.getDisplay(this).setCurrent(b);
}

public void pauseApp() {
}

public void destroyApp(boolean unconditional) {
}

}

/*
* @(#)Board.java 1.14 00/05/23 Copyright (c) 2000 Sun Microsystems, Inc. All
* Rights Reserved.
*
* This software is the confidential and proprietary information of Sun
* Microsystems, Inc. ("Confidential Information"). You shall not disclose such
* Confidential Information and shall use it only in accordance with the terms
* of the license agreement you entered into with Sun.
*
* SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
* SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED
* WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR
* NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES SUFFERED BY
* LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES.
*/

class Board extends Canvas implements CommandListener {

MIDlet midlet;
Command exitCommand;
Font font;

// Character Position
int xPos, yPos;

// Chracter Height and Width in pixels
int charW, charH;

public Board(MIDlet midlet_) {
int i;

midlet = midlet_;
Display dpy = Display.getDisplay(midlet);
int letterWidth = 4;

font = Font.getFont(Font.FACE_SYSTEM, Font.STYLE_PLAIN, Font.SIZE_MEDIUM);

charW = font.charWidth('M') + 7;
charH = font.getHeight() + 1;

xPos = (getWidth() - (letterWidth * charW) + 1) / 2;
yPos = 1;

exitCommand = new Command("Exit", Command.SCREEN, 2);
addCommand(exitCommand);

setCommandListener(this);
repaint();
}

public void commandAction(Command c, Displayable d) {
if (c == exitCommand) {
midlet.notifyDestroyed();
}
}

public void paint(Graphics g) {
g.setColor(0);
g.drawRect(4, 4, 4 * charW + 2, 4 * charH + 2);
}

public void keyPressed(int code) {
int game = getGameAction(code);

switch (game) {
case Canvas.UP:
System.out.println("Canvas.UP");
break;
case Canvas.DOWN:
System.out.println("Canvas.DOWN");
break;
case Canvas.LEFT:
System.out.println("Canvas.LEFT");
break;
case Canvas.RIGHT:
System.out.println("Canvas.RIGHT");
break;
}

switch (code) {

case Canvas.KEY_NUM0:
System.out.println("Key 0");
break;
case Canvas.KEY_NUM1:
System.out.println("Key 1");
break;
case Canvas.KEY_NUM2:
System.out.println("Key 2");
break;
case Canvas.KEY_NUM3:
System.out.println("Key 3");
break;
case Canvas.KEY_NUM4:
System.out.println("Key 4");
break;
case Canvas.KEY_NUM5:
System.out.println("Key 5");
break;
case Canvas.KEY_NUM6:
System.out.println("Key 6");
break;
case Canvas.KEY_NUM7:
System.out.println("Key 7");
break;
case Canvas.KEY_NUM8:
System.out.println("Key 8");
break;
case Canvas.KEY_NUM9:
System.out.println("Key 9");
break;
case Canvas.KEY_STAR:
System.out.println("Star Key");
break;

case Canvas.KEY_POUND:
System.out.println("Pound Key");
break;

// default:

// System.out.println( "default" );
// return;
}

}

}

List Example 05( Implicit List )

2008-03-21T15:41:00.001+05:30

/*--------------------------------------------------
* ImplicitList.java
*
* Example from the book: Core J2ME Technology
* Copyright John W. Muchow
* You may use/modify for any non-commercial purpose
*-------------------------------------------------*/
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;

public class ImplicitList extends MIDlet implements CommandListener
{
private Display display; // Reference to Display object
private List lsDocument; // Main list
private Command cmExit; // Command to exit
private Command cmAdd; // Command to add an element

public ImplicitList()
{
display = Display.getDisplay(this);

// Create the Commands
cmExit = new Command("Exit", Command.EXIT, 1);
cmAdd = new Command("Add", Command.SCREEN, 1);

try
{
// Create array of image objects
Image images[] = {Image.createImage("/ff.png"),
Image.createImage("/rr.png"),
Image.createImage("/new.png")};

// Create array of corresponding string objects
String options[] = {" Next", " Previous", " New"};

// Create list using arrays, add commands, listen for events
lsDocument = new List("Document Option:",
List.IMPLICIT, options, images);
lsDocument.addCommand(cmExit);
lsDocument.addCommand(cmAdd);
lsDocument.setCommandListener(this);
}
catch (java.io.IOException e)
{
System.err.println("Unable to locate or read .png file");
}
}

public void startApp()
{
display.setCurrent(lsDocument);
}

public void pauseApp()
{
}

public void destroyApp(boolean unconditional)
{
}

public void commandAction(Command c, Displayable s)
{
// If an implicit list generated the event
if (c == List.SELECT_COMMAND)
{
switch (lsDocument.getSelectedIndex())
{
case 0:
System.out.println("Next");
break;

case 1:
System.out.println("Previous");
break;

case 2:
System.out.println("New");
break;
default:
System.out.println("New Element");
}
}
else if (c == cmAdd)
{
try
{

System.out.println("lsDocument.size():" + lsDocument.size());
// Add a new element. Using size() as the insertion point,
// the element will appended to the list.
lsDocument.insert(lsDocument.size(), " Delete ", Image.createImage("/delete.png"));
}
catch (java.io.IOException e)
{
System.err.println("Unable to locate or read .png file");
}
}
else if (c == cmExit)
{
destroyApp(false);
notifyDestroyed();
}
}
}

List Example 04(Travel List with Images)

2008-03-21T15:37:00.000+05:30

import java.io.IOException;

import javax.microedition.lcdui.Alert;
import javax.microedition.lcdui.AlertType;
import javax.microedition.lcdui.Command;
import javax.microedition.lcdui.CommandListener;
import javax.microedition.lcdui.Display;
import javax.microedition.lcdui.Displayable;
import javax.microedition.lcdui.Image;
import javax.microedition.lcdui.List;
import javax.microedition.midlet.MIDlet;

public class TravelList extends MIDlet implements CommandListener {
private List mList;

private Command mExitCommand, mNextCommand;

public TravelList() {
String[] stringElements = { "A", "B", "C" };
Image[] imageElements = { loadImage("/airplane.png"), loadImage("/car.png"),
loadImage("/hotel.png") };
mList = new List("Reservation type", List.IMPLICIT, stringElements, imageElements);
mNextCommand = new Command("Next", Command.SCREEN, 0);
mExitCommand = new Command("Exit", Command.EXIT, 0);
mList.addCommand(mNextCommand);
mList.addCommand(mExitCommand);
mList.setCommandListener(this);
}

public void startApp() {
Display.getDisplay(this).setCurrent(mList);
}

public void commandAction(Command c, Displayable s) {
if (c == mNextCommand || c == List.SELECT_COMMAND) {
int index = mList.getSelectedIndex();
Alert alert = new Alert("Your selection", "You chose " + mList.getString(index) + ".", null,
AlertType.INFO);
Display.getDisplay(this).setCurrent(alert, mList);
} else if (c == mExitCommand)
notifyDestroyed();
}

public void pauseApp() {
}

public void destroyApp(boolean unconditional) {
}

private Image loadImage(String name) {
Image image = null;
try {
image = Image.createImage(name);
} catch (IOException ioe) {
System.out.println(ioe);
}

return image;
}
}

List Example 03(List of Radio Buttons)

2008-03-21T15:35:00.000+05:30

//jad file (please verify the jar size)
/*
MIDlet-Name: ListRadioButtons
MIDlet-Version: 1.0
MIDlet-Vendor: excelBoss.com
MIDlet-Jar-URL: ListRadioButtons.jar
MIDlet-1: ListRadioButtons, , ListRadioButtons
MicroEdition-Configuration: CLDC-1.0
MicroEdition-Profile: MIDP-1.0
MIDlet-JAR-SIZE: 100
*/
import javax.microedition.lcdui.Alert;
import javax.microedition.lcdui.AlertType;
import javax.microedition.lcdui.Command;
import javax.microedition.lcdui.CommandListener;
import javax.microedition.lcdui.Display;
import javax.microedition.lcdui.Displayable;
import javax.microedition.lcdui.List;
import javax.microedition.midlet.MIDlet;

public class ListRadioButtons extends MIDlet implements CommandListener {
private Display display;

private Command exit = new Command("Exit", Command.EXIT, 1);

private Command submit = new Command("Submit", Command.SCREEN, 2);

private List list = new List("Select one", List.EXCLUSIVE);

public ListRadioButtons() {
display = Display.getDisplay(this);

list.append("Male", null);
list.append("Female", null);
list.addCommand(exit);
list.addCommand(submit);
list.setCommandListener(this);
}

public void startApp() {
display.setCurrent(list);
}

public void pauseApp() {
}

public void destroyApp(boolean unconditional) {
}

public void commandAction(Command command, Displayable Displayable) {
if (command == submit) {
Alert alert = new Alert("Choice", list.getString(list.getSelectedIndex()), null, null);
alert.setTimeout(Alert.FOREVER);
alert.setType(AlertType.INFO);
display.setCurrent(alert);
list.removeCommand(submit);
} else if (command == exit) {
destroyApp(false);
notifyDestroyed();
}
}
}

List Example 02(Multiple Choice List)

2008-03-21T15:31:00.000+05:30

/*--------------------------------------------------
* MultipleChoiceList.java
*
* Create multiple choice list and save selection
* status of each element in an array.
*
* Example from the book: Core J2ME Technology
* Copyright John W. Muchow
* You may use/modify for any non-commercial purpose
*-------------------------------------------------*/
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;

public class MultipleChoiceList extends MIDlet implements CommandListener
{
private Display display; // Reference to display object
private Command cmExit; // A Command to exit the MIDlet
private Command cmView; // View the choice selected
private List lsPrefs; // Choice Group of preferences

public MultipleChoiceList()
{
display = Display.getDisplay(this);

// Create a multiple choice list
lsPrefs = new List("Preferences", List.MULTIPLE);

// Append options, with no associated images
lsPrefs.append("Auto Indent", null);
lsPrefs.append("Replace Tabs", null);
lsPrefs.append("Wrap Text", null);

cmExit = new Command("Exit", Command.EXIT, 1);
cmView = new Command("View", Command.SCREEN,2);

// Add commands, listen for events
lsPrefs.addCommand(cmExit);
lsPrefs.addCommand(cmView);
lsPrefs.setCommandListener(this);
}

public void startApp()
{
display.setCurrent(lsPrefs);
}

public void pauseApp()
{ }

public void destroyApp(boolean unconditional)
{ }

public void commandAction(Command c, Displayable s)
{
if (c == cmView)
{
boolean selected[] = new boolean[lsPrefs.size()];

// Fill array indicating whether each element is checked
lsPrefs.getSelectedFlags(selected);

for (int i = 0; i < lsPrefs.size(); i++)
System.out.println(lsPrefs.getString(i) + (selected[i] ? ": selected" : ": not selected"));

}
else if (c == cmExit)
{
destroyApp(false);
notifyDestroyed();
}
}
}

List Example 01(List Demo)

2008-03-21T15:25:00.002+05:30

/* License
*
* Copyright 1994-2004 Sun Microsystems, Inc. All Rights Reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* * Redistribution of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* * Redistribution in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of Sun Microsystems, Inc. or the names of contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* This software is provided "AS IS," without a warranty of any kind. ALL
* EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, INCLUDING
* ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
* OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN MICROSYSTEMS, INC. ("SUN")
* AND ITS LICENSORS SHALL NOT BE LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE
* AS A RESULT OF USING, MODIFYING OR DISTRIBUTING THIS SOFTWARE OR ITS
* DERIVATIVES. IN NO EVENT WILL SUN OR ITS LICENSORS BE LIABLE FOR ANY LOST
* REVENUE, PROFIT OR DATA, OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL,
* INCIDENTAL OR PUNITIVE DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY
* OF LIABILITY, ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE,
* EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
*
* You acknowledge that this software is not designed, licensed or intended
* for use in the design, construction, operation or maintenance of any
* nuclear facility.
*/

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

public class ListDemoMIDlet extends MIDlet {

private Display display;
private int mode = List.IMPLICIT;

private Command exitCommand = new Command( "Exit", Command.SCREEN, 2 );
private Command selectCommand = new Command( "Select", Command.OK, 1 );
private Command nextCommand = new Command( "Next", Command.SCREEN, 2 );
public ListDemoMIDlet(){
}

protected void destroyApp( boolean unconditional ) throws MIDletStateChangeException {
exitMIDlet();
}

protected void pauseApp(){
}

protected void startApp() throws MIDletStateChangeException {
if( display == null ){ // first time called...
initMIDlet();
}
}

private void initMIDlet(){
display = Display.getDisplay( this );
display.setCurrent( new SampleList( mode ) );
}

public void exitMIDlet(){
notifyDestroyed();
}

public static final String[] items = {
"First", "Second", "Third", "Fourth"
};

class SampleList extends List implements CommandListener {

private int mode;

SampleList( int mode ){
super( "", mode, items, null );
addCommand( exitCommand );
addCommand( selectCommand );
addCommand( nextCommand );
setCommandListener( this );

switch( mode ){
case IMPLICIT:
setTitle( "Implicit" );
break;
case EXCLUSIVE:
setTitle( "Exclusive" );
break;
case MULTIPLE:
setTitle( "Multiple" );
break;
}

this.mode = mode;
}

public void commandAction( Command c,Displayable d ){
if( c == exitCommand ){
exitMIDlet();
} else if( c == selectCommand ){
showSelection( false );
} else if( c == SELECT_COMMAND ){
showSelection( true );
} else if( c == nextCommand ){
if( mode == List.IMPLICIT ){
mode = List.EXCLUSIVE;
} else if( mode == List.EXCLUSIVE ){
mode = List.MULTIPLE;
} else {
mode = List.IMPLICIT;
}

display.setCurrent( new SampleList(
mode ) );
}
}

private void showSelection( boolean implicit ){
Alert alert = new Alert(
implicit ? "Implicit Selection"
: "Explicit Selection" );
StringBuffer buf = new StringBuffer();

if( mode == MULTIPLE ){
boolean[] selected = new boolean[ size() ];
getSelectedFlags( selected );

for( int i = 0; i < selected.length; ++i ){
if( selected[i] ){
if( buf.length() == 0 ){
buf.append(
"You selected: " );
} else {
buf.append( ", " );
}

buf.append( getString( i ) );
}
}

if( buf.length() == 0 ){
buf.append( "No items are selected." );
}
} else {
buf.append( "You selected " );
buf.append( getString(
getSelectedIndex() ) );
}

alert.setString( buf.toString() );
alert.setTimeout( Alert.FOREVER );

display.setCurrent( alert,display.getCurrent() );
}
}
}

Font Example 03(Canvas Midlet)

2008-03-21T15:09:00.001+05:30

import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
public class FontCanvasMIDlet extends MIDlet {

public FontCanvasMIDlet() { // constructor
}

public void startApp() {
Canvas canvas = new FontCanvas();
Display display = Display.getDisplay(this);
display.setCurrent(canvas);
}

public void pauseApp() {
}

public void destroyApp(boolean unconditional) {
}
}
class FontCanvas extends Canvas {
public void paint(Graphics g) {
g.setColor(0xffffff);
g.fillRect(0, 0, getWidth(), getHeight());
g.setColor(0x000000);

g.setFont(Font.getFont(Font.FACE_SYSTEM, Font.STYLE_PLAIN, Font.SIZE_LARGE));
g.drawString("System Font", 0, 0, g.LEFT | g.TOP);
g.setFont(Font.getFont(Font.FACE_SYSTEM, Font.STYLE_PLAIN, Font.SIZE_MEDIUM));
g.drawString("Medium Size", 0, 15, g.LEFT | g.TOP);
g.setFont(Font.getFont(Font.FACE_SYSTEM, Font.STYLE_BOLD, Font.SIZE_MEDIUM));
g.drawString("Bold Style", 0, 30, g.LEFT | g.TOP);
g.setFont(Font.getFont(Font.FACE_SYSTEM, Font.STYLE_ITALIC, Font.SIZE_MEDIUM));
g.drawString("Italic Style", 0, 45, g.LEFT | g.TOP);
g.setFont(Font.getFont(Font.FACE_SYSTEM, Font.STYLE_UNDERLINED, Font.SIZE_MEDIUM));
g.drawString("Underlined Style", 0, 60, g.LEFT | g.TOP);
}
}

Font Example 02(Font Midlet)

2008-03-21T15:07:00.000+05:30

/*
Wireless Java 2nd edition
Jonathan Knudsen
Publisher: Apress
ISBN: 1590590775
*/

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

public class FontMIDlet extends MIDlet implements CommandListener {
private FontCanvas mFontCanvas;
private Command mBoldCommand, mItalicCommand, mUnderlineCommand;

public FontMIDlet() {
mFontCanvas = new FontCanvas();

mBoldCommand = new Command("Bold", Command.SCREEN, 0);
mItalicCommand = new Command("Italic", Command.SCREEN, 0);
mUnderlineCommand = new Command("Underline", Command.SCREEN, 0);
Command exitCommand = new Command("Exit", Command.EXIT, 0);

mFontCanvas.addCommand(mBoldCommand);
mFontCanvas.addCommand(mItalicCommand);
mFontCanvas.addCommand(mUnderlineCommand);
mFontCanvas.addCommand(exitCommand);
mFontCanvas.setCommandListener(this);
}

public void startApp() {
Display.getDisplay(this).setCurrent(mFontCanvas);
}

public void pauseApp() {}

public void destroyApp(boolean unconditional) {}

public void commandAction(Command c, Displayable s) {
if (c.getCommandType() == Command.EXIT) {
notifyDestroyed();
return;
}

boolean isBold = mFontCanvas.isBold() ^ (c == mBoldCommand);
boolean isItalic = mFontCanvas.isItalic() ^ (c == mItalicCommand);
boolean isUnderline = mFontCanvas.isUnderline() ^
(c == mUnderlineCommand);

int style = (isBold ? Font.STYLE_BOLD : 0) | (isItalic ? Font.STYLE_ITALIC : 0) | (isUnderline ? Font.STYLE_UNDERLINED : 0);

mFontCanvas.setStyle(style);
mFontCanvas.repaint();
}
}

Font Example( Font Canvas)

2008-03-21T15:06:00.000+05:30

import javax.microedition.lcdui.Canvas;
import javax.microedition.lcdui.Font;
import javax.microedition.lcdui.Graphics;

public class FontCanvas extends Canvas {

private Font systemFont, monospaceFont, proportionalFont;

public FontCanvas() {
this(Font.STYLE_PLAIN);
}

public FontCanvas(int style) {
setStyle(style);
}

public void setStyle(int style) {
systemFont = Font.getFont(Font.FACE_SYSTEM, style, Font.SIZE_MEDIUM);
monospaceFont = Font.getFont(Font.FACE_MONOSPACE, style, Font.SIZE_MEDIUM);
proportionalFont = Font.getFont(Font.FACE_PROPORTIONAL, style, Font.SIZE_MEDIUM);
}
public void paint(Graphics g) {
int w = getWidth();
int h = getHeight();

// Clear the Canvas.
g.setGrayScale(255);
g.fillRect(0, 0, w - 1, h - 1);
g.setGrayScale(0);
g.drawRect(0, 0, w - 1, h - 1);

int x = w / 2;
int y = 20;

y += showFont(g, "System", x, y, systemFont);
y += showFont(g, "Monospace", x, y, monospaceFont);
y += showFont(g, "Proportional", x, y, proportionalFont);
}

private int showFont(Graphics g, String s, int x, int y, Font f) {
g.setFont(f);
g.drawString(s, x, y, Graphics.TOP | Graphics.HCENTER);
return f.getHeight();
}
}

Form Example 07(Read Display File)

2008-03-21T14:57:00.000+05:30

/*--------------------------------------------------
* ReadDisplayFile.java
*
* Example from the book: Core J2ME Technology
* Copyright John W. Muchow
* You may use/modify for any non-commercial purpose
*-------------------------------------------------*/
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
import java.io.*;

public class ReadDisplayFile extends MIDlet implements CommandListener
{
private Display display; // Reference to Display object
private Form fmMain; // Main form
private Command cmHelp; // Command to show a help file
private Command cmExit; // Command to exit the MIDlet
private Alert alHelp; // Alert to display help file text

public ReadDisplayFile()
{
display = Display.getDisplay(this);

cmHelp = new Command("Help", Command.SCREEN, 1);
cmExit = new Command("Exit", Command.EXIT, 1);

fmMain = new Form("Read File");
fmMain.addCommand(cmExit);
fmMain.addCommand(cmHelp);
fmMain.setCommandListener(this);
}

public void startApp()
{
display.setCurrent(fmMain);
}

public void pauseApp()
{ }

public void destroyApp(boolean unconditional)
{ }

public void commandAction(Command c, Displayable s)
{
if (c == cmHelp)
{
String str;
// Access the resource and read its contents
if ((str = readHelpText()) != null)
{
// Create an Alert to display the help text
alHelp = new Alert("Help", str, null, null);
alHelp.setTimeout(Alert.FOREVER);
display.setCurrent(alHelp, fmMain);
}
}
else if (c == cmExit)
{
destroyApp(false);
notifyDestroyed();
}
}

private String readHelpText()
{
InputStream is = getClass().getResourceAsStream("help.txt");
try
{
StringBuffer sb = new StringBuffer();
int chr, i = 0;
// Read until the end of the stream
while ((chr = is.read()) != -1)
sb.append((char) chr);

return sb.toString();
}
catch (Exception e)
{
System.out.println("Unable to create stream");
}
return null;
}
}

Form Example 06(Form Juggle)

2008-03-21T14:54:00.000+05:30

/*--------------------------------------------------
* FormJuggle.java
*
* Show how a Form component handles inserting and
* setting (replacing) Items
*
* Example from the book: Core J2ME Technology
* Copyright John W. Muchow
* You may use/modify for any non-commercial purpose
*-------------------------------------------------*/
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;

public class FormJuggle extends MIDlet implements CommandListener
{
private Display display; // Reference to display object
private Form fmMain; // The main form
private Command cmInsert; // Command to insert items
private DateField dfDate; // Display date
private TextField tfSize; // Product size
private TextField tfQuantity; // Product quantity
private int dateIndex; // Index of dfDate

public FormJuggle()
{
display = Display.getDisplay(this);

// Create the date and populate with current date
dfDate = new DateField("", DateField.DATE);
dfDate.setDate(new java.util.Date());

// Define two textfields and two commands
tfSize = new TextField("Size", "Large", 5, TextField.ANY);
tfQuantity = new TextField("Quantity:", "3", 2, TextField.NUMERIC);
cmInsert = new Command("Insert", Command.SCREEN, 1);

// Create the form, add insert command
fmMain = new Form("Form Stuff");
fmMain.addCommand(cmInsert);

// Append date to form & save index value where it was inserted
dateIndex = fmMain.append(dfDate);

// Capture events
fmMain.setCommandListener(this);
}

// Called by application manager to start the MIDlet.
public void startApp()
{
display.setCurrent(fmMain);
}

public void pauseApp()
{ }

public void destroyApp(boolean unconditional)
{ }

public void commandAction(Command c, Displayable s)
{
if (c == cmInsert)
{
// One item on form, insert textfield prior to datefield
if (fmMain.size() == 1)
{
fmMain.insert(dateIndex, tfQuantity);
dateIndex += 1; // Date index has changed, update it
}
// If two items and last item is datefield, replace it
else if (fmMain.size() == 2 && fmMain.get(1) == dfDate)
fmMain.set(dateIndex, tfSize);
}
}
}

Form Example 05(Form Scroll Example)

2008-03-21T14:41:00.001+05:30

/*--------------------------------------------------
* FormScroll.java
*
* Show how a Form component handles scrolling
* when multiple Items are on the display
*
* Copyright John W. Muchow
* You may use/modify for any non-commercial purpose
*-------------------------------------------------*/
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;

public class FormScroll extends MIDlet implements CommandListener
{
private Display display; // Reference to display object
private Form frmMain; // The main form
private Command cmdExit; // Command to exit
private TextField txfSize; // Product size
private ChoiceGroup chgEmail; // Choice group
private Gauge gauVolume; // Volume

public FormScroll()
{
display = Display.getDisplay(this);

// Create TextField
txfSize = new TextField("Size", "Large", 5, TextField.ANY);

// Create an exclusive (radio) choice group, and append entries
chgEmail = new ChoiceGroup("Email Options", Choice.EXCLUSIVE);
chgEmail.append("Read", null);
chgEmail.append("Forward", null);
chgEmail.append("Delete", null);

// Create the gauge
gauVolume = new Gauge("Sound Level", true, 30, 4);

cmdExit = new Command("Exit", Command.EXIT, 1);

// Create the form
frmMain = new Form("Form Stuff");
frmMain.append(txfSize);
frmMain.append(chgEmail);
frmMain.append(gauVolume);
frmMain.addCommand(cmdExit);

// Capture events
frmMain.setCommandListener(this);
}

// Called by application manager to start the MIDlet.
public void startApp()
{
display.setCurrent(frmMain);
}

public void pauseApp()
{ }

public void destroyApp(boolean unconditional)
{ }

public void commandAction(Command c, Displayable s)
{
if (c == cmdExit)
{
destroyApp(false);
notifyDestroyed();
}
}
}

Form Example 04(Change Label Text)

2008-03-21T14:35:00.001+05:30

/*--------------------------------------------------
* ChangeLabelText.java
*
* Example from the book: Core J2ME Technology
* Copyright John W. Muchow
* You may use/modify for any non-commercial purpose
*-------------------------------------------------*/
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;

public class ChangeLabelText extends MIDlet implements CommandListener
{
private Display display; // Reference to Display object
private Form fmMain; // The main form
private StringItem siUser; // The message
private Command cmNext; // Next label and message
private Command cmExit; // Command to exit the MIDlet

public ChangeLabelText()
{
display = Display.getDisplay(this);

// Create text message and commands
siUser = new StringItem("UserId: ", "johnm");
cmNext = new Command("Next", Command.SCREEN, 1);
cmExit = new Command("Exit", Command.EXIT, 1);

// Create Form, add Command & StringItem, listen for events
fmMain = new Form("Preferences");
fmMain.addCommand(cmExit);
fmMain.addCommand(cmNext);
fmMain.append(siUser);
fmMain.setCommandListener(this);
}

// Called by application manager to start the MIDlet.
public void startApp()
{
display.setCurrent(fmMain);
}

public void pauseApp()
{ }

public void destroyApp(boolean unconditional)
{ }

public void commandAction(Command c, Displayable s)
{
if (c == cmNext)
{
// This method is inherited from the Item class
siUser.setLabel("Account #: ");

// Change the text
siUser.setText("731");

// Remove the Next command
fmMain.removeCommand(cmNext);
}
else if (c == cmExit)
{
destroyApp(false);
notifyDestroyed();
}
}
}

Form Example 03( Verify Area Code)

2008-03-21T14:30:00.000+05:30

/*--------------------------------------------------
* VerifyAreaCode.java
*
* Example from the book: Core J2ME Technology
* Copyright John W. Muchow
* You may use/modify for any non-commercial purpose
*-------------------------------------------------*/
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;

public class VerifyAreaCode extends MIDlet implements CommandListener
{
private Display display; // Reference to Display object
private Form fmMain; // The main form
private Command cmTest; // Next label and message
private Command cmExit; // Command to exit the MIDlet
private TextField tfPhone; // Phone number
private String areaCodeTable [][] = {
{"512", "912"}, // Old area code, new area code
{"717", "917"} };

public VerifyAreaCode()
{
display = Display.getDisplay(this);

// Create commands
cmTest = new Command("Test", Command.SCREEN, 1);
cmExit = new Command("Exit", Command.EXIT, 1);

// Textfield for phone number
tfPhone = new TextField("Phone:", "", 10, TextField.PHONENUMBER);

// Create Form, add Commands & textfield, listen for events
fmMain = new Form("Area Codes");
fmMain.addCommand(cmExit);
fmMain.addCommand(cmTest);
fmMain.append(tfPhone);
fmMain.setCommandListener(this);
}

// Called by application manager to start the MIDlet.
public void startApp()
{
display.setCurrent(fmMain);
}

public void pauseApp()
{ }

public void destroyApp(boolean unconditional)
{ }

public void commandAction(Command c, Displayable s)
{
if (c == cmTest)
{
if (tfPhone.size() == 10)
{
char buffer[] = new char[10];

// Get phone number into byte array
tfPhone.getChars(buffer);

// Call method to check the area code table.
// Create a new StringItem to display,
// passing in 'null' as the StringItem
StringItem tmp = new StringItem(null, ("The area code " + (areaCodeLookup(buffer) ? "has" : "has not") + " been updated."));

// Place at the end of the form
if (fmMain.size() == 1) // Only tfPhone on form
fmMain.append(tmp);
else // Replace previous StringItem
fmMain.set(1, tmp);
}
}
else if (c == cmExit)
{
destroyApp(false);
notifyDestroyed();
}
}

/*--------------------------------------------------
* Compare the area code the user entered with the
* area code table. If a match is found, replace
* the user's code with the new code from the table
*-------------------------------------------------*/
private boolean areaCodeLookup(char [] buffer)
{
// Get the area code (only) from the users entry
String str = new String(buffer, 0, 3);

for (int x = 0; x < areaCodeTable.length; x++)
{
// If we find a match in the table
if (str.equals(areaCodeTable[x][0]))
{
// Delete the area code
tfPhone.delete(0, 3);

// Insert the new area code
tfPhone.insert(areaCodeTable[x][1].toCharArray(), 0, 3, 0);
return true;
}
}
return false;
}
}

Form Example 02(Display Status)

2008-03-21T14:25:00.000+05:30

/*--------------------------------------------------
* DisplayStats.java
* Example from the book: Core J2ME Technology
* Copyright John W. Muchow
* You may use/modify for any non-commercial purpose
*-------------------------------------------------*/
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;

public class DisplayStatus extends MIDlet implements CommandListener
{
private Display display; // Reference to Display object
private Form fmMain; // A Form
private Alert alTest; // An Alert
private Command cmExit; // A Command to exit the MIDlet

public DisplayStatus()
{
display = Display.getDisplay(this);

cmExit = new Command("Exit", Command.SCREEN, 1);
fmMain = new Form("Welcome");
fmMain.addCommand(cmExit);
fmMain.setCommandListener(this);

System.out.println("Display " + (display.isColor() ? "does" : "does not") + " support Color");
System.out.println("Number of colors: " + display.numColors());
}

// Called by application manager to start the MIDlet.
public void startApp()
{
alTest = new Alert("Alert", "This alert screen will be followed by the main form", null, null);
alTest.setTimeout(Alert.FOREVER);
display.setCurrent(alTest, fmMain);
}

// We are about to be placed in the Paused state
public void pauseApp()
{
}

// We are about to enter the Destroyed state
public void destroyApp(boolean unconditional)
{
}

// Check to see if the Exit command was selected
public void commandAction(Command c, Displayable s)
{
if (c == cmExit)
{
destroyApp(true);
notifyDestroyed();
}
}
}

Forms Example 01(Form with Items)

2008-03-21T14:22:00.000+05:30

//jad file (please verify the jar size)
/*
MIDlet-Name: CreatingFormWithItems
MIDlet-Version: 1.0
MIDlet-Vendor: excelBoss.com
MIDlet-Jar-URL: CreatingFormWithItems.jar
MIDlet-1: CreatingFormWithItems, , CreatingFormWithItems
MicroEdition-Configuration: CLDC-1.0
MicroEdition-Profile: MIDP-1.0
MIDlet-JAR-SIZE: 100

*/
import javax.microedition.lcdui.Command;
import javax.microedition.lcdui.CommandListener;
import javax.microedition.lcdui.Display;
import javax.microedition.lcdui.Displayable;
import javax.microedition.lcdui.Form;
import javax.microedition.lcdui.StringItem;
import javax.microedition.midlet.MIDlet;

public class CreatingFormWithItems extends MIDlet implements CommandListener {
private Display display;

private Form form;

private Command exit = new Command("Exit", Command.SCREEN, 1);

public CreatingFormWithItems() {
display = Display.getDisplay(this);

StringItem messages[] = new StringItem[] { new StringItem("Welcome, ", "glad you could come."),
new StringItem("Hello, ", "Mary.") };
form = new Form("Display Form with Items", messages);
form.addCommand(exit);
form.setCommandListener(this);
}

public void startApp() {
display.setCurrent(form);
}

public void pauseApp() {
}

public void destroyApp(boolean unconditional) {
}

public void commandAction(Command command, Displayable displayable) {
if (command == exit) {
destroyApp(true);
notifyDestroyed();
}
}
}

TextBox Example ( PhoneBook Example )

2008-03-21T13:15:00.000+05:30

/*
* PhoneBook.java
* Copyright (c) 2000 Sun Microsystems, Inc. All Rights Reserved.
*
* This software is the confidential and proprietary information of Sun
* Microsystems, Inc. ("Confidential Information"). You shall not
* disclose such Confidential Information and shall use it only in
* accordance with the terms of the license agreement you entered into
* with Sun.
*
* SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
* SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
* IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
* PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES
* SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
* THIS SOFTWARE OR ITS DERIVATIVES.
*/

import javax.microedition.lcdui.Command;
import javax.microedition.lcdui.CommandListener;
import javax.microedition.lcdui.Display;
import javax.microedition.lcdui.Displayable;
import javax.microedition.lcdui.TextBox;
import javax.microedition.lcdui.TextField;
import javax.microedition.midlet.MIDlet;

/**
*/
public class PhoneBook extends MIDlet implements CommandListener {

private Command exitCommand; // The exit command

private Command nextCommand;

private Command newCommand;

private TextBox t1;

private TextBox t;

private Display display; // The display for this MIDlet

private String _name;

private String _number;

public PhoneBook() {
display = Display.getDisplay(this);
nextCommand = new Command("Next", Command.SCREEN, 2);
exitCommand = new Command("Exit", Command.SCREEN, 2);
newCommand = new Command("NewNumber", Command.SCREEN, 2);

}

public void startApp() {
t = new TextBox("Name", "", 256, TextField.ANY);
t.addCommand(nextCommand);
t.setCommandListener(this);

t1 = new TextBox("Number", "", 256, TextField.PHONENUMBER);
t1.addCommand(newCommand);
t1.addCommand(exitCommand);
t1.setCommandListener(this);

display.setCurrent(t);

}

public void pauseApp() {
}

public void destroyApp(boolean unconditional) {
}

public void commandAction(Command c, Displayable s) {
if (c == exitCommand) {
_name = t.getString();
_number = t1.getString();
System.out.println("Name = " + t.getString() + ", Number = "
+ t1.getString());
destroyApp(false);
notifyDestroyed();
}
if (c == nextCommand) {
t1.setString(" ");
display.setCurrent(t1);
}
if (c == newCommand) {
display.setCurrent(t);
_name = t.getString();
_number = t1.getString();
System.out.println("Name = " + t.getString() + ", Number = "
+ t1.getString());
t.setString(" ");
}

}

}

TextBox Example 09(TextBox Midlet)

2008-03-21T13:11:00.001+05:30

/*
J2ME in a Nutshell
By Kim Topley
ISBN: 0-596-00253-X
*/
import java.io.*;
import javax.microedition.lcdui.Command;
import javax.microedition.lcdui.CommandListener;
import javax.microedition.lcdui.Displayable;

import javax.microedition.lcdui.*;

import javax.microedition.midlet.MIDlet;

public class TextBox2MIDlet extends TextBoxMIDlet implements CommandListener {

// Exit command
private static final Command EXIT_COMMAND =
new Command("Exit", Command.EXIT, 0);

// OK command
private static final Command OK_COMMAND =
new Command("OK", Command.OK, 0);

// Clear text box content
private static final Command CLEAR_COMMAND =
new Command("Clear", Command.SCREEN, 1);

// Reverse the content of the text box
private static final Command REVERSE_COMMAND =
new Command("Reverse", Command.SCREEN, 1);

protected void startApp() {
boolean firstTime = !started;
super.startApp();

// If this is the first execution
// of startApp, install commands
if (firstTime) {
textBox.addCommand(OK_COMMAND);
textBox.addCommand(EXIT_COMMAND);
textBox.addCommand(CLEAR_COMMAND);
textBox.addCommand(REVERSE_COMMAND);
textBox.setCommandListener(this);
}
}

// Command implementations.
public void commandAction(Command c, Displayable d) {
if (c == EXIT_COMMAND) {
destroyApp(true);
notifyDestroyed();
} else if (c == OK_COMMAND) {
System.out.println("OK pressed");
} else if (c == CLEAR_COMMAND) {
textBox.setString(null);
} else if (c == REVERSE_COMMAND) {
String str = textBox.getString();
if (str != null) {
StringBuffer sb = new StringBuffer(str);
textBox.setString(sb.reverse().toString());
}
}
}
}

class TextBoxMIDlet extends MIDlet {

// Maximum size of the text in the TextBox
private static final int MAX_TEXT_SIZE = 64;

// The TextBox
protected TextBox textBox;

// The MIDlet's Display object
protected Display display;

// Flag indicating first call of startApp
protected boolean started;

protected void startApp() {
if (!started) {
// First time through - initialize
// Get the text to be displayed
String str = null;
try {
InputStream is = getClass().getResourceAsStream("test.txt");
InputStreamReader r = new InputStreamReader(is);
char[] buffer = new char[32];
StringBuffer sb = new StringBuffer();
int count;
while ((count = r.read(buffer, 0, buffer.length)) > -1) {
sb.append(buffer, 0, count);
}
str = sb.toString();
} catch (IOException ex) {
str = "Failed to load text";
}

// Create the TextBox
textBox = new TextBox("TextBox Example", str,
MAX_TEXT_SIZE, TextField.ANY);

// Create a ticker and install it
Ticker ticker = new Ticker("This is a ticker...");
textBox.setTicker(ticker);

// Install the TextBox as the current screen
display = Display.getDisplay(this);
display.setCurrent(textBox);

started = true;
}
}

protected void pauseApp() {
}

protected void destroyApp(boolean unconditional) {
}
}

TextBox Example 08(GUI Test in Midlet)

2008-03-21T12:49:00.003+05:30

/*
Learning Wireless Java
Help for New J2ME Developers
By Qusay Mahmoud
ISBN: 0-596-00243-2
*/
import javax.microedition.lcdui.*;
import javax.microedition.midlet.*;

public class GuiTests extends MIDlet implements CommandListener {
// display manager
Display display = null;

// a menu with items
List menu = null; // main menu

// list of choices
List choose = null;

// textbox
TextBox input = null;

// ticker
Ticker ticker = new Ticker("Test GUI Components");

// alerts
final Alert soundAlert = new Alert("sound Alert");

// date
DateField date = new DateField("Today's date: ", DateField.DATE);

// form
Form form = new Form("Form for Stuff");

// gauge
Gauge gauge = new Gauge("Progress Bar", false, 20, 9);

// text field
TextField textfield = new TextField("TextField Label", "abc", 50, 0);

// command
static final Command backCommand = new Command("Back", Command.BACK, 0);
static final Command mainMenuCommand = new Command("Main", Command.SCREEN, 1);
static final Command exitCommand = new Command("Exit", Command.STOP, 2);
String currentMenu = null;

// constructor.
public GuiTests() {
}

/** * Start the MIDlet by creating a list of items and associating the
* exit command with it. */
public void startApp() throws MIDletStateChangeException {
display = Display.getDisplay(this);
// open a db stock file

menu = new List("Test Components", Choice.IMPLICIT);
menu.append("Test TextBox", null);
menu.append("Test List", null);
menu.append("Test Alert", null);
menu.append("Test Date", null);
menu.append("Test Form", null);
menu.addCommand(exitCommand);
menu.setCommandListener(this);
menu.setTicker(ticker);

mainMenu();
}

public void pauseApp() {
display = null;
choose = null;
menu = null;
ticker = null;
form = null;
input = null;
gauge = null;
textfield = null;
}

public void destroyApp(boolean unconditional) {
notifyDestroyed();
}

// main menu
void mainMenu() {
display.setCurrent(menu);
currentMenu = "Main";
}

/** * Test the TextBox component. */
public void testTextBox() {
input = new TextBox("Enter Some Text:", "", 10, TextField.ANY);
input.setTicker(new Ticker("Testing TextBox"));
input.addCommand(backCommand);
input.setCommandListener(this);
input.setString("");
display.setCurrent(input);
currentMenu = "input";
}

/** * Test the List component. */
public void testList() {
choose = new List("Choose Items", Choice.MULTIPLE);
choose.setTicker(new Ticker("Testing List"));
choose.addCommand(backCommand);
choose.setCommandListener(this);
choose.append("Item 1", null);
choose.append("Item 2", null);
choose.append("Item 3", null);
display.setCurrent(choose);
currentMenu = "list";
}

/** * Test the Alert component. */
public void testAlert() {
soundAlert.setType(AlertType.ERROR);
//soundAlert.setTimeout(20);
soundAlert.setString("** ERROR **");
display.setCurrent(soundAlert);
}

/** * Test the DateField component. */
public void testDate() {
java.util.Date now = new java.util.Date();
date.setDate(now);
Form f = new Form("Today's date");
f.append(date);
f.addCommand(backCommand);
f.setCommandListener(this);
display.setCurrent(f);
currentMenu = "date";
}

/** * Test the Form component. */
public void testForm() {
form.append(gauge);
form.append(textfield);
form.addCommand(backCommand);
form.setCommandListener(this);
display.setCurrent(form);
currentMenu = "form";
}

/** * Handle events. */
public void commandAction(Command c, Displayable d) {
String label = c.getLabel();
if (label.equals("Exit")) {
destroyApp(true);
} else if (label.equals("Back")) {
if(currentMenu.equals("list") || currentMenu.equals("input") ||
currentMenu.equals("date") || currentMenu.equals("form")) {
// go back to menu
mainMenu();
}

} else {
List down = (List)display.getCurrent();
switch(down.getSelectedIndex()) {
case 0: testTextBox();break;
case 1: testList();break;
case 2: testAlert();break;
case 3: testDate();break;
case 4: testForm();break;
}

}
}
}

TextBox Example 07(Shared ClipBoard)

2008-03-21T12:43:00.001+05:30

/*--------------------------------------------------
* SharedClipBoard.java
*
* A List component that can show one of two
* textboxes. Each textbox shares a common clipboard
*
* Example from the book: Core J2ME Technology
* Copyright John W. Muchow
* You may use/modify for any non-commercial purpose
*-------------------------------------------------*/
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;

public class SharedClipBoard extends MIDlet implements CommandListener
{
private Display display; // Reference to Display object
private List lsMain; // Main list
private TextBoxCB tbClip1; // Textbox with clipboard
private TextBoxCB tbClip2; // Textbox with clipboard
private Command cmExit; // Command to exit

public SharedClipBoard()
{
display = Display.getDisplay(this);

// Create list
lsMain = new List("ClipBoard Testing", List.IMPLICIT);
lsMain.append("TextBox1", null);
lsMain.append("TextBox2", null);

// Create the exit command, add to list
cmExit = new Command("Exit", Command.EXIT, 1);
lsMain.addCommand(cmExit);
lsMain.setCommandListener(this);

// Allocate textboxes
tbClip1 = new TextBoxCB("TextBox1", "Email Address: john@corej2me.com", 50, TextField.ANY, this);
tbClip2 = new TextBoxCB("TextBox2", "Web Address: www.", 50, TextField.ANY, this);
}

public void startApp()
{
showList();
}

public void pauseApp()
{
}

public void destroyApp(boolean unconditional)
{
}

public void showList()
{
// Display the list component
display.setCurrent(lsMain);
}

public void commandAction(Command c, Displayable s)
{
// If an implicit list generated the event
if (c == List.SELECT_COMMAND)
{
switch (lsMain.getSelectedIndex())
{
case 0:
// Display textbox 1
display.setCurrent(tbClip1);
break;

case 1:
// Display textbox 2
display.setCurrent(tbClip2);
break;
}
}
else if (c == cmExit)
{
destroyApp(false);
notifyDestroyed();
}
}
}

/*--------------------------------------------------
* TextBoxCB.java
*
* A textbox that includes a clipboard. This class
* encapsulates all the commands necessary to show
* a menu for mark, copy, cut and paste.
*
* Example from the book: Core J2ME Technology
* Copyright John W. Muchow
* You may use/modify for any non-commercial purpose
*-------------------------------------------------*/
class TextBoxCB extends TextBox implements CommandListener
{
private ClipBoard clipboard; // The clipboard class
private Command cmBack; // Command to go back
private Command cmStartMark; // Command to start marking a block

private Command cmCopy; // Command to copy to clipboard

private Command cmCut; // Command to cut to clipboard

private Command cmPaste; // Command to paste into textbox
private SharedClipBoard midlet; // The midlet

public TextBoxCB(String title, String text, int maxSize, int constraints, SharedClipBoard midlet)
{
// Call the TextBox constructor
super(title, text, maxSize, constraints);

// Save reference to MIDlet so we can access its methods
this.midlet = midlet;

// Create the Commands. Notice the priorities assigned
cmBack = new Command("Back", Command.BACK, 1);
cmStartMark = new Command("Mark", Command.SCREEN, 2);
cmCopy = new Command("Copy", Command.SCREEN, 3);
cmCut = new Command("Cut", Command.SCREEN, 4);
cmPaste = new Command("Paste", Command.SCREEN, 5);

this.addCommand(cmBack);
this.addCommand(cmStartMark);
this.addCommand(cmCopy);
this.addCommand(cmCut);
this.addCommand(cmPaste);
this.setCommandListener(this);

// Create a clipboard
clipboard = new ClipBoard(this);
}

public void commandAction(Command c, Displayable s)
{
if (c == cmStartMark)
{
// Start to mark a block of text
clipboard.startMark();
}
else if (c == cmCopy)
{
// Copy text to clipboard
clipboard.copy();
}
else if (c == cmCut)
{
// Cut text to clipboard
clipboard.cut();
}
else if (c == cmPaste)
{
// Paste from clipboard to textbox
clipboard.paste();
}
else if (c == cmBack)
{
// Return to the list component
midlet.showList();
}
}
}

/*--------------------------------------------------
* ClipBoard.java
*
* Core clipboard code - mark, copy, cut and paste
*
* Example from the book: Core J2ME Technology
* Copyright John W. Muchow
* You may use/modify for any non-commercial purpose
*-------------------------------------------------*/
class ClipBoard
{
//--------------------------------------------------
// Allocate clipboard. Note, both clipboard & count
// of characters are shared across all instances
//--------------------------------------------------
private static char[] _clipBoard = new char[1000];
private static int _clipBoardCount = 0;

private int beginOffset = 0; // The start index of copy
private TextBox tb = null; // textbox for this instance

/*--------------------------------------------------
* Hold reference to textbox that created clipboard
*-------------------------------------------------*/
public ClipBoard(TextBox textbox)
{
tb = textbox;
}

/*--------------------------------------------------
* Set starting point of copy
*-------------------------------------------------*/
public void startMark()
{
beginOffset = tb.getCaretPosition();
}

/*--------------------------------------------------
* Copy text into the clipboard
*-------------------------------------------------*/
public void copy()
{
copy2clipboard();
}

/*--------------------------------------------------
* Copy text into the clipboard. If successful copy,
* delete text from the textbox.
*-------------------------------------------------*/
public void cut()
{
if (copy2clipboard())
tb.delete(beginOffset, tb.getCaretPosition() - beginOffset);
}

/*--------------------------------------------------
* Do the actual copy into the clipboard
*-------------------------------------------------*/
private boolean copy2clipboard()
{
// Can only mark (copy/cut) going forward
if (tb.getCaretPosition() > beginOffset)
{
// Allocate an array to hold the current textbox contents
char[] chr = new char[tb.size()];

// Get the current textbox contents
tb.getChars(chr);

// The count of characters in the clipboard
_clipBoardCount = tb.getCaretPosition() - beginOffset;

// Copy the text into the clipboard
// arraycopy(source, sourceindex, dest, destindex, count)
System.arraycopy(chr, beginOffset, _clipBoard, 0, _clipBoardCount);
return true;
}
else
return false;
}

/*--------------------------------------------------
* Paste text from clipboard into the textbox
*-------------------------------------------------*/
public void paste()
{
// Make sure the paste will not overrun the textbox length
if ((tb.size() + _clipBoardCount) <= tb.getMaxSize())
tb.insert(_clipBoard, 0, _clipBoardCount, tb.getCaretPosition());
}
}

TextField Example 06(Simple ClipBoard)

2008-03-21T12:39:00.000+05:30

/*--------------------------------------------------
* SimpleClipBoard.java
*
* Example from the book: Core J2ME Technology
* Copyright John W. Muchow
* You may use/modify for any non-commercial purpose
*-------------------------------------------------*/
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;

public class SimpleClipBoard extends MIDlet implements CommandListener
{
private Display display; // Reference to Display object
private TextBox tbClip; // Main textbox
private Command cmExit; // Command to exit
private Command cmStartMark; // Command to start marking a block
private Command cmCopy; // Command to copy to clipboard
private Command cmPaste; // Command to paste into textbox
private int beginOffset = 0; // The start index of copy
private char[] clipBoard = null; // The clipboard
private int clipBoardChars = 0; // Number of chars in clipboard

public SimpleClipBoard()
{
display = Display.getDisplay(this);

// Create the Commands. Notice the priorities assigned
cmExit = new Command("Exit", Command.EXIT, 1);
cmStartMark = new Command("Mark", Command.SCREEN, 2);
cmCopy = new Command("Copy", Command.SCREEN, 3);
cmPaste = new Command("Paste", Command.SCREEN, 4);

tbClip = new TextBox("Clip Board", "Tee to grn", 15, TextField.ANY);
tbClip.addCommand(cmExit);
tbClip.addCommand(cmStartMark);
tbClip.addCommand(cmCopy);
tbClip.addCommand(cmPaste);
tbClip.setCommandListener(this);

// Allocate a clipboard big enough to hold the entire textbox
clipBoard = new char[tbClip.getMaxSize()];
}

public void startApp()
{
display.setCurrent(tbClip);
}

public void pauseApp()
{
}

public void destroyApp(boolean unconditional)
{
}

public void commandAction(Command c, Displayable s)
{
if (c == cmStartMark)
{
beginOffset = tbClip.getCaretPosition();
}
else if (c == cmCopy && (tbClip.getCaretPosition() > beginOffset))
{
// Allocate an array to hold the current textbox contents
char[] chr = new char[tbClip.size()];

// Get the current textbox contents
tbClip.getChars(chr);

// The count of characters in the clipboard
clipBoardChars = tbClip.getCaretPosition() - beginOffset;

// Copy the text into the clipboard
// arraycopy(source, sourceindex, dest, destindex, count)
System.arraycopy(chr, beginOffset, clipBoard, 0, clipBoardChars);
}
else if (c == cmPaste)
{
// Make sure the paste will not overrun the textbox length.
if ((tbClip.size() + clipBoardChars) <= tbClip.getMaxSize())
tbClip.insert(clipBoard, 0, clipBoardChars, tbClip.getCaretPosition());
}
else if (c == cmExit)
{
destroyApp(false);
notifyDestroyed();
}
}
}

Text Box Example 05(Hide Text)

2008-03-21T12:29:00.001+05:30

//jad file (please verify the jar size)
/*
MIDlet-Name: HideText
MIDlet-Version: 1.0
MIDlet-Vendor: excelBoss.com
MIDlet-Jar-URL: HideText.jar
MIDlet-1: HideText, , HideText
MicroEdition-Configuration: CLDC-1.0
MicroEdition-Profile: MIDP-1.0
MIDlet-JAR-SIZE: 100
*/
import javax.microedition.lcdui.Command;
import javax.microedition.lcdui.CommandListener;
import javax.microedition.lcdui.Display;
import javax.microedition.lcdui.Displayable;
import javax.microedition.lcdui.Form;
import javax.microedition.lcdui.TextField;
import javax.microedition.midlet.MIDlet;

public class HideText extends MIDlet implements CommandListener {
private Display display;

private Form form = new Form("Enter Password");

private Command submit = new Command("Submit", Command.SCREEN, 1);

private Command exit = new Command("Exit", Command.EXIT, 1);

private TextField textfield = new TextField("Password:", "", 30, TextField.ANY
| TextField.PASSWORD);

public HideText() {
display = Display.getDisplay(this);
form.addCommand(exit);
form.addCommand(submit);
form.append(textfield);
form.setCommandListener(this);
}

public void startApp() {
display.setCurrent(form);
}

public void pauseApp() {
}

public void destroyApp(boolean unconditional) {
}

public void commandAction(Command command, Displayable displayable) {
if (command == submit) {
textfield.setConstraints(TextField.ANY);
textfield.setString("Thank you.");
form.removeCommand(submit);
} else if (command == exit) {
destroyApp(false);
notifyDestroyed();
}
}
}

Text Box Example 04( Login Midlet )

2008-03-21T12:27:00.001+05:30

/*
Learning Wireless Java
Help for New J2ME Developers
By Qusay Mahmoud
ISBN: 0-596-00243-2
*/
import javax.microedition.midlet.MIDlet;
import javax.microedition.lcdui.*;

public class LoginMidlet extends MIDlet implements CommandListener {
private Display display;
private TextField userName;
private TextField password;
private Form form;
private Command cancel;
private Command login;

public LoginMidlet() {
userName = new TextField("LoginID:", "", 10, TextField.ANY);
password = new TextField("Password:", "", 10, TextField.PASSWORD);
form = new Form("Sign in");
cancel = new Command("Cancel", Command.CANCEL, 2);
login = new Command("Login", Command.OK, 2);
}

public void startApp() {
display = Display.getDisplay(this);
form.append(userName);
form.append(password);
form.addCommand(cancel);
form.addCommand(login);
form.setCommandListener(this);
display.setCurrent(form);
}

public void pauseApp() {
}

public void destroyApp(boolean unconditional) {
notifyDestroyed();
}

public void validateUser(String name, String password) {
if (name.equals("qm") && password.equals("j2")) {
menu();
} else {
tryAgain();
}
}

public void menu() {
List services = new List("Choose one", Choice.EXCLUSIVE);
services.append("Check Mail", null);
services.append("Compose", null);
services.append("Addresses", null);
services.append("Options", null);
services.append("Sign Out", null);
display.setCurrent(services);
}

public void tryAgain() {
Alert error = new Alert("Login Incorrect", "Please try again", null, AlertType.ERROR);
error.setTimeout(Alert.FOREVER);
userName.setString("");
password.setString("");
display.setCurrent(error, form);
}

public void commandAction(Command c, Displayable d) {
String label = c.getLabel();
if(label.equals("Cancel")) {
destroyApp(true);
} else if(label.equals("Login")) {
validateUser(userName.getString(), password.getString());
}
}
}

TextBox Example 03(Hello Midlet)

2008-03-21T12:21:00.000+05:30

/*
*
* Copyright (c) 2000 Sun Microsystems, Inc. All Rights Reserved.
*
* Author: Srikanth Raju
*
* This software is the confidential and proprietary information of Sun
* Microsystems, Inc. ("Confidential Information"). You shall not
* disclose such Confidential Information and shall use it only in
* accordance with the terms of the license agreement you entered into
* with Sun.
*
* SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
* SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
* IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
* PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES
* SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
* THIS SOFTWARE OR ITS DERIVATIVES.
*/

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

/**
* An example MIDlet with simple "Hello" text in a TextBox
* Refer to the startApp, pauseApp, and destroyApp
* methods so see how each handles the requested transition.
*/
public class HelloTextBoxMIDlet extends MIDlet
{

private Display display; // The display for this MIDlet

public HelloTextBoxMIDlet() {
display = Display.getDisplay(this);
}

/**
* Start up the Hello MIDlet by creating the TextBox
*/
public void startApp() {
TextBox t = new TextBox("Hello excelBoss", "Hello Saturday!", 256, 0);

display.setCurrent(t);
}

/**
* Pause is a no-op since there are no background activities or
* record stores that need to be closed.
*/
public void pauseApp() {
}

/**
* Destroy must cleanup everything not handled by the garbage collector.
* In this case there is nothing to cleanup.
*/
public void destroyApp(boolean unconditional) {
}

}

TextBox/Field Example 02( TextBox Capture )

2008-03-21T12:17:00.000+05:30

/*
J2ME: The Complete Reference
James Keogh
Publisher: McGraw-Hill
ISBN 0072227109
*/
//jad file (please verify the jar size)
/*
MIDlet-Name: TextBoxCapture
MIDlet-Version: 1.0
MIDlet-Vendor: excelBoss.com
MIDlet-Jar-URL: TextBoxCapture.jar
MIDlet-1: TextBoxCapture, , TextBoxCapture
MicroEdition-Configuration: CLDC-1.0
MicroEdition-Profile: MIDP-1.0
MIDlet-JAR-SIZE: 100

*/
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
public class TextBoxCapture extends MIDlet implements CommandListener
{
private Display display;
private TextBox textbox;
private Command submit;
private Command exit;
public TextBoxCapture()
{
display = Display.getDisplay(this);
submit = new Command("Submit", Command.SCREEN, 1);
exit = new Command("Exit", Command.EXIT, 1);
textbox = new TextBox("First Name:", "", 30, TextField.ANY);
textbox.addCommand(exit);
textbox.addCommand(submit);
textbox.setCommandListener(this);
}
public void startApp()
{
display.setCurrent(textbox);
}
public void pauseApp()
{
}
public void destroyApp(boolean unconditional)
{
}
public void commandAction(Command command, Displayable displayable)
{
if (command == submit)
{
textbox.setString("Hello, " + textbox.getString());
textbox.removeCommand(submit);
}
else if (command == exit)
{
destroyApp(false);
notifyDestroyed();
}
}
}

Text Box/Field Example 01(TextField Capture)

2008-03-21T12:15:00.000+05:30

//jad file (please verify the jar size)
/*
MIDlet-Name: TextFieldCapture
MIDlet-Version: 1.0
MIDlet-Vendor: excelBoss.com
MIDlet-Jar-URL: TextFieldCapture.jar
MIDlet-1: TextFieldCapture, , TextFieldCapture
MicroEdition-Configuration: CLDC-1.0
MicroEdition-Profile: MIDP-1.0
MIDlet-JAR-SIZE: 100
*/
import javax.microedition.lcdui.Command;
import javax.microedition.lcdui.CommandListener;
import javax.microedition.lcdui.Display;
import javax.microedition.lcdui.Displayable;
import javax.microedition.lcdui.Form;
import javax.microedition.lcdui.TextField;
import javax.microedition.midlet.MIDlet;

public class TextFieldCapture extends MIDlet implements CommandListener {
private Display display;

private Form form = new Form("Sign In Please");

private Command submit = new Command("Submit", Command.SCREEN, 1);

private Command exit = new Command("Exit", Command.EXIT, 1);

private TextField textfield = new TextField("First Name:", "", 30, TextField.ANY);

public TextFieldCapture() {
display = Display.getDisplay(this);
form.addCommand(exit);
form.addCommand(submit);
form.append(textfield);
form.setCommandListener(this);
}

public void startApp() {
display.setCurrent(form);
}

public void pauseApp() {
}

public void destroyApp(boolean unconditional) {
}

public void commandAction(Command command, Displayable displayable) {
if (command == submit) {
textfield.setString("Hello, " + textfield.getString());
form.removeCommand(submit);
} else if (command == exit) {
destroyApp(false);
notifyDestroyed();
}
}
}

Date Example 04( KVM TimeZones )

2008-03-21T12:12:00.000+05:30

import java.util.TimeZone;

public class KVMTimeZones {

public static void main(String[] args) {
TimeZone defaultTZ = TimeZone.getDefault();
String[] ids = TimeZone.getAvailableIDs();

System.out.println("Available time zone ids: ");
for (int i = 0; i < ids.length; i++) {
System.out.print(ids[i] + " ");
}
System.out.println("\nDefault timezone is " + defaultTZ.getID() +
", GMT offset = " + defaultTZ.getRawOffset());
}
}

Date Example 03(KVM Calendar)

2008-03-21T12:11:00.000+05:30

import java.util.Calendar;
import java.util.Date;

public class KVMCalendar {

public static void main(String[] args) {
Calendar cal = Calendar.getInstance();
Date date = new Date();
cal.setTime(date);
int month = cal.get(Calendar.MONTH);
int day = cal.get(Calendar.DAY_OF_MONTH);
System.out.println("Day is " + day + ", month is " + month);

final long MILLIS_PER_DAY = 24 * 60 * 60 * 1000L;
long offset = date.getTime();
offset += 20 * MILLIS_PER_DAY;
date.setTime(offset);
cal.setTime(date);

month = cal.get(Calendar.MONTH);
day = cal.get(Calendar.DAY_OF_MONTH);
System.out.println("In 20 days time, day will " + day + ", month will be " + month);
System.out.println(cal);
}
}

Date Example 02 (Date Field)

2008-03-21T11:46:00.000+05:30

/*--------------------------------------------------
* Snooze.java
*
* Example from the book: Core J2ME
* You may use/modify for any non-commercial purpose
*-------------------------------------------------*/
import java.util.*;
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
import java.util.Timer;
import java.util.TimerTask;

public class Snooze extends MIDlet implements ItemStateListener, CommandListener
{
private Display display; // Reference to display object
private Form fmMain; // The main form
private Command cmSnooze; // Start the timer
private Command cmReset; // Reset to current date/time
private Command cmExit; // Exit the MIDlet
private DateField dfSnoozeTime; // How long to snooze
private int dateIndex; // Index of the DateField on the Form
private Date currentTime; // Current time...changes when pressing reset
private Timer tmSnooze; // The timer - keeps track of system time
private SnoozeTimer ttSnooze; // Called by the timer
private boolean dateOK = false; // Was the user input valid?

public Snooze()
{
display = Display.getDisplay(this);

// The main form
fmMain = new Form("When to sound the alarm:");

// Save today's date
currentTime = new Date();

// DateField with todays date as a default
dfSnoozeTime = new DateField("", DateField.DATE_TIME);
dfSnoozeTime.setDate(currentTime);

// All the commands/buttons
cmSnooze = new Command("Snooze", Command.SCREEN, 1);
cmReset = new Command("Reset", Command.SCREEN, 1);
cmExit = new Command("Exit", Command.EXIT, 1);

// Add to form and listen for events
dateIndex = fmMain.append(dfSnoozeTime);
fmMain.addCommand(cmSnooze);
fmMain.addCommand(cmReset);
fmMain.addCommand(cmExit);
fmMain.setCommandListener(this);
fmMain.setItemStateListener(this);
}

public void startApp ()
{
display.setCurrent(fmMain);
}

public void pauseApp()
{ }

public void destroyApp(boolean unconditional)
{ }

public void itemStateChanged(Item item)
{
if (item == dfSnoozeTime)
{
// If the user selected date and/or time that is earlier
// than today, set a flag. We are using getTime()
// method of the Date class, which returns the # of
// milliseconds since January 1, 1970
if (dfSnoozeTime.getDate().getTime() < currentTime.getTime())
dateOK = false;
else
dateOK = true;
}
}

public void commandAction(Command c, Displayable s)
{
if (c == cmSnooze)
{
if (dateOK == false)
{
Alert al = new Alert("Unable to set alarm", "Please choose another date and time.", null, null);
al.setTimeout(Alert.FOREVER);
al.setType(AlertType.ERROR);
display.setCurrent(al);
}
else
{
// Create a new timer
tmSnooze = new Timer();
ttSnooze = new SnoozeTimer();

// Amount of time to delay
long amount = dfSnoozeTime.getDate().getTime() - currentTime.getTime();
tmSnooze.schedule(ttSnooze,amount);

// Remove the commands
fmMain.removeCommand(cmSnooze);
fmMain.removeCommand(cmReset);

// Remove the DateField
fmMain.delete(dateIndex);

// Change the Form message
fmMain.setTitle("Snoozing...");
}
}
else if (c == cmReset)
{
// Reset to the current date/time
dfSnoozeTime.setDate(currentTime = new Date());
}
else if (c == cmExit)
{
destroyApp(false);
notifyDestroyed();
}
}

// Handle the timer task
private class SnoozeTimer extends TimerTask
{
public final void run()
{
Alert al = new Alert("Time to wake up!");
al.setTimeout(Alert.FOREVER);
al.setType(AlertType.ALARM);
AlertType.ERROR.playSound(display);
display.setCurrent(al);

// Cancel this timer task
cancel();
}
}
}

Date Example 01(Today's date)

2008-03-21T11:23:00.002+05:30

//jad file (please verify the jar size)
/*
MIDlet-Name: DateToday
MIDlet-Version: 1.0
MIDlet-Vendor: MyCompany
MIDlet-Jar-URL: DateToday.jar
MIDlet-1: DateToday, , DateToday
MicroEdition-Configuration: CLDC-1.0
MicroEdition-Profile: MIDP-1.0
MIDlet-JAR-SIZE: 100

*/
import java.util.Date;

import javax.microedition.lcdui.Command;
import javax.microedition.lcdui.CommandListener;
import javax.microedition.lcdui.DateField;
import javax.microedition.lcdui.Display;
import javax.microedition.lcdui.Displayable;
import javax.microedition.lcdui.Form;
import javax.microedition.midlet.MIDlet;

public class DateToday extends MIDlet implements CommandListener {
private Display display;

private Form form = new Form("Today's Date");

private Date today = new Date(System.currentTimeMillis());

private Command exit = new Command("Exit", Command.EXIT, 1);

private DateField datefield = new DateField("", DateField.DATE_TIME);

public DateToday() {
display = Display.getDisplay(this);
datefield.setDate(today);
form.append(datefield);
form.addCommand(exit);
form.setCommandListener(this);
}

public void startApp() {
display.setCurrent(form);
}

public void pauseApp() {
}

public void destroyApp(boolean unconditional) {
}

public void commandAction(Command command, Displayable displayable) {
if (command == exit) {
destroyApp(false);
notifyDestroyed();
}
}
}

Midlet State Transitions Example

2008-03-20T23:14:00.000+05:30

import javax.microedition.midlet.*;

public class StateTransitions extends MIDlet
{
public StateTransitions()
{
System.out.println("Inside constructor()");
}

// Required: called by application manager to start the MIDlet.
public void startApp()
{
System.out.println("Inside startApp()");
}

// Required: called by application manager to pause the MIDlet.
public void pauseApp()
{
System.out.println("Inside pauseApp()");
}

// Required: called by application manager before shutting down the MIDlet.
public void destroyApp(boolean unconditional)
{
System.out.println("Inside destroyApp()");
}

}

Midlet Example (GoodByeWorld.java)

2008-03-20T23:11:00.000+05:30

import javax.microedition.lcdui.Command;
import javax.microedition.lcdui.CommandListener;
import javax.microedition.lcdui.Display;
import javax.microedition.lcdui.Displayable;
import javax.microedition.lcdui.TextBox;
import javax.microedition.midlet.MIDlet;

public class GoodbyeWorld extends MIDlet implements CommandListener {
private Display display;

private TextBox textBox = new TextBox("Goodbye World", "My second MIDlet", 40, 0);

private Command quitCommand = new Command("Quit", Command.SCREEN, 1);

public void startApp() {
display = Display.getDisplay(this);
textBox.addCommand(quitCommand);
textBox.setCommandListener(this);
display.setCurrent(textBox);
}

public void pauseApp() {
}

public void destroyApp(boolean unconditional) {
}

public void commandAction(Command choice, Displayable displayable) {
if (choice == quitCommand) {
destroyApp(false);
notifyDestroyed();
}
}
}

MIDLET LifeCycle Example

2008-03-20T22:58:00.000+05:30

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

/**
* An example MIDlet with simple "Hello" text.
* Refer to the startApp, pauseApp, and destroyApp
* methods so see how each handles the requested transition.
*/
public class ConsoleHelloMIDlet extends MIDlet
{
/**
* Start up the Hello MIDlet. Just write some info
*/
public void startApp() {
System.out.println( "\nHello Camp" );
pauseApp();
}

/**
* Pause is a no-op since there are no background activities or
* record stores that need to be closed.
*/
public void pauseApp() {
System.out.println( "In pauseApp... " );
destroyApp( true );
}

/**
* Destroy must cleanup everything not handled by the garbage collector.
* In this case there is nothing to cleanup.
*/
public void destroyApp(boolean unconditional) {
System.out.println( "In destroyApp... " );
}

}

JAD Example

2008-03-20T22:57:00.000+05:30

MIDlet-Name: Hello World
MIDlet-Version: 1.0
MIDlet-Vendor: Ashish Jain
MIDlet-Description: My First MIDlet suite
MIDlet-1: HelloWorld, /greeting/myLogo.png, greeting.HelloWorld
MIDlet-Jar-URL: HelloWorld.jar
MIDlet-Jar-Size: 1428

Midlet Example 04

2008-03-20T22:55:00.000+05:30

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

public class WelcomeBack extends MIDlet implements CommandListener
{
private Display display; // Reference to Display object for this MIDlet
private List lsMain; // A List of items
private Command cmExit; // A Command to exit the MIDlet

public WelcomeBack()
{
display = Display.getDisplay(this);

cmExit = new Command("Exit", Command.SCREEN, 1);

lsMain = new List("Welcome Back", Choice.IMPLICIT);
lsMain.append("Core J2ME", null);
lsMain.addCommand(cmExit);
lsMain.setCommandListener(this);
}

// Called by application manager to start the MIDlet.
public void startApp()
{
display.setCurrent(lsMain);
}

// A required method
public void pauseApp()
{ }

// A required method
public void destroyApp(boolean unconditional)
{ }

// Check to see if our Exit command was selected
public void commandAction(Command c, Displayable s)
{
if (c == cmExit)
{
destroyApp(false);
notifyDestroyed();
}
}
}

Midlet Example 03 ( Welcome Midlet )

2008-03-20T22:53:00.000+05:30

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

public class WelcomeMIDlet extends MIDlet implements CommandListener
{
private Display display; // Reference to Display object for this MIDlet
private TextBox tbMain; // A Textbox to display a message
private Command cmExit; // A Command to exit the MIDlet

public WelcomeMIDlet()
{
display = Display.getDisplay(this);

cmExit = new Command("Exit", Command.SCREEN, 1);

tbMain = new TextBox("Welcome", "Core J2ME", 50, 0);
tbMain.addCommand(cmExit);
tbMain.setCommandListener(this);
}

// Called by application manager to start the MIDlet.
public void startApp()
{
display.setCurrent(tbMain);
}

// A required method
public void pauseApp()
{ }

// A required method
public void destroyApp(boolean unconditional)
{ }

// Check to see if our Exit command was selected
public void commandAction(Command c, Displayable s)
{
if (c == cmExit)
{
destroyApp(false);
notifyDestroyed();
}
}
}

Midlet Example 02 ( Using Canvas)

2008-03-20T22:49:00.000+05:30

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

public class MyMidlet extends MIDlet {
public MyMidlet() { // constructor
}

public void startApp() {
Canvas canvas = new MyCanvas();
Display display = Display.getDisplay(this);
display.setCurrent(canvas);
}

public void pauseApp() {
}

public void destroyApp(boolean unconditional) {
}
}
class MyCanvas extends Canvas {
public void paint(Graphics g) {
g.setColor(255, 0, 0);
g.fillRect(0, 0, getWidth(), getHeight());
g.setColor(255, 255, 255);
g.drawString("Hello World!", 0, 0, g.TOP | g.LEFT);
}
}

Midlet Example 01

2008-03-20T22:14:00.005+05:30

import java.util.Timer;
import java.util.TimerTask;
import javax.microedition.midlet.MIDlet;
import javax.microedition.midlet.MIDletStateChangeException;

public class ExampleMIDlet extends MIDlet {

// Flag to indicate first call to startApp
private boolean started = false;

// Background thread
private Thread thread;

// Timer interval
private int timerInterval;

// Timer
private Timer timer;

// Task to run via the timer
private TimerTask task;

// Required public constructor. Can be omitted if nothing to do and no other
// constructors are created.
public ExampleMIDlet() {
System.out.println("Constructor executed");

// Get the timer interval from the manifest or JAD file.
String interval = getAppProperty("Timer-Interval");
timerInterval = Integer.parseInt(interval);
System.out.println("Timer interval is " + interval);
}

protected void startApp() throws MIDletStateChangeException {
if (!started) {
// First invocation. Create and start a timer.
started = true;
System.out.println("startApp called for the first time");
startTimer();
} else {
// Resumed after pausing.
System.out.println("startApp called following pause");
}

// In all cases, start a background thread.
synchronized (this) {
if (thread == null) {
thread = new Thread() {
public void run() {
System.out.println("Thread running");
while (thread == this) {
try {
Thread.sleep(1000);
System.out.println("Thread still active");
} catch (InterruptedException ex) {
}
}
System.out.println("Thread terminating");
}
};
}
}
thread.start();
}

protected void pauseApp() {
// Called from the timer task to do whatever is necessary to pause the MIDlet.
// Tell the background thread to stop.
System.out.println("pauseApp called.");
synchronized (this) {
if (thread != null) {
thread = null;
}
}
}

protected void destroyApp(boolean unconditional) throws MIDletStateChangeException {
// Called to destroy the MIDlet.
System.out.println("destroyApp called - unconditional = " + unconditional);
if (thread != null) {
Thread bgThread = thread;
thread = null; // Signal thread to die
try {
bgThread.join();
} catch (InterruptedException ex) {
}
}
stopTimer();
}

// Starts a timer to run a simple task
private void startTimer() {

// Create a task to be run
task = new TimerTask() {
private boolean isPaused;
private int count;

public void run() {
// Pause or resume the MIDlet.
System.out.println("Timer scheduled");
if (count++ == 4) {
// Terminate the MIDlet
try {
ExampleMIDlet.this.destroyApp(true);
} catch (MIDletStateChangeException ex) {
// Ignore pleas for mercy!
}
ExampleMIDlet.this.notifyDestroyed();
return;
}
if (isPaused) {
System.out.println(">> Resuming MIDlet");
ExampleMIDlet.this.resumeRequest();
isPaused = false;
} else {
System.out.println(">> Pausing MIDlet");
isPaused = true;
ExampleMIDlet.this.pauseApp();
ExampleMIDlet.this.notifyPaused();
}
}
};

// Create a timer and schedule it to run
timer = new Timer();
timer.schedule(task, timerInterval, timerInterval);
System.out.println("Timer started.");
}

// Stops the timer
private void stopTimer() {
if (timer != null) {
System.out.println("Stopping the timer");
timer.cancel();
}
}
}