Java 2 Micro Edition: Professional Developer's Guide

* This model can be used to define any tic-tac-toe game * of size n, where 3 <= n <= 6. To win you have to fill * a complete row. A better game would be to reduce the * number of cells you have to fill in order to win. * As it stands this game isn’t too challenging, but it’s * here mainly for demonstration purposes! */ public class TicTacToeModel { /** * The initial state of a cell. */ public static final int NO_PLAYER = 10; /** * A cell owned by player 1. */ public static final int PLAYER_1 = 1; /** * A cell owned by player 2. */ public static final int PLAYER_2 = -1; /** * An error value. */ public static final int ERROR = 0; /** * Constructs a model for a tic-tac-toe game. */ public TicTacToeModel(){ } /** * Adds a listener to this model. The listener * is notified whenever changes occur. * * @param listener the listener to register.

67957_Wiley_Giguere_AppA

10/17/2000 5:18 PM

Page 245

Tic-Tac-Toe Source Code

245

*/ public void addListener( TicTacToeModelListener listener ){ if( listener == null ) return; listeners.addElement( listener ); if( gameStarted ){ listener.gameStarted( this ); } } /** * Calculates the indices of each row and stores the * information in the rowIndices array. */ private void calculateIndices(){ int numIndices = cellsPerRow * numTotals; if( rowIndices == null || rowIndices.length < numIndices ){ rowIndices = new int[ numIndices ]; } // Now initialize each set of indices. // horizontal indices.

Start with the

int i, j, k; int index = 0; for( i = 0; i < numCells; ++i ){ rowIndices[index++] = i; } // Then the vertical indices: 0, (n+1), 2*(n+1), etc. for( i = 0; i < cellsPerRow; ++i ){ for( j = 0, k = 0; j < cellsPerRow; ++j, k += cellsPerRow ){ rowIndices[index++] = i + k; } } // Finally the two diagonals for( i = 0; i < cellsPerRow; ++i ){ rowIndices[index++] = i * ( cellsPerRow + 1 ); } for( i = 1; i <= cellsPerRow; ++i ){ rowIndices[index++] = i * ( cellsPerRow - 1 ); } }

67957_Wiley_Giguere_AppA

246

10/17/2000 5:18 PM

Page 246

APPENDIX A /** * Calculates the totals of each row. */ private void calculateTotals(){ int index = 0; for( int i = 0; i < numTotals; ++i ){ int total = 0; for( int j = 0; j < cellsPerRow; ++j ){ total += cells[ rowIndices[index++] ]; } totals[i] = total; } } /** * Fills a byte array with the states of the cells. * * @param outStates the byte array. If the array is not long * enough, nothing happens and false * is returned. * * @return true if the states were copied into the * given array. */ public boolean fillCellStates( byte[] outStates ){ if( outStates == null || outStates.length < numCells ) return false; System.arraycopy( cells, 0, outStates, 0, numCells ); return true; } /** * Fills an int array with the row totals. * * @param rowTotals the int array. If the array is not long * enough, nothing happens and false * is returned. * * @return true if the totals were copied into the * given array. */ public boolean fillTotals( int[] rowTotals ){ if( rowTotals == null || rowTotals.length < numTotals ) return false; System.arraycopy( totals, 0, rowTotals, 0, numTotals ); return true; }

67957_Wiley_Giguere_AppA

10/17/2000 5:18 PM

Page 247

Tic-Tac-Toe Source Code /** * Returns the number of cells in this game. * * @return the number of cells. */ public int getCellCount(){ return numCells; } /** * Returns the state of a particular cell. * * @param index the cell index. * * @return the state of the cell, either NO_PLAYER, PLAYER_1 * or PLAYER_2. Errors return ERROR. */ public int getCellState( int index ){ if( index < 0 || index >= numCells ) return ERROR; return cells[index]; } /** * Returns the state of a particular cell. * * @param row the row index of the cell. * @param col the column index of the cell. * * @return the state of the cell, either NO_PLAYER, PLAYER_1 * or PLAYER_2. Errors return ERROR. */ public int getCellState( int row, int col ){ return getCellState( row * cellsPerRow + col ); } /** * Returns the states of all the cells. A new array * is created and returned to prevent cheating. * * @return an array of cell states. */ public byte[] getCellStates(){ byte[] arr = new byte[ numCells ]; fillCellStates( arr ); return arr; }

247

67957_Wiley_Giguere_AppA

248

10/17/2000 5:18 PM

Page 248

APPENDIX A /** * Returns the indices for the given row. * * @param index the row index. * @param out the array in which to store the indices. */ public boolean getRowIndices( int index, int[] out ){ if( index < 0 || index >= numTotals ) return false; System.arraycopy( rowIndices, index * cellsPerRow, out, 0, cellsPerRow ); return true; } /** * Returns the size of the game. * * @return the size of the game, the number of cells in * a single row. */ public int getSize(){ return cellsPerRow; } /** * Returns the totals for all the rows in the game. * A new array is created and returned to prevent cheating. * * @return an array of row totals. */ public int[] getTotals(){ int[] t = new int[ numTotals ]; fillTotals( t ); return t; } /** * Returns the winner of the game that just ended. * * @return the winner of the game, either NO_PLAYER, * PLAYER_1 or PLAYER_2. */ public int getWinner(){ for( int i = 0; i < numTotals; ++i ){ int total = totals[i]; if( total == player1Wins ){ return PLAYER_1; } else if( total == player2Wins ){

67957_Wiley_Giguere_AppA

10/17/2000 5:18 PM

Page 249

Tic-Tac-Toe Source Code

249

return PLAYER_2; } } return NO_PLAYER; } /** * Returns the cell indices of the winning row. * * @param out the array in which to store the indices. * The array must be large enough, otherwise * an error occurs. * * @return true if one of the players is a winner * and the winning indices are stored in the given * array. */ public boolean getWinningCells( int[] out ){ for( int i = 0; i < numTotals; ++i ){ int total = totals[i]; if( total == player1Wins || total == player2Wins ){ System.arraycopy( rowIndices, i * cellsPerRow, out, 0, cellsPerRow ); return true; } } return false; } /** * Returns whether or not the game is over. * * @return true if the game is over, either because * someone has one or else there’s a tie. */ public boolean isGameOver(){ if( !gameStarted ) return true; if( getWinner() != NO_PLAYER ) return true; for( int i = 0; i < numCells; ++i ){ if( cells[i] == NO_PLAYER ) return false; } return true; } /** * Returns whether or not a game has been started. * * @return true if a game has been started.

67957_Wiley_Giguere_AppA

250

10/17/2000 5:18 PM

Page 250

APPENDIX A */ public boolean isGameStarted(){ return gameStarted; } /** * Starts a new game of size 3. If a game is * currently under way it notifies any listeners that the existing game * is finishing before notifying them about the new game. */ public void newGame(){ newGame( 3 ); } /** * Starts a new game of the given size. If a game is * currently under way it notifies any listeners that the existing game * is finishing before notifying them about the new game. * * @param size the size of the game, the number of * cells on one side of a game square. */ public void newGame( int size ){ // First some sanity checking. // too small or too big.

We don’t want the board

if( size < 3 || size > 6 ){ size = 3; } // Tell anyone waiting that the game is now over. endGame(); // Figure out the dimensions we need to worry about. // The number of cells is n**2, the number of rows is 2*n+2. cellsPerRow = size; numCells = size * size; numTotals = 2 * size + 2; player1Wins = size * PLAYER_1; player2Wins = size * PLAYER_2; // Initialize the cells and totals.

67957_Wiley_Giguere_AppA

10/17/2000 5:18 PM

Page 251

Tic-Tac-Toe Source Code

251

if( cells == null || cells.length < numCells ){ cells = new byte[ numCells ]; } int i; for( i = 0; i < numCells; ++i ){ cells[i] = NO_PLAYER; } if( totals == null || totals.length < numTotals ){ totals = new int[ numTotals ]; } int initial = cellsPerRow * NO_PLAYER; for( i = 0; i < numTotals; ++i ){ totals[i] = NO_PLAYER; } calculateIndices(); // Tell everyone we’re ready and that a new game // has started. gameStarted = true; notifyGameStarted(); } /** * Notify listeners that the game is over. */ private void notifyGameOver(){ Enumeration e = listeners.elements(); while( e.hasMoreElements() ){ TicTacToeModelListener l = (TicTacToeModelListener) e.nextElement(); l.gameOver( this ); } } /** * Notify listeners that the game has started. */ private void notifyGameStarted(){ Enumeration e = listeners.elements(); while( e.hasMoreElements() ){ TicTacToeModelListener l = (TicTacToeModelListener) e.nextElement();

67957_Wiley_Giguere_AppA

252

10/17/2000 5:18 PM

Page 252

APPENDIX A l.gameStarted( this ); } } /** * Notify listeners that the game has been updated. */ private void notifyGameUpdated( int cell, int value ){ Enumeration e = listeners.elements(); while( e.hasMoreElements() ){ TicTacToeModelListener l = (TicTacToeModelListener) e.nextElement(); l.gameUpdated( this, cell, value ); } } /** * Quits an existing game, notifying any listeners * that the game is over. */ public void endGame(){ if( gameStarted ){ gameStarted = false; notifyGameOver(); } } /** * Removes a listener from this model. * * @param listener the listener to remove. */ public void removeListener( TicTacToeModelListener listener ){ listeners.removeElement( listener ); } /** * Sets the value of a cell. * * @param index the cell index. * @param value the cell value. */ public void setCellState( int index, int value ){ if( !gameStarted || index < 0 || index >= numCells ) return; if( cells[index] != NO_PLAYER ) return; cells[index] = (byte) value;

67957_Wiley_Giguere_AppA

10/17/2000 5:18 PM

Page 253

Tic-Tac-Toe Source Code calculateTotals(); notifyGameUpdated( index, value ); if( isGameOver() ){ endGame(); } } /** * Sets the value of a cell by row and column. * * @param row the row index of the cell. * @param col the column index of the cell. * @param value the cell value. */ public void setCellState( int row, int col, int value ){ setCellState( row * cellsPerRow + col, value ); } /** * The cells used by the game. */ private byte[] cells; /** * The number of cells per row. */ private int cellsPerRow; /** * Whether a game is active or not. */ private boolean gameStarted; /** * The vector of listeners. */ private Vector listeners = new Vector(); /** * The number of cells in the game. */ private int numCells; /**

253

67957_Wiley_Giguere_AppA

254

10/17/2000 5:18 PM

Page 254

APPENDIX A * The number of rows in the game. */ private int numTotals; /** * Player 1 is a winner. */ private int player1Wins; /** * Player 2 is a winner. */ private int player2Wins; /** * The indices for each row. */ private int[] rowIndices; /** * The running totals to determine who is winning. */ private int[] totals; }

