Midlets: Compilarle da riga di comando

Recentemente, dove lavoro mi hanno fatto fare un corso per lo sviluppo di applicazioni per telefonini con J2ME. Ovviamente l’ambiente da utilizzare era configurato su macchine windows, con netbeans.

Da buon linuxaro che sono ho deciso di provare a fare le stesse cose da linux, evitando peró di installare netbeans. In questo articolo spiegheró gli step da seguire per installare i tools necessari, e compilare una Midlet di esempio.

Parte 1 – Installazione

Ovviamente il requisito base per scrivere MIDLet é avere installato almeno il Java JDK quindi prima di tutto procuratevene una copia e installatelo (Lo trovate qui).

Il secondo tool da installare é il Java Wireless Toolkit, contenente gli emulatori, e le librerie necessarie per sviluppare in J2ME. Il pacchetto lo potete scaricare da qua

Portatevi nella cartella dove é stato scaricato Il file, notate che é uno script shell, quindi rendiamolo eseguibile con il comando:

chmod a+x sun_java_wireless_toolkit-2.5.2_01-linuxi486.bin.sh

(controllate il nome del file che avete potrebbe essere leggermente differente), dopo di che lanciatelo con il comando:

./sun_java_wireless_toolkit-2.5.2_01-linuxi486.bin.sh

Seguite le istruzioni a video, al termine avrete il wireless toolkit installato nel path da voi specificato (io l’ho installato in /opt/WTK2.5.2).

