J2ME Source Codes

Animation With PNG Files

2009-12-14T23:12:00.000-08:00

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

public class GIFDemo extends MIDlet {

private boolean boolMotion=false;
private int iX=10,iY=60;

Display mDisplay;
Thread th;

public void destroyApp(boolean unconditional){}

public void pauseApp() {}

public void startApp() {
mDisplay = Display.getDisplay(this);

final MyCanvas can = new MyCanvas();

mDisplay.setCurrent(can);
}

}

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

public class MyCanvas extends Canvas implements Runnable {
Image img[]=new Image[3];
public MyCanvas() {
try {
img[0]=Image.createImage("/img1.png");
img[1]=Image.createImage("/img2.png");
img[2]=Image.createImage("/img3.png");

}catch(Exception e){}

Thread th=new Thread(this);
th.start();

}

//Display GIF image
public void paint(Graphics g) {
g.drawImage(img[imgIndex],0,0,g.TOP|g.LEFT);
}

//Handling keyEvents
protected void keyPressed(int keyCode) {

}

public void run() {
while(true) {
imgIndex++;
imgIndex%=3;
try {
Thread.sleep(500);
}catch(Exception e){}
}
}

}

J2ME GIF Decoder Animation

2009-12-14T23:10:00.000-08:00

import java.io.*;
import java.util.*;
import javax.microedition.lcdui.*;

/**
* Class GifDecoder - Decodes a GIF file into one or more frames.
*
* Example:
* GifDecoder d = new GifDecoder();
* d.read("sample.gif");
* int n = d.getFrameCount();
* for (int i = 0; i < n; i++) {
* BufferedImage frame = d.getFrame(i); // frame i
* int t = d.getDelay(i); // display duration of frame in milliseconds
* // do something with frame
* }
*
* No copyright asserted on the source code of this class. May be used for
* any purpose, however, refer to the Unisys LZW patent for any additional
* restrictions. I am not responsible if your phone blows up. : )
*
* @author: Jitsu Wan with reference to work done by Kevin Weiner, FM Software; LZW decoder adapted from John Cristy's ImageMagick.
* @version 1.03 November 2004
*
*/

public class Helix_GifDecoder {

/**
* File read status: No errors.
*/
public static final int STATUS_OK = 0;

/**
* File read status: Error decoding file (may be partially decoded)
*/
public static final int STATUS_FORMAT_ERROR = 1;

/**
* File read status: Unable to open source.
*/
public static final int STATUS_OPEN_ERROR = 2;

protected byte[] in;
protected int status;

protected int width; // full image width
protected int height; // full image height
protected boolean gctFlag; // global color table used
protected int gctSize; // size of global color table
protected int loopCount = 1; // iterations; 0 = repeat forever

protected int[] gct; // global color table
protected int[] lct; // local color table
protected int[] act; // active color table

protected int bgIndex; // background color index
protected int bgColor; // background color
protected int lastBgColor; // previous bg color
protected int pixelAspect; // pixel aspect ratio

protected boolean lctFlag; // local color table flag
protected boolean interlace; // interlace flag
protected int lctSize; // local color table size

protected int ix, iy, iw, ih; // current image rectangle
protected int[] lastRect; // last image rect
protected Image image; // current frame
protected Image lastImage; // previous frame

protected byte[] block = new byte[256]; // current data block
protected int blockSize = 0; // block size

// last graphic control extension info
protected int dispose = 0;
// 0=no action; 1=leave in place; 2=restore to bg; 3=restore to prev
protected int lastDispose = 0;
protected boolean transparency = false; // use transparent color
protected int delay = 0; // delay in milliseconds
protected int transIndex; // transparent color index

protected static final int MaxStackSize = 4096;
// max decoder pixel stack size

// LZW decoder working arrays
protected short[] prefix;
protected byte[] suffix;
protected byte[] pixelStack;
protected byte[] pixels;

protected Vector frames; // frames read from current file
protected int frameCount;

static class GifFrame {
public GifFrame(Image im, int del) {
image = im;
delay = del;
}
public Image image;
public int delay;
}

/**
* Gets display duration for specified frame.
*
* @param n int index of frame
* @return delay in milliseconds
*/
public int getDelay(int n) {
//
delay = -1;
if ((n >= 0) && (n < frameCount)) {
delay = ((GifFrame) frames.elementAt(n)).delay;
}
return delay;

}

/**
* Gets the number of frames read from file.
* @return frame count
*/
public int getFrameCount() {
return frameCount;
}

/**
* Gets the first (or only) image read.
*
* @return BufferedImage containing first frame, or null if none.
*/
public Image getImage() {
return getFrame(0);
}

/**
* Gets the "Netscape" iteration count, if any.
* A count of 0 means repeat indefinitiely.
*
* @return iteration count if one was specified, else 1.
*/
public int getLoopCount() {
return loopCount;
}

/**
* Creates new frame image from current data (and previous
* frames as specified by their disposition codes).
*/
protected void setPixels() {
// expose destination image's pixels as int array
int[] dest =new int[image.getWidth()*image.getHeight()];
image.getRGB(dest, 0,0,0,0,image.getWidth(), image.getHeight());

// fill in starting image contents based on last image's dispose code
if (lastDispose > 0) {
if (lastDispose == 3) {
// use image before last
int n = frameCount - 2;
if (n > 0) {
lastImage = getFrame(n - 1);
} else {
lastImage = null;
}
}

if (lastImage != null) {
int[] prev = new int[lastImage.getHeight()*lastImage.getWidth()];
lastImage.getRGB(prev, 0,0,0,0,lastImage.getWidth(), lastImage.getHeight());
System.arraycopy(prev, 0, dest, 0, width * height);
// copy pixels

if (lastDispose == 2) {
// fill last image rect area with background color
Graphics g = image.getGraphics();

if (transparency) {
g.setColor(0x00000000); // assume background is transparent
} else {
g.setColor(lastBgColor); // use given background color
}

g.fillRect(lastRect[0],lastRect[1],lastRect[2],lastRect[3]);

}
}
}

// copy each source line to the appropriate place in the destination
int pass = 1;
int inc = 8;
int iline = 0;
for (int i = 0; i < ih; i++) {
int line = i;
if (interlace) {
if (iline >= ih) {
pass++;
switch (pass) {
case 2 :
iline = 4;
break;
case 3 :
iline = 2;
inc = 4;
break;
case 4 :
iline = 1;
inc = 2;
}
}
line = iline;
iline += inc;
}
line += iy;
if (line < height) {
int k = line * width;
int dx = k + ix; // start of line in dest
int dlim = dx + iw; // end of dest line
if ((k + width) < dlim) {
dlim = k + width; // past dest edge
}
int sx = i * iw; // start of line in source
while (dx < dlim) {
// map color and insert in destination
int index = ((int) pixels[sx++]) & 0xff;
int c = act[index];
if (c != 0) {
dest[dx] = c;
}
dx++;
}
}
}
}

/**
* Gets the image contents of frame n.
*
* @return BufferedImage representation of frame, or null if n is invalid.
*/
public Image getFrame(int n) {
Image im = null;
if ((n >= 0) && (n < frameCount)) {
im = ((GifFrame) frames.elementAt(n)).image;
}
return im;
}

/**
* Gets image size.
*
* @return GIF image dimensions
*/
public int[] getFrameSize() {

int[] dimension = new int[2];
dimension[0] = width;
dimension[1] = height;

return dimension;
}

/**
*
* This method loads the GifDecoder with a GIF image byte array
*
* This is a modification from the original GifDecoder, which accepts a InputStream and is geared towards direct loading from the connection.
* The Helix_Parser takes care of this in this case and therefore no streaming is required.
*
* CHANGES:
*
* Remove any DataInputStream functionality
* Replace with byte[] reading functionality.
*
* Strip away unwanted methods.
* Better understand LZW compression
*
* Consider legal issues.
*
*
**/

public int read(byte[] raw) {
init();

if (raw != null) {

in = raw;
readHeader();
if (!err()) {
readContents();
if (frameCount < 0) {
status = STATUS_FORMAT_ERROR;
}

}

} else {
status = STATUS_OPEN_ERROR;
}

return status;

}

/**
* Decodes LZW image data into pixel array.
* Adapted from John Cristy's ImageMagick.
*/
protected void decodeImageData() {
int NullCode = -1;
int npix = iw * ih;
int available,
clear,
code_mask,
code_size,
end_of_information,
in_code,
old_code,
bits,
code,
count,
i,
datum,
data_size,
first,
top,
bi,
pi;

if ((pixels == null) || (pixels.length < npix)) {
pixels = new byte[npix]; // allocate new pixel array
}
if (prefix == null) prefix = new short[MaxStackSize];
if (suffix == null) suffix = new byte[MaxStackSize];
if (pixelStack == null) pixelStack = new byte[MaxStackSize + 1];

// Initialize GIF data stream decoder.

data_size = read();
clear = 1 << data_size;
end_of_information = clear + 1;
available = clear + 2;
old_code = NullCode;
code_size = data_size + 1;
code_mask = (1 << code_size) - 1;
for (code = 0; code < clear; code++) {
prefix[code] = 0;
suffix[code] = (byte) code;
}

// Decode GIF pixel stream.

datum = bits = count = first = top = pi = bi = 0;

for (i = 0; i < npix;) {
if (top == 0) {
if (bits < code_size) {
// Load bytes until there are enough bits for a code.
if (count == 0) {
// Read a new data block.
count = readBlock();
if (count <= 0)
break;
bi = 0;
}
datum += (((int) block[bi]) & 0xff) << bits;
bits += 8;
bi++;
count--;
continue;
}

// Get the next code.

code = datum & code_mask;
datum >>= code_size;
bits -= code_size;

// Interpret the code

if ((code > available) || (code == end_of_information))
break;
if (code == clear) {
// Reset decoder.
code_size = data_size + 1;
code_mask = (1 << code_size) - 1;
available = clear + 2;
old_code = NullCode;
continue;
}
if (old_code == NullCode) {
pixelStack[top++] = suffix[code];
old_code = code;
first = code;
continue;
}
in_code = code;
if (code == available) {
pixelStack[top++] = (byte) first;
code = old_code;
}
while (code > clear) {
pixelStack[top++] = suffix[code];
code = prefix[code];
}
first = ((int) suffix[code]) & 0xff;

// Add a new string to the string table,

if (available >= MaxStackSize)
break;
pixelStack[top++] = (byte) first;
prefix[available] = (short) old_code;
suffix[available] = (byte) first;
available++;
if (((available & code_mask) == 0)
&& (available < MaxStackSize)) {
code_size++;
code_mask += available;
}
old_code = in_code;
}

// Pop a pixel off the pixel stack.

top--;
pixels[pi++] = pixelStack[top];
i++;
}

for (i = pi; i < npix; i++) {
pixels[i] = 0; // clear missing pixels
}

}

/**
* Returns true if an error was encountered during reading/decoding
*/
protected boolean err() {
return status != STATUS_OK;
}

/**
* Initializes or re-initializes reader
*/
protected void init() {
status = STATUS_OK;
frameCount = 0;
frames = new Vector();
gct = null;
lct = null;
}

protected int readCounter = 0;

/**
* Reads a single byte from the input stream.
*/
protected int read() {
int curByte = 0;
try {

curByte = in[readCounter];
readCounter++;
} catch (IOException e) {
status = STATUS_FORMAT_ERROR;
}
return curByte;
}

/**
* Reads next variable length block from input.
*
* @return number of bytes stored in "buffer"
*/
protected int readBlock() {
blockSize = read();
int n = 0;
if (blockSize > 0) {
try {
int count = 0;
while (n < blockSize) {

count = in.read(block, n, blockSize - n);
if (count == -1)
break;
n += count;
}
} catch (IOException e) {
}

if (n < blockSize) {
status = STATUS_FORMAT_ERROR;
}
}
return n;
}

/**
* Reads color table as 256 RGB integer values
*
* @param ncolors int number of colors to read
* @return int array containing 256 colors (packed ARGB with full alpha)
*/
protected int[] readColorTable(int ncolors) {
int nbytes = 3 * ncolors;
int[] tab = null;
byte[] c = new byte[nbytes];
int n = 0;
try {
n = in.read(c);
} catch (IOException e) {
}
if (n < nbytes) {
status = STATUS_FORMAT_ERROR;
} else {
tab = new int[256]; // max size to avoid bounds checks
int i = 0;
int j = 0;
while (i < ncolors) {
int r = ((int) c[j++]) & 0xff;
int g = ((int) c[j++]) & 0xff;
int b = ((int) c[j++]) & 0xff;
tab[i++] = 0xff000000 | (r << 16) | (g << 8) | b;
}
}
return tab;
}

/**
* Main file parser. Reads GIF content blocks.
*/
protected void readContents() {
// read GIF file content blocks
boolean done = false;
while (!(done || err())) {
int code = read();
switch (code) {

case 0x2C : // image separator
readImage();
break;

case 0x21 : // extension
code = read();
switch (code) {
case 0xf9 : // graphics control extension
readGraphicControlExt();
break;

case 0xff : // application extension
readBlock();
String app = "";
for (int i = 0; i < 11; i++) {
app += (char) block[i];
}
if (app.equals("NETSCAPE2.0")) {
readNetscapeExt();
}
else
skip(); // don't care
break;

default : // uninteresting extension
skip();
}
break;

case 0x3b : // terminator
done = true;
break;

case 0x00 : // bad byte, but keep going and see what happens
break;

default :
status = STATUS_FORMAT_ERROR;
}
}
}

/**
* Reads Graphics Control Extension values
*/
protected void readGraphicControlExt() {
read(); // block size
int packed = read(); // packed fields
dispose = (packed & 0x1c) >> 2; // disposal method
if (dispose == 0) {
dispose = 1; // elect to keep old image if discretionary
}
transparency = (packed & 1) != 0;
delay = readShort() * 10; // delay in milliseconds
transIndex = read(); // transparent color index
read(); // block terminator
}

/**
* Reads GIF file header information.
*/
protected void readHeader() {
String id = "";
for (int i = 0; i < 6; i++) {
id += (char) read();
}
if (!id.startsWith("GIF")) {
status = STATUS_FORMAT_ERROR;
return;
}

readLSD();
if (gctFlag && !err()) {
gct = readColorTable(gctSize);
bgColor = gct[bgIndex];
}
}

/**
* Reads next frame image
*/
protected void readImage() {
ix = readShort(); // (sub)image position & size
iy = readShort();
iw = readShort();
ih = readShort();

int packed = read();
lctFlag = (packed & 0x80) != 0; // 1 - local color table flag
interlace = (packed & 0x40) != 0; // 2 - interlace flag
// 3 - sort flag
// 4-5 - reserved
lctSize = 2 << (packed & 7); // 6-8 - local color table size

if (lctFlag) {
lct = readColorTable(lctSize); // read table
act = lct; // make local table active
} else {
act = gct; // make global table active
if (bgIndex == transIndex)
bgColor = 0;
}
int save = 0;
if (transparency) {
save = act[transIndex];
act[transIndex] = 0; // set transparent color if specified
}

if (act == null) {
status = STATUS_FORMAT_ERROR; // no color table defined
}

if (err()) return;

decodeImageData(); // decode pixel data
skip();

if (err()) return;

frameCount++;

// create new image to receive frame data

image.createImage(width, height);
setPixels(); // transfer pixel data to image

frames.addElement(new GifFrame(image, delay)); // add image to frame list

if (transparency) {
act[transIndex] = save;
}
resetFrame();

}

/**
* Reads Logical Screen Descriptor
*/
protected void readLSD() {

// logical screen size
width = readShort();
height = readShort();

// packed fields
int packed = read();
gctFlag = (packed & 0x80) != 0; // 1 : global color table flag
// 2-4 : color resolution
// 5 : gct sort flag
gctSize = 2 << (packed & 7); // 6-8 : gct size

bgIndex = read(); // background color index
pixelAspect = read(); // pixel aspect ratio
}

/**
* Reads Netscape extenstion to obtain iteration count
*/
protected void readNetscapeExt() {
do {
readBlock();
if (block[0] == 1) {
// loop count sub-block
int b1 = ((int) block[1]) & 0xff;
int b2 = ((int) block[2]) & 0xff;
loopCount = (b2 << 8) | b1;
}
} while ((blockSize > 0) && !err());
}

/**
* Reads next 16-bit value, LSB first
*/
protected int readShort() {
// read 16-bit value, LSB first
return read() | (read() << 8);
}

/**
* Resets frame state for reading next image.
*/
protected void resetFrame() {
lastDispose = dispose;
lastRect = new int[4];
lastRect[0] = ix;
lastRect[1] = iy;
lastRect[2] = iw;
lastRect[3] = ih;

lastImage = image;
lastBgColor = bgColor;
int dispose = 0;
boolean transparency = false;
int delay = 0;
lct = null;
}

/**
* Skips variable length blocks up to and including
* next zero length block.
*/
protected void skip() {
do {
readBlock();
} while ((blockSize > 0) && !err());
}
}