TicTacToeModelListener The model is accompanied by a listener interface so that interested parties can receive notifications about games that are in progress: package com.ericgiguere.j2mebook.models; /** * Defines an event listener for the TicTacToeModel. * Classes that implement this interface are notified * of the game status held by a model. */ public interface TicTacToeModelListener { /** * A game has just finished. * who won.

The listener can ask the model

67957_Wiley_Giguere_AppA

10/17/2000 5:18 PM

Page 255

Tic-Tac-Toe Source Code

255

* * @param model the model triggering the event. */ void gameOver( TicTacToeModel model ); /** * A game has started. * * @param model the model triggering the event. */ void gameStarted( TicTacToeModel model ); /** * A cell * * @param * @param * @param */

in the game has been updated. model the model triggering the event. cell the index of the updated cell. value the new value of the cell.

void gameUpdated( TicTacToeModel model, int cell, int value ); }

TicTacToePlayer Finally, we define a listener that behaves like a player, selecting cells in response to the user’s own selections: package com.ericgiguere.j2mebook.models; import java.util.Random; /** * Defines an automatic tic-tac-toe player. This player works * by implementing the TicTacToeModelListener interface and * receiving notifications from a TicTacToeModel. When the * opponent sets a cell, the player sets a cell in response. */ public class TicTacToePlayer implements TicTacToeModelListener { /** * Constructs an automatic tic-tac-toe player. * * @param which which player number, either PLAYER_1 or PLAYER_2.

67957_Wiley_Giguere_AppA

256

10/17/2000 5:18 PM

Page 256

APPENDIX A */ public TicTacToePlayer( int which ){ whichPlayer = which; } /** * Fills the first empty cell in a row with the value * for this player. * * @param model the game model. * @param row the row index. */ private void fillRow( TicTacToeModel model, int row ){ model.getRowIndices( row, indices ); for( int j = 0; j < indices.length; ++j ){ if( model.getCellState( indices[j] ) == TicTacToeModel.NO_PLAYER ){ model.setCellState( indices[j], whichPlayer ); break; } } } /** * Called when a game is started, prepares some values based * on the current settings of the model. * * @param model the game model. */ public void gameStarted( TicTacToeModel model ){ totals = model.getTotals(); canWinValue = ( 2 * whichPlayer ) + TicTacToeModel.NO_PLAYER; dangerValue = ( -2 * whichPlayer ) + TicTacToeModel.NO_PLAYER; indices = new int[ model.getSize() ]; }

/** * Called whenever a cell is updated while a game is in progress. * The automatic player uses this notification to track the * opponent’s moves and to prepare a move in response. * * @param model the game model. * @param index the cell index. * @param value the cell’s new value. */ public void gameUpdated( TicTacToeModel model, int index, int value

67957_Wiley_Giguere_AppA

10/17/2000 5:18 PM

Page 257

Tic-Tac-Toe Source Code

257

){ // Ignore our own moves... if( value == whichPlayer ) return; // Get the updated totals and see if we can win by filing // in a row. Otherwise see if the opposing player is about // to win and fill in the appropriate row... model.fillTotals( totals ); int i; int n = totals.length; for( i = 0; i < n; ++i ){ if( totals[i] == canWinValue ){ fillRow( model, i ); return; } } for( i = 0; i < n; ++i ){ if( totals[i] == dangerValue ){ fillRow( model, i ); return; } } // No danger values, so choose a cell at random... int max = model.getCellCount(); while( !model.isGameOver() ){ int cell = ( generator.nextInt() % max ); if( model.getCellState( cell ) == TicTacToeModel.NO_PLAYER ){ model.setCellState( cell, whichPlayer ); return; } } } /** * Called when the game is over. * * @param model the game model. */

Clears out some values.

public void gameOver( TicTacToeModel model ){ totals = null; indices = null;

67957_Wiley_Giguere_AppA

258

10/17/2000 5:18 PM

Page 258

APPENDIX A } private private private private private private

int int[] int[] int int Random

whichPlayer; totals; indices; canWinValue; dangerValue; generator = new Random();

}

Palm-Specific Code The Palm version of tic-tac-toe defines just a single class in addition to the common ones we just listed. We discussed this class in Chapter 8.

TicTacToe The class is a spotlet that draws the tic-tac-toe game board and traps user input: // Copyright 2000 by Eric Giguere. // From Java 2 Micro Edition: Professional Developer’s Guide, // published by John Wiley & Sons. package com.ericgiguere.j2mebook.palm; import com.ericgiguere.j2mebook.models.*; import com.sun.kjava.*; /** * A simple tic-tac-toe game for the Palm port of the CLDC. * This game uses the unsupported com.sun.kjava classes * to do the drawing and to get user input. */ public class TicTacToe extends Spotlet implements DialogOwner, TicTacToeModelListener { /** * Starts our game. */ public static void main( String[] args ){ new TicTacToe(); }

67957_Wiley_Giguere_AppA

10/17/2000 5:18 PM

Page 259

Tic-Tac-Toe Source Code

259

/** * Constructs a tic-tac-toe game. */ public TicTacToe() { register( NO_EVENT_OPTIONS ); Graphics.getGraphics().clearScreen(); model = new TicTacToeModel(); model.addListener( this ); model.addListener( new TicTacToePlayer( TicTacToeModel.PLAYER_2 ) ); model.newGame(); } /** * Called when a dialog is dismissed. We re-register the spotlet * and start a new game. * * @param title the title of the dialog. */ public void dialogDismissed( String title ){ register( NO_EVENT_OPTIONS ); model.newGame(); } /** * Draws the tic-tac-toe grid. * * @param g the Graphics object. */ public void drawGrid( Graphics g ){ int i, x, y; x = cellWidth; y = cellHeight; for( i = 0; i < cellsPerRow - 1; ++i ){ g.drawLine( x, 0, x, screenHeight, g.PLAIN ); g.drawLine( 0, y, screenWidth, y, g.PLAIN ); x += cellWidth; y += cellHeight; } } /**

67957_Wiley_Giguere_AppA

260

10/17/2000 5:18 PM

Page 260

APPENDIX A * Draws each cell. * * @param g the Graphics object. */ public void drawPlayers( Graphics g ){ for( int i = 0; i < numCells; ++i ){ cells[i].paint( g ); } } /** * Called when the game is over. * with the result of the game. * * @param model the game model. */

Displays a dialog

public void gameOver( TicTacToeModel model ){ String text; switch( model.getWinner() ){ case TicTacToeModel.PLAYER_1: text = "Player 1 wins!"; break; case TicTacToeModel.PLAYER_2: text = "Player 2 wins!"; break; default: text = "A tie!"; break; } Dialog d = new Dialog( this, "Game Over", text, "OK" ); d.showDialog(); } /** * Called * * @param * @param * @param */

when a cell in the game is updated. model the game model. index the cell index. value the cell’s new value.

public void gameUpdated( TicTacToeModel model, int index, int value ){ Cell cell = cells[index]; cell.state = value; paint(); }

67957_Wiley_Giguere_AppA

10/17/2000 5:18 PM

Page 261

Tic-Tac-Toe Source Code /** * Called when a game is started. Clears the screen, * calculates the dimensions of the cells and then paints * the grid. * * @param model the game model. */ public void gameStarted( TicTacToeModel model ){ Graphics.getGraphics().clearScreen(); cellsPerRow = model.getSize(); numCells = cellsPerRow * cellsPerRow; cellHeight cellWidth

= screenHeight / cellsPerRow; = screenWidth / cellsPerRow;

cells = new Cell[ numCells ]; int i, j, y; for( i = 0, y = 0; i < numCells; i += cellsPerRow ){ for( j = 0; j < cellsPerRow; ++j ){ cells[i+j] = new Cell( cellWidth * j + cellsPerRow, y + cellsPerRow ); } y += cellHeight; } this.model = model; paint(); } /** * General game paint routine. * cells. */

Draws the grid and then the

public void paint(){ Graphics g = Graphics.getGraphics(); if( model != null ){ drawGrid( g ); drawPlayers( g ); } } /** * Handles pen presses, checking to see if the user * has pressed over an empty cell. *

261

67957_Wiley_Giguere_AppA

262

10/17/2000 5:18 PM

Page 262

APPENDIX A * @param x the X coordinate of the pen press. * @parma y the Y coordinate of the pen press. */ public void penDown( int x, int y ){ if( model != null && model.isGameStarted() ){ for( int i = 0; i < numCells; ++i ){ if( cells[i].contains( x, y ) ){ model.setCellState( i, TicTacToeModel.PLAYER_1 ); return; } } } } private private private private private private private private

int int int int int int TicTacToeModel Cell[]

cellsPerRow; numCells; cellHeight; cellWidth; screenHeight = 160; screenWidth = 160; model; cells;

//--------------------------------------------------------/** * Defines a simple inner class for holding the state and * the location of each cell. Since it’s an inner class * each instance has access to the private data of its * parent class, i.e. the cellHeight and cellWidth values. */ private class Cell { int state; int x; int y; /** * Constructs an empty cell at the given location. * * @param x the X value. * @param y the Y value. */ public Cell( int x, int y ){ state = TicTacToeModel.NO_PLAYER; this.x = x; this.y = y; } /**

67957_Wiley_Giguere_AppA

10/17/2000 5:18 PM

Page 263

Tic-Tac-Toe Source Code

263

* Determines whether or not the given point is in the * cell. * * @param px the X value. * @param py the Y value. * * @return true if the point is within the cell. */ public boolean contains( int px, int py ){ return( px >= x && px <= x + cellWidth && py >= y && py <= y + cellHeight ); } /** * Paints a cell according to its state. * * @param g the graphics object. */ public void paint( Graphics g ){ if( state == TicTacToeModel.PLAYER_1 ){ g.drawLine( x, y, x+cellWidth-6, y+cellHeight-6, g.PLAIN ); g.drawLine( x+cellWidth-6, y, x, y+cellHeight-6, g.PLAIN ); } else if( state == TicTacToeModel.PLAYER_2 ){ g.drawBorder( x, y, cellWidth-6, cellHeight-6, g.PLAIN, g.RAISED ); } } } }

