Relation to MIDP 1.0

• MIDP 2.0 is an extension of MIDP 1.0
• Nothing is removed from MIDP 1.0, so all programs that run under MIDP 1.0 should also run under MIDP 2.0
• MIDP 2.0 adds classes in the areas of
  • Networking
  • Multi-media
  • GUI

Networking extensions

Networking is still based on the Connector.open class. Other types of connection are added

• Sockets: (SocketConnection) Connector.open("socket://...")
• HTTPS: (HttpsConnection) Connector.open("https://...")
SSL: (SSLConnection) Connector.open(ssl://...")
• Server Socket: omit the server name (ServerSocketConnection) Connector.open(socket://:80 starts a server on port 80
• UDP datagram:
(UDPDatagramConnection) Connector.open("datagram://...")
• Serial port: (CommConnection) new Connector.open("comm:...")

Packaging

• To develop a MIDP application the java compiler can be used to create .class files and these can be run directly from the emulator
• In a mobile environment, the files have to be downloaded from somewhere else to the mobile phone e.g. from a web server
• The class files have to be packaged together in a particular way before they can be downloaded
• A manifest.mf must be created using a text editor to hold information about the class files, entry point (where main() is) etc. This is standard to all versions of Java
• A .jar file is created to hold the class files and manifest file, using the jar command
• A .jad file is created using a text editor. This includes the location of the jar file (maybe as a URL)
• Load the jad and jar files onto the web server, configured to recognise their extensions
• Point the emulator/phone to the jad file

Push Registry

• A normal server machine has large disk and RAM (e.g 512M RAM) with virtual memory capabilities
• There is enough capacity to run a separate process for each service (e.g. telnet server, HTTP server, mail server...)
• A CLDC device does not have enough memory to run lots of servers
• A CLDC device can use a trick like the Unix inet server: a single server that listens on lots of ports,and starts the appropriate service when a message arrives
• An application descriptor file holds lines like

  
        MIDlet-Push-1: socket://:79, com.sun.example.SampleChat, *
        

• When downloaded to the CLDC device, the application manager reads this and will call the midlet's startApp() method when a TCP connection is made on port 79

Push registry pseudocode

• A midlet can be registered with the push registry statically, by putting information in the jad file
• You never start a statically registered midlet yourself. It is always started by the AMS (Application management system)
• A midlet started from the push registry should run only long enough to handle the session (typically just a couple of messages) and then exit
• Pseudocode

  
    startApp() {
        // we have been started because there is a connection for us
        open connection
        handle message(s)
        exit the midlet
    }
        

• The alternative is that the first time a midlet has been run, it registers itself
• Pseudocode

  
    startApp() {
        if (first time this midlet has run)
            register the midlet
            exit
        else
            open connection
            handle message(s)
            exit
    }
        

• Note that in neither case is there a while loop - the midlet just handles one session and then exits. The while loop in previous servers is handled by the AMS

Turning pseudocode to real code

• How does the midlet exit? By calling notifyDestroyed(). For safety (ensure it cleans up) also call destroyApp()

  
        // exit
        destroyApp();
        notifyDestroyed();
        

• How do we know it's the first time? Ask how many connections there are for the midlet. If there are none, then it's the first time the midlet has started

  
        String[] connections = PushRegistry.listConnections();
        if (connections == null || connections.length == 0) {
            // first time - so register
        } else {
            // called by AMS in response to incoming connection
        }
        

GUI

• A Spacer allows control over spacing between elements in a Form
• A Sprite contains multiple images that can displayed to give simple animations
  
• A Layer is a superclass for visual elements in games. A Sprite is a subclass of Layer
• A TiledLayer is used for e.g. backgrounds made up of tiled images
• A CustomItem can be subclassed to define your own additional elements for Forms

Multi-media

MIDP 2.0 has a number of classes for handling multi-media

• Player
• Manager
• Control
• ToneControl
• VolumeControl
• PlayerListener
• Controllable

Media support

The CLDC device can tell you what protocols and what media types it can handle

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

public class MediaInfo extends MIDlet {

    public MediaInfo() {
    }

    public void startApp() {
	String [] protocols = Manager.getSupportedProtocols(null);
	System.out.println("Supported protocols are:");
	for (int n = 0; n < protocols.length; n++) {
	    System.out.println("- " + protocols[n]);
	    String [] contentTypes = 
		Manager.getSupportedContentTypes(protocols[n]);
	    System.out.println("    Supported content types are:");
	    for (int m = 0; m < contentTypes.length; m++) {
		System.out.println("        " + contentTypes[m]);
	    }
	}
    }

    public void pauseApp() {
    }

    public void destroyApp(boolean unconditional) {
    }
}

Single tones

• The Manager.playTone(int tone, int duration, int volume) can be used to pplay a single tone
• The method returns immediately, with the tone played asynchronously
• It can't really be used to play a tone sequence due to timing issues

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

public class Tone1 extends MIDlet {

    protected Display display;
    protected Form form;

    public Tone1() {
	display = Display.getDisplay(this);
	form = new Form("Info entry form");
    }

    public void startApp() {
	display.setCurrent(form);
	try {
	    Manager.playTone(ToneControl.C4, 200, 100);
	    // sleep about the same time as the
	    // tone plays for
	    Thread.sleep(2000);
	    // the next tone may be early, late
	    // or maybe on time
	    Manager.playTone(80, 2000, 100);
	} catch(MediaException e) {
	    System.out.println(e.toString());
	} catch(InterruptedException e) {
	}
    }

    public void pauseApp() {
    }

    public void destroyApp(boolean unconditional) {
	display = null;
	form = null;
    }
}

Tone sequences

• A player that can play tone sequences can be found by

  
        Player p = Manager.createPlayer(Manager.TONE_DEVICE_LOCATOR)
        

• See the API for Manager.TONE_DEVICE_LOCATO for information on using this

Echo server

The following server uses ServerSocketConnection to listen to connections on port 8189. Each message that is received on this port is echo'ed back to the client

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

public class EchoServer extends MIDlet implements Runnable {
    
    public static int MYECHOPORT = 8189;

    public void run() {
	ServerSocketConnection s = null;
	try {
	    s = (ServerSocketConnection) Connector.open("socket://:" + 
							 MYECHOPORT);
	} catch(IOException e) {
	    System.out.println(e);
	    return;
	}

	while (true) {
	    try {
		// Wait for a connection.
		SocketConnection sc = (SocketConnection) s.acceptAndOpen();

		handleSocket(sc);
	    } catch(IOException e) {
		break;
	    }
	}  
    }

    public void startApp() {
	new Thread(this).start();
    }

    public void pauseApp() {
    }
    
    public void destroyApp(boolean unconditional) {
    }
    
    public static void handleSocket(SocketConnection incoming)
	throws IOException {
	System.out.println("Got connection");
	DataInputStream din = incoming.openDataInputStream();
	DataOutputStream dout = incoming.openDataOutputStream();
	
	boolean done = false;
	while ( ! done) {
	    String str = din.readUTF();
	    if (str == null) {
		done = true;
		System.out.println("Null received");
	    }
	    else {
		System.out.println("Echo: " + str);
		dout.writeUTF(str);
	    }
	    
	}
	din.close();
	dout.close();
	incoming.close();
    }
}

Echo client

This client connects to a server on port 8189 and sends two messages

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

public class EchoClient extends MIDlet implements Runnable {

    public static final int MYECHOPORT = 8189;

    public void run() {
	String address = "localhost";

	SocketConnection sock = null;
	DataInputStream din = null;
	DataOutputStream dout = null;
	System.out.println("Opening connection");
	try {
	    sock = (SocketConnection) Connector.open("socket://" +
						     address + ":" +
						     MYECHOPORT);
	    din = sock.openDataInputStream();
	    dout = sock.openDataOutputStream();
	} catch(IOException e) {
	    e.printStackTrace();
	    System.exit(3);
	}

	System.out.println("Opened connection");
	String response = null;
	try {
	    // Just send a few messages, for testing
	    dout.writeUTF("Hello");
	    response = din.readUTF();
	    System.out.println("Response: " + response);

	    dout.writeUTF("Bye");
	    response = din.readUTF();
	    System.out.println("Response: " + response);
	} catch(IOException e) {
	    e.printStackTrace();
	    return;
	}

	return;
    }

    public void startApp() {
	// run all the socket handling code 
	// in a separate thread
	new Thread(this).start();
    }

    public void pauseApp() {
    }
    
    public void destroyApp(boolean unconditional) {
    }
} // Client

Reading and writing on sockets

J2ME does not have the full range of IO classes that are in the J2SE. For example, it does not have BufferedReader and PrintStream that are useful for reading and writing lines of text. It only has InputStream, DataInputStream, OutputStream and DataOutputStream.

To read and write strings using In/OutputStream, you need to turn the strings into byte arrays

    InputStream in = ...;
    OutputStream out = ...;
    String msg = "hello";
    byte[] barray = msg.getBytes();
    out.write(barray);

    in.read(barray);
    msg = new String(barrray);

To read and write strings using DataIn/OutputStream, use the UTF methods

    DataInputStream din = ...;
    DataOutputStream dout = ...;

    String str = din.readUTF();
    dout.writeUTF(str);