Splitting String/Text In J2ME

2008-08-06T01:01:00.000-07:00

To split string/text in J2ME you can use these methods.
Include one of these method in your applications

public static String[] split (String a,String delimeter){
String c[]=new String[0];
String b=a;
while (true){
int i=b.indexOf(delimeter);
String d=b;
if (i>=0)
d=b.substring(0,i);
String e[]=new String[c.length+1];
for (int k=0;k
e[k]=c[k];
e[e.length-1]=d;
c=e;
b=b.substring(i+delimeter.length(),b.length());
if (b.length()<=0 || i<0 )
break;
} return c;
}

-----

/**
* A method for splitting a string in J2ME.
*
* @param splitStr The string to split.
* @param delimiter The characters to use as delimiters.
* @return An array of strings.
*/
public static String[] Split(String splitStr, String delimiter) {

StringBuffer token = new StringBuffer();
Vector tokens = new Vector();

// split
char[] chars = splitStr.toCharArray();
for (int i=0; i < chars.length; i++) {
if (delimiter.indexOf(chars[i]) != -1) {
// we bumbed into a delimiter
if (token.length() > 0) {
tokens.addElement(token.toString());
token.setLength(0);
}
} else {
token.append(chars[i]);
}
}
// don't forget the "tail"...
if (token.length() > 0) {
tokens.addElement(token.toString());
}

// convert the vector into an array
String[] splitArray = new String[tokens.size()];
for (int i=0; i < splitArray.length; i++) {
splitArray[i] = tokens.elementAt(i);
}
return splitArray;
}

J2ME SMS : Receiving SMS in J2ME

2008-02-22T20:29:00.001-08:00

/*
J2ME SMS
Source code example for receiving SMS in J2ME
*
* @(#)SMSReceive.java 1.11 04/03/22
*
* Copyright (c) 1999-2004 Sun Microsystems, Inc. All rights reserved.
* PROPRIETARY/CONFIDENTIAL
* Use is subject to license terms
*/

package example.sms;

import javax.microedition.midlet.*;
import javax.microedition.io.*;
import javax.microedition.lcdui.*;
import javax.wireless.messaging.*;

import java.io.IOException;

/**
* An example MIDlet displays text from an SMS MessageConnection
*/
public class SMSReceive extends MIDlet
implements CommandListener, Runnable, MessageListener {

/** user interface command for indicating Exit request. */
Command exitCommand = new Command("Exit", Command.EXIT, 2);
/** user interface command for indicating Reply request */
Command replyCommand = new Command("Reply", Command.OK, 1);
/** user interface text box for the contents of the fetched URL. */
Alert content;
/** current display. */
Display display;
/** instance of a thread for asynchronous networking and user interface. */
Thread thread;
/** Connections detected at start up. */
String[] connections;
/** Flag to signal end of processing. */
boolean done;
/** The port on which we listen for SMS messages */
String smsPort;
/** SMS message connection for inbound text messages. */
MessageConnection smsconn = null;
/** Current message read from the network. */
Message msg;
/** Address of the message's sender */
String senderAddress;
/** Alert that is displayed when replying */
Alert sendingMessageAlert;
/** Prompts for and sends the text reply */
SMSSender sender;
/** The screen to display when we return from being paused */
Displayable resumeScreen;

/**
* Initialize the MIDlet with the current display object and
* graphical components.
*/
public SMSReceive() {
smsPort = getAppProperty("SMS-Port");

display = Display.getDisplay(this);

content = new Alert("SMS Receive");
content.setTimeout(Alert.FOREVER);
content.addCommand(exitCommand);
content.setCommandListener(this);
content.setString("Receiving...");

sendingMessageAlert = new Alert("SMS", null, null, AlertType.INFO);
sendingMessageAlert.setTimeout(5000);
sendingMessageAlert.setCommandListener(this);

sender = new SMSSender(smsPort, display, content, sendingMessageAlert);

resumeScreen = content;
}

/**
* Start creates the thread to do the MessageConnection receive
* text.
* It should return immediately to keep the dispatcher
* from hanging.
*/
public void startApp() {
// SMS connection to be read.
String smsConnection = "sms://:" + smsPort;
content.setString(smsConnection);

// Open the message connection.

// if (smsconn == null) {
try {
smsconn = (MessageConnection)Connector.open(smsConnection, Connector.READ);
// smsconn.setMessageListener(this);
} catch (Throwable t) {
content.setString(t.toString());
}
// } catch (IOException ioe) {
// content.setString(ioe.toString());
// ioe.printStackTrace();
// }
// }
/*
// Initialize the text if we were started manually.
connections = PushRegistry.listConnections(true);
if (connections == null || connections.length == 0) {
content.setString("Waiting for SMS on port " + smsPort + "...");
}
done = false;
thread = new Thread(this);
thread.start();
*/
display.setCurrent(resumeScreen);
}

/**
* Notification that a message arrived.
* @param conn the connection with messages available
*/
public void notifyIncomingMessage(MessageConnection conn) {
if (thread == null) {
done = false;
thread = new Thread(this);
thread.start();
}
}

/** Message reading thread. */
public void run() {
/** Check for sms connection. */
try {
msg = smsconn.receive();
if (msg != null) {
senderAddress = msg.getAddress();
content.setTitle("From: " + senderAddress);
if (msg instanceof TextMessage) {
content.setString(((TextMessage)msg).getPayloadText());
} else {
StringBuffer buf = new StringBuffer();
byte[] data = ((BinaryMessage)msg).getPayloadData();
for (int i = 0; i < data.length; i++) {
int intData = (int)data & 0xFF;
if (intData < 0x10) {
buf.append("0");
}
buf.append(Integer.toHexString(intData));
buf.append(' ');
}
content.setString(buf.toString());
}
content.addCommand(replyCommand);
display.setCurrent(content);
}
} catch (IOException e) {
// e.printStackTrace();
}
}
/**
* Pause signals the thread to stop by clearing the thread field.
* If stopped before done with the iterations it will
* be restarted from scratch later.
*/
public void pauseApp() {
done = true;
thread = null;
resumeScreen = display.getCurrent();
}

/**
* Destroy must cleanup everything. The thread is signaled
* to stop and no result is produced.
* @param unconditional true if a forced shutdown was requested
*/
public void destroyApp(boolean unconditional) {
done = true;
thread = null;
if (smsconn != null) {
try {
smsconn.close();
} catch (IOException e) {
// Ignore any errors on shutdown
}
}
}

/**
* Respond to commands, including exit
* @param c user interface command requested
* @param s screen object initiating the request
*/
public void commandAction(Command c, Displayable s) {
try {
if (c == exitCommand || c == Alert.DISMISS_COMMAND) {
destroyApp(false);
notifyDestroyed();
} else if (c == replyCommand) {
reply();
}
} catch (Exception ex) {
ex.printStackTrace();
}
}

/**
* Allow the user to reply to the received message
*/
private void reply() {
// remove the leading "sms://" for diplaying the destination address
String address = senderAddress.substring(6);
String statusMessage = "Sending message to " + address + "...";
sendingMessageAlert.setString(statusMessage);
sender.promptAndSend(senderAddress);
}
}

J2ME SMS : Sending SMS in J2ME

2008-02-22T20:27:00.000-08:00

/************************************************** ***
J2ME SMS
Sending SMS in J2ME

insert this line into JAD file:
Port-SMS: 50056

************************************************** ****/

import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
import javax.wireless.messaging.*;
import javax.microedition.io.*;
import java.io.*;

public class SendSMSextends MIDlet
implements CommandListener, Runnable {

private Display display;
private Command cmdExit, cmdContinue, cmdBack, cmdSend;
private Displayable prevScreen;
private TextBox tfNum, tfText;
private String port;
private Thread thread;
private Alert alert;

private final String INVALID_PHONE =
"Nomor yang dimasukkan tidak absah";

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

port = "50056";
if(getAppProperty("Port-SMS") != null)
port = getAppProperty("Port-SMS");

cmdExit = new Command("Exit", Command.EXIT, 1);
cmdContinue = new Command("Continue", Command.SCREEN, 1);
cmdBack = new Command("Back", Command.BACK, 1);
cmdSend = new Command("Send", Command.SCREEN, 1);

alert = new Alert(null);
alert.setTimeout(3000);
}

public void startApp() {
tfNum = generatePhoneInput();
}

public void pauseApp() {
}

public void destroyApp(boolean unconditional) {
}

public void commandAction(Command c, Displayable s) {
if (c == cmdExit) {
destroyApp(false);
notifyDestroyed();
} else if (c == cmdBack) {
display.setCurrent(tfNum);
} else if (c == cmdContinue) {
if (!isValidPhoneNumber(tfNum.getString())) {
alert.setType(AlertType.ERROR);
alert.setString(INVALID_PHONE);
display.setCurrent(alert,tfNum);
} else {
tfText = generateMessageInput();
}
} else {
thread = new Thread(this);
thread.start();
}
}

public void run() {
MessageConnection conn = null;
String address= "sms://" + tfNum.getString() + ":" + port;
try {
conn = (MessageConnection) Connector.open(address);
TextMessage msg = (TextMessage)
conn.newMessage(MessageConnection.TEXT_MESSAGE);
msg.setAddress(address);
msg.setPayloadText(tfText.getString());
conn.send(msg);
alert.setString("Sending to " +
address.substring(6));
alert.setType(AlertType.INFO);
display.setCurrent(alert);
} catch (IOException ioe) {
ioe.printStackTrace();
}
if (conn != null) {
try {
conn.close();
} catch (IOException ioe) {
ioe.printStackTrace();
}
}
}

public TextBox generatePhoneInput() {
TextBox tfPhone = new TextBox("Number?", null,
15, TextField.PHONENUMBER);
tfPhone.addCommand(cmdExit);
tfPhone.addCommand(cmdContinue);
tfPhone.setCommandListener(this);
display.setCurrent(tfPhone);
return tfPhone;
}

public TextBox generateMessageInput() {
TextBox tfMessage = new TextBox("Text Message", null,
500, TextField.ANY);
tfMessage.addCommand(cmdBack);
tfMessage.addCommand(cmdSend);
tfMessage.setCommandListener(this);
display.setCurrent(tfMessage);
return tfMessage;
}

private static boolean isValidPhoneNumber(String number) {
char[] chars = number.toCharArray();
if (chars.length == 0) {
return false;
}
int startPos = 0;
//+
if (chars[0] == '+') {
startPos = 1;
}
for (int i = startPos; i < chars.length; ++i) {
if (!Character.isDigit(chars[i])) {
return false;
}
}
return true;
}
}