MIDP-Specific Code A MIDP version of the tic-tac-toe game is discussed in Chapter 9. It defines two classes in addition to the common code already listed.

TicTacToe This class defines the entry point for the MIDlet: package com.ericgiguere.j2mebook.midp; import com.ericgiguere.j2mebook.models.*;

67957_Wiley_Giguere_AppA

264

10/17/2000 5:18 PM

Page 264

APPENDIX A import javax.microedition.midlet.*; import javax.microedition.lcdui.*; /** * Defines a tic-tac-toe MIDlet that uses the TicTacToeModel * class to control the game logic. The actual user interface * is defined by TicTacToeUI. */ public class TicTacToe extends MIDlet implements CommandListener { private private private private

Display Command TicTacToeUI TicTacToeModel

display; exitCommand; gameScreen; model;

/** * Constructs the MIDlet. */ public TicTacToe() { display = Display.getDisplay( this ); exitCommand = new Command( "Exit", Command.SCREEN, 2 ); model = new TicTacToeModel(); } /** * Called whenever a Command is triggered. * * @param c the Command that was triggered. * @param s the display object active when it was triggered. */ public void commandAction( Command c, Displayable s ) { if( c == exitCommand ){ destroyApp( false ); notifyDestroyed(); } } /** * Called when the MIDlet is asked to destroy itself. * * @param unconditional if true the MIDlet must * quit immediately. */ public void destroyApp( boolean unconditional ) { model.endGame(); }

67957_Wiley_Giguere_AppA

10/17/2000 5:18 PM

Page 265

Tic-Tac-Toe Source Code

265

/** * Called when the MIDlet starts. Creates the initial * screen and the attaches the appropriate listeners. */ public void startApp() { gameScreen = new TicTacToeUI( this ); model.addListener( gameScreen ); model.addListener( new TicTacToePlayer( TicTacToeModel.PLAYER_2 ) ); gameScreen.addCommand( exitCommand ); gameScreen.setListener( this ); display.setCurrent( gameScreen ); model.newGame(); } /** * Called when the MIDlet pauses. */ public void pauseApp() { } }

TicTacToeUI The user-interface code for the MIDP tic-tac-toe game is found in this class: package com.ericgiguere.j2mebook.midp; import com.ericgiguere.j2mebook.models.*; import javax.microedition.midlet.*; import javax.microedition.lcdui.*; /** * Displays a user interface for a tic-tac-toe game. The state * of the game is stored in a TicTacToeModel instance, so this * class is responsible for drawing the grid and the cell values * and interpreting user input. */ public class TicTacToeUI extends Canvas implements TicTacToeModelListener {

67957_Wiley_Giguere_AppA

266

10/17/2000 5:18 PM

Page 266

APPENDIX A /** * Constructs a tic-tac-toe user interface. * * @param main the main tic-tac-toe class. */ public TicTacToeUI( TicTacToe main ){ application = main; screenHeight = getHeight(); screenWidth = getWidth(); } /** * Draws the tic-tac-toe grid. * * @param g the graphics object. */ public void drawGrid( Graphics g ){ int i, x, y; x = cellWidth; y = cellHeight; for( i = 0; i < cellsPerRow - 1; ++i ){ g.drawLine( x, 0, x, screenHeight ); g.drawLine( 0, y, screenWidth, y ); x += cellWidth; y += cellHeight; } } /** * Draws each cell’s value. * * @param g the graphics object. */ public void drawPlayers( Graphics g ){ for( int i = 0; i < numCells; ++i ){ cells[i].paint( g ); } } /** * Called when the game is over. * with the result of the game. * * @param model the game model. */

Displays an alert

67957_Wiley_Giguere_AppA

10/17/2000 5:18 PM

Page 267

Tic-Tac-Toe Source Code

267

public void gameOver( TicTacToeModel model ){ repaint(); Alert alert = new Alert( "Game Over" ); String text; switch( model.getWinner() ){ case TicTacToeModel.PLAYER_1: text = "Player 1 wins!"; break; case TicTacToeModel.PLAYER_2: text = "Player 2 wins!"; break; default: text = "A tie!"; break; } alert.appendString( text ); alert.setTime( Alert.FOREVER ); Display.getDisplay( application ).setCurrent( alert, this ); } /** * Called * * @param * @param * @param */

when a cell in the game is updated. model the game model. index the cell index. value the cell’s new value.

public void gameUpdated( TicTacToeModel model, int index, int value ){ Cell cell = cells[index]; cell.state = value; repaint( cell.x, cell.y, cellWidth, cellHeight ); serviceRepaints(); } /** * Called when a game is started. * Calculates the dimensions of the cells and then paints * the grid. * * @param model the game model. */ public void gameStarted( TicTacToeModel model ){ cellsPerRow = model.getSize(); numCells = cellsPerRow * cellsPerRow;

67957_Wiley_Giguere_AppA

268

10/17/2000 5:18 PM

Page 268

APPENDIX A cellHeight cellWidth

= screenHeight / cellsPerRow; = screenWidth / cellsPerRow;

cells = new Cell[ numCells ]; int i, j, y; for( i = 0, y = 0; i < numCells; i += cellsPerRow ){ for( j = 0; j < cellsPerRow; ++j ){ cells[i+j] = new Cell( cellWidth * j + cellsPerRow, y + cellsPerRow ); } y += cellHeight; } this.model = model; repaint(); } /** * Handles key presses, selecting a cell if the cell is empty. * * @param keyCode the key that was pressed. */ public void keyPressed( int keyCode ){ if( model == null || !model.isGameStarted() ) return; int index; for( index = 0; index < keypad.length; ++index ){ if( keypad[index] == keyCode ) break; } if( index < keypad.length ){ model.setCellState( index, TicTacToeModel.PLAYER_1 ); } } /** * Paints the grid and the cells. * * @param g the graphics object. */ public void paint( Graphics g ){ if( model != null ){ drawGrid( g ); drawPlayers( g ); }

67957_Wiley_Giguere_AppA

10/17/2000 5:18 PM

Page 269

Tic-Tac-Toe Source Code

269

} /** * Called whenever the screen is shown. Starts a new * game if called after the alert is displayed. */ protected void showNotify(){ if( model != null && !model.isGameStarted() ){ model.newGame(); repaint(); } } private private private private private private private private private private

int int int int int int TicTacToeModel TicTacToe Cell[] static final int[]

cellsPerRow; numCells; cellHeight; cellWidth; screenHeight; screenWidth; model; application; cells; keypad = new int[]{ KEY_NUM1, KEY_NUM2, KEY_NUM3, KEY_NUM4, KEY_NUM5, KEY_NUM6, KEY_NUM7, KEY_NUM8, KEY_NUM9 };

//--------------------------------------------------------/** * Defines a simple inner class for holding the state and * the location of each cell. Since it’s an inner class * each instance has access to the private data of its * parent class, i.e. the cellHeight and cellWidth values. */ private class Cell { int state; int x; int y; /** * Constructs an empty cell at the given location. * * @param x the X value. * @param y the Y value. */ public Cell( int x, int y ){

67957_Wiley_Giguere_AppA

270

10/17/2000 5:18 PM

Page 270

APPENDIX A state = TicTacToeModel.NO_PLAYER; this.x = x; this.y = y; } /** * Determines whether or not the given point is in the * cell. * * @param px the X value. * @param py the Y value. * * @return true if the point is within the cell. */ public boolean contains( int px, int py ){ return( px >= x && px <= x + cellWidth && py >= y && py <= y + cellHeight ); } /** * Paints a cell according to its state. * * @param g the graphics object. */ public void paint( Graphics g ){ if( state == TicTacToeModel.PLAYER_1 ){ g.drawLine( x, y, x+cellWidth-6, y+cellHeight-6 ); g.drawLine( x+cellWidth-6, y, x, y+cellHeight-6 ); } else if( state == TicTacToeModel.PLAYER_2 ){ g.drawArc( x, y, cellWidth-6, cellHeight-6, 0, 360 ); } } } }

