J2ME Tech Tips: October 15, 2001

// Defines a class that prompts the user
// for a numeric password.

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

public class PasswordPrompter
          extends TextBox
          implements CommandListener {

    private Display     display;
    private Displayable next;
    private int         pin;

    // Constructor with a default title

    public PasswordPrompter( int pin,
                             int maxchars,
                             Display display,
                             Displayable next ){
        this( defaultTitle, pin, maxchars,
              display, next );
    }

    // Constructor with a specific title

    public PasswordPrompter( String title,
                             int pin,
                             int maxchars,
                             Display display,
                             Displayable next ){
        super( title, "", maxchars,
          TextField.NUMERIC | 
            TextField.PASSWORD );

        addCommand( okCommand );
        setCommandListener( this );

        this.display = display;
        this.next    = next;
        this.pin     = pin;

        display.setCurrent( this );
    }

    // Responds to the one-and-only command event
    // by checking the entered password against
    // the pin. If it's OK, the user is 
    // "forwarded" to the next displayable, 
    // otherwise an alert is displayed.

    public void commandAction( Command c,
      Displayable d ){
        String pinStr = getString();

        try {
            if( Integer.parseInt( pinStr ) 
               == pin ){
                display.setCurrent( next );
                return;
            }
        }
        catch( NumberFormatException e ){
        }

        Alert alert = new Alert( "Error!",
          "Invalid password", null,
            AlertType.ERROR );

        setString( "" );
        display.setCurrent( alert, this );
    }

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

    private static final String defaultTitle =
      "Enter Password";
}

// A MIDlet that demonstrates the use of the
// password prompter.

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

public class PasswordTester extends MIDlet
  implements CommandListener {

    private Display display;
    private Command exitCommand
      = new Command( "Exit", Command.EXIT, 1 );

    public PasswordTester(){
    }

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

    protected void pauseApp(){
    }

    protected void startApp()
      throws MIDletStateChangeException {
        if( display == null ){ // 
          first time called... initMIDlet();
        }
    }

    private void initMIDlet(){
        display = Display.getDisplay( this );

        // First time through, ask for 
        // the password.

        new PasswordPrompter( 1234, 4, display,
          new TrivialForm() );
    }

    public void exitMIDlet(){
      notifyDestroyed();
    }

    public void commandAction( 
                   Command c, Displayable d ){
        exitMIDlet();
    }

    // A trivial UI screen

    class TrivialForm extends Form {
        TrivialForm(){
            super( "MainApp" );
            addCommand( exitCommand );
            setCommandListener( 
              PasswordTester.this );
        }
    }
}

    MIDlet midlet = ....;
    int    password;
    
    try {
        String p = midlet.getAppProperty( 
          "Password" );
        password = Integer.parseInt( p );
    }
    catch( NumberFormatException e ){
    }

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

/**
 * A MIDP application that fetches and displays  
 * an arbitrary image from the Web using the  
 * ImageAdapter servlet. This class depends on  
 * HttpConnectionHelper, described in an earlier 
 * J2ME Tech Tip.
 */

