Burak Dede – Read Once Do Everytime

J2ME isn’t a specific piece of software or specification. All it means is Java for small devices. Small devices range in size from pagers, mobile phones, and personal digital assistants (PDAs) all the way up to things like set-top boxes.

J2ME is divided into configurations, profiles, and optional APIs, which provide specific information about APIs and different families of devices. A configuration is designed for a specific kind of device based on memory constraints and processor power. It specifies a Java Virtual Machine (JVM) that can be easily ported to devices supporting the configuration. It also specifies a strict subset of the Java 2 Platform, Standard Edition (J2SE) APIs that will be used on the platform, as well as additional APIs that may be necessary. Device manufacturers are responsible for porting a specific configuration to their devices.

Profiles are more specific than configurations. A profile is based on a configuration and provides additional APIs, such as user interface, persistent storage, and whatever else is necessary to develop running applications for the device.

Optional APIs define specific additional functionality that may be included in a particular configuration (or profile). The whole caboodle—configuration, profile, and optional APIs— that is implemented on a device is called a stack. For example, a possible future device stack might be CLDC/MIDP + Mobile Media API. See the section “Platform Standardization” later in this chapter for information on JSR 185, which defines a standard J2ME stack.

J2ME configuration divided into 2 categories according to device specifications.First one is Connected Device Configuration called CDC which sits on top of the J2ME.These devices have to meet the requirements specified by JSR community process.CDC devices target especially high end PDA’s , navigation systems , settop boxes.Therse devices has ,at a minimum, 512KB of read-only memory (ROM), 256KB of random access memory (RAM), and some kind of network connection.And also CDC devices gives full JVM support.

Other type of configuration is Connected Limited Device Configuration which is called CLDC.This configuration category include devices like mobile phones,pagers,PDA’s…As you see these devices smaller than the devices listed on CDC.CDC devices have limited memory , limited processor power ,limited screen size,limited battery life because of these developing applications for these devices is a important process.The CLDC is designed for devices with 160KB to 512KB of total memory, including a minimum of 160KB of ROM and 32KB of RAM available for the Java platform.For note connected means here network connection that is not very fast and intermitted.These devices support specific implementation of JVM which is KVM.K means here as far as i know “it is a JVM whose size is measured in kilobytes rather than megabytes”.

Other important part of J2ME is profiles.I am not going to dive into other profiles just MIDP which is the important and known one  in J2ME development.MIDP stands for Mobile Information Device Profile and have also JSR process and specifications.Here is the MIDP 2.0 specifications.

• A minimum of 256KB of ROM for the MIDP implementation (this is in addition to the requirements of the CLDC)
• A minimum of 128KB of RAM for the Java runtime heap
• A minimum of 8KB of nonvolatile writable memory for persistent data
• A screen of at least 96×54 pixels • Some capacity for input, either by keypad, keyboard, or touch screen
• Two-way network connection, possibly intermittent

Most of the latest devices support MIDP 2.0 specification but older ones user MIDP 1.0.

Structure of MIDP Application

MIDP application has a API which comes from both CLDC and also MIDP 2.0 .CLCD api comes from core api defined in Java SE and MIDP api comes with java micro edition packages.Here is a list of avaliable packages.

For CLDC

• java.lang
• java.lang.ref
• java.io
• java.util
• javax.microedition.io

For MIDP

• javax.microedition.lcdui
• javax.microedition.lcdui.game
• javax.microedition.media
• javax.microedition.media.control
• javax.microedition.midlet
• javax.microedition.pki
• javax.microedition.rms

Also device vendors supply their own API’s specific to their device.These are different API’s from MIDP and as i said specific to that device not platform independent and make developers to reach device specific features.MIDP applications sits on top of the device specific OS , and use only api provided by MIDP and CLDC.Device specific java application use API provided by device vendor.(Device Specific API’s).

Advantages of MIDP

Portability