BlackBerry-Specific Code The BlackBerry version of tic-tac-toe game adapts the two MIDP classes for use with the RIM user interface components.

TicTacToe Again, this is the entry point to the application:

67957_Wiley_Giguere_AppA

10/17/2000 5:18 PM

Page 271

Tic-Tac-Toe Source Code

271

// Copyright 2000 by Eric Giguere. // From Java 2 Micro Edition: Professional Developer’s Guide, // published by John Wiley & Sons. package com.ericgiguere.j2mebook.rim; import import import import

com.ericgiguere.j2mebook.models.*; net.rim.device.api.ui.*; net.rim.device.api.ui.component.*; net.rim.device.api.system.*;

/** * Defines a tic-tac-toe RIM application that uses the TicTacToeModel * class to control the game logic. The actual user interface * is defined by TicTacToeUI. */ public class TicTacToe extends UiApplication { private TicTacToeUI gameScreen; private TicTacToeModel model; /** * Starts the application. */ public static void main( String[] args ){ TicTacToe app = new TicTacToe(); app.enterEventDispatcher(); } /** * Constructs the tic-tac-toe game. */ public TicTacToe() { model = new TicTacToeModel(); } /** * Called when the application starts. Creates the initial * screen and the attaches the appropriate listeners. */ public void activate() { gameScreen = new TicTacToeUI( this ); model.addListener( gameScreen ); model.addListener( new TicTacToePlayer( TicTacToeModel.PLAYER_2 ) ); model.newGame();

67957_Wiley_Giguere_AppA

272

10/17/2000 5:18 PM

Page 272

APPENDIX A pushScreen( gameScreen ); } }

TicTacToeUI The user interface is very similar to that of the MIDP version, except that it also allows cells to be selected using the thumbwheel: // Copyright 2000 by Eric Giguere. // From Java 2 Micro Edition: Professional Developer’s Guide, // published by John Wiley & Sons. package com.ericgiguere.j2mebook.rim; import import import import

com.ericgiguere.j2mebook.models.*; net.rim.device.api.ui.*; net.rim.device.api.ui.component.*; net.rim.device.api.system.*;

