Sending HTTP Requests from a Wireless J2ME Device
Learn to use the J2ME networking classes found in the javax.microedition.io package to send HTTP requests to a Web server or similar HTTP-enabled network server.
by
Kyle Gabhart, Java Pro
s more and more cellular phones and PDAs
begin to merge onto the information superhighway, it becomes
increasingly interesting to access Web sites from mobile devices. Since
Java was initially created for consumer appliances with a small memory
footprint, it is the perfect language for developing applications for
phones, pagers, and other micro devices.
In this 10-Minute Solution, we will learn how to send an HTTP GET
request and an HTTP POST request to a server from a J2ME client.
Although this is a rather introductory discussion, it is assumed that
the reader is accustomed to working with Java, J2ME, and Java midlets
(MIDP applications). We will use the MIDP profile for J2ME and compile,
deploy, and test our application using Sun's J2ME Wireless Toolkit.
For the HTTP server, any WWW address may be accessed, but by default we
will use a simple Java servlet that will return the details about our
HTTP request. 
How can a J2ME client send HTTP requests to a Web server or similar HTTP-enabled network server?
Using the Java 2 Micro Edition networking classes found in the javax.microedition.io package.
Overview:
Wireless Network Programming with J2ME
The networking capabilities of Java are quite robust. The Java 2 Standard Edition (J2SE) defines well over 100 interfaces, classes, and exceptions between the java.io and java.net packages. The functionality made available through these libraries is great for traditional computer systems with substantial CPU power, active memory, and persistent data storage, but not for most wireless devices. Consequently, the Java 2 Micro Edition (J2ME) defines a subset of this functionality and provides a consolidated package for networking and file access—the javax.microedition.io package. Due to the wide variety of mobile devices, this package merely defines a set of interfaces, leaving the actual implementation up to each vendor. This provides an optimum balance between portability and the utilization of device specific features.
The abstract networking and file I/O framework defined by the
javax.microedition.io classes are referred to as the Generic Connection
Framework (GCF). The GCF defines a set of related abstractions to
represent different communication methods. The top-level abstraction is
called Connection, from which six more interfaces are declared (four
direct, and two indirect). These seven interfaces are declared as a part
of J2ME's Connected Limited Device Configuration (CLDC), which is the
configuration used by most Java-enabled wireless devices. This is
designed to provide common networking and file I/O capabilities for all
CLDC devices (cell phones, two-way pagers, low-end PDAs, etc.).
The networking capabilities of Java are quite robust. The Java 2 Standard Edition (J2SE) defines well over 100 interfaces, classes, and exceptions between the java.io and java.net packages. The functionality made available through these libraries is great for traditional computer systems with substantial CPU power, active memory, and persistent data storage, but not for most wireless devices. Consequently, the Java 2 Micro Edition (J2ME) defines a subset of this functionality and provides a consolidated package for networking and file access—the javax.microedition.io package. Due to the wide variety of mobile devices, this package merely defines a set of interfaces, leaving the actual implementation up to each vendor. This provides an optimum balance between portability and the utilization of device specific features.
Although the purpose behind the GCF is to provide a common networking and file I/O framework, device manufacturers are not compelled to implement all of the interfaces declared in the GCF. The manufacturer may decide to only support socket connections (used with circuit-switched wireless networks), while others may choose to only support datagram-based communication (used with packet-switched networks). In order to promote portability across similar devices the Mobile Information Device Profile (MIDP) specification requires that all MIDP devices implement the HttpConnection interface. HttpConnection is not part of the GCF, but it does derive from one of the GCF interfaces, ContentConnection. We will use the HttpConnection interface to build our sample application.
Sending an HTTP GET Request
The code that will be explained in this section and the next section will only address the Generic Connection Framework interfaces and the HttpConnection interface used for sending an HTTP request and retrieving the response returned by the server. The code for creating the MIDP user interface can be downloaded at the end of the article.
We will begin by defining a method to house the code for sending an HTTP GET request. Since several of the operations contained in the method can potentially throw an IOException, we will throw such exceptions to the calling method.
public String sendHttpGet( String url ) throws IOException {
HttpConnection hcon = null;
DataInputStream dis = null;
StringBuffer message = "";
try {
The first step is to open a connection to the
server using the Connector class, the crux of the GCF. We will then cast
this connection to the specific type needed, in this case the HttpConnection type.
hcon = ( HttpConnection ) Connector.open( url );
Next, we obtain a DataInputStream on our HttpConnection, allowing us to read the server's response data, character by character.
dis = new DataInputStream( hcon.openInputStream() );
Using the read() method of DataInputStream, each character of the server's response is collected and appended to the StringBuffer object.
int ch;
while ( ( ch = dis.read() ) != -1 ) {
message = message.append( ( char ) ch );
}
Finally (no pun intended), the connection objects
are cleaned up to preserve resources, and the message is returned from
the method.
} finally {
if ( hcon != null ) hcon.close();
if ( dis != null ) dis.close();
}//end try/finally
return message.toString();
}//end sendGetRequest( String )
How to Send an HTTP POST Request
As you might imagine, sending an HTTP POST request is a very similar process to sending a GET request. We'll modify one of the existing commands, add a handful of new commands, and add one additional object from the Generic Connection Framework and one additional StringBuffer object to push the content in the POST body to the server. The rest of the commands will remain unchanged.
Copy the sendHttpGet() method we just created, paste it into the same class file, and rename it to sendHttpPost(). Now we will modify this new method to send an HTTP POST request to the server.As you might imagine, sending an HTTP POST request is a very similar process to sending a GET request. We'll modify one of the existing commands, add a handful of new commands, and add one additional object from the Generic Connection Framework and one additional StringBuffer object to push the content in the POST body to the server. The rest of the commands will remain unchanged.
Add two new variable declarations to the top of the method. Declare a variable of type DataOutputStream and declare another variable of type String. We will use the DataOutputStream object to push our POST request body (contained in the String) to the server.
DataOutputStream dos = null;
String requestBody = null;
hcon = ( HttpConnection ) Connector.open( url, Connector.READ_WRITE );
hcon.setRequestMethod( HttpConnection.POST );
Obtain a DataOutputStream object for the existing HTTP connection.
dos = hc.openDataOutputStream();
byte[] byteRequest = requestBody.getBytes();
for( int i = 0; i < byteRequest.length; i++ ) {
dos.writeByte(byteRequest[i]);
}//end for( int i = 0; i < byteRequest.length; i++ )
dos.flush(); //Including this line may produce undesiredresults on certain devices
| Editor's Note: Thanks to DevX reader Marc Palmer for technical assistance. |
} finally {
if ( hc != null ) hc.close();
if ( dis != null ) dis.close();
if ( dos != null ) dis.close();
}//end try/finally
DevX Java Pro Kyle Gabhart is a consultant for Objective Solutions,
a high-end engineering services company focusing on the medical,
semiconductor, and telecommunications domains. He is an Associate Member
of the Worldwide Institute of Software Architects (WWISA),
an organization dedicated to promoting and enriching software
architecture as a profession. Kyle is a co-author of "Professional Java
and XML".