The advantage of using Java over using other tools for small device application development is portability. You could write device applications with C or C++, but the result would be specific to a single platform. An application written using the MIDP APIs will be directly portable to any MIDP device.

Security

A second compelling reason for using Java for small device development is security. Java is well known for its ability to safely run downloaded code like applets. This is a perfect fit—it’s easy to imagine nifty applications dynamically downloading to your mobile phone.

As you may know auto boxing and unboxing is a new feature of the Java 6.(which is not new for languages like C#, we can say it is new feature for the Java).Java has two main data types one is primitive type and other is reference types.Primitive types are the types generally built in language (like int , short,byte,long,float,double,bool,char…) and allocated on the stack side of the memory.But reference types are the types lets say shortly any type that subtype of the class Object in java (like class,array,String…) and they allocated on the heap side of the memory.

What about boxing and unboxing , boxing is conversion of the one primitive type to its corresponding reference type (int to Integer in this situation) while unboxing is conversion of the reference type to corresponding primitive type.You can think of actually “boxing” the varaible and putting it to heap side , and unboxing as reverse procedure to the stack side.

These boxing and unboxing operations are automatically done by java while using generics.Generics  can think of as a compile time check for class or interface or any other types that used with generics for their parameters.From definition its hard to understand so lets show a example of generics use.

1
2
3

List<Integer> ints = new ArrayList<Integer>();
ints.add(1);
int n = ints.get(0);

Here as you can see we are creating a list from arraylist(which is a class the implements list interface so assigment is OK) with specified parameters String in angle brackets.With the help of generics it is guaranteed that all the parameters that added to arraylist is String , if you try to add something other that String it is a compile time error.Before java generics its programmer job to guess what is the variable type coming from list and make suitable cast to that object.It is a extra work for programmer.With generics its is now compiler responsibility to check parameters and give compile time error.

You can say it is not different from c++ templates , but actually it does.There is a different implementation of the generics in bot c++ and java side.In C++ if you use generics and create and objects lets say List<String> and List<Integer> and List<List<String>> , C++ made 3 copy of your code for each generic in use.If you use 100 different type of generics there will be 100 different code , this can lead to code bloat.But in java no matter how many differnt generics you use there is only one code for all.C++ model generics called expansion,it can be lead to code bloat but in performance side it is more efficient that Java model.Also if you are using generics with C++ you have to be careful about usage of angle brackets.

Lets look at another code to see how auto boxing and unboxing work with Java.

1
2
3
4
5

public static int sum (List<Integer> ints) {
  int s = 0;
  for (int n : ints) { s += n; }
  return s;
}

In this code sample we again using a list from arraylist as  parameter to sum function with specified Integer generic.(you can say what is the difference between “Integer” and “int” , and why we not using “int” for generics like this “List<int> ints”) Cause type parameters always bound to reference type not primitive types.And also you can ask why we are using “int” insted of “Integer” as return type like “return Integer”? .Because result types may be either primitive or reference types, and it is more efficient to use the former than the latter.Also you can say why for variable(or you can say foreach another new feature of java 6) not “Integer” insted of  “int”.This is actually hold performace issue behind.If you use “Integer” instead of “int” compiler unbox the value of “Integer” every time and perform operation than box the value back for later iteration.This is a big performance loss.

Here how generics doing auto boxing and unboxing.

1
2
3

List<Integer> ints = new ArrayList<Integer>();
ints.add(new Integer(1));
int n = ints.get(0).intValue();

This is the different version of the first code sample at top.This is how it looks when we are using generics in our code.As you can see if we try to add int value to List that expects Integer , it automatically box the value and then add it to the list.On the other hand if we try to get the value out of list , it again automatically unbox the value and assign it .(here we using integer so if we try to box int value it is done with new Integer(x) , and if we try to unbox it you have to call intValue method of the Integer).

For more information about generics you can look at Sun documentation for generics and also for Collections framework of Java.