/** * Displays a user interface for a tic-tac-toe game. The state * of the game is stored in a TicTacToeModel instance, so this * class is responsible for drawing the grid and the cell values * and interpreting user input. */ public class TicTacToeUI extends FullScreen implements TicTacToeModelListener, MenuListener, Runnable { /** * The menu ID for the Close item. */ private static final int MENU_CLOSE = 0; /** * The menu ID for selecting the current cell. */ private static final int MENU_SELECT_CELL = 1; /** * Constructs a tic-tac-toe user interface. * * @param main the main tic-tac-toe class.

67957_Wiley_Giguere_AppA

10/17/2000 5:18 PM

Page 273

Tic-Tac-Toe Source Code

273

*/ public TicTacToeUI( TicTacToe main ){ super( false ); application = main; // Create a menu that we’ll popup later menu = new Menu(); menu.add( new MenuStringField( "Select Cell", MENU_SELECT_CELL ) ); menu.add( new MenuStringField( "Close", MENU_CLOSE ) ); menu.addMenuListener( this ); } /** * Draws the tic-tac-toe grid. * * @param g the graphics object. */ public void drawGrid( Graphics g ){ int i, x, y; x = cellWidth; y = cellHeight; for( i = 0; i < cellsPerRow - 1; ++i ){ g.drawLine( x, 0, x, screenHeight ); g.drawLine( 0, y, screenWidth, y ); x += cellWidth; y += cellHeight; } } /** * Draws each cell’s value. * * @param g the graphics object. */ public void drawPlayers( Graphics g ){ for( int i = 0; i < numCells; ++i ){ cells[i].paint( g ); } } /** * Called when the game is over. * with the result of the game. *

Displays an alert

67957_Wiley_Giguere_AppA

274

10/17/2000 5:18 PM

Page 274

APPENDIX A * @param model the game model. */ public void gameOver( TicTacToeModel model ){ doPaint(); String text; switch( model.getWinner() ){ case TicTacToeModel.PLAYER_1: text = "Player 1 wins!"; break; case TicTacToeModel.PLAYER_2: text = "Player 2 wins!"; break; default: text = "A tie!"; break; } // Inform the user about the win/loss/tie, then // push a request to start a new game on the // event queue.... Dialog.inform( text ); invalidate(); application.invokeLater( this ); } /** * Called * * @param * @param * @param */

when a cell in the game is updated. model the game model. index the cell index. value the cell’s new value.

public void gameUpdated( TicTacToeModel model, int index, int value ){ Cell cell = cells[index]; cell.state = value; invalidate( cell.x, cell.y, cellWidth, cellHeight ); } /** * Called when a game is started. * Calculates the dimensions of the cells and then paints * the grid. * * @param model the game model. */

67957_Wiley_Giguere_AppA

10/17/2000 5:18 PM

Page 275

Tic-Tac-Toe Source Code public void gameStarted( TicTacToeModel model ){ this.model = model; if( screenWidth != 0 ){ initializeCells(); } } /** * Initialize the cell information for a game. */ public void initializeCells(){ selectableCell = 0; cellsPerRow = model.getSize(); numCells = cellsPerRow * cellsPerRow; cellHeight cellWidth

= screenHeight / cellsPerRow; = screenWidth / cellsPerRow;

cells = new Cell[ numCells ]; int i, j, y; for( i = 0, y = 0; i < numCells; i += cellsPerRow ){ for( j = 0; j < cellsPerRow; ++j ){ cells[i+j] = new Cell( cellWidth * j + cellsPerRow, y + cellsPerRow ); } y += cellHeight; } cells[ selectableCell ].setSelectable( true ); invalidate(); } /** * Handles key presses, selecting a cell if the cell is empty. * * @param keyCode the key that was pressed. */ public boolean keyDown( int status, int time, char key ){ if( model == null || !model.isGameStarted() ) return false; int index = (int) key - '0'; if( index >= 0 && index < numCells ){ model.setCellState( index, TicTacToeModel.PLAYER_1 ); }

275

67957_Wiley_Giguere_AppA

276

10/17/2000 5:18 PM

Page 276

APPENDIX A return true; } /** * Called by the system when a popup menu closes * without the user selecting any of its items. * Removes the menu by popping it off the display * stack. * * @param menu the menu that just closed. */ public void menuClosed( Menu menu ){ application.popScreen(); } /** * Called by the system when the user selects * a popup menu item. Removes the menu and * then acts on the selection. * * @param menu the menu that was just closed. * @param field the selected field in the menu. */ public void menuSelected( Menu menu, Field field ){ application.popScreen(); switch( ((MenuStringField) field).getId() ){ case MENU_CLOSE: System.exit( 0 ); break; case MENU_SELECT_CELL: model.setCellState( selectableCell, TicTacToeModel.PLAYER_1 ); invalidate(); break; } } /** * Called to perform layout of the screen. * * @param width the screen’s width. * @param height the screen’s height. */ public void sublayout( int width, int height ){ screenHeight = height; screenWidth = width; setExtent( width, height );

67957_Wiley_Giguere_AppA

10/17/2000 5:18 PM

Page 277

Tic-Tac-Toe Source Code if( model != null ){ initializeCells(); } } /** * Paints the grid and the cells. * * @param g the graphics object. */ public void paint( Graphics g ){ if( model != null ){ drawGrid( g ); drawPlayers( g ); } } /** * Called whenever the screen is shown. Starts a new * game if called after the alert is displayed. */ public void onDisplay(){ if( model != null && !model.isGameStarted() ){ model.newGame(); } } /** * Starts a new game. */ public void run(){ model.newGame(); } /** * Moves the selectable cell to a new cell. * * @param offset the direction and number of * cells to move (negative for up/left, * positive for down/right). */ private void moveCell( int offset ){ cells[ selectableCell ].setSelectable( false ); selectableCell += offset; if( selectableCell >= numCells ){ selectableCell = 0; } else if( selectableCell < 0 ){

277

67957_Wiley_Giguere_AppA

278

10/17/2000 5:18 PM

Page 278

APPENDIX A selectableCell = numCells - 1; } cells[ selectableCell ].setSelectable( true ); invalidate(); } /** * Called when the user clicks the thumbwheel. * Opens the popup menu in response. * * @param status ignored. * @param time ignored. * @return true to indicate it’s been handled. */ public boolean thumbClick( int status, int time ){ application.pushScreen( menu ); return true; } /** * Called when the user rolls the thumbwheel down. * Moves the selected cell in response. * * @param status ignored. * @param time ignored. * @parma amount ignored. * @return true to indicate it’s been handled. */ public boolean thumbRollDown( int status, int time, int amount ){ moveCell( 1 ); return true; } /** * Called when the user rolls the thumbwheel up. * Moves the selected cell in response. * * @param status ignored. * @param time ignored. * @parma amount ignored. * @return true to indicate it’s been handled. */ public boolean thumbRollUp( int status, int time, int amount ){ moveCell( -1 ); return true; } private int

cellsPerRow;

67957_Wiley_Giguere_AppA

10/17/2000 5:18 PM

Page 279

Tic-Tac-Toe Source Code private private private private private private private private private private

int int int int int TicTacToeModel TicTacToe Cell[] Menu int

279

numCells; cellHeight; cellWidth; screenHeight; screenWidth; model; application; cells; menu; selectableCell;

//--------------------------------------------------------/** * Defines a simple inner class for holding the state and * the location of each cell. Since it’s an inner class * each instance has access to the private data of its * parent class, i.e. the cellHeight and cellWidth values. */ private class Cell { int state; int x; int y; boolean selectable; /** * Constructs an empty cell at the given location. * * @param x the X value. * @param y the Y value. */ public Cell( int x, int y ){ state = TicTacToeModel.NO_PLAYER; this.x = x; this.y = y; selectable = false; } /** * Determines whether or not the given point is in the * cell. * * @param px the X value. * @param py the Y value. * * @return true if the point is within the cell. */ public boolean contains( int px, int py ){

67957_Wiley_Giguere_AppA

280

10/17/2000 5:18 PM

Page 280

APPENDIX A return( px >= x && px <= x + cellWidth && py >= y && py <= y + cellHeight ); } /** * Paints a cell according to its state. * * @param g the graphics object. */ public void paint( Graphics g ){ g.clear( x, y, cellWidth-6, cellHeight-6 ); if( state == TicTacToeModel.PLAYER_1 ){ g.drawLine( x, y, x+cellWidth-6, y+cellHeight-6 ); g.drawLine( x+cellWidth-6, y, x, y+cellHeight-6 ); } else if( state == TicTacToeModel.PLAYER_2 ){ g.drawRect( x, y, cellWidth-6, cellHeight-6 ); } if( selectable ){ g.invert( x, y, cellWidth-6, cellHeight-6 ); } } /** * Sets the selectable state of the cell. * * @param sel the new selectable state. */ public void setSelectable( boolean sel ){ selectable = sel; } } }

Waba-Specific Code Although minor changes are required to make the TicTacToeModel and TicTacToePlayer classes work with Waba, we do not list the changes here. Refer to the CD-ROM for the updated classes. Here is the code for the new TicTacToe class, however: // Copyright 2000 by Eric Giguere. // From Java 2 Micro Edition: Professional Developer’s Guide, // published by John Wiley & Sons.

67957_Wiley_Giguere_AppA

10/17/2000 5:18 PM

Page 281

Tic-Tac-Toe Source Code

281

