The J2ME Wireless Toolkit WMA Console

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

// A WMA test application that opens a server
// connection on the specified port and waits
// for text messages to arrive. It then sends
// the reversed text message back to the client.

public class WMATest extends MIDlet
implements CommandListener,
MessageReceiver,
Runnable {

// The application data

private Display                 display;
private String                  port = "1000";
private Form                    setupForm;
private TextField               portTF;
private Form                    statusForm;
private MessageConnection       currentConn;
private MessageReceiverListener messageListener;

// Our commands

public static final Command exitCommand =
new Command( "Exit",
Command.EXIT, 1 );

public static final Command okCommand =
new Command( "OK",
Command.OK, 1 );

public static final Command resetCommand =
new Command( "Reset",
Command.SCREEN, 1 );

public WMATest(){
}

// Adds a message to the status form.

public void addStatus( String msg ){
statusForm.append( msg );
}

// Handles the screen events.

public void commandAction( Command c,
Displayable d ){
if( c == exitCommand ){
exitMIDlet();
} else if( c == okCommand ){
port = portTF.getString();
new Thread( this ).start();
} else if( c == resetCommand ){
closeConnection();
getDisplay().setCurrent( setupForm );
}
}

// Clears the status form.

private void clearStatus(){
int s;

while( ( s = statusForm.size() ) > 0 ){
statusForm.delete( s-1 );
}

addStatus( "Waiting for messages on port " +
port );
}

// Closes the current server connection, if any.

private void closeConnection(){
if( currentConn != null ){
try {
currentConn.close();
}
catch( IOException e ){
}

currentConn = null;
}
}

// Called by system to destroy the MIDlet.

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

// General cleanup.

public void exitMIDlet(){
if( messageListener != null ){
messageListener.stop();
messageListener = null;
}

closeConnection();
notifyDestroyed();
}

// Returns the MIDlet's display object.

public Display getDisplay(){ return display; }

// Handles errors simply using an alert to
// display the exception.

private void handleError( Throwable e, Displayable next ){
Alert a = new Alert( "Exception",
e.toString(),
null,
AlertType.ERROR );
a.setTimeout( Alert.FOREVER );
getDisplay().setCurrent( a, next );
}

// Initializes the MIDlet by creating the two forms
// as well as the message listener.

protected void initMIDlet(){
messageListener = new MessageReceiverListener( this );

setupForm = new Form( "Receiver Setup" );
setupForm.addCommand( exitCommand );
setupForm.addCommand( okCommand );
setupForm.setCommandListener( this );

portTF = new TextField( "Port number:", port,
5, TextField.NUMERIC );

setupForm.append( portTF );

statusForm = new Form( "Status" );
statusForm.addCommand( resetCommand );
statusForm.addCommand( exitCommand );
statusForm.setCommandListener( this );

getDisplay().setCurrent( setupForm );
}

// Implements the MessageReceiver interface. Called
// when an error occurs while receiving a message.

public void messageError( MessageConnection conn,
Throwable excep ){
handleError( excep, statusForm );
}

// Implements the MessageReceiver interface. Called
// when a message has been successfully received.

public void messageReceived( MessageConnection conn,
Message msg ){
if( messageListener == null ) return;
if( conn != currentConn ) return;

if( msg instanceof BinaryMessage ){
addStatus( "Ignoring binary message" );
return;
}

TextMessage tmsg = (TextMessage) msg;
String text = tmsg.getPayloadText();
String addr = tmsg.getAddress();

addStatus( "Received " + text );

if( addr == null ){
addStatus( "No return address, ignoring" );
return;
}

if( text != null ){
StringBuffer b =
new StringBuffer( text.length() );
b.append( text );
b.reverse();
tmsg.setPayloadText( b.toString() );

addStatus( "Sending reverse to " + addr );

try {
conn.send( tmsg );
}
catch( IOException e ){
handleError( e, statusForm );
}
}
}

// Called by the system to pause the MIDlet.

protected void pauseApp(){
}

// Creates the server connection. This needs to run in
// a separate thread to avoid blocking the user interface,
// since the device may prompt the user to confirm
// that the application has permission to use wireless
// connectivity.

public void run(){
closeConnection();

String url = "sms://:" + port;

try {
// Create the connection and register it with
// the message listener.

currentConn = (MessageConnection)
Connector.open( url );
currentConn.setMessageListener( messageListener );

// Move to the status form.

getDisplay().setCurrent( statusForm );
clearStatus();
}
catch( IOException e ){
handleError( e, setupForm );
}
}

// Called by the system to activate the MIDlet.

protected void startApp()
throws MIDletStateChangeException {
if( display == null ){
display = Display.getDisplay( this );
initMIDlet();
}
}
}