J2ME Game: Maze Game

2008-02-22T20:26:00.000-08:00

*
Title: J2ME Games With MIDP2
Authors: Carol Hamer
Publisher: Apress
ISBN: 1590593820
*/

import java.util.Random;
import java.util.Vector;

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

/**
* This is the main class of the maze game.
*
* @author Carol Hamer
*/
public class Maze extends MIDlet implements CommandListener {

//----------------------------------------------------------------
// game object fields

/**
* The canvas that the maze is drawn on.
*/
private MazeCanvas myCanvas;

/**
* The screen that allows the user to alter the size parameters
* of the maze.
*/
private SelectScreen mySelectScreen;

//----------------------------------------------------------------
// command fields

/**
* The button to exit the game.
*/
private Command myExitCommand = new Command("Exit", Command.EXIT, 99);

/**
* The command to create a new maze. (This command may appear in a menu)
*/
private Command myNewCommand = new Command("New Maze", Command.SCREEN, 1);

/**
* The command to dismiss an alert error message. In MIDP 2.0
* an Alert set to Alert.FOREVER automatically has a default
* dismiss command. This program does not use it in order to
* allow backwards com
*/
private Command myAlertDoneCommand = new Command("Done", Command.EXIT, 1);

/**
* The command to go to the screen that allows the user
* to alter the size parameters. (This command may appear in a menu)
*/
private Command myPrefsCommand
= new Command("Size Preferences", Command.SCREEN, 1);

//----------------------------------------------------------------
// initialization

/**
* Initialize the canvas and the commands.
*/
public Maze() {
try {
myCanvas = new MazeCanvas(Display.getDisplay(this));
myCanvas.addCommand(myExitCommand);
myCanvas.addCommand(myNewCommand);
myCanvas.addCommand(myPrefsCommand);
myCanvas.setCommandListener(this);
} catch(Exception e) {
// if there's an error during creation, display it as an alert.
Alert errorAlert = new Alert("error",
e.getMessage(), null, AlertType.ERROR);
errorAlert.setCommandListener(this);
errorAlert.setTimeout(Alert.FOREVER);
errorAlert.addCommand(myAlertDoneCommand);
Display.getDisplay(this).setCurrent(errorAlert);
}
}

//----------------------------------------------------------------
// implementation of MIDlet

/**
* Start the application.
*/
public void startApp() throws MIDletStateChangeException {
if(myCanvas != null) {
myCanvas.start();
}
}

/**
* Clean up.
*/
public void destroyApp(boolean unconditional)
throws MIDletStateChangeException {
myCanvas = null;
System.gc();
}

/**
* Does nothing since this program occupies no shared resources
* and little memory.
*/
public void pauseApp() {
}

//----------------------------------------------------------------
// implementation of CommandListener

/*
* Respond to a command issued on the Canvas.
* (reset, exit, or change size prefs).
*/
public void commandAction(Command c, Displayable s) {
if(c == myNewCommand) {
myCanvas.newMaze();
} else if(c == myAlertDoneCommand) {
try {
destroyApp(false);
notifyDestroyed();
} catch (MIDletStateChangeException ex) {
}
} else if(c == myPrefsCommand) {
if(mySelectScreen == null) {
mySelectScreen = new SelectScreen(myCanvas);
}
Display.getDisplay(this).setCurrent(mySelectScreen);
} else if(c == myExitCommand) {
try {
destroyApp(false);
notifyDestroyed();
} catch (MIDletStateChangeException ex) {
}
}
}

}

/**
* This class is the display of the game.
*
* @author Carol Hamer
*/
class MazeCanvas extends javax.microedition.lcdui.Canvas {

//---------------------------------------------------------
// static fields

/**
* color constant
*/
public static final int BLACK = 0;

/**
* color constant
*/
public static final int WHITE = 0xffffff;

//---------------------------------------------------------
// instance fields

/**
* a handle to the display.
*/
private Display myDisplay;

/**
* The data object that describes the maze configuration.
*/
private Grid myGrid;

/**
* Whether or not the currently displayed maze has
* been completed.
*/
private boolean myGameOver = false;

/**
* maze dimension: the width of the maze walls.
*/
private int mySquareSize;

/**
* maze dimension: the maximum width possible for the maze walls.
*/
private int myMaxSquareSize;

/**
* maze dimension: the minimum width possible for the maze walls.
*/
private int myMinSquareSize;

/**
* top corner of the display: x-coordiate
*/
private int myStartX = 0;

/**
* top corner of the display: y-coordinate
*/
private int myStartY = 0;

/**
* how many rows the display is divided into.
*/
private int myGridHeight;

/**
* how many columns the display is divided into.
*/
private int myGridWidth;

/**
* the maximum number columns the display can be divided into.
*/
private int myMaxGridWidth;

/**
* the minimum number columns the display can be divided into.
*/
private int myMinGridWidth;

/**
* previous location of the player in the maze: x-coordiate
* (in terms of the coordinates of the maze grid, NOT in terms
* of the coordinate system of the Canvas.)
*/
private int myOldX = 1;

/**
* previous location of the player in the maze: y-coordinate
* (in terms of the coordinates of the maze grid, NOT in terms
* of the coordinate system of the Canvas.)
*/
private int myOldY = 1;

/**
* current location of the player in the maze: x-coordiate
* (in terms of the coordinates of the maze grid, NOT in terms
* of the coordinate system of the Canvas.)
*/
private int myPlayerX = 1;

/**
* current location of the player in the maze: y-coordinate
* (in terms of the coordinates of the maze grid, NOT in terms
* of the coordinate system of the Canvas.)
*/
private int myPlayerY = 1;

//-----------------------------------------------------
// gets / sets

/**
* Changes the width of the maze walls and calculates how
* this change affects the number of rows and columns
* the maze can have.
* @return the number of columns now that the the
* width of the columns has been updated.
*/
int setColWidth(int colWidth) {
if(colWidth < 2) {
mySquareSize = 2;
} else {
mySquareSize = colWidth;
}
myGridWidth = getWidth() / mySquareSize;
if(myGridWidth % 2 == 0) {
myGridWidth -= 1;
}
myGridHeight = getHeight() / mySquareSize;
if(myGridHeight % 2 == 0) {
myGridHeight -= 1;
}
myGrid = null;
return(myGridWidth);
}

/**
* @return the minimum width possible for the maze walls.
*/
int getMinColWidth() {
return(myMinSquareSize);
}

/**
* @return the maximum width possible for the maze walls.
*/
int getMaxColWidth() {
return(myMaxSquareSize);
}

/**
* @return the maximum number of columns the display can be divided into.
*/
int getMaxNumCols() {
return(myMaxGridWidth);
}

/**
* @return the width of the maze walls.
*/
int getColWidth() {
return(mySquareSize);
}

/**
* @return the number of maze columns the display is divided into.
*/
int getNumCols() {
return(myGridWidth);
}

//-----------------------------------------------------
// initialization and game state changes

/**
* Constructor performs size calculations.
* @throws Exception if the display size is too
* small to make a maze.
*/
public MazeCanvas(Display d) throws Exception {
myDisplay = d;
// a few calculations to make the right maze
// for the current display.
int width = getWidth();
int height = getHeight();
// tests indicate that 5 is a good default square size,
// but the user can change it...
mySquareSize = 5;
myMinSquareSize = 3;
myMaxGridWidth = width / myMinSquareSize;
if(myMaxGridWidth % 2 == 0) {
myMaxGridWidth -= 1;
}
myGridWidth = width / mySquareSize;
if(myGridWidth % 2 == 0) {
myGridWidth -= 1;
}
myGridHeight = height / mySquareSize;
if(myGridHeight % 2 == 0) {
myGridHeight -= 1;
}
myMinGridWidth = 15;
myMaxSquareSize = width / myMinGridWidth;
if(myMaxSquareSize > height / myMinGridWidth) {
myMaxSquareSize = height / myMinGridWidth;
}
// if the display is too small to make a reasonable maze,
// then we throw an Exception
if(myMaxSquareSize < mySquareSize) {
throw(new Exception("Display too small"));
}
}

/**
* This is called as soon as the application begins.
*/
void start() {
myDisplay.setCurrent(this);
repaint();
}

/**
* discard the current maze and draw a new one.
*/
void newMaze() {
myGameOver = false;
// throw away the current maze.
myGrid = null;
// set the player back to the beginning of the maze.
myPlayerX = 1;
myPlayerY = 1;
myOldX = 1;
myOldY = 1;
myDisplay.setCurrent(this);
// paint the new maze
repaint();
}

//-------------------------------------------------------
// graphics methods

/**
* Create and display a maze if necessary, otherwise just
* move the player. Since the motion in this game is
* very simple, it is not necessary to repaint the whole
* maze each time, just the player + erase the square
* that the player just left..
*/
protected void paint(Graphics g) {
// If there is no current maze, create one and draw it.
if(myGrid == null) {
int width = getWidth();
int height = getHeight();
// create the underlying data of the maze.
myGrid = new Grid(myGridWidth, myGridHeight);
// draw the maze:
// loop through the grid data and color each square the
// right color
for(int i = 0; i < myGridWidth; i++) {
for(int j = 0; j < myGridHeight; j++) {
if(myGrid.mySquares[i][j] == 0) {
g.setColor(BLACK);
} else {
g.setColor(WHITE);
}
// fill the square with the appropriate color
g.fillRect(myStartX + (i*mySquareSize),
myStartY + (j*mySquareSize),
mySquareSize, mySquareSize);
}
}
// fill the extra space outside of the maze
g.setColor(BLACK);
g.fillRect(myStartX + ((myGridWidth-1) * mySquareSize),
myStartY, width, height);
// erase the exit path:
g.setColor(WHITE);
g.fillRect(myStartX + ((myGridWidth-1) * mySquareSize),
myStartY + ((myGridHeight-2) * mySquareSize), width, height);
// fill the extra space outside of the maze
g.setColor(BLACK);
g.fillRect(myStartX,
myStartY + ((myGridHeight-1) * mySquareSize), width, height);
}
// draw the player (red):
g.setColor(255, 0, 0);
g.fillRoundRect(myStartX + (mySquareSize)*myPlayerX,
myStartY + (mySquareSize)*myPlayerY,
mySquareSize, mySquareSize,
mySquareSize, mySquareSize);
// erase the previous location
if((myOldX != myPlayerX) || (myOldY != myPlayerY)) {
g.setColor(WHITE);
g.fillRect(myStartX + (mySquareSize)*myOldX,
myStartY + (mySquareSize)*myOldY,
mySquareSize, mySquareSize);
}
// if the player has reached the end of the maze,
// we display the end message.
if(myGameOver) {
// perform some calculations to place the text correctly:
int width = getWidth();
int height = getHeight();
Font font = g.getFont();
int fontHeight = font.getHeight();
int fontWidth = font.stringWidth("Maze Completed");
g.setColor(WHITE);
g.fillRect((width - fontWidth)/2, (height - fontHeight)/2,
fontWidth + 2, fontHeight);
// write in red
g.setColor(255, 0, 0);
g.setFont(font);
g.drawString("Maze Completed", (width - fontWidth)/2,
(height - fontHeight)/2,
g.TOP|g.LEFT);
}
}

/**
* Move the player.
*/
public void keyPressed(int keyCode) {
if(! myGameOver) {
int action = getGameAction(keyCode);
switch (action) {
case LEFT:
if((myGrid.mySquares[myPlayerX-1][myPlayerY] == 1) &&
(myPlayerX != 1)) {
myOldX = myPlayerX;
myOldY = myPlayerY;
myPlayerX -= 2;
repaint();
}
break;
case RIGHT:
if(myGrid.mySquares[myPlayerX+1][myPlayerY] == 1) {
myOldX = myPlayerX;
myOldY = myPlayerY;
myPlayerX += 2;
repaint();
} else if((myPlayerX == myGrid.mySquares.length - 2) &&
(myPlayerY == myGrid.mySquares[0].length - 2)) {
myOldX = myPlayerX;
myOldY = myPlayerY;
myPlayerX += 2;
myGameOver = true;
repaint();
}
break;
case UP:
if(myGrid.mySquares[myPlayerX][myPlayerY-1] == 1) {
myOldX = myPlayerX;
myOldY = myPlayerY;
myPlayerY -= 2;
repaint();
}
break;
case DOWN:
if(myGrid.mySquares[myPlayerX][myPlayerY+1] == 1) {
myOldX = myPlayerX;
myOldY = myPlayerY;
myPlayerY += 2;
repaint();
}
break;
}
}
}

}