Una volta terminato vi suggerisco di aggiungere il path degli eseguibili del WTK alla variabile d’ambiente PATH, digitate il seguente comando (o inseritelo nell’ultima riga del vostro file .bashrc:

PATH=$PATH:/opt/WTK2.5.2/bin

I jar  che andremo ad utilizzare si trovano nella cartella lib di WTK, quindi nel mio caso staranno in: /opt/WTK2.5.2/lib, se volete potete creare una variabile d’ambiente anche per questo path:

WTK_LIB=/opt/WTK2.5.2/lib

In particolare i jar che ci servono sono:

  • midpapi20.jar
  • cldcapi10.jar

Parte 2 – Creiamo i files necessari

Creiamo innanzitutto una cartella che conterrá il nostro progetto, nell’esempio verrá chiamata MidletExample:

mkdir MidletExample

Al suo interno creiamo due cartelle:

mkdir compiled
mkdir verified

Dopo di che sempre all’interno della cartella MidletExample, creiamo il file Manifest (verrá utilizzato per creare poi il file jad utilizzato dal telefonino), con le seguenti informazioni:

MIDlet-Name: PrinterMIDlet
MIDlet-Vendor: Vendor
MIDlet-Version: 1.0
MIDlet-Icon: /icon.png
MIDlet-URL: http://italialinux.altervista.org
MicroEdition-Configuration: CLDC-1.0
MicroEdition-Profile: MIDP-2.0
MIDlet-1: PrinterMIDlet, /icon.png, PrinterMidlet

Dove i campi indicano:

  • MIDlet-Name: Il nome della MIDlet
  • MIDlet-Vendor: il nome di chi la distribuisce (il vostro nome, il nome della vostra societá)
  • MIDlet-Version: La versione della Midlet
  • MIDlet-Icon: l’icona da utilizzare per la vostra applicazione
  • MIDlet-Url: l’url della Midlet
  • Midlet-1: Prende tre parametri, il nome dell’applicazione, l’icona, e la classe da lanciare all’avvio. Da notare che il parametro icon è facoltativo quindi si puo omettere (ma anche se nn lo mettete lasciate lo spazio vuoto inserendo comunque 2 virgole).
  • Microedition-Configuration e Microedition-Profile indicano la versione del CLDC e del MIDP.

Dopo di che scriviamo la nostra classe di esempio (Da notare che deve avere lo stesso nome della Midlet definita nel manifest, quindi nel Manifest abbiamo PrinterMidlet, creiamo il nostro file PrinterMidlet.java e inseriamo il nostro codice:

/*
 * PrinterMidlet.java
 *  by: italialinux.altervista.org
 */
 
import javax.microedition.lcdui.Display;
import javax.microedition.lcdui.Form;
import javax.microedition.midlet.*;
 
/**
 * @author inuyasha
 */
public class PrinterMidlet extends MIDlet {
 
    public void startApp() {
        Form myForm = new Form("My Frist App");
        myForm.append("J2me example!!!");
        Display.getDisplay(this).setCurrent(myForm);
    }
 
    public void pauseApp() {
    }
 
    public void destroyApp(boolean unconditional) {
    }
}

Parte 3 – Compiliamo

Bene abbiamo creato la nostra classe di esempio e il file manifest, passiamo ora alla compilazione e creazione del pacchetto per il telefonino. Ci serviranno:

  • javac
  • jar
  • unzip
  • preverify (scaricato con il Wireless Toolkit)

Il primo passo ovviamente è compilare la classe con il comando:

javac -bootclasspath $WTK_LIB/midpapi20.jar:$WTK_LIB/cldcapi11.jar -target 1.3
-source 1.3 -d compiled -classpath compiled -sourcepath .
-g PrinterMidlet.java

Con questo comando compiliamo il nostro file sorgente nella cartella destinazione compiled, usando come librerie i files midpapi20.jar e cldcapi10.jar.

Il passo successivo e usare un utility chiamata preverify

preverify -classpath $WTK_LIB/midpapi20.jar:$WTK_LIB/cldcapi11.jar:compiled
-d verified PrinterMidlet

Si tratta di uno step che fa una serie di verifiche sul bytecode, aggiungendo delle annotations al classfile. Questo serve perche quando un sistema J2ME tenta di eseguire una classe, verifica prima la presenza di queste annotations..

Il comando come vedete è abbastanza semplice, gli argomenti sono: il classpath (viene aggiunta anche la cartella compiled, in quanto questa conterrà il file .class compilato con il comando precedente), la cartella di destinazione del file verificato (-d verified) e il nome della classe da verificare (senza l’estensione .class) PrinterMidlet.

Una volta terminato questo step siamo pronti a creare il jar file:

jar cfm PrinterMidlet.jar Manifest icon.png -C verified PrinterMidlet.class

Dove diciamo con cfm di:

  • creare il .jar PrinterMidlet (la lettera cf)
  • includere il manifest file  Manifest (la lettera m)

Inoltre con -C indichiamo al programma jar di  portarsi nella cartella verified ed aggiungere a partire da quella cartella il file PrinterMidlet.class (ovviamente possiamo aggiungere anche altri files).

Siamo a un passo dalla fine, ora abbiamo il nostro file jar, ci manca di creare il file .jad che viene utilizzato dal telefonino per installare (e scaricare se necessario) il nostro programma. Questo puo tranquillamente venir fatto a partire dal nostro Manifest che si trova nel jar aggiungendo alcune informazioni. Quindi prima di tutto estraiamo le informazioni dal Manifest al nuovo file PrinterMidlet.jad:

unzip -aa -j -p PrinterMidlet.jar "META-INF/MANIFEST.MF" > PrinterMidlet.jad

Ora dobbiamo aggiungere dove si trova il file .jar (potrebbe essere anche uno URL) e la dimensione di questo:

echo "Midlet-Jar-URL: PrinterMidlet.jar" >> PrinterMidlet.jad 
echo "Midlet-Jar-Size: jarfilesize" >> PrinterMidlet.jad

Bene il nostro pacchetto è creato. Ora non ci resta che caricarlo sul telefonino e lanciare il file jad (se tutto va bene vi dovrebbe chiedere di installarlo).

Se volete provarlo potete utilizzare l’emulatore del WTK, con il comando:

emulator -Xdescriptor:PrinterMidlet.jad

Se tutto ha funzionato correttamente il risultato dell’emulatore sarà simile al seguente:

Ciao alla prossima!

4 thoughts on “Midlets: Compilarle da riga di comando”

  1. Per fare tutto questo in modo ancora più semplice, potresti usare Apache Ant.

    Basta creare i task che ti servono (clean, build, preverify, pack/jar e run) e all’atto della compilazione specificare il bootclasspath o il classpath adeguato.

    1. Sisi lo so.

      Ma il mio scopo in questo articolo era proprio usare solamente la linea di comando, senza ausilio di tool esterni.
      Ivan

Leave a Reply

Your email address will not be published. Required fields are marked *