Jimmy's Blog » Java

Java ME (J2ME) JSON Implementation For Array Object

jimmy — Tue, 13 Sep 2011 16:47:04 +0000

One of the comment in JSON ME tutorial (http://jimmod.com/blog/2010/03/java-me-j2me-json-implementation-tutorialsample/) asking about how to parse this kind of JSON :

{\”api_status\”: \”OK\”,\”threads\”: [{\"tid\": \"2\",\"title\": \"First Title\" }, { \"tid\": \"4\", \"title\": \"this is 2nd Title\"}]}
-246">

Latest JSON ME library : https://github.com/upictec/org.json.me/

From the JSON format we can easily see that the object have 2 property:

api_status : String
threads : Array of object

The Threads Object:

tid : Integer
title : String

My solution is not exactly the same because I have different approach on handling the arrays.

First I will make the threads class, I name it ThreadData. It should also implement the JSONable interface (see the 1st tutorial for the code).

class ThreadData implements JSONAble {
	private int tid;
	private String title;
	public int getTid() {
		return tid;
	}
	public void setTid(int tid) {
		this.tid = tid;
	}
	public String getTitle() {
		return title;
	}
	public void setTitle(String title) {
		this.title = title;
	}
	public void fromJSON(String jsonString) {
		try {
			JSONObject json = new JSONObject(jsonString);
			setTid(json.getInt("tid"));
			setTitle(json.getString("title"));
		} catch (JSONException ex) {
			ex.printStackTrace();
		}
	}
	public String toJSON() {
		JSONObject inner = new JSONObject();
		try {
			inner.put("tid", getTid());
			inner.put("title", getTitle());
		} catch (JSONException ex) {
			ex.printStackTrace();
		}
		return inner.toString();
	}
 
	public String toString() {
		return getTid() + "-" + getTitle(); 
	}
}

Above implementation is just like the 1st tutorial, the main class JSONable implementation is different. Please focus on the JSONArray usage.

class Response implements JSONAble {
 
	private String api_status;
	private ThreadData[] threads;
 
	public String getApi_status() {
		return api_status;
	}
	public void setApi_status(String apiStatus) {
		api_status = apiStatus;
	}
	public ThreadData[] getThreads() {
		return threads;
	}
	public void setThreads(ThreadData[] threads) {
		this.threads = threads;
	} 
 
	public void fromJSON(String jsonString) {
		try {
			JSONObject json = new JSONObject(jsonString);
			setApi_status(json.getString("api_status"));
			JSONArray jsonArray = json.getJSONArray("threads");
			int total = jsonArray.length();
			ThreadData[] threads = new ThreadData[total];
			for (int i=0;i<total;i++) {
				String threadsJSON = jsonArray.getString(i);
				threads[i] = new ThreadData();
				threads[i].fromJSON(threadsJSON);
			}
			setThreads(threads);
		} catch (JSONException ex) {
			ex.printStackTrace();
		}
	}
	public String toJSON() {
		JSONObject inner = new JSONObject();
		try {
			inner.put("api_status", getApi_status());
			JSONArray jsonArray = new JSONArray();
			ThreadData[] threads = getThreads();
			for (int i=0;i<threads.length;i++) {
				jsonArray.put(threads[i].toJSON());
			}
			inner.put("threads", jsonArray);
		} catch (JSONException ex) {
			ex.printStackTrace();
		}
		return inner.toString();
	}
 
	public String toString() {
		String response = getApi_status() + "-";
		ThreadData[] threads = getThreads();
		for (int i=0;i<threads.length;i++) {
			response += "[" + threads[i].toString() + "]";
		}
		return response; 
	}
}

So when you setup the startapp function:

	protected void startApp() throws MIDletStateChangeException {
		//Converting Object to JSON
		Response response = new Response();
		ThreadData[] threads = new ThreadData[2];
		threads[0] = new ThreadData();
		threads[0].setTid(2);
		threads[0].setTitle("First Title");
		threads[1] = new ThreadData();
		threads[1].setTid(4);
		threads[1].setTitle("this is 2nd Title");
		response.setApi_status("OK");
		response.setThreads(threads);
		System.out.println("Convert to JSON : "+response.toJSON());
 
 
		//Converting JSON to Object
		String sample = "{\"api_status\":\"SAMPLE\",\"threads\":[\"{\\\"tid\\\":10,\\\"title\\\":\\\"3rdTitle\\\"}\",\"{\\\"tid\\\":15,\\\"title\\\":\\\"this is 4th Title\\\"}\"]}";
		Response reponse = new Response();
		response.fromJSON(sample);
		System.out.println("Convert from JSON : "+ response);
	}

It will have output:

Convert to JSON : {"api_status":"OK","threads":["{\"tid\":2,\"title\":\"First Title\"}","{\"tid\":4,\"title\":\"this is 2nd Title\"}"]}
Convert from JSON : SAMPLE-[10-3rdTitle][15-this is 4th Title]

It demonstrate the sample for creating JSON string and parsing JSON string which have array/object inside the JSON.

Jimmy’s Blog – ISO 8583 Tutorial – Build and Parse ISO Message using JPOS library

jimmy — Tue, 26 Jul 2011 12:42:27 +0000

ISO 8583 Tutorial article

In the beginning

OK after my article about ISO 8583 let’s go deeper into programming using Java + JPOS library.

Quote from JPOS website:

jPOS is a Java® platform-based, mission-critical, ISO-8583 based financial transaction library/framework that can be customized and extended in order to implement financial interchanges.

So first thing to do is download JPOS from it website.

Then we setup our development environment by creating Java Project using your favorites IDE. Add to the project all jar in JPOS library.
Here’s my Eclipse package explorer looks like.

package explorer

Create Data Elements (DE) types XML

Like I said that ISO 8583 is a ’standard’ which mean can be different between one implementation and another
To put it simple, although there’s a (some) standard for DE list sometime we need to change it.
Either way, we need to tell JPOS how our DE will be formatted or packaged.

Since in the complete XML there’s 128 DE, I’ll quote only the DE # we used. Full xml can be downloaded here (basic.xml)

 version="1.0" encoding="UTF-8" standalone="no"?>

>
  
      id="0"
      length="4"
      name="MESSAGE TYPE INDICATOR"
      class="org.jpos.iso.IFA_NUMERIC"/>
  
      id="1"
      length="64"
      name="BIT MAP"
      class="org.jpos.iso.IFA_BITMAP"/>
  
      id="3"
      length="6"
      name="PROCESSING CODE"
      class="org.jpos.iso.IFA_NUMERIC"/>
  
      id="4"
      length="12"
      name="AMOUNT, TRANSACTION"
      class="org.jpos.iso.IFA_NUMERIC"/>
  
      id="7"
      length="10"
      name="TRANSMISSION DATE AND TIME"
      class="org.jpos.iso.IFA_NUMERIC"/>
  
      id="11"
      length="6"
      name="SYSTEM TRACE AUDIT NUMBER"
      class="org.jpos.iso.IFA_NUMERIC"/>
  
      id="44"
      length="25"
      name="ADITIONAL RESPONSE DATA"
      class="org.jpos.iso.IFA_LLCHAR"/>
  
      id="105"
      length="999"
      name="RESERVED ISO USE"
      class="org.jpos.iso.IFA_LLLCHAR"/>
>

The XML should easily understand in each isofield tag we define:

id : the DE number
length : the max/fixed length of the DE
name : yes, it’s the name or description
class : this define the type of the DE, which in this case represent by the JPOS class. You can see the whole class list here. I only list some of it.
- IFA_NUMERIC : Numeric – Left padder with zeros.
- IFA_BITMAP : For ISO Bitmap
- IFA_LLCHAR : ASCII variable len CHAR – 2 digit length info
- IFA_LLLCHAR : ASCII variable len CHAR – 3 digit length info

So this XML will be used for build (pack) ISO Message or parse (unpack) ISO Message.

You will need the XML data schema (genericpackager.dtd) to be put on same directory with basic.xml

Build (pack) ISO Message

Below is the code. The code is quite straight forward, review it first and I’ll discuss a bit afterward.

package gnu.jimmod.iso8583.utility;
 
import java.io.IOException;
import org.jpos.iso.ISOException;
import org.jpos.iso.ISOMsg;
import org.jpos.iso.packager.GenericPackager;
 
public class BuildISOMessage {
 
	public static void main(String[] args) throws IOException, ISOException {
		// Create Packager based on XML that contain DE type
		GenericPackager packager = new GenericPackager("basic.xml");
 
		// Create ISO Message
		ISOMsg isoMsg = new ISOMsg();
		isoMsg.setPackager(packager);
		isoMsg.setMTI("0200");
		isoMsg.set(3, "201234");
		isoMsg.set(4, "10000");
		isoMsg.set(7, "110722180");
		isoMsg.set(11, "123456");
		isoMsg.set(44, "A5DFGR");
		isoMsg.set(105, "ABCDEFGHIJ 1234567890");
 
		// print the DE list
		logISOMsg(isoMsg);
 
		// Get and print the output result
		byte[] data = isoMsg.pack();
		System.out.println("RESULT : " + new String(data));
	}
 
	private static void logISOMsg(ISOMsg msg) {
		System.out.println("----ISO MESSAGE-----");
		try {
			System.out.println("  MTI : " + msg.getMTI());
			for (int i=1;i&lt;=msg.getMaxField();i++) {
				if (msg.hasField(i)) {
					System.out.println("    Field-"+i+" : "+msg.getString(i));
				}
			}
		} catch (ISOException e) {
			e.printStackTrace();
		} finally {
			System.out.println("--------------------");
		}
 
	}
 
}

The output:

----ISO MESSAGE-----
  MTI : 0200
    Field-3 : 201234
    Field-4 : 10000
    Field-7 : 110722180
    Field-11 : 123456
    Field-44 : A5DFGR
    Field-105 : ABCDEFGHIJ 1234567890
--------------------
RESULT : 0200B2200000001000000000000000800000201234000000010000011072218012345606A5DFGR021ABCDEFGHIJ 1234567890

The program flow:

Create ISO packager based on the xml file.
Set the DE values. I use the previous article examples.
Print the DE values set.
Pack the message.
Print the formatted ISO message. As you can see the result is the same with the previous article examples.

Parse (unpack) ISO Message

On this case it’s reversed. We have the ISO Message, and we need to see the DE values of it.
Like the previous code this one also similar and should be easy to understand.

package gnu.jimmod.iso8583.utility;
 
import java.io.IOException;
import org.jpos.iso.ISOException;
import org.jpos.iso.ISOMsg;
import org.jpos.iso.packager.GenericPackager;
 
public class ParseISOMessage {
 
	public static void main(String[] args) throws IOException, ISOException {
		// Create Packager based on XML that contain DE type
		GenericPackager packager = new GenericPackager("basic.xml");
 
		// Print Input Data
		String data = "0200B2200000001000000000000000800000201234000000010000011072218012345606A5DFGR021ABCDEFGHIJ 1234567890";
		System.out.println("DATA : " + data);
 
		// Create ISO Message
		ISOMsg isoMsg = new ISOMsg();
		isoMsg.setPackager(packager);
		isoMsg.unpack(data.getBytes());
 
		// print the DE list
		logISOMsg(isoMsg);
	}
 
	private static void logISOMsg(ISOMsg msg) {
		System.out.println("----ISO MESSAGE-----");
		try {
			System.out.println("  MTI : " + msg.getMTI());
			for (int i=1;i&lt;=msg.getMaxField();i++) {
				if (msg.hasField(i)) {
					System.out.println("    Field-"+i+" : "+msg.getString(i));
				}
			}
		} catch (ISOException e) {
			e.printStackTrace();
		} finally {
			System.out.println("--------------------");
		}
 
	}
 
}

The output:

DATA : 0200B2200000001000000000000000800000201234000000010000011072218012345606A5DFGR021ABCDEFGHIJ 1234567890
----ISO MESSAGE-----
  MTI : 0200
    Field-3 : 201234
    Field-4 : 000000010000
    Field-7 : 0110722180
    Field-11 : 123456
    Field-44 : A5DFGR
    Field-105 : ABCDEFGHIJ 1234567890
--------------------

The program flow:

Create ISO packager based on the xml file.
Set ISO Message.
Print the ISO Message.
Unpack the message.
Print the DE values. As you can see the result is correct, just like the DE set in first example.

In the end

Ok, like always I hope I make it clear for you.
This might not (yet) a tutorial to make you able the whole financial platform or a bank platform
But everyone need to start somewhere.

I see this code example as the implementation of my previous article (ISO 8583 introduction)

Just leave comment if you have questions.

Jimmy’s Blog – Slide Number Puzzle Game with Echo2 Framework

jimmy — Mon, 14 Feb 2011 06:12:32 +0000

I’m checking Echo2 framework these couple days and try to make a simple game just to get to know the framework better.
Since I’m not a JavaScript expert it’s good to know that there’s framework that I can use to create AJAX web app with desktop feel easily.
The game is about re-ordering number by moving number to the empty space. It’s simple and fun, this sample is hardcoded to only support 3×3 size.

I assume you know Java, JSP, Servlet basics.
Download Echo 2 from : Echo2 Website
I personally use Eclipse for my IDE.

Step by step:

1. Create web project with your IDE, this should set up your project structure based on IDE you used.
2. Add Echo 2 library to your build path (Echo2_App.jar, Echo2_WebContainer.jar, Echo2_WebRender.jar).
3. Add servlet mapping in your web.xml

  >
    >>
    >NumberGameServlet>
    >NumberGameServlet>
    >gnu.jimmy.java.echo2.numbergame.NumberGameServlet>
  >
  >
    >NumberGameServlet>
    >/game>
  >

4. Create NumberGameServlet that extend WebContainerServlet. This class will only return the application instance to be displayed to user.

 
package gnu.jimmy.java.echo2.numbergame;
 
import nextapp.echo2.app.ApplicationInstance;
import nextapp.echo2.webcontainer.WebContainerServlet;
 
/**
 * Servlet implementation class NumberGameServlet
 */
public class NumberGameServlet extends WebContainerServlet {
	private static final long serialVersionUID = 1L;
 
	@Override
	public ApplicationInstance newApplicationInstance() {
        return new NumberGameApp();
	}
}

5. Create class NumberGameApp that extend ApplicationInstance.
This is the core of the game, the game code is simple – we store the number position data and allow user to switch between number with button up/down/left/right or click the button near the empty one.
After that there will be checking if the number is order properly.
There’s also button to random the numbers, this will trigger up/down/left/right movements.

 
package gnu.jimmy.java.echo2.numbergame;
 
import nextapp.echo2.app.ApplicationInstance;
import nextapp.echo2.app.Button;
import nextapp.echo2.app.Color;
import nextapp.echo2.app.ContentPane;
import nextapp.echo2.app.Extent;
import nextapp.echo2.app.Grid;
import nextapp.echo2.app.ImageReference;
import nextapp.echo2.app.Label;
import nextapp.echo2.app.ResourceImageReference;
import nextapp.echo2.app.Window;
import nextapp.echo2.app.WindowPane;
import nextapp.echo2.app.event.ActionEvent;
import nextapp.echo2.app.event.ActionListener;
import nextapp.echo2.app.layout.GridLayoutData;
 
public class NumberGameApp extends ApplicationInstance implements ActionListener {
 
	private Window window;
	private ContentPane contentPane;
	private Grid container;
	private Button[] numbers = new Button[9];
	private Button random;
	private Button up;
	private Button left;
	private Button right;
	private Button down;
	private WindowPane pane;
	private Label paneLabel;
	private int[] numberData = new int[9];
	private int[] numberPos = new int[9];
 
	@Override
	public Window init() {
		window = new Window();
		contentPane = new ContentPane();
		window.setContent(contentPane);
 
		container = new Grid();
		container.setSize(3);
		contentPane.add(container);
 
		for (int i=0;i<numbers.length;i++) {
			ImageReference image = new ResourceImageReference("image/"+(i+1)+".png");
			numbers[i] = new Button(image);
			GridLayoutData layoutData = new GridLayoutData();
			layoutData.setBackground(new Color(0xffffcf));
			numbers[i].setLayoutData(layoutData);
			numbers[i].addActionListener(this);
			numberData[i] = i;
			numberPos[i] = i;
		}
 
		random = new Button(new ResourceImageReference("image/b_random.png"));
		random.addActionListener(this);
		up = new Button(new ResourceImageReference("image/b_up.png"));
		up.addActionListener(this);
		down = new Button(new ResourceImageReference("image/b_down.png"));
		down.addActionListener(this);
		left = new Button(new ResourceImageReference("image/b_left.png"));
		left.addActionListener(this);
		right = new Button(new ResourceImageReference("image/b_right.png"));
		right.addActionListener(this);
 
		pane = new WindowPane("Message", new Extent(200), new Extent(100));
		paneLabel = new Label();
		pane.add(paneLabel);
		pane.setModal(true);
 
		imageRefresh();
 
		return window;
 
	}
 
	private void switchNumber(int n1, int n2) {
		System.out.println("Switching : " + n1 + " - " + n2);
		int t = numberData[n1];
		numberData[n1] = numberData[n2];
		numberData[n2] = t;
		numberPos[numberData[n1]]=n1;
		numberPos[numberData[n2]]=n2;
		imageRefresh();
	}
 
	private void imageRefresh() {
		container.removeAll();
		for (int i=0;i<numbers.length;i++) {
			container.add(numbers[numberData[i]]);
		}
		ImageReference imgEmpty = new ResourceImageReference("image/empty.png");
		container.add(new Label(imgEmpty));
		container.add(new Label(imgEmpty));
		container.add(new Label(imgEmpty));
		container.add(new Label(imgEmpty));
		container.add(up);
		container.add(new Label(imgEmpty));
		container.add(left);
		container.add(random);
		container.add(right);
		container.add(new Label(imgEmpty));
		container.add(down);
		container.add(new Label(imgEmpty));
	}
 
	@Override
	public void actionPerformed(ActionEvent e) {
		int numberPress=-1;
		if (e.getSource() == up) {
			moveUp();
		} else if (e.getSource() == down) {
			moveDown();
		} else if (e.getSource() == left) {
			moveLeft();
		} else if (e.getSource() == right) {
			moveRight();
		} else if (e.getSource() == random) {
			int total = ((int)(Math.random()*100))+10;
			for (int i=0;i<total;i++) {
				int move = ((int)(Math.random()*100));
				if (move%4 == 0) {
					moveUp();
				} else if (move%4 == 1) {
					moveDown();
				} else if (move%4 == 2) {
					moveLeft();
				} else if (move%4 == 3) {
					moveRight();
				}
			}
		} else {
			for (int i=0;i<9;i++) {
				 if (e.getSource() == numbers[i]) {
					 numberPress=numberPos[i];
				 }
			}
			if (numberPress==numberPos[8]-3) {
				moveDown();
			} else if (numberPress==numberPos[8]+3) {
				moveUp();
			} else if (numberPress==numberPos[8]-1) {
				moveRight();
			} else if (numberPress==numberPos[8]+1) {
				moveLeft();
			}
		}
		if (checking()) {
			contentPane.add(pane);
			pane.setPositionX(new Extent(10));
			pane.setPositionY(new Extent(10));
			paneLabel.setText("Puzzle Finished");
		} else {
			paneLabel.setText("");
		}
	}
 
	private void moveUp() {
		if (numberPos[8]<=5) {
			switchNumber(numberPos[8], numberPos[8]+3);
		}
	}
 
	private void moveDown() {
		if (numberPos[8]>=3) { 
			switchNumber(numberPos[8], numberPos[8]-3);
		}
	}
 
	private void moveLeft() {
		if (numberPos[8]%3 != 2) { 
			switchNumber(numberPos[8], numberPos[8]+1);
		}
	}
 
	private void moveRight() {
		if (numberPos[8]%3 != 0) { 
			switchNumber(numberPos[8], numberPos[8]-1);
		}
	}
 
	private boolean checking() {
		boolean match=true;
		for (int i=0;i<9;i++) {
			if (numberData[i]!=i) {
				match=false;
			}
		}
		return match;
	}
 
}

Screenshot:

Game Screenshot

Code logic:
- I create all number using button and add action listener on it.
- On number button clicked it will check if the number is next to empty space, if yes it will switch it.
- Random button will random the movement from 10-110 movement, so the numbers will be disordered but for sure it can be re-ordered.
- Arrow will make empty space switch with number next to it
- After every movement it will check if the numbers already ordered properly

Any question just drop a comment

Jimmy’s Blog – Send & Receiving SMS on specific Port with J2ME Application

jimmy — Thu, 10 Feb 2011 04:19:58 +0000

It’s been a while since I write an article, personal and work have been taken my time much lately.

What I will write is not a new things, maybe a lot of article already write this kind of feature. But yesterday I see this kind of project request in freelancer.com so I decide to create a simple sample and write an article about it.

Java Mobile (J2ME) application have a capability to send or receive SMS, but the phone need to support JSR-120 (Wireless Messaging API – WMA 1.0) or JSR-205 (WMA 2.0)
How to check if the phone is supporting this? Easy way if the phone’s brand website. For example for Nokia E72 we can see the technical specifications at http://developer.nokia.com/Devices/Device_specifications/E72/
If your phone doesn’t have WMA library the application will prompt error (the error can be different from one phone to another)

Sending SMS with J2ME is simple, one thing that programmer can forget is about putting it on another thread. To prevent a dead lock on sending, we need to create a thread to execute the sending.
Another thing is we can specifically send the SMS to specific port, which is important in this J2ME case. Because in J2ME we can only listen SMS on specific port (cannot on default port).

The sample is simple, with basic J2ME programming skill you should able to understand it. If you don’t just drop me a comment

Source code:

package poc.jwork.j2me.sendrecvsms;
 
import java.io.IOException;
 
import javax.microedition.io.Connector;
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;
import javax.microedition.midlet.MIDletStateChangeException;
import javax.wireless.messaging.MessageConnection;
import javax.wireless.messaging.MessageListener;
import javax.wireless.messaging.TextMessage;
 
public class SMSSender extends MIDlet implements CommandListener {
 
	private Form formSender = new Form("SMS Sender");
	private TextField tfDestination = new TextField("Destination", "", 20, TextField.PHONENUMBER);
	private TextField tfPort = new TextField("Port", "5000", 6, TextField.NUMERIC);
	private TextField tfMessage = new TextField("Message", "message", 150, TextField.ANY);
	private Command cmdSend = new Command("Send", Command.OK, 1);
	private Command cmdExit = new Command("Exit", Command.EXIT, 1);
	private Display display;
 
	public SMSSender() {
		formSender.append(tfDestination);
		formSender.append(tfPort);
		formSender.append(tfMessage);
		formSender.addCommand(cmdSend);
		formSender.addCommand(cmdExit);
		formSender.setCommandListener(this);
 
		display = Display.getDisplay(this);
	}
 
	protected void destroyApp(boolean arg0) throws MIDletStateChangeException {
	}
 
	protected void pauseApp() {
 
	}
 
	protected void startApp() throws MIDletStateChangeException {
		display.setCurrent(formSender);
	}
 
	public void commandAction(Command c, Displayable d) {
		if (c==cmdSend) {
			SendMessage.execute(tfDestination.getString(), tfPort.getString(), tfMessage.getString());
		} else if (c==cmdExit) {
			notifyDestroyed();
		}
	}
 
}
 
class SendMessage {
 
	public static void execute(final String destination, final String port, final String message) {
 
		Thread thread = new Thread(new Runnable() {
 
			public void run() {
				MessageConnection msgConnection;
				try {
					msgConnection = (MessageConnection)Connector.open("sms://"+destination+":" + port);
					TextMessage textMessage = (TextMessage)msgConnection.newMessage(
							MessageConnection.TEXT_MESSAGE);
					textMessage.setPayloadText(message);
					msgConnection.send(textMessage);
					msgConnection.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		});
 
		thread.start();
	}
 
}

package poc.jwork.j2me.sendrecvsms;
 
import java.io.IOException;
import java.io.InterruptedIOException;
 
import javax.microedition.io.Connector;
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;
import javax.microedition.midlet.MIDletStateChangeException;
import javax.wireless.messaging.Message;
import javax.wireless.messaging.MessageConnection;
import javax.wireless.messaging.MessageListener;
import javax.wireless.messaging.TextMessage;
 
public class SMSReceiver extends MIDlet implements CommandListener, MessageListener {
 
	private Form formReceiver = new Form("SMS Receiver");
	private TextField tfPort = new TextField("Port", "5000", 6, TextField.NUMERIC);
	private Command cmdListen = new Command("Listen", Command.OK, 1);
	private Command cmdExit = new Command("Exit", Command.EXIT, 1);
	private Display display;
 
	public SMSReceiver() {
		formReceiver.append(tfPort);
		formReceiver.addCommand(cmdListen);
		formReceiver.addCommand(cmdExit);
		formReceiver.setCommandListener(this);
 
		display = Display.getDisplay(this);
	}
 
	protected void destroyApp(boolean unconditional)
			throws MIDletStateChangeException {
 
	}
 
	protected void pauseApp() {
 
	}
 
	protected void startApp() throws MIDletStateChangeException {
		display.setCurrent(formReceiver);
	}
 
	public void commandAction(Command c, Displayable d) {
		if (c==cmdListen) {
			ListenSMS sms = new ListenSMS(tfPort.getString(), this);
			sms.start();
			formReceiver.removeCommand(cmdListen);
		} else if (c==cmdExit) {
			notifyDestroyed();
		}
	}
 
	public void notifyIncomingMessage(MessageConnection conn) {
		Message message;
		try {
			message = conn.receive();
			if (message instanceof TextMessage) {
				TextMessage tMessage = (TextMessage)message;
				formReceiver.append("Message received : "+tMessage.getPayloadText()+"\n");
			} else {
				formReceiver.append("Unknown Message received\n");
			}
		} catch (InterruptedIOException e) {
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
 
}
 
class ListenSMS extends Thread {
	private MessageConnection msgConnection;
	private MessageListener listener;
	private String port;
 
	public ListenSMS(String port, MessageListener listener) {
		this.port = port;
		this.listener = listener;
	}
 
	public void run() {
		try {
			msgConnection = (MessageConnection)Connector.open("sms://:" + port);
			msgConnection.setMessageListener(listener);
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
 
}

Screenshot:

SMS Sender in simulator

SMS Reveiver in Simulator

Build:
JAD FILE
JAR FILE

Basic LWUIT tutorial/sample with Eclipse Pulsar

jimmy — Sat, 17 Apr 2010 17:31:41 +0000

I was really want to try LWUIT since several months ago. It’s look promising and it’s developed by SUN so I think every Java ME developer should take a look on this technology.
I’m also still new in LWUIT so there won’t be a lot that I can share for now, but at least I will show you a basic demonstration of how to use Form, Label, Command, and 3D Form transition (sound cool huh :p)

REQUIREMENT

What you need:

LWUIT
Eclipse Pulsa
Emulator like Sun WTK
Know basic Java ME programming

CONFIGURE ECLIPSE

First you need to setup your emulator in Eclipse.
Run your Eclipse and select at the menu : Window – Preferences
Select : Java ME – Device Management – click Import
Then browse to your emulator folder, it will scan and give you option to add it to your device list.

Eclipse Pulsar Device Management

*I found that the automatic javadoc folder detection for each jar library is not all correct (I’m using Ubuntu 9.04, WTK 2.5.1)

CREATE NEW MIDlet PROJECT & CONFIGURE

Ok, now we ready to create the new project.
I assume you already know how to use Eclipse properly, create a new MIDlet Project there you will select your default emulator you want to use in the project, MIDP – CLDC version, etc.
After the new project created we gonna add the LWUIT library to the project.
Right click on the project (at package explorer) and select Properties.
Select ‘Java Build Path’ and tab ‘Libraries’ then click ‘Add External Jars’ and browse to select where your LWUIT jar is. (It will be on the lib folder where you extract you LWUIT zip)

MIDlet Project Properties

You will see the LWUIT.jar shown.
Select tab ‘Order and Export’, check the LWUIT.jar library so it will be included in our application jar.

Pulsa MIDlet project order and export

One of the cool thing about LWUIT is theme feature, you can see there’s ResourceEditor in LWUIT’s ‘util’ folder it’s for editing theme.
Let’s use default theme from the package. Copy file that located at ./LWUITDemo/src/LWUITtheme.res to our project ‘res’ folder (you can drag ‘n drop it to Eclipse).

THE CODING

Now we finally get to real coding.
Add a new MIDlet to the project. In my example I will create BasicForm Class:

package gnu.jimmy.blog.lwuit;
 
import java.io.IOException;
 
import javax.microedition.midlet.MIDlet;
import javax.microedition.midlet.MIDletStateChangeException;
 
import com.sun.lwuit.Command;
import com.sun.lwuit.Display;
import com.sun.lwuit.Form;
import com.sun.lwuit.Label;
import com.sun.lwuit.animations.CommonTransitions;
import com.sun.lwuit.animations.Transition3D;
import com.sun.lwuit.events.ActionEvent;
import com.sun.lwuit.events.ActionListener;
import com.sun.lwuit.layouts.BorderLayout;
import com.sun.lwuit.layouts.BoxLayout;
import com.sun.lwuit.plaf.UIManager;
import com.sun.lwuit.util.Resources;
 
public class BasicForm extends MIDlet implements ActionListener {
 
	private Form form1;
	private Form form2;
 
	private Command cmdRotate = new Command("Rotate");
	private Command cmdSlide = new Command("Slide");
	private Command cmdExit = new Command("Exit");
 
	public BasicForm() {
		//Initialize the LWUIT
		Display.init(this);
	}
 
	protected void startApp() throws MIDletStateChangeException {
		//Load the Theme
		Resources r;
		try {
			r = Resources.open("/LWUITtheme.res");
			UIManager.getInstance().
			setThemeProps(r.getTheme("LWUITDefault"));
		} catch (IOException e) {
			e.printStackTrace();
		}
 
		//Setup Form 1
		form1 = new Form("Form 1");
		form1.setLayout(new BorderLayout());
		form1.addComponent(BorderLayout.NORTH, new Label("My First Form"));
		form1.addComponent(BorderLayout.WEST, new Label("WEST"));
		form1.addComponent(BorderLayout.CENTER, new Label("CENTER"));
		form1.addComponent(BorderLayout.EAST, new Label("EAST"));
		form1.addComponent(BorderLayout.SOUTH, new Label("Click Rotate"));
		form1.addCommand(cmdRotate);
		form1.addCommand(cmdExit);
		form1.addCommandListener(this);
		form1.setTransitionInAnimator(CommonTransitions.createSlide(CommonTransitions.SLIDE_HORIZONTAL, true, 1000));
 
		//Setup Form 2
		form2 = new Form("Form 2");
		form2.setLayout(new BoxLayout(BoxLayout.Y_AXIS));
		form2.addComponent(0,null,new Label("This is the second Form"));
		form2.addCommand(cmdSlide);
		form2.addCommand(cmdExit);
		form2.addCommandListener(this);
		form2.setTransitionInAnimator(Transition3D.createCube(1000, true));
 
		form1.show();
	}
 
	public void actionPerformed(ActionEvent evt) {
		//check which command cliked
		if (evt.getCommand()==cmdExit) {
			notifyDestroyed();
		} else if (evt.getCommand()==cmdRotate) {
			form2.show();
		} else if (evt.getCommand()==cmdSlide) {
			form1.show();
		}
	}
 
	protected void destroyApp(boolean unconditional) throws MIDletStateChangeException {
	}
 
	protected void pauseApp() {
	}
 
}

Try to run the class.
It should display a form and when you click the left softkey change to the second form with cube rotate effect.
When you click the left softkey again it will go back to first form with slide effect.

LWUIT sample

NOTE
* all UI classes are from package com.sun.lwuit don’t import the WTK default.
* Display.init function (the one I put in constructor) needed to execute first before initializing Forms
* Theme need to be load first before initializing Forms
* Transition3D will require M3G, so if you want to test it on real phone make sure your phone support it. If not you can just change the Transition3D to CommonTransition.

ENDING

If you have prompt to follow the tutorial just drop me a comment here.

Cheers

Java ME (J2ME) JSON Implementation Tutorial/Sample

jimmy — Wed, 03 Mar 2010 05:48:25 +0000

JSON is one of the most popular format used for communicating between (Java ME) J2ME client and App Server. Strangely it’s hard to find JSON implementation sample in J2ME. So I decide to write a sample.

– Next Tutorial : Java ME (J2ME) JSON Implementation For Array Object –

The JSON library I used is from json.org : http://www.json.org/java/org.json.me.zip
(link reported not valid anymore, try the one I’ve uploaded : http://www.megaupload.com/?d=QDW9N225)

Extract it to your source code folder.

For example we have this User Class:

public class User{
   private int id;
   private String name;
   private String description;
}

To implement JSON to this class I usually create an Interface JSONAble:

public interface JSONAble {
String toJSON();
void fromJSON(String jsonString);
}

To make the User class is JSON compatible let’s add the JSONAble interface & implement it:

public class User implements JSONAble{
 
	private int id;
	private String name;
	private String description;
 
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getDescription() {
		return description;
	}
	public void setDescription(String description) {
		this.description = description;
	}
	public String toString() {
		return getId()+"-"+getName()+"-"+getDescription();
	}
 
	public void fromJSON(String jsonString) {
		try {
			JSONObject json = new JSONObject(jsonString);
			setId(json.getInt("id"));
			setName(json.getString("name"));
			setDescription(json.getString("description"));
		} catch (JSONException ex) {
			ex.printStackTrace();
		}
	}
	public String toJSON() {
		JSONObject inner = new JSONObject();
		try {
			inner.put("id", getId());
			inner.put("name", getName());
			inner.put("description", getDescription());
		} catch (JSONException ex) {
			ex.printStackTrace();
		}
		return inner.toString();
	}
}

To test it let’s create a MIDlet that have these startApp() implementation:

	protected void startApp() throws MIDletStateChangeException {
		//Converting Object to JSON
		User user = new User();
		user.setId(10);
		user.setName("jimmy");
		user.setDescription("testing json in j2me");
		System.out.println("Convert to JSON : "+user.toJSON());
 
		//Converting JSON to Object
		String sample = "{\"id\":99,\"name\":\"tester\",\"description\":\"This is JSON Data\"}";
		User user2 = new User();
		user2.fromJSON(sample);
		System.out.println("Convert from JSON : "+user2);
	}

As you can see the output results:
Convert to JSON : {"name":"jimmy","description":"testing json in j2me","id":10} Convert from JSON : 99-tester-This is JSON Data

The toJSON() function is the implementation how the object converted to JSON format. In J2ME we still implement it manually since we don’t have Java reflection which can enable automatically scan the variables.
What the JSON library help is building the JSON data. We just need to put the variables.

On the fromJSON() function what it does is getting out the data from JSON format and set it to class variables.

Next I will cover about converting more complex class structure.
Or create a fromJSON () & toJSON() generator (:?). Let see..

Thanks for reading this, although this is the basic hope it’ll help

– Next Tutorial : Java ME (J2ME) JSON Implementation For Array Object –

Bind JBoss to specific IP address

jimmy — Mon, 28 Dec 2009 12:37:36 +0000

Simple but I think it will help JBoss newbie (like me :]) when searching the internet.

By default when you run JBoss ( ./run.sh in Linux) it will bind to localhost/127.0.0.1
This will cause the JBoss default port 8080 cannot be access from other computer, because you need to open http://127.0.0.1:8080/ instead of your IP http://:8080/

To make the JBoss binding to specific IP you need to run it with :
./run.sh -Djboss.bind.address=xxx.xxx.xxx.xxx
*which of course the xxx.xxx.xxx.xxx is your IP

Other PC will able to access the JBoss with that IP

For Windows I think it will be the same :
./run.bat -Djboss.bind.address=xxx.xxx.xxx.xxx

Cheers ^^

No related posts.

Java Application – Make sure only single/one instance running – with File Lock and ShutdownHook

jimmy — Mon, 21 Jul 2008 09:51:14 +0000

Often we want to make sure that only 1 instance our application running.
Because something terrible could happen when more than 1 instance running (for example the whole server would exploded and that would make you fired )

Nevertheless what the reason, one of the way to make this happen is by creating a lock file as a sign that an instance is currently running.
So you application will have this flow:

Check if the lock file exists.
Try to delete the lock file to check if there’s really a running process lock the file.
Get the file lock.
If failed to get the lock file, show error that there’s already an instance running
If successfully get the lock then go on with your application want to do.
When application ended/closed release the lock and delete the file lock.

package test.jimmy.filelock;
 
import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.channels.FileChannel;
import java.nio.channels.FileLock;
 
public class MyApp {
 
private static File f;
private static FileChannel channel;
private static FileLock lock;
 
public static void main(String[] args) {
  try {
    f = new File("RingOnRequest.lock");
    // Check if the lock exist
    if (f.exists()) {
    // if exist try to delete it
    f.delete();
  }
  // Try to get the lock
  channel = new RandomAccessFile(f, "rw").getChannel();
  lock = channel.tryLock();
  if(lock == null)
  {
    // File is lock by other application
    channel.close();
    throw new RuntimeException("Only 1 instance of MyApp can run.");
  }
  // Add shutdown hook to release lock when application shutdown
  ShutdownHook shutdownHook = new ShutdownHook();
  Runtime.getRuntime().addShutdownHook(shutdownHook);
 
  //Your application tasks here..
  System.out.println("Running");
  try {
    Thread.sleep(10000);
  } catch (InterruptedException e) {
    e.printStackTrace();
  } catch(IOException e) {
    throw new RuntimeException("Could not start process.", e);
  }
}
 
public static void unlockFile() {
// release and delete file lock
  try {
    if(lock != null)
    lock.release();
    channel.close();
    f.delete();
  } catch(IOException e) {
    e.printStackTrace();
  }
}
 
static class ShutdownHook extends Thread {
  public void run() {
    unlockFile();
  }
}
 
}

Technorati Tags: java, file lock, shutdownhook, lock, single, one, intance

Using mock object with jmock 2

jimmy — Wed, 26 Dec 2007 11:33:25 +0000

Okay, finally you decide it’s time to create a unit testing for your project (after a long ad hoc programming life :p).
When you create a sample unit testing, it’s all seem so simple.. you fascinate by the junit easiness, how it can do reflection and make it simple.

When you want to create a real unit testing for your project, you realize that a ‘real’ method is not like just adding 2 int argument and return a result. It’s more complex and using interface as parameter is common…
Now a thought cross your mind “do I have to create all stupid classes to implement all the interface I need?”, you starting to think that creating unit testing is really waste of time & you don’t want to do it anymore :p

It’s time mock object framework come to rescue… before you fall to the darkness of untested code
There’re several mock object framework like jMock, easymock, etc

Here’s an example creatin HttpMethod mock-object with jMock 2 & JUnit 3

[sourcecode language='java']
public class sampleJMockTest extends MockObjectTestCase {
public void testCreateHTTPMethod() {
final HttpMethod httpMethod = mock(HttpMethod.class);
checking(new Expectations() {
{
allowing(httpMethod).getResponseBodyAsString();
will(returnValue(”sample response”));
}
});
SomeObject someObject = new SomeObject();
someObject.someMethod(httpMethod);
}
}[/sourcecode]
This sample will create an instance of HttpMethod (which is an interface) and when this mock object’s ‘getResponseBodyAsString’ method called it’ll return “sample response”.
So now we can easily create all interface implementation we need.Of course there’re more in jMock than just this simple feature, check it more at jMock Cookbook

Java – Adding new Classpath at Runtime

jimmy — Wed, 19 Dec 2007 11:59:14 +0000

There are cases where we need to add classpath at runtime. For example adding jar to classpath, but depends on configuration or some logic at runtime.

The class who responsible for handling classpath list is URLClassloader.
You can get current system URLClassLoader with:
URLClassLoader urlClassLoader = (URLClassLoader) ClassLoader.getSystemClassLoader();

If you check javadoc about this class you’ll see:

protected void addURL(URL url)
Appends the specified URL to the list of URLs to search for classes and resources.

So you’ll just need to call the addUrl method to add new path/jar file.
But wait a minute, the method is protected… do I need to create a subclass or put the caller class on same package?
Creating a subclass is one way to do it, but there’s simpler way (I’ll create article about creating URLClassLoader subclass next time :p)

Here come the savior : Reflection
By using reflection we can break OOP concept about encapsulating method. It’s feel good to break the rules right (warning : use this at your own risk, you know you’re breaking the OO rule. So I won’t responsible if your computer explode or you’ll fighting with OO fans because of this)

Here a sample how to called it with reflection:
[sourcecode language='java']
public static void addPath(String s) throws Exception {
File f = new File(s);
URL u = f.toURL();
URLClassLoader urlClassLoader = (URLClassLoader) ClassLoader.getSystemClassLoader();
Class urlClass = URLClassLoader.class;
Method method = urlClass.getDeclaredMethod(”addURL”, new Class[]{URL.class});
method.setAccessible(true);
method.invoke(urlClassLoader, new Object[]{u});
}[/sourcecode]
Happy reflecting..