package com.ericgiguere.j2mebook.waba; import com.ericgiguere.j2mebook.models.*; import waba.fx.*; import waba.ui.*; /** * A simple tic-tac-toe game for Waba. */ public class TicTacToe extends MainWindow implements TicTacToeModelListener { /** * Constructs a tic-tac-toe game. */ public TicTacToe() { screenHeight = height; screenWidth = width; model = new TicTacToeModel(); model.addListener( this ); model.addListener( new TicTacToePlayer( TicTacToeModel.PLAYER_2 ) ); model.newGame(); } /** * Draws the tic-tac-toe grid. * * @param g the Graphics object. */ public void drawGrid( Graphics g ){ int i, x, y; x = cellWidth; y = cellHeight; for( i = 0; i < cellsPerRow - 1; ++i ){ g.drawLine( x, 0, x, screenHeight ); g.drawLine( 0, y, screenWidth, y ); x += cellWidth; y += cellHeight; } } /** * Draws each cell.

67957_Wiley_Giguere_AppA

282

10/17/2000 5:18 PM

Page 282

APPENDIX A * * @param g the Graphics object. */ public void drawPlayers( Graphics g ){ for( int i = 0; i < numCells; ++i ){ cells[i].paint( g ); } } /** * Called when the game is over. Sets the text to display * about the winner of the game. The message will be displayed * when the paint event is called. * * @param model the game model. */ public void gameOver( TicTacToeModel model ){ String text; switch( model.getWinner() ){ case TicTacToeModel.PLAYER_1: winnerText = "Player 1 wins!"; break; case TicTacToeModel.PLAYER_2: winnerText = "Player 2 wins!"; break; default: winnerText = "A tie!"; break; } } /** * Called * * @param * @param * @param */

when a cell in the game is updated. model the game model. index the cell index. value the cell’s new value.

public void gameUpdated( TicTacToeModel model, int index, int value ){ Cell cell = cells[index]; cell.state = value; repaint(); } /** * Called when a game is started.

Clears the screen,

67957_Wiley_Giguere_AppA

10/17/2000 5:18 PM

Page 283

Tic-Tac-Toe Source Code * calculates the dimensions of the cells and then paints * the grid. * * @param model the game model. */ public void gameStarted( TicTacToeModel model ){ damageRect( 0, 0, height, width ); cellsPerRow = model.getSize(); numCells = cellsPerRow * cellsPerRow; cellHeight cellWidth

= screenHeight / cellsPerRow; = screenWidth / cellsPerRow;

cells = new Cell[ numCells ]; int i, j, y; for( i = 0, y = 0; i < numCells; i += cellsPerRow ){ for( j = 0; j < cellsPerRow; ++j ){ cells[i+j] = new Cell( cellWidth * j + cellsPerRow, y + cellsPerRow ); } y += cellHeight; } this.model = model; repaint(); } /** * Handles key presses, selecting a cell if the cell is empty. * * @param keyCode the key that was pressed. */ public void keyPressed( int keyCode ){ if( model == null || !model.isGameStarted() ) return; if( keyCode < '0' || keyCode > '9' ) return; model.setCellState( keyCode - '0', TicTacToeModel.PLAYER_1 ); } /** * Called by Waba whenever an event occurs. * * @param e the event object with information about the event. */

283

67957_Wiley_Giguere_AppA

284

10/17/2000 5:18 PM

Page 284

APPENDIX A public void onEvent( Event e ){ if( model == null ) return; if( e instanceof KeyEvent ){ keyPressed( ((KeyEvent)e).key ); } else if( e instanceof PenEvent ){ PenEvent pe = (PenEvent) e; if( pe.type == PenEvent.PEN_DOWN ){ if( model.isGameStarted() ){ penDown( pe.x, pe.y ); } else { model.newGame(); } } } } /** * General game paint routine. Draws the grid and then the * cells. Also draws the winner text if the game is over. * * @param g the graphics object. */ public void onPaint( Graphics g ){ g.setColor( 0, 0, 0 ); if( model != null ){ drawGrid( g ); drawPlayers( g ); if( !model.isGameStarted() ){ g.fillRect( 10, 40, width-20, height-80 ); g.setColor( 255, 255, 255 ); g.drawText( winnerText, 15, 40 ); g.drawText( "Tap to start over", 15, 60 ); } } } /** * Handles pen presses, checking to see if the user * has pressed over an empty cell. * * @param x the X coordinate of the pen press. * @parma y the Y coordinate of the pen press. */ public void penDown( int x, int y ){ if( model != null && model.isGameStarted() ){ for( int i = 0; i < numCells; ++i ){

67957_Wiley_Giguere_AppA

10/17/2000 5:18 PM

Page 285

Tic-Tac-Toe Source Code if( cells[i].contains( x, y ) ){ model.setCellState( i, TicTacToeModel.PLAYER_1 ); return; } } } } private private private private private private private private private

int int int int int int TicTacToeModel Cell[] String

cellsPerRow; numCells; cellHeight; cellWidth; screenHeight; screenWidth; model; cells; winnerText;

//--------------------------------------------------------/** * Defines a simple inner class for holding the state and * the location of each cell. Since it’s an inner class * each instance has access to the private data of its * parent class, i.e. the cellHeight and cellWidth values. */ private class Cell { int state; int x; int y; /** * Constructs an empty cell at the given location. * * @param x the X value. * @param y the Y value. */ public Cell( int x, int y ){ state = TicTacToeModel.NO_PLAYER; this.x = x; this.y = y; } /** * Determines whether or not the given point is in the * cell. * * @param px the X value. * @param py the Y value.

285

67957_Wiley_Giguere_AppA

286

10/17/2000 5:18 PM

Page 286

APPENDIX A * * @return true if the point is within the cell. */ public boolean contains( int px, int py ){ return( px >= x && px <= x + cellWidth && py >= y && py <= y + cellHeight ); } /** * Paints a cell according to its state. * * @param g the graphics object. */ public void paint( Graphics g ){ if( state == TicTacToeModel.PLAYER_1 ){ g.drawLine( x, y, x+cellWidth-6, y+cellHeight-6 ); g.drawLine( x+cellWidth-6, y, x, y+cellHeight-6 ); } else if( state == TicTacToeModel.PLAYER_2 ){ g.drawRect( x, y, cellWidth-6, cellHeight-6 ); } } } }

67957_Wiley_Giguere_About CD

10/17/2000 5:19 PM

Page 287

What’s on the CD-ROM?

O

n the CD-ROM, you’ll find:

■■

A beta copy of the Motorola iDEN SDK for Java

■■

An early access version of the Research In Motion BlackBerry Java Development Environment

■■

Borland’s JBuilder 3.5 Foundation, including a copy of the Handheld Express beta

■■

Other software, including a copy of kAWT and two XML parsers

■■

And, of course, the source code to the tic-tac-toe games

Consult the index.html file at the root of the CD for installation and usage instructions.

System Requirements Minimum system requirements: Windows 95, NT 4.0 or higher; 200 MHz Pentium; 64 MB RAM required. Recommended system requirements: Windows 95, NT 4.0, or higher; 500 MHz Pentium; and 128 MB RAM recommended depending on file sizes.

287

67957_Wiley_Giguere_About CD

288

10/17/2000 5:19 PM

Page 288

J A VA ™ 2 M I C R O E D I T I O N

Hard drive space: Consult the installation documentation for each third-party software on the CD-ROM for hard drive requirements. Peripherals: CD-ROM drive You also will need to have the following applications to make full use of the CDROM: a browser such as Microsoft Internet Explorer or Netscape Navigator to open the index.html file and to navigate the CD-ROM, an unzip utility to extract archived files, and a copy of Adobe Acrobat Reader 4.0 to read certain documents.

User Assistance and Information The software accompanying this book is being provided as is without warranty or support of any kind. Should you require basic installation assistance, or if your media is defective, please call our product support number at (212) 8506194 weekdays between 9 A.M. and 4 P.M. Eastern Standard Time. Or, we can be reached via e-mail at: [email protected]. To place additional orders or to request information about other Wiley products, please call (800) 879-4539.

67957_Wiley_Giguere_Index/Dis

10/17/2000 5:19 PM

Page 289

Index

A Abstract Windowing Toolkit, see AWT alternatives (to Java), 241—242 Waba, 227 bridge classes, 229 classes, compiling and running, 233 debugging programs, 235 foundation classes, 235—237 HelloWorld application, 233 installing, 230 runtime library, 228 samples (SDK), running, 231—232 Tic-Tac-Toe example, 237—238 virtual machine, 227—228 always-available devices, 14 networking, 15 APIs (application programming interfaces), MIDlet Suites, 111 applications descriptors, 113 lifecycles, 114 manifest attributes, 111

applets (features of Java 1.02), 41—42 application programming Interfaces, see APIs, 109 applications building RIM Blackberry J2ME implementation, 214—216, 218—220 smaller (programming strategies), 54—55 CLDC (Connected Limited Device Configuration) HelloWorld example, 136—137 HelloWorld Spotlet, 137 debugging (CLDC), 141—142 delivery dynamic (configurations), 91 sandbox CLDC support, 96 MIDlets, 113 HelloWorld (CLDC for Palm devices), 153—155 installing (JAR files), 55 Java 1.02, 43 lifecycles (MIDlets), 114 MIDP Early Access Release HelloMIDlet, 184, 186—187

Tic-Tac-Toe example, 187, 190 simplifying (programming strategies), 53—54 speed, 4 Waba debugging, 235 HelloWorld, 233 ARDIS, 15 attributes, manifest (MIDlets), 111 Automatic Player (CLDC for Palm devices), 171 avoiding exceptions (reducing memory usage at run time), 61 string concatenation (coding for performance), 63 thread synchronization (coding for performance), 64—65 AWT (Abastract Windowing Toolkit), MIDP UI APIclass, 115—116 B barcode readers (input methods), 12 289

67957_Wiley_Giguere_Index/Dis

290

10/17/2000 5:19 PM

Page 290

INDEX

battery operation, 7—8 Palm V, 14 Blackberry wireless handhelds, 201—203 classes, 222 IDE, 204—205 starting, 204 J2ME implementation, 213 applications, building, 214—216, 218—220 JDE installing, 203 samples, running, 211—212 network communication, 221 simulator, 208—210 Tic-Tac-Toe example, 222—225 Bluetooth, 15 bridge classes (Waba), 229 browsers (upgrading to Java 1.1), 47 building applications (programming strategies), 54—55 input method, 12 models (MVC), 66—67 C CDC configuration, 101, 103 cellular phones emulators (Motorola SDK for J2ME), 195—199 Ericsson T18s, 12 keypads, 12 simulators (MIDP Early Access Release), 180—182 central processing units (CPUs), 8 character-recognition software, 9 classes CLDC (Connected Limited Device Configuration), compiling and running, 134—135 files, 28, 30 Generic Connections (CLDC), 97—100 MIDP (Mobile Information Device Profile) HTTP connections, 123—124

Record Management System, 120—123 timer notifications, 124 MIDP Early Access Release (compiling and running), 183—184 MIDP user interface, 115 drawing and repainting, 119 MIDP UIAPIs and AWT, 115—116 screens and events, 116, 118 threading issues, 120 network connection Connector (CLDC for Palm devices), 165—167 HTTP (CLDC for Palm devices), 167 RIM Blackberry J2ME implementation, 222 updates in J2ME, 79 user interface (CLDC for Palm devices), 158—163 VM class loader, 35, 37 VM class verifier, 37—38 bridge, 229 foundation, 235—237 CLDC (Connected Limited Device Configuration), 91—93, 129—130 classes compiling and running, 134—135 Generic Connections, 98, 100 inherited, 97—98 debugging applications, 141—142 HelloWorld Spotlet, 137 installing, 130—131 JAM sample implementation, 139—140 language support, 94 memory usage, 139 Palm devices, 143 Automatic Player, 171 Color KVM, 172 Connector class (network connections), 165—167 databases, 163—165 development issues, 145

