1 / 16


J2ME. Java for Mobile Environments Based on J2ME In A Nutshell , by Kim Topley, O’Reilly & Associates Inc., 2002, and Tetris by Alexei Patinov. What is J2ME?. J2ME : Java 2 Micro Edition J2ME defines two configurations , ranges of hardware for which it can generate software:

Télécharger la présentation


An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.


Presentation Transcript

  1. J2ME Java for Mobile Environments Based on J2ME In A Nutshell, by Kim Topley, O’Reilly & Associates Inc., 2002,and Tetris by Alexei Patinov.

  2. What is J2ME? • J2ME : Java 2 Micro Edition • J2ME defines two configurations, ranges of hardware for which it can generate software: • CLDC : Connected Limited Device Configuration • CLDC devices include cell phones, PDAs, other items with roughly up to 512Kb of RAM. • CLDC devices have very limited processors; for example, CLDC devices are not required to support double or float types. • CDC : Connected Device Configuration • CDC devices fill the gap between PDAs and desktops; typical CDC devices might include Psions, smart phones, and set-top web devices. • Choice of Virtual machine is up to the hardware vendor. • Many CLDC device vendors use Sun’s KVM, the Kilobyte Virtual Machine.

  3. J2ME : Java 2 Micro Edition • Profiles • J2ME complements configurations with profiles, software to match the hardware. • Each configuration supports several profiles. • The most common profile in mobile phones is MIDP, the Mobile Information Device Protocol, which adds networking, user interface, and persistent storage support to the CLDC configuration. • J2SE re-use • J2ME is designed to re-use J2SE code wherever possible, or at least to pretend to. • Within the scope of features supported by a given configuration and set of profiles, wherever possible the J2ME implementation must not change interfaces or behavior from the J2SE original.

  4. J2ME : Java 2 Micro Edition • CLDC hardware requirements • 128 Kb permanent storage for the J2ME engine and classes • 32 Kb of RAM for applications to run in • MIDP hardware requirements • A screen at least 96 pixels wide and 54 pixels tall • Things the CLDC does not require: • Keyboard • Mouse • Floating-point support • Persistent app data storage • (This is supported by the MIDP profile.) • Multithreading or multiprocessing • (This is not required of the hardware; it’s left to the JVM.)

  5. J2ME : Java 2 Micro Edition • J2SE features missing from the CLDC: • Reflection (java.lang.reflect) • Weak references (java.lang.ref) • Object finalization (java.lang.Object has no finalize() method) • J2SE features reduced in the CLDC: • Advanced thread handling • Advanced error handling • JNI (the Java Native Interface) • J2SE behavior changed in the CLDC: • A number of security restrictions • The class verification step • (J2SE verifies bytecode on load. J2ME shifts the bytecode verification step to the vendor’s compiler.)

  6. MIDP Software Development • MIDP applications are called MIDlets. • (Because everything in Java is a somethinglet.) • MIDlets are groups of classes, one of which is derrived from the abstract class javax.microedition.midlet.MIDlet. • MIDlets can be packaged in MIDlet suites to group one or more MIDlets into the same space. • MIDlets sharing a suite can access each other’s persistent data and are run concurrently, giving an application-level interface to multithreading. • MIDlets sharing a suite are installed and uninstalled together. • Classes defined in a MIDlet suite are shared between all concurrent midlets; only one instance of each class in the suite is loaded per suite.

  7. MIDP Software Development • MIDlet packaging and installation • Deploying a MIDlet requires several more steps than deploying a conventional application. • JAR files and JAD files • The MIDlet [suite] being deployed is packaged, along with all of its supporting classes and data files, into a JAR file. • The JAR also needs to include a manifest which will detail the contents of the JAR. • The JAR must be paired with a JAD (Java Application Descriptor) file for installation. • The .jad is almost identical to the JAR’s; where the manifest is to allow installed software to be described to the user after loading, the .jad is used to describe the application to the user before it’s downloaded as part of the installation process.

  8. MIDP Software Development • Sample .jad or : MIDlet-1: Tetris,, TetrisMIDlet MIDlet-Description: Tetris MIDlet demo MIDlet-Name: Tetris MIDlet-Vendor: Me MIDlet-Version: 1.0.0 MicroEdition-Configuration: CLDC-1.0 MicroEdition-Profile: MIDP-1.0

  9. MIDP Software Development • Software you’ll need to install in order to develop MIDP applications: • The Java 2 SDK • I use J2SDK version • The J2ME CLDC • Sun’s Wireless Toolkit 1.04 • At least one cell phone emulator • I use the Nokia 7210 MIDP SDK 1.0 emulator • Software to deploy to your phone • I use the Nokia Developer Suite

  10. MIDP Software Development • Compiling and deploying a MIDlet 1) Java compiler • javac.exe -target 1.1 -bootclasspath "[Wireless toolkit path]\lib\" -d preverify *.java 2) Preverify • preverify.exe-classpath "[Wireless toolkit path]\lib\" -cldc -d postverify .\preverify 3) JAR builder • jar.exe cvfm Project.jar Project.jad -C postverify . 4) Deploy and test

  11. MIDP Software Deployment • Deploying MIDlets over the WWW • After you’ve tested your MIDlet on your local emulator and on a locally-connected cell phone (perhaps connected over an IR port) you’ll want to ship it to the world at large. • You’ll need to configure your web server to support the JAD MIME type. The JAD MIME type is • text/ • The user can now click on an HTML link such as • Click <a href=“sample.jad”>here</a> to... • This will download the JAD file. An attribute in the JAD file is the MIDlet-Jar-URL; if the phone user chooses to continue, the phone requests this URL from the server. • The JAR file is then transmitted with MIME type • application/java-archive

  12. Anatomy of a MIDlet • A MIDlet consists of [at least] one class extending javax.microedition.midlet.MIDlet, plus supporting classes. • You must implement three abstract methods: • startApp() • pauseApp() • destroyApp(boolean unconditional) • In startApp() you’ll create a user interface object--a Canvas or Screen.

  13. Anatomy of a MIDlet • J2ME provides two user interface approaches: • High-level UI: Screen • The Screen class and those derrived from it provide support for an assisted layout of high-level objects like buttons and text fields. This means that while it’s easier to control what goes where and how events are passed and so on, it’s harder to control precisely the contents of the screen. • Derived classes: Alert, Form, List and TextBox. • Low-level UI: Canvas • The Canvas class gives the developer complete control over the contents of the screen. While this has the upshot of giving you advanced graphical abilities and precise screen control, it has the downside that you have to do everything yourself. Tetris was written on a Canvas.

  14. Anatomy of a MIDlet • “Hello World”, the MIDlet: import javax.microedition.midlet.*; import javax.microedition.lcdui.*; public class HelloWorldMIDlet extends MIDlet { public HelloWorldMIDlet() { } public void pauseApp() { } public void destroyApp(boolean unconditional) { } public void startApp() { if (Display.getDisplay(this).getCurrent() == null) { HelloScreen helloScreen = new HelloScreen(this, "Hello World."); Display.getDisplay(this).setCurrent(helloScreen); } } void exitRequested() { destroyApp(false); notifyDestroyed(); } }

  15. Anatomy of a MIDlet • “Hello World” screen class: import javax.microedition.lcdui.*; class HelloScreen extends TextBox implements CommandListener { private final HelloWorldMIDlet m_midlet; private final Command m_exitCommand; HelloScreen(HelloWorldMIDlet midlet, String string) { super("HelloWorldMIDlet", string, 256, 0); m_midlet = midlet; m_exitCommand = new Command("Exit", Command.EXIT, 1); addCommand(m_exitCommand); setCommandListener(this); } public void commandAction(Command c, Displayable d) { if (c == m_exitCommand) m_midlet.exitRequested(); } }

  16. Recommended Reading • J2ME In A Nutshell, by Kim Topley, O’Reilly & Associates Inc., 2002 • Dense yet informative; details the guts of J2ME from below CLDC on up to forms and timers. Also has a handy reference to the new J2ME Java classes. • • The resource of all things Java. • This is where you can download the J2SDK and Wireless Toolkit. • • Good site to download phone emulators and SDKs. • Non-intrusive signup process required

More Related