/**
* This is the screen that allows the user to modify the
* width of the maze walls..
*
* @author Carol Hamer
*/
class SelectScreen extends Form
implements ItemStateListener, CommandListener {

//----------------------------------------------------------------
// fields

/**
* The "Done" button to exit this screen and return to the maze.
*/
private Command myExitCommand = new Command("Done", Command.EXIT, 1);

/**
* The gague that modifies the width of the maze walls.
*/
private Gauge myWidthGauge;

/**
* The gague that displays the number of columns of the maze.
*/
private Gauge myColumnsGauge;

/**
* A handle to the main game canvas.
*/
private MazeCanvas myCanvas;

//----------------------------------------------------------------
// initialization

/**
* Create the gagues and place them on the screen.
*/
public SelectScreen(MazeCanvas canvas) {
super("Size Preferences");
addCommand(myExitCommand);
setCommandListener(this);
myCanvas = canvas;
setItemStateListener(this);
myWidthGauge = new Gauge("Column Width", true,
myCanvas.getMaxColWidth(),
myCanvas.getColWidth());
myColumnsGauge = new Gauge("Number of Columns", false,
myCanvas.getMaxNumCols(),
myCanvas.getNumCols());
// Warning: the setLayout method does not exist in
// MIDP 1.4. If there is any chance that a target
// device will be using MIDP 1.4, comment out the
// following two lines:
//myWidthGauge.setLayout(Item.LAYOUT_CENTER);
//myColumnsGauge.setLayout(Item.LAYOUT_CENTER);
append(myWidthGauge);
append(myColumnsGauge);
}

//----------------------------------------------------------------
// implementation of ItemStateListener

/**
* Respond to the user changing the width.
*/
public void itemStateChanged(Item item) {
if(item == myWidthGauge) {
int val = myWidthGauge.getValue();
if(val < myCanvas.getMinColWidth()) {
myWidthGauge.setValue(myCanvas.getMinColWidth());
} else {
int numCols = myCanvas.setColWidth(val);
myColumnsGauge.setValue(numCols);
}
}
}

//----------------------------------------------------------------
// implementation of CommandListener

/*
* Respond to a command issued on this screen.
* (either reset or exit).
*/
public void commandAction(Command c, Displayable s) {
if(c == myExitCommand) {
myCanvas.newMaze();
}
}

}

/**
* This class contains the data necessary to draw the maze.
*
* @author Carol Hamer
*/
class Grid {

/**
* Random number generator to create a random maze.
*/
private Random myRandom = new Random();

/**
* data for which squares are filled and which are blank.
* 0 = black
* 1 = white
* values higher than 1 are used during the maze creation
* algorithm.
* 2 = the square could possibly be appended to the maze this round.
* 3 = the square's color is not yet decided, and the square is
* not close enough to be appended to the maze this round.
*/
int[][] mySquares;

//--------------------------------------------------------
// maze generation methods

/**
* Create a new maze.
*/
public Grid(int width, int height) {
mySquares = new int[width][height];
// initialize all of the squares to white except a lattice
// framework of black squares.
for(int i = 1; i < width - 1; i++) {
for(int j = 1; j < height - 1; j++) {
if((i % 2 == 1) || (j % 2 == 1)) {
mySquares[i][j] = 1;
}
}
}
// the entrance to the maze is at (0,1).
mySquares[0][1] = 1;
createMaze();
}

/**
* This method randomly generates the maze.
*/
private void createMaze() {
// create an initial framework of black squares.
for(int i = 1; i < mySquares.length - 1; i++) {
for(int j = 1; j < mySquares[i].length - 1; j++) {
if((i + j) % 2 == 1) {
mySquares[i][j] = 0;
}
}
}
// initialize the squares that can be either black or white
// depending on the maze.
// first we set the value to 3 which means undecided.
for(int i = 1; i < mySquares.length - 1; i+=2) {
for(int j = 1; j < mySquares[i].length - 1; j+=2) {
mySquares[i][j] = 3;
}
}
// Then those squares that can be selected to be open
// (white) paths are given the value of 2.
// We randomly select the square where the tree of maze
// paths will begin. The maze is generated starting from
// this initial square and branches out from here in all
// directions to fill the maze grid.
Vector possibleSquares = new Vector(mySquares.length
* mySquares[0].length);
int[] startSquare = new int[2];
startSquare[0] = getRandomInt(mySquares.length / 2)*2 + 1;
startSquare[1] = getRandomInt(mySquares[0].length / 2)*2 + 1;
mySquares[startSquare[0]][startSquare[1]] = 2;
possibleSquares.addElement(startSquare);
// Here we loop to select squares one by one to append to
// the maze pathway tree.
while(possibleSquares.size() > 0) {
// the next square to be joined on is selected randomly.
int chosenIndex = getRandomInt(possibleSquares.size());
int[] chosenSquare = (int[])possibleSquares.elementAt(chosenIndex);
// we set the chosen square to white and then
// remove it from the list of possibleSquares (i.e. squares
// that can possibly be added to the maze), and we link
// the new square to the maze.
mySquares[chosenSquare[0]][chosenSquare[1]] = 1;
possibleSquares.removeElementAt(chosenIndex);
link(chosenSquare, possibleSquares);
}
// now that the maze has been completely generated, we
// throw away the objects that were created during the
// maze creation algorithm and reclaim the memory.
possibleSquares = null;
System.gc();
}

/**
* internal to createMaze. Checks the four squares surrounding
* the chosen square. Of those that are already connected to
* the maze, one is randomly selected to be joined to the
* current square (to attach the current square to the
* growing maze). Those squares that were not previously in
* a position to be joined to the maze are added to the list
* of "possible" squares (that could be chosen to be attached
* to the maze in the next round).
*/
private void link(int[] chosenSquare, Vector possibleSquares) {
int linkCount = 0;
int i = chosenSquare[0];
int j = chosenSquare[1];
int[] links = new int[8];
if(i >= 3) {
if(mySquares[i - 2][j] == 1) {
links[2*linkCount] = i - 1;
links[2*linkCount + 1] = j;
linkCount++;
} else if(mySquares[i - 2][j] == 3) {
mySquares[i - 2][j] = 2;
int[] newSquare = new int[2];
newSquare[0] = i - 2;
newSquare[1] = j;
possibleSquares.addElement(newSquare);
}
}
if(j + 3 <= mySquares[i].length) {
if(mySquares[i][j + 2] == 3) {
mySquares[i][j + 2] = 2;
int[] newSquare = new int[2];
newSquare[0] = i;
newSquare[1] = j + 2;
possibleSquares.addElement(newSquare);
} else if(mySquares[i][j + 2] == 1) {
links[2*linkCount] = i;
links[2*linkCount + 1] = j + 1;
linkCount++;
}
}
if(j >= 3) {
if(mySquares[i][j - 2] == 3) {
mySquares[i][j - 2] = 2;
int[] newSquare = new int[2];
newSquare[0] = i;
newSquare[1] = j - 2;
possibleSquares.addElement(newSquare);
} else if(mySquares[i][j - 2] == 1) {
links[2*linkCount] = i;
links[2*linkCount + 1] = j - 1;
linkCount++;
}
}
if(i + 3 <= mySquares.length) {
if(mySquares[i + 2][j] == 3) {
mySquares[i + 2][j] = 2;
int[] newSquare = new int[2];
newSquare[0] = i + 2;
newSquare[1] = j;
possibleSquares.addElement(newSquare);
} else if(mySquares[i + 2][j] == 1) {
links[2*linkCount] = i + 1;
links[2*linkCount + 1] = j;
linkCount++;
}
}
if(linkCount > 0) {
int linkChoice = getRandomInt(linkCount);
int linkX = links[2*linkChoice];
int linkY = links[2*linkChoice + 1];
mySquares[linkX][linkY] = 1;
int[] removeSquare = new int[2];
removeSquare[0] = linkX;
removeSquare[1] = linkY;
possibleSquares.removeElement(removeSquare);
}
}

/**
* a randomization utility.
* @param upper the upper bound for the random int.
* @return a random non-negative int less than the bound upper.
*/
public int getRandomInt(int upper) {
int retVal = myRandom.nextInt() % upper;
if(retVal < 0) {
retVal += upper;
}
return(retVal);
}

}

Add a Bluetooth text protocol to J2ME apps

2008-02-22T20:25:00.000-08:00

package bluetooth.livingroom;

import com.ibm.btevents.*;