hardware specs, 146 HelloWorld application, 136—137, 153—155 HTTP connections (network connections), 167 installing, 150—151 Jbed MicroEdition, 173—174 JBuilder Handheld Express, 173 kAWT, 172 KVMulti application, 152 memory model, 147—148 model differences, 144—145 operating system, 146 Palm OS Emulator, 149 resetting, 148 samples, running, 151 Tic-Tac-Toe example, 167, 169—171 user interface classes, 158—163 samples, running, 131—133 sandbox support, 96 virtual machine support, 95 coding disassembling code, 28 Blackberry IDE, 206—207 with performance in mind, 62 local variables, 62—63 string concatenation, avoiding, 63 threads without synchronization, 64—65 Color KVM (CLDC for Palm devices), 172 CompactFlash Type II expansion slot, 7 compiling classes CLDC (Connected Limted Device Configuration), 134—135 MIDP Early Access Release, 183—184 Waba, 233 just-in-time (Java 1.1 features), 44

67957_Wiley_Giguere_Index/Dis

10/17/2000 5:19 PM

Page 291

INDEX

computing devices input/output, 8 memory capacity, 5 Palm V, 4 PDA, 4 CDC, 101, 103 CLDC (Connected Limited Device Configuration), 91, 93 Generic Connections classe, 98, 100 inherited classes, 97—98 language support, 94 sandbox support, 96 virtual machine support, 95 device families, 90 dynamic applicaiton delivery, 91 identifying, 91 configuring J2ME, 80—81 connected device families (configurations), 90 Connector class (CLDC for Palm devices), 165—167 cradles, 15 D data synchronization, 14 databases (CLDC for Palm devices), 163—165 debugging applications Blackberry IDE, 206—207 CLDC (Connected Limited Device Configuration), 141—142 Waba, 235 delivery, application (configurations), 91 devices Blackberry wireless handhelds, 201—203 classes, 222 IDE, 204—207 J2ME implementation, 213—216, 218—220 JDE, 203, 211—212 network communication, 221 simulator, 208—210 Tic-Tac-Toe example, 222—225 families (configurations), 90

MIDP user interface classes, 119 E Embedded Java vs. J2ME, 86 emulators cellular phone (Motorola SDK for J2ME), 195—199 Palm OS Emulator, 149 Ericsson T18s, 12 events (MIDP user interface classes), 116, 118 exceptions, avoiding (reducing memory usage at run time), 61 execution engine, 25 class loader, 25 class verifier, 25 garbage collector, 25, 33—34 Java ( native code interface), 25 virtual machine, 25—28, 32 class loader, 35, 37 class verifier, 37—38 disassembling Java bytecode, 28 native code interface, 38 pointers, 31 runtime checks, 31 security checks, 31 speed, 31 synchronization primitives, 32 F families, device (configurations), 90 files (class), 28, 30 form factor constraints on I/O methods, 14 small computing devices, 13 foundation classes (Waba), 235 I/O, 237 user interface, 236 Foundation Profile, 125 G Garbage collectors, 33—34 reducing memory at run time, 57 Generic Connections class (CLDC), 98, 100

291

H HelloMIDlet application (MIDP Early Access Release), 184, 186—187 HelloWorld application CLDC (Connected Limited Device Configuration) example, 136—137 for Palm devices, 153—155 Waba, 233 HelloWorld Spotlet, CLDC (Connected Limited Device Configuration) example, 137 Hewlett-Packard Jornada 430se, 7 HotSpot virtual machine, 78—79 HTTP connections CLDC for Palm devices, 167 MIDP classes, 123—124 I I/O Waba classes, 237 identifying configurations, 91 profiles, 107 implementations, CLDC (Connected Limited Device Configuration), 129—130 classes, compiling and running, 134—135 debugging applications, 141—142 HelloWorld application, 136—137 HelloWorld Spotlet, 137 installing, 130—131 JAM sample implementation, 139—140 memory usage, 139 samples, running, 131—133 indicator lights (output methods), 13 infrared communication, 15 infrared ports (output methods), 13 input methods barcode readers, 12 buttons, 12 character-recognition software, 9

67957_Wiley_Giguere_Index/Dis

292

10/17/2000 5:19 PM

Page 292

INDEX

input methods (cont.) joysticks, 12 keyboards, 10 keypads, 12 roller wheels, 12 touch-sensitive screens, 9 trackballs, 12 voice recognition, 12 input/output methods form factor constraints, 9, 14 small computing devices, 8 installing applications (JAR files), 55 Blackberry JDE, 203 CLDC (Connected Limited Device Configuration), 130—131 MIDP Early Access Release, 178—179 Motorola SDK for J2ME, 194 Waba, 230 J JAM sample implementation, CLDC (Connected Limited Device Configuration), 139—140 JAR (Java Archive) files (installing applications), 55 Java architecture, 23 execution engine, 25 class files, 28, 30 class loader, 25, 35, 37 class verifier, 25, 37—38 garbage collector, 25, 33—34 native code interface, 25, 38 virtual machine, 25—28, 31—32 runtime libraries, 39 Java 1.02, 40 applets, 41—42 applications, 43 Java 1.1, 43—44 browser upgrades, 47 database connectivity, 45 JavaBeans, 46 JRE (Java runtime environment), 48

just-in-time compiling, 44 object serialization, 45 RMI, 45 Servlets, 46 Java 2, 48—49 Java 2 Enterprise Edition, 49 Java 2 Standard Edition, 49 Java 2 Micro Edition (J2ME) alternatives to, 241—242 cellular phone emulator, 195—199 installing, 194 configurations, 89—90 CDC, 101, 103 CLDC, 91, 93—98, 100 device families, 90 dynamic applicaiton delivery, 91 identifying, 91 RIM Blackberry implementation, 213 classes, 222 network communication, 221 Tic-Tac-Toe example, 222—225 specifications, 77 class changes, 79 configurations, 80—81 HotSpot virtual machine, 78—79 KVM virtual machine, 81—85 profiles, 80—81 vs. Embedded Java, 86 vs. Java Card, 87 vs. Personal Java, 86 Java Archive, see JAR Java Card vs. J2ME, 87 Java runtime environment, see JRE Java Virtual Machine Specifications, see JVMS JavaBeans (Java 1.1 features), 46 Jbed MicroEdition (CLDC for Palm devices), 173—174 JBuilder Handheld Express (CLDC for Palm devices), 173 JLS (Java Language Specification), 19

joysticks, 12 JRE (Java runtime environment), 19 Java 1.1, 48 Java 1.1, 44 JVMS (Java Virtual Machine Specification), 19, 25 K kAWT (CLDC for Palm devices), 172 keyboards collapsibles, 12 input methods, 10 QWERTY, 11 keypads, 12 KVM virtual machine, 81—85 CLDC memory usage, 139 KVMulti application (CLDC for Palm devices), 152 L languages (CLDC support), 94 lazy instantiation (reducing memory usage at run time), 58 libraries, runtime, 39 local variables coding for performance, 62—63 CLDC for Palm devices, 155, 157 M manifest attributes (MIDlets), 111 memory capacity (small computing devices), 5 CLDC (Connected Limited Device Configuration) usage, 139 Palm devices, 147—148 using less at run time (programming strategies), 56—61 MIDlets, 109, 111 applications descriptors, 113 lifecycles, 114 manifest attributes, 111

67957_Wiley_Giguere_Index/Dis

10/17/2000 5:19 PM

Page 293

INDEX

MIDlet Suites, 111 application lifecycles, 114 application descriptors, 113 manifest attributes, 111 MIDP (Mobile Information Device Profile), 105—109 HTTP connections, 123—124 MIDlet Suites, 111 application descriptors, 113 manifest attributes, 111 MIDlets, 109, 111 application descriptors, 113 application lifecycles, 114 manifest attributes, 111 Record Management System class, 120—123 timer notifications, 124 user interface classes, 115 drawing and repainting, 119 MIDP UIAPIs and AWT, 115—116 screens and events, 116, 118 threading issues, 120 MIDP Early Access Release, 177—178 cellular phone simulator, 180—182 classes, compiling and running, 183—184 HelloMIDlet application, 184, 186—187 installing, 178—179 samples, running, 182 Tic-Tac-Toe example, 187, 190 MIDs (Mobile Information Devices), 108 mobitex, 15 model-view-controller, see MVC models, application (RIMBlackberry J2ME implementation), 219—220 Motorola SDK for J2ME, 193—195 cellular phone emulator, 195—199 installing, 194

