Download Programming of Handheld and Mobile Devices

Programming of Handheld and Mobile
Devices
Lecture 8 CDC andJ2ME
Rob Pooley [email protected]
Programming Handheld and
Mobile devices
1
Mobile Information Device Profile
• The first J2ME profile
• 􀀀Targets devices implementing CLDC
• 􀀀Profile addresses:
– Display toolkit, user input methods
– Persistent data storage
– Messaging( SMS, email, etc), security and
networking over wireless network connection
– Sun provides Reference Implementation FCS in
September 2000
Programming Handheld and
Mobile devices
2
Related Technologies:
Java Card™ Technology
• Specifies minimized subset of
Java technology for GSM
SIM cards, smart cards, Java
rings, and other extremely
constrained devices
• 􀀀 Key benefits versus nonJava smart cards
– Multiple applications per
card
– Post-issuance updates to
apps on card
Programming Handheld and
Mobile devices
3
Related Technologies:
EmbeddedJava™ Technology
•
•
EmbeddedJava. technology is a program from Sun
supporting development of dedicated-function
embedded devices for a wide range of end uses
􀀀 EmbeddedJava technology gives device
manufacturers the ability to:
– Configure the Java platform to leave out unneeded
classes and VM features
– Minimize resource requirements and cost for a
deeply-embedded device
– Optimize for devices with no GUI and intermittent
(at best) networking
– Keep APIs for their devices private
Programming Handheld and
Mobile devices
4
J2ME™: Connected Device Configuration
• Connected Device Configuration (CDC)
– Targeted for devices that have 2 MB or more total
available memory
– Memory dedicated to J2ME environment
– More than 2MB ROM/Flash
– More than 512 KB RAM
– Network connectivity
– Full Java 2 Virtual Machine specification
Programming Handheld and
Mobile devices
5
Example J2ME™ CDC Uses
•
•
•
•
•
•
•
Wireless communicators
High-end PDAs
TV set-top boxes
Gateways
Automotive entertainment and navigation systems
Telecomm/Networking Equipment
Industrial Controllers
Programming Handheld and
Mobile devices
6
What Is CVM?
• Basis for J2ME CDC and profiles
– Large VMs for desktops/servers don.t scale well to
devices
– Static and dynamic memory footprint too big
– Not embeddable, ROMable, not portable
– Implicit assumption of virtual memory
– Native stack use, address range reservation
– Implicit assumption of process model
• Global variables, .system threads.
Programming Handheld and
Mobile devices
7
CVM features
•
•
•
•
•
Good JVM features
Device friendliness.
Easily re-targetable
Narrow porting interface
Almost entirely in C (except
dynamic compiler)
• ~256KB with JNI, reflection,
verification,.
• CVM supports all Java 2 Platform,
version 1.3,
• VM features and libraries for
security, weak references, JNI, RMI
and JVMDI
• CVM allows devices to map Java
threads directly to native threads.
• Can run Java classes out of ROM
• Contains a precise memory system
with advanced Garbage Collection
features:
• Small average GC pause times
• Pluggable Garbage Collectors
• Full separation of VM from memory
system
Programming Handheld and
Mobile devices
8
J2ME Profiles
• Mobile Information Device Profile (MIDP)
– Profile for wireless devices implementing CLDC
• J2ME Foundation Profile
– Profile for non-GUI networked devices implementing
CDC
• 􀀀 J2ME Personal Basis, Personal, RMI Profiles
– Basic graphics, next generation PersonalJava
environment, and RMI support for CDC & Foundation
Profile based devices
Programming Handheld and
Mobile devices
9
CDC APIs
• 􀀀 Defines minimum set of APIs for Java VM support
– java.lang.VM system classes (Object, Thread, etc.)
– java.util.Underlying utilities
– java.net.UDP Datagram and File URL
– java.io.File
– java.text.I18n support for Java VM error messages
– java.security.Fine grain security and encryption for
object serialization
Programming Handheld and
Mobile devices
10
CVM Sizes Today
• CVM only
– Static ROM + RAM req.= 258 KB
• Natives only
– Static ROM + RAM req.= 124 KB
• Porting layer only
– Static ROM + RAM req.= 28 KB
• CVM+natives+porting_layer
– Static ROM + RAM req.= 410 KB
Programming Handheld and
Mobile devices
11
Foundation Profile APIs
• Defines core set of Java platform functionality
– No GUI
– Subset of JDK 1.3
• Completes full functionality from CDC
– java.lang.Rounds out full java.lang.*(Compiler,
UnknownError)
– java.util.Adds full zip support, Timer, etc.
– java.net.Adds TCP Socket and HTTP
– java.io.Rounds out full java.io.* (Readers and Writers)
– java.text.Full I18n (Annotation, Collator, Iterators, etc.)
– java.security.Adds Code Signing and Certificates
Programming Handheld and
Mobile devices
12
CVM Sizes with Foundation Profile APIs
• CDC Java libraries (ROMized)
– Static ROM + RAM req.= 1011 KB
• Foundation Java libraries (ROMized)
– Static ROM + RAM req.= 1564 KB
• CDC TOTAL (CVM+natives+porting+libraries)
– Static ROM + RAM req.= 1421 KB
• Java libraries + natives for Foundation Profile
– Static ROM + RAM req = 553 KB
• Foundation TOTAL (CVM+natives+porting+libraries)
– Static ROM + RAM req.= 1974 KB
Programming Handheld and
Mobile devices
13
Header files
/*
* RMSGameScores.java
* Copyright (c) 2000 Sun Microsystems, Inc. All Rights Reserved.
*
* Author: Srikanth Raju
*
* This software is the confidential and proprietary information of Sun
* Microsystems, Inc. ("Confidential Information"). You shall not
* disclose such Confidential Information and shall use it only in
* accordance with the terms of the license agreement you entered
into
* with Sun.
*
* SUN MAKES NO REPRESENTATIONS OR WARRANTIES
ABOUT THE SUITABILITY OF THE
* SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT
NOT LIMITED TO THE
* IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR
A PARTICULAR
* PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE
LIABLE FOR ANY DAMAGES
* SUFFERED BY LICENSEE AS A RESULT OF USING,
MODIFYING OR DISTRIBUTING
* THIS SOFTWARE OR ITS DERIVATIVES.
*/
import javax.microedition.midlet.*;
import javax.microedition.rms.*;
import java.io.DataOutputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ByteArrayInputStream;
import java.io.DataInputStream;
import java.io.EOFException;
Programming Handheld and
Mobile devices
14
Final example
/**
* A class used for storing and showing game
scores.
*/
public class RMSGameScores extends MIDlet
implements RecordFilter,
RecordComparator
{
/*
* The RecordStore used for storing the
game scores.
*/
private RecordStore recordStore = null;
/*
* The player name to use when
filtering.
*/
public static String playerNameFilter =
null;
/**
* The constuctor opens the underlying
record store,
* creating it if necessary.
*/
public RMSGameScores()
{
// Create a new record store for
this example
try
{
recordStore =
RecordStore.openRecordStore( "scores",
true );
}
catch ( RecordStoreException rse )
{
System.out.println( "Record
Store Exception in the ctor." + rse );
rse.printStackTrace();
}
}
Programming Handheld and
Mobile devices
15
Final example
/**
* startApp()
*/
public void startApp() throws
MIDletStateChangeException
{
RMSGameScores rmsgs = new
RMSGameScores();
rmsgs.addScore( 100, "Alice" );
rmsgs.addScore( 120, "Bill" );
rmsgs.addScore( 80, "Candice" );
rmsgs.addScore( 40, "Dean" );
rmsgs.addScore( 200, "Ethel" );
rmsgs.addScore( 110, "Farnsworth" );
rmsgs.addScore( 220, "Alice" );
RMSGameScores.playerNameFilter =
"Alice";
System.out.println( "Print all scores
followed by Scores for Farnsworth" );
rmsgs.printScores();
}
/*
* Part of the RecordFilter interface.
*/
public boolean matches( byte[] candidate )
throws IllegalArgumentException
{
// If no filter set, nothing can match it.
if ( this.playerNameFilter == null )
{
return false;
}
ByteArrayInputStream bais = new
ByteArrayInputStream( candidate );
DataInputStream inputStream = new
DataInputStream( bais );
String name = null;
try {
int score = inputStream.readInt();
name = inputStream.readUTF();
}
catch ( EOFException eofe ) {
System.out.println(eofe);
eofe.printStackTrace();
}
catch ( IOException eofe ) {
System.out.println( eofe );
eofe.printStackTrace();
}
return( this.playerNameFilter.equals( name ));
}
Programming Handheld and
Mobile devices
16
Final example
/**
/*
* Part of the RecordComparator interface.
*/
public int compare(byte[] rec1, byte[] rec2)
{
// Construct DataInputStreams for extracting the scores from
// the records.
ByteArrayInputStream bais1
= new ByteArrayInputStream( rec1
);
DataInputStream inputStream1 = new DataInputStream( bais1 );
ByteArrayInputStream bais2
= new ByteArrayInputStream( rec2
);
DataInputStream inputStream2 = new DataInputStream( bais2 );
int score1 = 0;
int score2 = 0;
try
{
// Extract the scores.
score1 = inputStream1.readInt();
score2 = inputStream2.readInt();
}
catch ( EOFException eofe )
{
System.out.println( eofe );
eofe.printStackTrace();
}
catch ( IOException eofe ) {
System.out.println( eofe );
eofe.printStackTrace();
}
// Sort by score
if ( score1 > score2 )
{
return RecordComparator.FOLLOWS;
}
else if ( score1 < score2 )
{
return RecordComparator.PRECEDES;
}
else
{
return RecordComparator.EQUIVALENT;
}
}
* Add a new score to the storage.
*
* @param score the score to store.
* @param playerName the name of the play achieving this score.
*/
public void addScore( int score, String playerName )
{
// Each score is stored in a separate record, formatted with
// the score, followed by the player name.
ByteArrayOutputStream baos
= new ByteArrayOutputStream();
DataOutputStream outputStream = new DataOutputStream( baos );
try
{
// Push the score into a byte array.
outputStream.writeInt( score );
// Then push the player name.
outputStream.writeUTF( playerName );
}
catch ( IOException ioe )
{
System.out.println( ioe );
ioe.printStackTrace();
}
// Extract the byte array
byte[] b = baos.toByteArray();
try
{
// Add it to the record store
recordStore.addRecord( b, 0, b.length );
}
catch ( RecordStoreException rse )
{
System.out.println( rse );
rse.printStackTrace();
}
}
Programming Handheld and
Mobile devices
17
Final example
/**
/**
* A helper method for the printScores methods.
*/
private void printScoresHelper( RecordEnumeration re )
{
try
{
while( re.hasNextElement() )
{
int id = re.nextRecordId();
ByteArrayInputStream bais = new
ByteArrayInputStream( recordStore.getRecord( id ) );
DataInputStream inputStream = new DataInputStream(
bais );
try
{
int score = inputStream.readInt( );
String playerName = inputStream.readUTF();
System.out.println( playerName + " = " + score
);
}
catch ( EOFException eofe )
{
System.out.println( eofe );
eofe.printStackTrace();
}
}
}
catch ( RecordStoreException rse )
{
System.out.println( rse );
rse.printStackTrace();
}
catch ( IOException ioe )
{
System.out.println( ioe );
ioe.printStackTrace();
}
* This method prints all of the scores sorted by game score.
*/
public void printScores()
{
try
{
// Enumerate the records using the comparator implemented
// above to sort by game score.
// No RecordFilter here. All records in
the RecordStore
RecordEnumeration re = recordStore.enumerateRecords( null,
this, true );
// Print all scores
System.out.println( "Print all scores..."
);
printScoresHelper( re );
RecordFilter
this, true );
+ this.playerNameFilter );
// Enumerate records respecting a
re = recordStore.enumerateRecords( this,
//Print scores for Farnsworth
System.out.println( "Print scores for : "
printScoresHelper( re );
}
catch ( RecordStoreException rse )
{
System.out.println( rse );
rse.printStackTrace();
}
}
}
Programming Handheld and
Mobile devices
18
Final example
/**
* pauseApp()
*/
public void pauseApp()
{
System.out.println( "pauseApp()");
}
/**
* destroyApp()
*
* This closes our open RecordStore when we are destroyed.
* @param cond true if this is an unconditional destroy
*
false if it is not
*
(ignored here and treated as unconditional)
*/
public void destroyApp( boolean cond )
{
System.out.println( "destroyApp( )");
try
{
if( recordStore != null )
recordStore.closeRecordStore();
}
catch ( Exception ignore )
{
// ignore this
}
}
}
Programming Handheld and
Mobile devices
19