public class TelephoneMonitor extends MIDlet implements BTEventListener,
                                                      PhoneListener {

  private BTManager btManager;

  public TelephoneMonitor() {
      btManager = new BTManager(this);
  }

  public void incomingCall(PhoneEvent event) {
      btManager.sendMessage(
              "bluetooth.livingroom.TelevisionMonitor",
              "incomingCall:"+event.getCaller()
      );
  }

  public void callEnded(PhoneEvent event) {
      btManager.sendMessage(
              "bluetooth.livingroom.TelevisionMonitor",
              "callEnded:"+event.getDuration()
      );
  }

  public void messageReceived(BTEvent event) {}
  public void messageSent(BTEvent event) {}
  public void devicesDiscovered(BTEvent event) {}
  public void diagnosticMessage(BTEvent event) {}

}


Get More Information in http://www-128.ibm.com/developerworks/wireless/library/wi-javab

J2ME Encryption with Bouncy Castle

2007-11-21T22:50:00.000-08:00

import org.bouncycastle.crypto.*;
import org.bouncycastle.crypto.engines.*;
import org.bouncycastle.crypto.modes.*;
import org.bouncycastle.crypto.params.*;

public class Encryptor {

private BufferedBlockCipher cipher;
private KeyParameter key;

// inisialisasi engine kriptografi.
// array key paling sedikit 8 bytes.
public Encryptor( byte[] key ){
cipher = new PaddedBlockCipher(new CBCBlockCipher(new DESEngine() ) );
this.key = new KeyParameter( key );
}

// inisialisasi engine kriptografi.
// string paling sedikit 8 chars.
public Encryptor( String key ){
this( key.getBytes() );
}

private byte[] callCipher( byte[] data ) throws CryptoException {
int size = cipher.getOutputSize( data.length );
byte[] result = new byte[ size ];
int olen = cipher.processBytes( data, 0, data.length, result, 0 );
olen += cipher.doFinal( result, olen );
if( olen <>
byte[] tmp = new byte[ olen ];
System.arraycopy( result, 0, tmp, 0, olen );
result = tmp;
}
return result;
}

// enkripsi arbitrary byte array
// mengembalikan data terenkripsi dalam bentuk yang berbeda
public synchronized byte[] encrypt( byte[] data ) throws CryptoException {
if( data == null || data.length == 0 ){
return new byte[0];
}

cipher.init( true, key );
return callCipher( data );
}

// enkripsi string.
public byte[] encryptString( String data ) throws CryptoException {

if( data == null || data.length() == 0 ){
return new byte[0];
}
return encrypt( data.getBytes() );
}

// Dekrip arbitrary data.
public synchronized byte[] decrypt( byte[] data )
throws CryptoException {
if( data == null || data.length == 0 ){
return new byte[0];
}

cipher.init( false, key );
return callCipher( data );
}

// Dekrip string
public String decryptString( byte[] data )
throws CryptoException {

if( data == null || data.length == 0 ){

return "";

}
return new String( decrypt( data ) );
}
}

View PNG Image with Thread

2007-07-23T04:10:00.000-07:00

/*--------------------------------------------------

* ViewPngThread.java

* Download and view a png file. The download is

* done in the background with a separate thread

* Example from the book: Core J2ME Technology

* Copyright John W. Muchow http://www.CoreJ2ME.com

* You may use/modify for any non-commercial purpose

*-------------------------------------------------*/

import javax.microedition.midlet.*;

import javax.microedition.lcdui.*;

import javax.microedition.io.*;

import java.io.*;

public class ViewPngThread extends MIDlet implements CommandListener