MVC (model-viewcontroller), 65 building a model, 66—67 Tic-Tac-Toe example, 68—72 N native code interface execution engines, 25 Java execution engine, 38 networks, 14 always-available devices, 15 building smaller applications, 55 connectivity (RIM Blackberry J2ME implementation), 221 occasionally connected devices, 15 O objects reusing (reducing memory usage at run time), 59—61 serialization (Java 1.1 features), 45 occasionally connected devices, 15 offline storage, 5, 7 online storage, 5 operating systems (Palm devices), 146 Palm OS Emulator, 149 output methods audio signals, 13 indicator lights, 13 infrared ports, 13 screens, 12 P Palm devices, 143 CLDC (Connected Limited Device Configuration) Automatic Player, 171 Color KVM, 172 databases, 163—165 HelloWorld application, 153—155 HTTP connections (network connections), 167 installing, 150—151 Jbed MicroEdition, 173—174

293

JBuilder Handheld Express, 173 kAWT, 172 KVMulti application, 152 MakePalmApp options, 155, 157 samples, running, 151 Tic-Tac-Toe example, 167, 169—171 user interface classes, 158—163 development issues, 145 hardware specs, 146 memory model, 147—148 model differences, 144—145 operating system, 146 Palm OS Emulator, 149 Palm V organizer, 4, 9 Palm Vx, 7 resetting, 148 PDAs (personal digital assitants), 3, 5 PDA profile, 125 performance (coding strategies), 62 local variables, 62—63 string concatenation, avoiding, 63 threads without synchronization, 64—65 personal digital assistants, see PDAs Personal Java vs. J2ME, 86 Personal Profile, 126 pointers (Java virtual machine), 31 processor power, 7—8 profiles, 105 Foundation, 125 identifying, 107 J2ME, 80—81 MIDP Early Access Release, 177—178 cellular phone simulator, 180—182 classes, compiling and running, 183—184 HelloMIDlet application, 184, 186—187 installing, 178—179 samples, running, 182 Tic-Tac-Toe example, 187, 190

67957_Wiley_Giguere_Index/Dis

294

10/17/2000 5:19 PM

Page 294

INDEX

purpose of, 106 MIDP (Mobile Information Device Profile), 105—109 MIDlet Suites, 111—114 MIDlets, 109—114 Record Management System class, 120—123 timer notifications, 124 user interface classes, 115—120 PDA, 125 Personal, 126 RMI, 126 programming strategies (small devices), 51—52 building smaller applications, 54—55 less memory at run time, 56—61 moving computations to servers, 52 MVC (model-viewcontroller), 65—72 simplifying applications, 53—54 Psion Series 7, 7 R Record Management System (MIDP classes), 120—123 releasing resources (reducing memory usage at run time), 59 repainting MIDP user interface classes, 119 resetting Palm devices, 148 resources, releasing early (reducing memory usage at run time), 59 reusing objects (reducing memory usage at run time), 59—61 RIM 957 Wireless Handheld, 11 RIM Blackberry wireless handhelds, 201—203 classes, 222 IDE, 204—205 running and debugging code, 206—207 starting, 204 J2ME implementation, 213 applications, building, 214—216, 218—220

JDE installing, 203 samples, running, 211—212 network communication, 221 simulator, 208—210 Tic-Tac-Toe example, 222—225 RMI (Java 1.1), 45 RMI Profile, 126 roller wheels, 12 runtime using less memory (programming strategies), 56—61 checks (Java virtual machine), 31 classes CLDC (Connected Limited Device Configuration), 134—135 MIDP Early Access Release, 183—184 Waba, 233 libraries, 39 Waba, 228 samples CLDC (Connected Limited Device Configuration), 131—133 CLDC for Palm devices, 151 MIDP Early Access Release, 182 SDKWaba samples, 231—232 S samples, running, 231—232 CLDC (Connected Limited Device Configuration), 131—133 CLDC for Palm devices, 151 MIDP Early Access Release, 182 RIM Blackberry handheld JDE, 211—212 sandboxes (CLDC support), 96 scalar types (reducing memory usage), 56 screens MIDP user interface classes, 116, 118 output methods, 12 security checks (Java virtual machine), 31 serial communication, 15

serialization, object (Java 1.1), 45 servers, moving computationintensive tasks to, 52 servlets (Java 1.1), 46 simulators (RIM Blackberry handhelds), 208—210 size, applications, reducing, 54—55 small computing devices cellular phones, 12 Ericsson T18s, 12 form factor, 13 Hewlett-Packard Jornada 430se, 5 IBM Microdrive, 7 input/output, 8 memory capacity, 5 networking, 14 Palm V, 4, 9, 14 Palm Vx, 7 PDA, 4 processor power, 7—8 programming strategies, 51—52 building smaller applications, 54—55 coding with performance in mind, 62—65 less memory at run time, 56—61 moving computations to servers, 52 MVC (model-viewcontroller), 65—72 simplifying applications, 53—54 Psion Series 7, 7 RIM 950 Wireless Handheld, 11 Sony’s Memory Stick, 7 storage capacity, 5 Web pads, 5 Sony’s Memory Stick, 7 specifications, Java 2 Micro Edition (J2ME), 77 class changes, 79 configurations, 80—81 Embedded Java comparisons, 86 HotSpot virtual machine, 78—79 Java Card comparisons, 87

67957_Wiley_Giguere_Index/Dis

10/17/2000 5:19 PM

Page 295

INDEX

KVM virtual machine, 81—85 Personal Java comparisons, 86 speed applications, 4 Java virtual machine, 31 Spotlet Model (CLDC for Palm devices), 158 storage capacities, 5 string concatenation, avoiding (coding for performance), 63 Sun’s runtime environment, see JRE synchronization coding with threads, 64—65 primitives (Java virtual machine), 32 T third-party tools Color KVM, 172 Jbed MicroEdition, 173—174 JBuilder Handheld Express, 173 kAWT, 172 threads coding for performance (avoiding synchronization), 64—65 MIDP user interface classes, 120 thumbwheels, see roller wheels Tic-Tac-Toe example CLDC for Palm devices, 167, 169—171 MIDP Early Access Release, 187, 190

RIM Blackberry J2ME implementation, 222—225 Waba, 237—238 timer notifications (MIDP classes), 124 touch-sensitive screens (input methods), 9 trackballs, 12 U Universal Serial Bus (USB) standard, 15 UP APIs (MIDP user interface classes), 115—116 users interface classes CLDC for Palm devices, 158—163 Waba, 236 MIDP interface classes, 115 drawing and repainting, 119 MIDP UIAPIs and AWT, 115—116 screens and events, 116, 118 threading issues, 120 V variables, local (coding for performance), 62—63 verifying classes (Java VM), 37—38 versions (Java) 1.02, 40—43 1.1, 43—48 2, 48—49 virtual machines, 25—28, 32 class files, 28, 30 class loader, 35, 37

295

class verifier, 37—38 CLDC support, 95 disassembling Java bytecode, 28 execution engines, 25 garbage collector, 25, 33—34 HotSpot, 78—79 KVM, 81—85 native code interface, 38 pointers, 31 runtime checks, 31 security checks, 31 speed, 31 synchronization primitives, 32 voice recognition, 12 W Waba, 227 applications debugging, 235 HelloWorld, 233 classes bridge, 229 compiling and running, 233 foundation, 235—237 installing, 230 runtime library, 228 samples (SDK), running, 231—232 Tic-Tac-Toe example, 237—238 virtual machine, 227—228 Waba.fx class, 236 Web pads, 5

67957_Wiley_Giguere_Index/Dis

10/17/2000 5:19 PM

Page 296

CUSTOMER NOTE: IF THIS BOOK IS ACCOMPANIED BY SOFTWARE, PLEASE READ THE FOLLOWING BEFORE OPENING THE PACKAGE. This software contains files to help you utilize the models described in the accompanying book. By opening the package, you are agreeing to be bound by the following agreement: This software product is protected by copyright and all rights are reserved by the author, John Wiley & Sons, Inc., or their licensors. You are licensed to use this software as described in the software and the accompanying book. Copying the software for any other purpose may be a violation of the U.S. Copyright Law. This software product is sold as is without warranty of any kind, either express or implied, including but not limited to the implied warranty of merchantability and fitness for a particular purpose. Neither Wiley nor its dealers or distributors assumes any liability for any alleged or actual damages arising from the use of or the inability to use this software. (Some states do not allow the exclusion of implied warranties, so the exclusion may not apply to you.)