Le J2Me : Java for Mobile Application
MIDLET's
Le Midlet est le coeur d'un programme J2ME. il, peut est comparé au "main" en c ou en J2SE classiquen sauf qu'il s'agit d'une classe entière.
Le MIDLET
La midlet est l'application lancée sous le contrôle du "Application Management Software".
Ce dernier est lancée sous controle de du Runtime de MIDP. L'AMS est donc en charge de la duirée de vie et de l'execution de toute applet.
On notera ainsi que chaque MIDLET (et tout programme J2ME hérite de MIDLET) doit implémenter 3 méthodes, qui seront controlées par l'AMS:
- startApp() est effectué au démarrage ou redémarrage.
- paused() utilisée pour empecher le blocage de ressoruce par l'applet
- destroyApp qui sert de fin de vie "naturelle" à l'applet
Exemple de MIDLET classique : le HelloWorld :
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
public class HelloWorld extends MIDlet {
private Display myDisplay;
public HelloWorld() {
}
public void startApp() throws MIDletStateChanged {
// first run, create forms
myDisplay = Display.getDisplay( this );
myDisplay.setCurrent(new Form("Hello World"););
}
public void pauseApp() {
}
public void destroyApp(
}
}
Dans l'exemple de code précédent, lze programme affiche un "formulaire" ayant pour titre Hello World. Cet exemple a pour but de faire percevoir les principes du MIDLET.
La manipulation graphique
Une midlet active a normalement accès à l'écran. Celui ci est représenté par la classe Display et l'unique instance de cette classe est obtenue en appelant Display.getDisplay(m) où m est la midlet comme dans l'exemple précédent. Il peut ainsi etre compéré à la Frame d'un porgramme Java.
Cependant ce display peut être manipulé sous deux formes :
- En dessinant dessus directement à l'aide des outils du package Canvas. Ces dernier agissant à bas niveau sur l'affichagenn ils permettent une manipulation fine de l'outil.
- les objets sous classant Screen (resp. Component en J2SE) permettant de manier des outils classiques tels que les listes, boite de dialogues... Le lecteur est renvoyé à la documentation Sun pour l'étendue de ces objets.
- Concernant les formulaires : la classe Form hérite de Screen comme tous les composants graphique mais peut (comme un Panel en J2SE), contenir d'autre composants. Elle est nécessaire à l'affichage de touts élément Screen car est la seul proposant un layout par défaut.
Les listeners:
Les boutons doivent être enregistrés aupres d'une classe implémentant l'interface CommandListener. Une fois déclaré (1), le bouton douit etre ajouter dans le pool du CommandListener (2).
L'appel du bouton utilise la méthode commandAction de l'interface (qui aura été détaillé) pour définir l'action a faire en fonction du bouton appelé(3). Ci dessous un exemple :
public class HelloWorld extends MIDlet implements CommandListener{
form = new Form("HelloWorld");
...
exitButton = new Command("Exit", Command.SCREEN,1); // 1
form.addCommand(exitButton); // (2)
public void commandAction(Command c, Displayable s) { //3
// verifie le bouton
if (c == exitButton) {
.../
}
}
Une commande (Command) encapsule à la fois le nom (ce qui est affiché), le type (intention de la commande comme BACK, CANCEL, OK) et la priorité d'une action.
L'utilsation des flux
Les objets permettant les entrées/sorties en MIDP sont des sous classes de la classe Connection. Ils sont créés par la méthode Connector.open et dépendent de l'argument URL passé. En particulier le type de connexion dépend du schéma de l'URL :
Si l'URL n'a pas de nom de machine, il s'agit d'un port en réception. Les arguments de configuration peuvent être passés comme arguments des URLs. Par exemple :
DatagramConnection dc = (DatagramConnection) Connector.open("datagram://:1024");
ouvrira un datagramme sur le port 1024 en réception, alors que :
HttpConnection http = (HttpConnection) Connector.open ("http://etudiant.univ-mlv.fr/~jfontera/j2me.txt");
Ouvrira une connexion sur une url donnée.
Les différents types possibles de connexion (liste exhaustive de par l'existence de flux proprietaires):
file ; http(s) ; datagram , socket sms, apdu.
Notons également, que MIDP 2.0 apporte de nouveau types de connexion en natif : sms, btl2cap pour le bluetooth
La persistence
Le stockage persistant est un endroit non-volatile pour stocker l'état d'objets. Sans stockage persistant, des objets et leurs états sont détruits quand une application se ferme.
la persistance, et est manipulé dans MIDP par RMS (système de gestion des registres).
Ce mécanisme est une base de données simple appelée Record Management System (RMS). Une base de données de MIDP se compose d'une collection d'enregistrements qui demeurent persistants après les sorties de MIDlet.
Ce mécanisme est implémenté dans le package javax.microedition.rms .
La création d'un flux se fait simplement :
RecordStore db = RecordStore.openRecordStore("myDBfile", true);
Il suffit ensuite d'opérer les actions souhaitées sur le flux en question :
Exemple de lecture:
ByteArrayOutputStream baos = new ByteArrayOutputStream(); DataOutputStream dos = new DataOutputStream(baos); dos.writeUTF(record); byte[] b = baos.toByteArray(); db.addRecord(b, 0, b.length);
Exemple d'écriture :
ByteArrayInputStream bais = new ByteArrayInputStream(db); DataInputStream dis = new DataInputStream(bais); String in = dis.readUTF();
Un exemple : les sms
Comme expliqué, les flux réseau sont gérés par le J2Me. La seule contrainte sera l'opportunité laissée au terminal d'avoir accès aux ressources.
Voyons ici un exemple simple d'envoie de sms.
On ouvre en premier lieu la connexion sur le terminal :
MessageConnection sms_con=(MessageConnection)Connector.open("sms://"+telNumber+":"+smsPort);
Puis on ecrit le message dans le flux ouvert :
TextMessage sms=(TextMessage)sms_con.newMessage(MessageConnection.TEXT_MESSGE);
sms.setAddress(tel+":"+smsPort);
sms.setPayloadText("I love you");
Enfin on envoie le SMS :
sms_con.send(sms);
sms_con.close();
Note : il est possible de connaitre le port par défaut (ici smsPort ) avec la commande :
String smsPort = getAppProperty("SMS-Port");