{

private Display display;

private TextBox tbMain;

private Alert alStatus;

private Form fmViewPng;

private Command cmExit;

private Command cmView;

private Command cmBack;

private static final int ALERT_DISPLAY_TIME = 3000;

Image im = null;

public ViewPngThread()

{

display = Display.getDisplay(this);

// Create the Main textbox with a maximum of 75 characters

tbMain = new TextBox("Enter url", "http://www.corej2me.com/midpbook_v1e1/ch14/bird.png", 75, 0);

// Create commands and add to textbox

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

cmView = new Command("View", Command.SCREEN, 2);

tbMain.addCommand(cmExit);

tbMain.addCommand(cmView );

// Set up a listener for textbox

tbMain.setCommandListener(this);

// Create the form that will hold the png image

fmViewPng = new Form("");

// Create commands and add to form

cmBack = new Command("Back", Command.BACK, 1);

fmViewPng.addCommand(cmBack);

// Set up a listener for form

fmViewPng.setCommandListener(this);

}

public void startApp()

{

display.setCurrent(tbMain);

}

public void pauseApp()

{ }

public void destroyApp(boolean unconditional)

{ }

/*--------------------------------------------------

* Process events

*-------------------------------------------------*/

public void commandAction(Command c, Displayable s)

{

// If the Command button pressed was "Exit"

if (c == cmExit)

{

destroyApp(false);

notifyDestroyed();

}

else if (c == cmView)

{

// Show alert indicating we are starting a download.

// This alert is NOT modal, it appears for

// approximately 3 seconds (see ALERT_DISPLAY_TIME)

showAlert("Downloading", false, tbMain);

// Create an instance of the class that will

// download the file in a separate thread

Download dl = new Download(tbMain.getString(), this);

// Start the thread/download

dl.start();

}

else if (c == cmBack)

{

display.setCurrent(tbMain);

}

/*--------------------------------------------------

* Called by the thread after attempting to download

* an image. If the parameter is 'true' the download

* was successful, and the image is shown on a form.

* If parameter is 'false' the download failed, and

* the user is returned to the textbox.

* In either case, show an alert indicating the

* the result of the download.

*-------------------------------------------------*/

public void showImage(boolean flag)

{

// Download failed...

if (flag == false)

{

// Alert followed by the main textbox

showAlert("Download Failure", true, tbMain);

}

else // Successful download...

{

ImageItem ii = new ImageItem(null, im, ImageItem.LAYOUT_DEFAULT, null);

// If there is already an image, set (replace) it

if (fmViewPng.size() != 0)

fmViewPng.set(0, ii);

else // Append the image to the empty form

fmViewPng.append(ii);

// Alert followed by the form holding the image

showAlert("Download Successful", true, fmViewPng);

}

/*--------------------------------------------------

* Show an alert with the parameters determining

* the type (modal or not) and the displayable to

* show after the alert is dismissed

*-------------------------------------------------*/

public void showAlert(String msg, boolean modal, Displayable displayable)

{

// Create alert, add text, associate a sound

alStatus = new Alert("Status", msg, null, AlertType.INFO);

// Set the alert type

if (modal)

alStatus.setTimeout(Alert.FOREVER);

else

alStatus.setTimeout(ALERT_DISPLAY_TIME);

// Show the alert, followed by the displayable

display.setCurrent(alStatus, displayable);

}

/*--------------------------------------------------

* Class - Download

* Download an image file in a separate thread

*-------------------------------------------------*/

class Download implements Runnable

{

private String url;

private ViewPngThread MIDlet;

private boolean downloadSuccess = false;

public Download(String url, ViewPngThread MIDlet)

{

this.url = url;

this.MIDlet = MIDlet;

}

/*--------------------------------------------------

* Download the image

*-------------------------------------------------*/

public void run()

{

try

{

getImage(url);

}

catch (Exception e)

{

System.err.println("Msg: " + e.toString());

}

/*--------------------------------------------------

* Create and start the new thread

*-------------------------------------------------*/

public void start()

{

Thread thread = new Thread(this);

try

{

thread.start();

}

catch (Exception e)

{

}

/*--------------------------------------------------

* Open connection and download png into a byte array.

*-------------------------------------------------*/

private void getImage(String url) throws IOException

{

ContentConnection connection = (ContentConnection) Connector.open(url);

// * There is a bug in MIDP 1.0.3 in which read() sometimes returns

// an invalid length. To work around this, I have changed the

// stream to DataInputStream and called readFully() instead of read()

// InputStream iStrm = connection.openInputStream();

DataInputStream iStrm = connection.openDataInputStream();

ByteArrayOutputStream bStrm = null;

Image im = null;

try

{

// ContentConnection includes a length method

byte imageData[];

int length = (int) connection.getLength();

if (length != -1)

{

imageData = new byte[length];

// Read the png into an array

// iStrm.read(imageData);

iStrm.readFully(imageData);

}

else // Length not available...

{

bStrm = new ByteArrayOutputStream();

int ch;

while ((ch = iStrm.read()) != -1)

bStrm.write(ch);

imageData = bStrm.toByteArray();

}

// Create the image from the byte array

im = Image.createImage(imageData, 0, imageData.length);

}

finally

{

// Clean up

if (connection != null)

connection.close();

if (iStrm != null)

iStrm.close();

if (bStrm != null)

bStrm.close();

}

// Return to the caller the status of the download

if (im == null)

MIDlet.showImage(false);

else

{

MIDlet.im = im;

MIDlet.showImage(true);

}

Canvas for processing game actions

2007-07-18T18:39:00.001-07:00

/*--------------------------------------------------
* GameActions.java
*
* Canvas for processing game actions
*
* Example from the book: Core J2ME Technology
* Copyright John W. Muchow http://www.CoreJ2ME.com
* You may use/modify for any non-commercial purpose
*-------------------------------------------------*/
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;

public class GameActions extends MIDlet
{
private Display display; // The display
private GameActionCanvas canvas; // Canvas

public GameActions()
{
display = Display.getDisplay(this);
canvas = new GameActionCanvas(this);
}

protected void startApp()
{
display.setCurrent( canvas );
}

protected void pauseApp()
{ }

protected void destroyApp( boolean unconditional )
{ }

public void exitMIDlet()
{
destroyApp(true);
notifyDestroyed();
}
}

/*--------------------------------------------------
* GameActionCanvas.java
*
* Game action event handling
*-------------------------------------------------*/
class GameActionCanvas extends Canvas implements CommandListener
{
private Command cmExit; // Exit midlet
private String keyText = null; // Key code text
private GameActions midlet;

/*--------------------------------------------------
* Constructor
*-------------------------------------------------*/
public GameActionCanvas(GameActions midlet)
{
this.midlet = midlet;

// Create exit command & listen for events
cmExit = new Command("Exit", Command.EXIT, 1);
addCommand(cmExit);
setCommandListener(this);
}

/*--------------------------------------------------
* Paint the text representing the key code
*-------------------------------------------------*/
protected void paint(Graphics g)
{
// Clear the background (to white)
g.setColor(255, 255, 255);
g.fillRect(0, 0, getWidth(), getHeight());

// Set color and draw text
if (keyText != null)
{
// Draw with black pen
g.setColor(0, 0, 0);
// Center the text
g.drawString(keyText, getWidth()/2, getHeight()/2, Graphics.TOP | Graphics.HCENTER);
}
}

/*--------------------------------------------------
* Command event handling
*-------------------------------------------------*/
public void commandAction(Command c, Displayable d)
{
if (c == cmExit)
midlet.exitMIDlet();
}

/*--------------------------------------------------
* Game action event handling
* A game action will be converted into a key code
* and handed off to this method
*-------------------------------------------------*/
protected void keyPressed(int keyCode)
{
switch (getGameAction(keyCode))
{
// Place logic of each action inside the case
case FIRE:
case UP:
case DOWN:
case LEFT:
case RIGHT:
case GAME_A:
case GAME_B:
case GAME_C:
case GAME_D:
default:
// Print the text of the game action
keyText = getKeyName(keyCode);
}
repaint();
}
}

Display Alert

2007-07-18T18:28:00.000-07:00

//jad file (please verify the jar size)
/*
MIDlet-Name: DisplayAlert
MIDlet-Version: 1.0
MIDlet-Vendor: MyCompany
MIDlet-Jar-URL: DisplayAlert.jar
MIDlet-1: DisplayAlert, , DisplayAlert
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.Form;
import javax.microedition.midlet.MIDlet;
import javax.microedition.midlet.MIDletStateChangeException;

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

private Alert alert;

private Form form = new Form("Throw Exception");

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

private boolean exitFlag = false;

public DisplayAlert() {
display = Display.getDisplay(this);
form.addCommand(exit);
form.setCommandListener(this);
}

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

public void pauseApp() {
}

public void destroyApp(boolean unconditional) throws MIDletStateChangeException {
if (unconditional == false) {
throw new MIDletStateChangeException();
}
}

public void commandAction(Command command, Displayable displayable) {
if (command == exit) {
try {
if (exitFlag == false) {
alert = new Alert("Busy", "Please try again.", null, AlertType.WARNING);
alert.setTimeout(Alert.FOREVER);
display.setCurrent(alert, form);
destroyApp(false);
} else {
destroyApp(true);
notifyDestroyed();
}
} catch (Exception exception) {
exitFlag = true;
}
}
}
}

Accessing Commands

2007-07-18T18:26:00.001-07:00

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

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

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

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

fmMain = new Form("Core J2ME");
fmMain.addCommand(cmExit);
fmMain.setCommandListener(this);
}

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

// 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();
}
}
}

Sample of graphics, commands, and event handling.

2007-07-18T18:23:00.000-07:00

/*
* @(#)Sample.java 1.9 01/06/08
* Copyright (c) 1999-2001 Sun Microsystems, Inc. All Rights Reserved.
*/

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

/*
* A quick sample of graphics, commands, and event handling.
*/
public class SampleCanvasMIDlet extends MIDlet implements CommandListener {
Display display;
Command exitCommand;
Command backCommand;
Command okCommand;
SampleCanvas sample; // Instance of sample canvas

List itemMenu;
List exclusiveList;
List multipleList;
TextBox textbox;
Ticker ticker;
Alert alert;
Form form;
StringItem stringItem;
ImageItem imageItem;
Image image;
TextField textItem;
ChoiceGroup choiceItem;
DateField dateItem;
Gauge gaugeItem;

public SampleCanvasMIDlet() {
display = Display.getDisplay(this);
exitCommand = new Command("Exit", Command.EXIT, 1);
backCommand = new Command("Back", Command.BACK, 2);
okCommand = new Command("OK", Command.OK, 3);

ticker = new Ticker("Select an item to display");
itemMenu = new List(null, Choice.IMPLICIT);
itemMenu.append("Canvas", null);
itemMenu.append("Form", null);
itemMenu.append("Alert", null);
itemMenu.append("TextBox", null);
itemMenu.append("Exclusive List", null);
itemMenu.append("Multiple Choice", null);

itemMenu.setCommandListener(this);
itemMenu.addCommand(exitCommand);
itemMenu.setTicker(ticker);
display.setCurrent(itemMenu);
}

public void startApp () {
}

public void destroyApp (boolean unconditional) {
}

public void pauseApp () {
}

public void commandAction(Command c, Displayable s) {
if (c == backCommand) {
display.setCurrent(itemMenu);
} else if (s == itemMenu) {
if (c == List.SELECT_COMMAND) {
// Handle the item sected to be displayed
int i = itemMenu.getSelectedIndex();
switch (i) {
case 0: // Show Sample canvas
display.setCurrent(getCanvas());
break;
case 1: // Show the form
display.setCurrent(getForm());
break;
case 2: // Show an alert
display.setCurrent(getAlert("Warning",
"This window will dismiss in two seconds."));
break;
case 3: // Show TextBox
display.setCurrent(getTextBox());
break;
case 4: // Show Exclusive list
display.setCurrent(getExclusiveList());
break;
case 5: // Show Multiple List
display.setCurrent(getMultipleList());
break;
}
} else if (c == exitCommand) {
notifyDestroyed();
}
} else if (s == exclusiveList) {
int i = exclusiveList.getSelectedIndex();
String value = exclusiveList.getString(i);
alert = getAlert("Border selected:", value);
display.setCurrent(alert, itemMenu);
} else if (s == multipleList) {
StringBuffer b = new StringBuffer();
for (int i = 0; i <= 2; i++) {
if (multipleList.isSelected(i)) {
b.append(multipleList.getString(i));
b.append("\n");
}
}
alert = getAlert("Colors selected:", b.toString());
display.setCurrent(alert, itemMenu);
} else if (s == textbox) {
String value = textbox.getString();
alert = getAlert("Text Entered:", value);
display.setCurrent(alert, itemMenu);
} else if (s == form) {
alert = getAlert("Image options saved", "");
display.setCurrent(alert, itemMenu);
}
}

SampleCanvas getCanvas() {
if (sample == null) {
sample = new SampleCanvas();
sample.addCommand(backCommand);
sample.setCommandListener(this);
}
return sample;
}

List getExclusiveList() {
if (exclusiveList == null) {
exclusiveList = new List("Border Style", Choice.EXCLUSIVE);
exclusiveList.append("None", null);
exclusiveList.append("Plain", null);
exclusiveList.append("Fancy", null);
exclusiveList.addCommand(backCommand);
exclusiveList.addCommand(okCommand);
exclusiveList.setCommandListener(this);
}
return exclusiveList;
}

List getMultipleList() {
if (multipleList == null) {
multipleList = new List("Colors to mix", Choice.MULTIPLE);
multipleList.append("Red", null);
multipleList.append("Green", null);
multipleList.append("Blue", null);
multipleList.addCommand(backCommand);
multipleList.addCommand(okCommand);
multipleList.setCommandListener(this);
}
return multipleList;
}

TextBox getTextBox() {
if (textbox == null) {
textbox = new TextBox("Enter a phone number","", 40,
TextField.PHONENUMBER);
textbox.addCommand(backCommand);
textbox.addCommand(okCommand);
textbox.setCommandListener(this);
}
return textbox;
}

Alert getAlert(String title, String contents) {
if (alert == null) {
alert = new Alert(title);
alert.setType(AlertType.WARNING);
alert.setTimeout(2000);
alert.setString(contents);
} else {
alert.setTitle(title);
alert.setString(contents);
}
return alert;
}

Form getForm() {
if (form == null) {
form = new Form("Options");

try {
image = Image.createImage("/images/PhotoAlbum.png");
imageItem = new ImageItem("Preview:", image,
ImageItem.LAYOUT_NEWLINE_BEFORE, "Mountain");
form.append(imageItem);
} catch (java.io.IOException ex) {
}

textItem = new TextField("Title:", "Mountain", 32,
TextField.ANY);
form.append(textItem);

dateItem = new DateField("Date:", DateField.DATE);
dateItem.setDate(new java.util.Date());
form.append(dateItem);

choiceItem = new ChoiceGroup("Size:", Choice.EXCLUSIVE);
choiceItem.append("Small", null);
choiceItem.append("Large", null);
form.append(choiceItem);

gaugeItem = new Gauge("Speed:", true, 10, 5);
form.append(gaugeItem);

form.addCommand(backCommand);
form.addCommand(okCommand);
form.setCommandListener(this);
}
return form;
}
}

class SampleCanvas extends Canvas {
int x, y; // Location of cross hairs
String event = ""; // Last key event type
int keyCode; // Last keyCode pressed
Font font; // Font used for drawing text
int fh; // height of the font
int w, h; // width and height of the canvas
int titleHeight; // Height of the title
int pieSize; // Size of the Pie chart used for width and height
int barSize; // Size of the Bar chart used for width and height
int eventHeight; // Size of the event region
int pad; // Padding used between items

SampleCanvas() {
w = getWidth();
h = getHeight();
font = Font.getFont(Font.FACE_SYSTEM,
Font.STYLE_PLAIN, Font.SIZE_SMALL);
fh = font.getHeight();

/* Compute the sizes of the bar and pie charts
* It should use all the space except for the title
* and event regions.
* Don't let the charts get too small
*/
pad = 2;
titleHeight = fh + pad * 2;
eventHeight = fh * 3;
barSize = h - (titleHeight + pad) - (eventHeight + pad);
if (barSize < 20) // Don't let them get too small
barSize = 20;
if (barSize > (w - pad) / 2) // Shrink to 1/2 width
barSize = (w - pad) / 2;
pieSize = barSize;
}

protected void keyPressed(int key) {
keyCode = key;
event = "Pressed";
handleActions(key);
repaint();
}

protected void keyRepeated(int key) {
keyCode = key;
event = "Repeated";
handleActions(key);
repaint();
}

protected void keyReleased(int key) {
keyCode = key;
event = "Released";
repaint();
}

protected void pointerPressed(int x, int y) {
this.x = x;
this.y = y;
keyCode = 0;
event = "Pressed";
repaint();
}
protected void pointerReleased(int x, int y) {
this.x = x;
this.y = y;
keyCode = 0;
event = "Released";
repaint();
}

protected void pointerDragged(int x, int y) {
this.x = x;
this.y = y;
keyCode = 0;
event = "Dragged";
}

void handleActions(int keyCode) {
int action = getGameAction(keyCode);
switch (action) {
case LEFT:
x -= 1;
break;
case RIGHT:
x += 1;
break;
case UP:
y -= 1;
break;
case DOWN:
y += 1;
break;
}
}

protected void paint(Graphics g) {

g.setFont(font);
g.setGrayScale(255);
g.fillRect(0, 0, w, h);

x = (x < 0) ? w - 1 : x;
y = (y < 0) ? h - 1 : y;
x = x % w;
y = y % h;

// Draw Fill and outline for background of title Text
int swidth = pad * 2 + font.stringWidth("Pie and Bar Samples");
int title_x = (w - swidth)/2;

g.setGrayScale(128);
g.fillRoundRect(title_x, 0, swidth, fh, 5, 5);
g.setGrayScale(0);
g.drawRoundRect(title_x, 0, swidth, fh, 5, 5);

// Sample Text
g.setColor(0, 0, 0);
g.drawString("Pie and Bar Samples",
title_x + pad, pad, Graphics.TOP|Graphics.LEFT);

// Translate to below title text
g.translate(0, titleHeight + pad);

/*
* Draw pie chart on the left side
* using the barSize for width and height
*/
g.setColor(255, 0, 0);
g.fillArc(0, 0, pieSize, pieSize, 45, 270);
g.setColor(0, 255, 0);
g.fillArc(0, 0, pieSize, pieSize, 0, 45);
g.setColor(0, 0, 255);
g.fillArc(0, 0, pieSize, pieSize, 0, -45);
g.setColor(0);
g.drawArc(0, 0, pieSize, pieSize, 0, 360);

// Draw Bar chart on right side of the display
// scale the values to the pieSize maximum value
int yorig = barSize;
int h1 = barSize / 3, h2 = barSize / 2, h3 = barSize;
int avg = (h1 + h2 + h3) / 3;

// Move over to draw Bar chart
g.translate((w + pad) / 2, 0);

int bw = pieSize / 7;
if (bw < 2)
bw = 2;
g.setColor(255, 0, 0);
g.fillRect(bw*1, yorig-h1, bw+1, h1);
g.setColor(0, 255, 0);
g.fillRect(bw*3, yorig-h2, bw+1, h2);
g.setColor(0, 0, 255);
g.fillRect(bw*5, yorig-h3, bw+1, h3);
g.setColor(0);
g.drawRect(bw*1, yorig-h1, bw, h1);
g.drawRect(bw*3, yorig-h2, bw, h2);
g.drawRect(bw*5, yorig-h3, bw, h3);

// Draw axis for bar chart.
g.setGrayScale(0);
g.drawLine(0, 0, 0, yorig);
g.drawLine(0, yorig, barSize, yorig);
g.setStrokeStyle(Graphics.DOTTED);
g.drawLine(0, yorig - avg, barSize, yorig-avg);
g.setStrokeStyle(Graphics.SOLID);

// Restore to left and move down
g.translate(-(w + pad) / 2, pieSize + pad);

// Draw the key and pointer status
g.setColor(128, 128, 128);
int col1 = font.stringWidth("Action:");
g.drawString("Key: ", col1, 0,
Graphics.TOP|Graphics.RIGHT);
g.drawString(keyString(keyCode), col1, 0,
Graphics.TOP|Graphics.LEFT);
g.drawString("Action:", col1, fh,
Graphics.TOP|Graphics.RIGHT);
g.drawString(actionString(keyCode), col1, fh,
Graphics.TOP|Graphics.LEFT);
g.drawString("Event:", col1, fh*2,
Graphics.TOP|Graphics.RIGHT);
g.drawString(event, col1, fh*2,
Graphics.TOP|Graphics.LEFT);
int col2 = 80;
g.drawString("x:", col2, 0,
Graphics.TOP|Graphics.RIGHT);
g.drawString(Integer.toString(x), col2, 0,
Graphics.TOP|Graphics.LEFT);
g.drawString("y:", col2, fh,
Graphics.TOP|Graphics.RIGHT);
g.drawString(Integer.toString(y), col2, fh,
Graphics.TOP|Graphics.LEFT);

// Restore the origin and draw the crosshairs on top
g.translate(-g.getTranslateX(), -g.getTranslateY());

g.setColor(0, 0, 0);
g.drawLine(x, y - 5, x, y + 5);
g.drawLine(x - 5, y, x + 5, y);
}

String keyString(int keyCode) {
if (keyCode == 0) {
return "";
}
return Integer.toString(keyCode);
}

String actionString(int keyCode) {
if (keyCode == 0) {
return "";
}

int action = getGameAction(keyCode);
switch (action) {
case FIRE:
return "Fire";
case LEFT:
return "Left";
case RIGHT:
return "Right";
case DOWN:
return "Down";
case UP:
return "Up";
case GAME_A:
return "Game A";
case GAME_B:
return "Game B";
case GAME_C:
return "Game C";
case GAME_D:
return "Game D";
case 0:
return "";
default:
return Integer.toString(action);
}
}
}

Thread Example in J2ME

2007-07-17T04:57:00.000-07:00

/*
J2ME: The Complete Reference

James Keogh

Publisher: McGraw-Hill

ISBN 0072227109

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

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

public class BackgroundProcessing extends MIDlet
implements CommandListener
{
private Display display;
private Form form;
private Command exit;
private Command start;
public BackgroundProcessing()
{
display = Display.getDisplay(this);
form = new Form("Background Processing");
exit = new Command("Exit", Command.EXIT, 1);
start = new Command("Start", Command.SCREEN, 2);
form.addCommand(exit);
form.addCommand(start );
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();
}
else if (command == start)
{
Process process = new Process(this);
process.start();
//Do foreground processing here
}
}
}
class Process implements Runnable
{
private BackgroundProcessing MIDlet;
public Process(BackgroundProcessing MIDlet)
{
this.MIDlet = MIDlet;
}
public void run()
{
try
{
transmit ();
}
catch (Exception error)
{
System.err.println(error.toString());
}
}
public void start()
{
Thread thread = new Thread(this);
try
{
thread.start();
}
catch (Exception error)
{
}
}
private void transmit() throws IOException
{
//Place code here to receive or send transmission.
}
}

Storing Image into RMS

2007-07-16T04:33:00.000-07:00

import javax.microedition.lcdui.*;
import javax.microedition.midlet.MIDlet;
import javax.microedition.rms.*;
import java.io.*;

public class ImageStore extends MIDlet implements CommandListener {

private Command CmdExit;
private Command CmdOpen;
private Command CmdBack;
private Command CmdSave;
private Display display;
RecordStore rStore;
Form form = null;
Image image = null;
InputStream is =null;

public ImageStore() {

rStore = null;

display = Display.getDisplay(this);

CmdExit = new Command("Exit", 1, 2);
CmdOpen = new Command("Show", 1, 3);
CmdBack = new Command("Back", 1, 3);
CmdSave = new Command("Save", 1, 3);

form = new Form("Image Show");

}

public void startApp() {
try {
rStore = RecordStore.openRecordStore("imagefile", true);
} catch(RecordStoreException recordstoreexception) {
recordstoreexception.printStackTrace();
}
try {

is = getClass().getResourceAsStream("/leaf.jpg");
image = Image.createImage(is);
form.append(image);

} catch(IOException ioexception) { }
form.addCommand(CmdExit);
form.addCommand(CmdSave);
form.addCommand(CmdOpen);
form.setCommandListener(this);
display.setCurrent(form);
}

public void pauseApp() {
}

public void Close() {
try {
rStore.closeRecordStore();
} catch(RecordStoreNotOpenException recordstorenotopenexception) {
recordstorenotopenexception.printStackTrace();
} catch(RecordStoreException recordstoreexception) {
recordstoreexception.printStackTrace();
}
}

public void destroyApp(boolean flag) {
Close();
}

public Image load(int width,int height) {

byte[] b = null;
String imagename = null;
Image image = null;

try {

int i = rStore.getNumRecords();

for(int j = 1; j < i + 1; j++) {

if(rStore.getRecord(j) != null) {

b = rStore.getRecord(j);
ByteArrayInputStream bin =
new ByteArrayInputStream( b );

DataInputStream din = new DataInputStream( bin );

imagename = din.readUTF();
int remaining =
(b.length-imagename.getBytes().length-2)/4;

int[] rawdata = new int[remaining];

for(int k =0 ;k < rawdata.length ;k++) {
rawdata[k] = din.readInt();
}

image = Image.createRGBImage(rawdata,
width, height, false);

bin.reset();
din.close();
din =null;
}
}
} catch (IOException e) {

e.printStackTrace();

} catch(RecordStoreException recordstoreexception) {

recordstoreexception.printStackTrace();

}

return image;
}

public boolean save(Image img, int width,
int height, String imgName) {

if (img == null || width < 0 || height < 0 || imgName == null) {

throw new IllegalArgumentException("Check arguments");

}

int[] imgRgbData = new int[width * height];

try {

img.getRGB(imgRgbData, 0, width, 0, 0, width, height);

} catch (Exception e) {
// Problem getting image RGB data
return false;
}
try {
// Write image data to output stream (in order to get
// the record bytes in needed form)
ByteArrayOutputStream baos = new ByteArrayOutputStream();
DataOutputStream dos = new DataOutputStream(baos);
dos.writeUTF(imgName);

for (int i = 0; i < imgRgbData.length; i++) {
dos.writeInt(imgRgbData[i]);
}

// Open record store, create if it doesn't exist
rStore.addRecord(baos.toByteArray(), 0,
baos.toByteArray().length); // Add record

} catch (RecordStoreNotFoundException rsnfe) {
// Record storage not found
return false;
} catch (RecordStoreException rse) {
// Other record storage problem
return false;
} catch (IOException ioe) {
// Problem writing data
return false;
}

return true; // We've successfuly done
}

public void commandAction(Command command, Displayable displayable) {

if(command == CmdExit) {

destroyApp(true);
notifyDestroyed();

}
else if(command == CmdOpen) {

Form showform = new Form("Image from DB");
Image i = load(image.getWidth(),image.getHeight());

if(i !=null ) {

Image img = Image.createImage(i);
showform.append(img);

}

showform.addCommand(CmdBack);
showform.setCommandListener(this);
display.setCurrent(showform);

} else if(command == CmdBack) {

display.setCurrent(form);

} else if(command == CmdSave) {

byte[] b = null;
Alert a =new Alert("Image saved");

try {
if(save(image,image.getWidth(),image.getHeight(),"leaf"))
a.setString("Success");
else
a.setString("Failed");
a.setTimeout(1000);
} catch (Exception e) {
e.printStackTrace();
}
display.setCurrent(a);
}
}
}

Animation Midlet

2007-07-16T04:26:00.000-07:00

/*
J2ME in a Nutshell
By Kim Topley
ISBN: 0-596-00253-X

*/

import java.util.Timer;
import java.util.TimerTask;
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.Form;
import javax.microedition.lcdui.Gauge;
import javax.microedition.lcdui.Graphics;
import javax.microedition.lcdui.Item;
import javax.microedition.lcdui.ItemStateListener;
import javax.microedition.midlet.MIDlet;

public class AnimationMIDlet extends MIDlet
implements CommandListener, ItemStateListener {

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

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

// Exit command
private Command exitCommand;

// Setup command
private Command setupCommand;

// Run command
private Command runCommand;

// Configuration form
private Form form;

// Animation canvas
private AnimationCanvas canvas;

// Gauge for block count
private Gauge blockGauge;

// Gauge for frame rate
private Gauge rateGauge;

// Initial frame rate
private static final int FRAME_RATE = 1;

// Initial number of blocks
private static final int BLOCK_COUNT = 1;

protected void startApp() {
if (!started) {
display = Display.getDisplay(this);
form = new Form("Animation");
rateGauge = new Gauge("Frame rate", true, 10, FRAME_RATE);
blockGauge = new Gauge("Blocks", true, 4, BLOCK_COUNT);
form.append(rateGauge);
form.append(blockGauge);
form.setItemStateListener(this);

canvas = createAnimationCanvas();

exitCommand = new Command("Exit", Command.EXIT, 0);
setupCommand = new Command("Setup", Command.SCREEN, 0);
runCommand = new Command("Run", Command.SCREEN, 0);

canvas.addCommand(exitCommand);
canvas.addCommand(setupCommand);
form.addCommand(exitCommand);
form.addCommand(runCommand);

form.setCommandListener(this);
canvas.setCommandListener(this);

display.setCurrent(form);
started = true;
}
}

protected void pauseApp() {
}

protected void destroyApp(boolean unconditional) {
}

public void commandAction(Command c, Displayable d) {
if (c == exitCommand) {
// Exit. No need to call destroyApp
// because it is empty.
notifyDestroyed();
} else if (c == runCommand) {
display.setCurrent(canvas);
} else if (c == setupCommand) {
display.setCurrent(form);
}
}

public void itemStateChanged(Item item) {
if (item == blockGauge) {
int count = blockGauge.getValue();
if (count < 1) {
count = 1;
}
canvas.setBlockCount(count);
} else if (item == rateGauge) {
int count = rateGauge.getValue();
if (count < 1) {
count = 1;
}
canvas.setFrameRate(count);
}
}

// Creates the canvas that will draw the block
protected AnimationCanvas createAnimationCanvas() {
return new AnimationCanvas();
}

class AnimationCanvas extends Canvas {

// Size of each block
protected static final int SIZE = 4;

// Initial speeds in the X direction
protected final int[] xSpeeds = { 2, -2, 0, -2 };

// Initial speeds in the Y direction
protected final int[] ySpeeds = { 2, -2, 2, -0 };

// Background color
protected int background = display.isColor() ? 0 : 0xc0c0c0;

// Foreground color
protected int foreground = display.isColor() ? 0xffff00 : 0;

// Width of screen
protected int width = getWidth();

// Height of screen
protected int height = getHeight();

// The screen update rate
protected int frameRate;

// The blocks to draw on the screen
protected Block[] blocks;

// The update timer
protected Timer timer;

// The update timer task
protected TimerTask updateTask;

// Gets the maximum number of blocks
public int getMaxBlocks() {
return blocks.length;
}

// Constructs a canvas with default settings
AnimationCanvas() {
setBlockCount(BLOCK_COUNT);
setFrameRate(FRAME_RATE);
}

// Sets the number of blocks to draw
public void setBlockCount(int count) {
if (count > xSpeeds.length) {
throw new IllegalArgumentException("Cannot have more than "
+ xSpeeds.length + " blocks");
}

blocks = new Block[count];
createBlocks();
}

// Gets the number of blocks to draw
public int getBlockCount() {
return blocks.length;
}

// Sets the number of updates per second
public void setFrameRate(int frameRate) {
if (frameRate < 1 || frameRate > 10) {
throw new IllegalArgumentException("Frame rate must be > 0 and <= 10");
}
this.frameRate = frameRate;
if (isShown()) {
startFrameTimer();
}
}

// Gets the number of updates per second
public int getFrameRate() {
return frameRate;
}

// Paint canvas background and all
// of the blocks in their correct locations.
protected void paint(Graphics g) {
// Paint with the background color
g.setColor(background);
g.fillRect(0, 0, width, height);

// Draw all of the blocks
g.setColor(foreground);
synchronized (this) {
for (int i = 0, count = blocks.length; i < count; i++) {
g.fillRect(blocks[i].x, blocks[i].y, SIZE, SIZE);
}
}
}

// Notification that the canvas has been made visible
protected void showNotify() {
// Start the frame timer running
startFrameTimer();
}

// Notification that the canvas is no longer visible
protected void hideNotify() {
// Stop the frame timer
stopFrameTimer();
}

// Creates the blocks to be displayed
private void createBlocks() {
int startX = (width - SIZE)/2;
int startY = (height - SIZE)/2;
for (int i = 0, count = blocks.length; i < count; i++) {
blocks[i] = new Block(startX, startY, xSpeeds[i], ySpeeds[i]);
}
}

// Starts the frame redraw timer
protected void startFrameTimer() {
timer = new Timer();

updateTask = new TimerTask() {
public void run() {
moveAllBlocks();
}
};
long interval = 1000/frameRate;
timer.schedule(updateTask, interval, interval);
}

// Stops the frame redraw timer
protected void stopFrameTimer() {
timer.cancel();
}

// Called on expiry of timer.
public synchronized void moveAllBlocks() {
// Update the positions and speeds
// of all of the blocks
for (int i = 0, count = blocks.length; i < count; i++) {
blocks[i].move();

// Request a repaint of the screen
repaint();
}
}

// Inner class used to represent a block on the screen
class Block {
int x; // X position
int y; // Y position
int xSpeed; // Speed in the X direction
int ySpeed; // Speed in the Y direction

Block(int x, int y, int xSpeed, int ySpeed) {
this.x = x;
this.y = y;
this.xSpeed = xSpeed;
this.ySpeed = ySpeed;
}

void move() {
x += xSpeed;
if (x <= 0 || x + SIZE >= width) {
xSpeed = -xSpeed;
}

y += ySpeed;
if (y <= 0 || y + SIZE >= height) {
ySpeed = -ySpeed;
}
}
}
}
}

Multiple ChoiceGroup

2007-07-16T04:25:00.002-07:00

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

public class MultipleChoiceGroup extends MIDlet implements ItemStateListener, CommandListener
{
private Display display; // Reference to display object
private Form fmMain; // The main form
private Command cmExit; // A Command to exit the MIDlet
private Command cmView; // View the choice selected
private int selectAllIndex; // Index of the "Select All" option
private ChoiceGroup cgPrefs; // Choice Group of preferences

private int choiceGroupIndex; // Index of choice group on form

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

// Create a multiple choice group
cgPrefs = new ChoiceGroup("Preferences", Choice.MULTIPLE);

// Append options, with no associated images
cgPrefs.append("Auto Indent", null);
cgPrefs.append("Replace Tabs", null);
cgPrefs.append("Wrap Text", null);
selectAllIndex = cgPrefs.append("Select All", null);

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

// Create Form, add components, listen for events
fmMain = new Form("");
choiceGroupIndex = fmMain.append(cgPrefs);
fmMain.addCommand(cmExit);
fmMain.addCommand(cmView);
fmMain.setCommandListener(this);
fmMain.setItemStateListener(this);
}

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

public void pauseApp()
{ }

public void destroyApp(boolean unconditional)
{ }

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

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

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

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

public void itemStateChanged(Item item)
{
if (item == cgPrefs)
{
// Is "Select all" option checked ?
if (cgPrefs.isSelected(selectAllIndex))
{
// Set all checkboxes to true
for (int i = 0; i < cgPrefs.size() - 1; i++)
cgPrefs.setSelectedIndex(i, true);

// Remove the check by "Select All"
cgPrefs.setSelectedIndex(selectAllIndex, false);
}
}
}
}

ChoiceGroup With Image

2007-07-16T04:25:00.001-07:00

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

public class ChoiceGroupWithImages extends MIDlet implements CommandListener
{
private Display display; // Reference to display object
private Form fmMain; // Main form
private Command cmExit; // Command to exit the MIDlet
private Command cmView; // View the choice selected
private ChoiceGroup cgPrefs; // Choice Group of preferences

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

try
{
// Create array of image objects
Image images[] = {Image.createImage("/up.png"), Image.createImage("/down.png"),
Image.createImage("/help.png") };

// Create array of corresponding string objects
String options[] = {"Upload", "Download", "Help"};

// Create a choice group using arrays
cgPrefs = new ChoiceGroup("Select Option:", Choice.EXCLUSIVE, options, images);

}
catch (java.io.IOException e)
{
System.err.println("Unable to locate or read .png file");
}

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

// Create Form, add components, listen for events
fmMain = new Form("");
fmMain.append(cgPrefs);
fmMain.addCommand(cmExit);
fmMain.addCommand(cmView);
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 == cmView)
{
boolean selected[] = new boolean[cgPrefs.size()];

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

// Print to console the status of each element
for (int i = 0; i < cgPrefs.size(); i++)
System.out.println(cgPrefs.getString(i) + (selected[i] ? ": selected" : ": not selected"));
}
else if (c == cmExit)
{
destroyApp(false);
notifyDestroyed();
}
}
}

GUI Test in Midlet

2007-07-16T04:20:00.001-07:00

/*
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 Capture

2007-07-16T04:18:00.002-07:00

/*
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: MyCompany
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();
}
}
}

TextField Capture

2007-07-16T04:18:00.001-07:00

//jad file (please verify the jar size)
/*
MIDlet-Name: TextFieldCapture
MIDlet-Version: 1.0
MIDlet-Vendor: MyCompany
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();
}
}
}

Basic RMS Example

2007-07-12T05:39:00.000-07:00

import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
import javax.microedition.rms.*;
import java.io.*;

public class RMSDemo extends MIDlet implements CommandListener {

private Display display;
private RecordStore rs=null;
private Command exit;
private RecordEnumeration re;
private int recordNO;
Form frm;
int index=0;
public RMSDemo() {
display = Display.getDisplay(this);

//Create a RMS
try {
rs= RecordStore.openRecordStore("myRecord",false);
rs.closeRecordStore();
} catch(Exception e) {
System.out.println(e);
}

}

public void startApp() {

frm=new Form("RMSDemo");

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

add= new Command("Add",Command.SCREN,1);
frm.addCommand(add);

delete= new Command("Delete",Command.SCREEN,2);
frm.addCommand(delete);

show= new Command("SHOW",Command.SCREEN ,3);
frm.addCommand(show);

frm.setCommandListener(this);
frm.append("#####");
display.setCurrent(frm);
}

public void pauseApp() {

}

public void destroyApp(boolean un) {
}

// Handling commands
public void commandAction(Command cmd,Displayable d) {
if(cmd==add) {
addRecord();
} else
if(cmd==delete) {
removeRecord();
} else
if(cmd==show) {
try {
byte b[]= rs.getRecord(recordNO);
String s= new String(b);
frm.append(s);
} catch(Exception e) {}
}
}

void addRecord() {
try {
rs= RecordStore.openRecordStore("myRecord",false);
index++;
byte b[]=("Record NO "+index).getBytes();
//Adding record to record store
rs.addRecord(b,0,b.length);
rs.closeRecordStore() ;
} catch(Exception e) {
System.out.println(e);
}

}

// Deleting a record
void removeRecord(int recordID) {
try {
rs= RecordStore.openRecordStore("myRecord",false);
rs.deleteRecord(recordID);
index--;
rs.closeRecordStore();
} catch(Exception e) {
System.out.println(e);
}
}

}

Font Demo J2ME

2007-07-12T05:36:00.002-07:00

The Font class represents fonts and font metrics. Fonts cannot be created by applications. The setFont(Font font) method of graphic class sets the font for all subsequent text rendering operations. And there is no call to showNotify and hideNotify method on some the device. This application will help game developer to find out the exact behaviour of mobile device.

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

public class FontDemo extends MIDlet {

private boolean boolMotion=false;
private int iX=10, iY=60;

Display mDisplay;
Thread th;
public void destroyApp(boolean unconditional){}

public void pauseApp() {}

public void startApp() {

mDisplay = Display.getDisplay(this);
final MyCanvas can = new MyCanvas();
mDisplay.setCurrent(can);

}
}

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

public class MyCanvas extends Canvas {

Font font;
String msg;
public MyCanvas() {

font=Font.getFont(Font.FACE_MONOSPACE,
Font.STYLE_ITALIC, Font.SIZE_LARGE);
msg = "Font:FACE_MONOSPACE Font.STYLE_ITALIC Font.SIZE_LARGE";
}

public void paint(Graphics g) {
g.setFont(font);
g.drawString(msg,0,10,g.TOP|g.LEFT);
g.drawString("press NUM KEY: 1 2 or 3",0,80,g.TOP|g.LEFT);
}

void changeValue(int change) {
switch(change) {
case '1':
font=Font.getFont(Font.FACE_MONOSPACE,
Font.STYLE_ITALIC, Font.SIZE_LARGE) ;
msg="Font:FACE_MONOSPACE Font.STYLE_ITALIC "+
"Font.SIZE_LARGE";
break;
case '2':
font=Font.getFont(Font.FACE_PROPORTIONAL,
Font.STYLE_ITALIC, Font.SMALL) ;
msg = "Font:FACE_PROPORTIONAL Font.STYLE_ITALIC "+
"Font.SIZE_SMALL";
break;
case '3':
font=Font.getFont(Font.FACE_SYSTEM ,
Font.STYLE_BOLD, Font.SIZE_LARGE) ;
msg="Font:FACE_SYSTEM Font.STYLE_BOLD "+
"Font.SIZE_LARGE";
break;
}
}

//Handling keyEvents
protected void keyPressed(int keyCode) {
changeValue(keyCode);
repaint();
}

}

Capturing Video with J2ME

2007-07-12T05:36:00.001-07:00

Illustration below takes pictures on a J2ME device.

import java.io.IOException;
import javax.microedition.lcdui.*;
import javax.microedition.media.*;
import javax.microedition.media.control.*;
import javax.microedition.midlet.MIDlet;
import javax.microedition.media.control.VideoControl;

public class VideoMIDlet extends MIDlet implements CommandListener {

private Display display;
private Form form;
private Command exit,back,capture,camera;
private Player player;
private VideoControl videoControl;
private Video video;

public VideoMIDlet() {

exit = new Command("Exit", Command.EXIT, 0);
camera = new Command("Camera", Command.SCREEN, 0);
back = new Command("Back", Command.BACK, 0);
capture = new Command("Capture", Command.SCREEN, 0);

form = new Form("Capture Video");
form.addCommand(camera);
form.setCommandListener(this);
}

public void startApp() {
display = Display.getDisplay(this);
display.setCurrent(form);
}

public void pauseApp() {}

public void destroyApp(boolean unconditional) {}

public void commandAction(Command c, Displayable s) {
if (c == exit) {
destroyApp(true);
notifyDestroyed();
} else if (c == camera) {
showCamera();
} else if (c == back)
display.setCurrent(form);
else if (c == capture) {
video = new Video(this);
video.start();
}
}

public void showCamera() {
try {
player = Manager.createPlayer("capture://video");
player.realize();

videoControl = (VideoControl)player.getControl("VideoControl");
Canvas canvas = new VideoCanvas(this, videoControl);
canvas.addCommand(back);
canvas.addCommand(capture);
canvas.setCommandListener(this);
display.setCurrent(canvas);
player.start();
} catch (IOException ioe) {} catch (MediaException me) {}
}

class Video extends Thread {
videoMIDlet midlet;
public Video(VideoMIDlet midlet) {
this.midlet = midlet;
}

public void run() {
captureVideo();

}

public void captureVideo() {
try {
byte[] raw = videoControl.getSnapshot(null);
Image image = Image.createImage(raw, 0, raw.length);
form.append(image);
display.setCurrent(form);

player.close();
player = null;
videoControl = null;
} catch (MediaException me) { }
}
};
}

import javax.microedition.lcdui.*;
import javax.microedition.media.MediaException;
import javax.microedition.media.control.VideoControl;

public class VideoCanvas extends Canvas {
private VideoMIDlet midlet;

public VideoCanvas(VideoMIDlet midlet, VideoControl videoControl) {
int width = getWidth();
int height = getHeight();
this.midlet = midlet;

videoControl.initDisplayMode(VideoControl.USE_DIRECT_VIDEO, this);
try {
videoControl.setDisplayLocation(2, 2);
videoControl.setDisplaySize(width - 4, height - 4);
} catch (MediaException me) {}
videoControl.setVisible(true);
}

public void paint(Graphics g) {
int width = getWidth();
int height = getHeight();

g.setColor(0x00ff00);
g.drawRect(0, 0, width - 1, height - 1);
g.drawRect(1, 1, width - 3, height - 3);
}

Vibrate Phone

2007-07-12T05:34:00.000-07:00

You can make your phone migrate in J2ME by calling vibrate(int duration) method of javax.microedition.lcdui.Display class. The duration parameter is the number of milliseconds the vibrator should be run.

Display.getDisplay(this).vibrate(800);