public class ImageClient extends MIDlet
              implements CommandListener {

    // Adjust this URL appropriately for 
    // the adapter

    private static String adapterURL =
      "http://localhost:8080/servlet/ImageAdapter";

    // A default image to display...

    private static String defaultURL =
   "http://java.sun.com/products/images/duke_j2ee.gif";

    private Display display;
    private Command exitCommand = new 
      Command( "Exit", Command.EXIT, 1 );
    private Command okCommand   = new 
      Command( "OK", Command.OK, 1 );
    private Command sendCommand = new 
      Command( "Get", Command.OK, 1 );
    private TextBox entryForm;
    private int     screenHeight;
    private int     screenWidth;
    private int     numColors;

    public ImageClient(){
    }

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

    protected void pauseApp(){
    }

    protected void startApp()
           throws MIDletStateChangeException {
        if( display == null ){ // first time 
          called... initMIDlet();
        }
    }

    // First we display the dummy canvas so 
    // we can get information about the display

    private void initMIDlet(){
        display = Display.getDisplay( this );
        entryForm = new EntryForm();
        display.setCurrent( new DummyCanvas() );
    }

    public void exitMIDlet(){
        notifyDestroyed();
    }

    public void commandAction( 
                   Command c, Displayable d ){
        if( c == sendCommand ){
            StatusForm f =
               new StatusForm( 
                 entryForm.getString() );
            display.setCurrent( f );
            f.start();
        } else if( c == okCommand ){
            display.setCurrent( entryForm );
        } else {
            exitMIDlet();
        }
    }

    // A dummy canvas to get the size of 
    // the screen

    class DummyCanvas extends Canvas {
        protected void paint( Graphics g ){
            screenHeight = getHeight();
            screenWidth  = getWidth();
            numColors    = display.numColors();

            // Go directly to the main screen

            display.setCurrent( entryForm );
        }
    }

    // The text entry form...

    class EntryForm extends TextBox {
        EntryForm(){
            super( "Enter a URL", defaultURL, 
              80, 0 );
            addCommand( exitCommand );
            addCommand( sendCommand );
            setCommandListener( 
              ImageClient.this );
        }
    }

    // Show the image...

    class ShowImage extends Canvas {
      ShowImage( byte[] imageData ){
        image = Image.createImage( imageData,
          imageData.length );
            display.setCurrent( this );
            addCommand( okCommand );
            setCommandListener( ImageClient.this );
        }

        protected void paint( Graphics g ){
            g.drawImage( image, 0, 0,
                         g.TOP | g.LEFT );
        }

        private Image image;
    }

    // A status for for displaying messages  
    // as the data is sent...

    class StatusForm extends Form
      implements Runnable,
        HttpConnectionHelper.Callback {
        StatusForm( String url ){
            super( "Status" );

            try {
                ByteArrayOutputStream bout =
                  new ByteArrayOutputStream();
                DataOutputStream      dout =
                  new DataOutputStream( bout );

                // Write info about the image and the
                // display settings for this device

                dout.writeUTF( "url" );
                dout.writeUTF( url );

                writeInt( 
                       dout, "minwidth", 
                         screenWidth );
                writeInt( 
                       dout, "maxwidth", 
                         screenWidth );
                writeInt( 
                     dout, "minheight", 
                       screenHeight );
                writeInt( 
                     dout, "maxheight", 
                       screenHeight );
                writeInt( 
                           dout, "colors", 
                             numColors );
                writeInt( dout, "reduce", 1 );
                writeInt( dout, "dither", 1 );

                dout.writeUTF( "" );

                data = bout.toByteArray();
                dout.close();
            }
            catch( IOException e ){
                // should handle this....
            }
        }

        void writeInt( DataOutputStream dout, 
          String key, int value ) 
            throws IOException {
            dout.writeUTF( key );
            dout.writeUTF( Integer.toString( 
              value ) );
        }

        // Updates the display.

        void display( String text ){
            if( message == null ){
                message = new StringItem( 
                  null, text );
                append( message );
            } else {
                message.setText( text );
            }
        }

        // We're done.

        void done( String msg ){
            display( msg != null ? msg : 
              "Done." );
            addCommand( okCommand );
            setCommandListener( 
              ImageClient.this );
        }

        // Callback for making the HTTP connection.

        public void prepareRequest( String 
          originalURL, HttpConnection conn ) 
            throws IOException
        {
          conn.setRequestMethod( HttpConnection.POST );
            conn.setRequestProperty( "User-Agent",
           "Profile/MIDP-1.0 
             Configuration/CLDC-1.0" );
           conn.setRequestProperty( 
             "Content-Language",
               "en-US" );
           conn.setRequestProperty( 
             "Accept", "image/png" );
            conn.setRequestProperty( 
              "Connection", "close" );
            conn.setRequestProperty( 
              "Content-Length", Integer.toString( 
                data.length ) );

            OutputStream os = 
              conn.openOutputStream();
            os.write( data );
            os.close();
        }

        // Do the connection on a separate  
        // thread to keep the UI responsive...

        public void run(){
            HttpConnection conn = null;

            display( 
              "Obtaining HttpConnection 
                object..." );

            try {
                conn =
                  HttpConnectionHelper.connect( 
                    adapterURL,
                      this );

                display( 
                  "Connecting to the server..." );
                int rc = conn.getResponseCode();

                if( rc == HttpConnection.HTTP_OK ){
                  try {
                    DataInputStream din = 
                      new DataInputStream(
                        conn.openInputStream() );
             data = new byte[ (int) 
               conn.getLength() ];
                        din.readFully( data );
                        din.close();
                    }
                    catch( IOException e ){
                    }

                    done( "Image received" );
                    new ShowImage( data );
                } else {
                    done( "Unexpected return 
                      code: " + rc );
                }

                conn.close();
            }
            catch( IOException e ){
                done( "Exception " + e +
                      " trying to connect." );
            }
        }

        // Starts the upload in the background...

        void start(){
            display( "Starting..." );

            Thread t = new Thread( this );
            try {
                t.start();
            }
            catch( Exception e ){
                done( "Exception " + e +
                  " trying to start thread." );
            }
        }

        private StringItem message;
        private byte[]     data;
    }
}