Developpez.com - Java
X

Choisissez d'abord la catégorieensuite la rubrique :


Développons en Java

Par Jean-Michel Doudoux (home)
 

Développons en Java : didactiel de JM-Doudoux, Version 0.8


Partie 6. Développement d'applications mobiles
55. J2ME
55.1. Présentation de J2ME
55.2. Les configurations
55.3. Les profiles
55.4. J2ME Wireless Toolkit 1.0.4
55.4.1. Installation du J2ME Wireless Toolkit 1.0.4
55.4.2. Premiers pas
55.5. J2ME wireless toolkit 2.1
55.5.1. Installation du J2ME Wireless Toolkit 2.1
55.5.2. Premiers pas
56. CLDC
56.1. Le package java.lang
56.2. Le package java.io
56.3. Le package java.util
56.4. Le package javax.microedition.io
57. MIDP
57.1. Les Midlets
57.2. L'interface utilisateur
57.2.1. La classe Display
57.2.2. La classe TextBox
57.2.3. La classe List
57.2.4. La classe Form
57.2.5. La classe Item
57.2.6. La classe Alert
57.3. La gestion des évenements
57.4. Le Stockage et la gestion des données
57.4.1. La classe RecordStore
57.5. MIDP for Palm O.S.
57.5.1. Installation
57.5.2. Création d'un fichier .prc
57.5.3. Installation et exécution d'une application
58. CDC
59. Les profils du CDC
59.1. Foundation profile
59.2. Personal Basis Profile (PBP)
59.3. Personal Profile (PP)
60. Les autres technologies pour les applications mobiles
60.1. KJava
60.2. PDAP (PDA Profile)
60.3. PersonalJava
60.4. Java Phone
60.5. JavaCard
60.6. Embedded Java
60.7. Waba, Super Waba, Visual Waba


Partie 6. Développement d'applications mobiles

Le marché des machines portables est en pleine expansion : téléphones mobiles, PDA, ... De plus en plus d'applications s'exécutent sur des machines embarquées.

Sun propose une édition particulière de Java pour ce type de développement : J2ME (Java 2 Micro Edition).

Cette partie contient les chapitres suivants :

  • J2ME : présente la plate-forme java pour le développement d'applications sur des appareils mobiles tel que des PDA ou des téléphones cellulaires
  • CLDC : présente les packages et les classes de la configuration CLDC
  • MIDP : propose une présentation et une mise en oeuvre du profil MIDP pour le développement d'applications mobiles
  • CDC : présente les packages et les classes de la configuration CDC
  • Les profils du CDC : propose une présentation et une mise en oeuvre des profils pouvant être mis en oeuvre avec la CDC
  • Les autres technologies pour les applications mobiles : propose une présentation des autres technologies basées sur Java pour développer des applications mobiles

55. J2ME

J2ME est la plate-forme java pour développer des applications sur des appareils mobiles tel que des PDA, des téléphones cellulaires, des terminaux de points de vente, des systèmes de navigations pour voiture, ...

C'est une sorte de retour aux sources puisque Java avait été initialement développé pour piloter des appareils électroniques.

Ce chapitre contient plusieurs sections :

  • Présentation de J2ME : présentation rapide de J2ME
  • Les configurations : présentation des deux configurations sur lesquels la plate-forme J2ME repose
  • Les profiles : présentation des profiles qui enrichissent les configurations pour un type machines ou à une fonctionnalité spécifique
  • J2ME Wireless Toolkit 1.0.4 : Installation et mise en oeuvre de cet outil proposé par Sun pour le développement d'applications utilisant MIDP 1.0
  • J2ME wireless toolkit 2.1 : Installation et mise en oeuvre de cet outil proposé par Sun pour le développement d'applications utilisant MIDP 1.0 et 2.0

55.1. Présentation de J2ME

Historiquement, Sun a proposé plusieurs plate-formes pour le développement d'applications sur des machines possédant des ressources réduites, typiquement celles ne pouvant exécuter une JVM répondant aux spécifications complètes de la plate-forme J2SE.

  • JavaCard : pour le développement sur des cartes à puces
  • EmbeddedJava :
  • PersonnalJava : pour le développement sur des machines possédant au moins 2mo de mémoire
En 1999, Sun propose de mieux structurer ces différentes plate-formes sous l'appellation J2ME (Java 2 Micro Edition). Seule le plate-forme JavaCard n'est pas incluse dans J2ME et reste à part.

Par rapport à J2SE, J2ME utilise des machines virtuelles différentes. Certaines classes de base de l'API sont communes avec cependant de nombreuses omissions dans l'API J2ME.

L'ensemble des appareils sur lequel peut s'exécuter une application écrite avec J2ME est tellement vaste et disparate que J2ME est composé de plusieurs parties : les configurations et les profiles qui sont spécifiés par le JCP. J2ME propose donc une architecture modulaire.

Chaque configuration peut être utilisée avec un ensemble de packages optionnels qui permet d'utiliser des technologies particulières (Bluetooth, services web, lecteur de codes barre, etc ...). Ces packages sont le plus souvent dépendant du matériel.

L'inconvénient de ce principe est qu'il déroge à la devise de Java "Write Once, Run Anywhere". Ceci reste cependant partiellement vrai pour des applications développées pour un profile praticulier. Il ne faut cependant pas oublier que les types de machines cibles de J2ME sont tellement differents (du téléphone mobile au set top box), qu'il est surement impossible de trouver un dénominateur commun. Ceci associé à l'explosion du marché des machines mobiles explique les nombreuses évolutions en cours de la plate-forme.

J2ME est la plate-forme Java la plus récente.

De plus amples informations peuvent être obtenues sur les deux sites de Sun :

et sur les sites


55.2. Les configurations

Les configurations définissent les caractéristiques de bases d'un environnement d'exécution pour un certain type de machine possédant un ensemble de caractéristiques et de ressources similaires. Elles se composent d'une machine virtuelle et d'un ensemble d'API de base.

Deux configurations sont actuellement définies :

  • CLDC (Connected Limited Device Configuration)
  • CDC (Connected Device Configuration).
La CLDC 1.0 est spécifiée dans la JSR 030 : elle concerne des appareils possédant des ressources faibles (moins de 512 Kb de RAM, faible vitesse du processeur, connexion réseau limitée et intermittente) et une interface utilisateur réduite (par exemple un téléphone mobile ou un PDA "bas de gamme"). Elle s'utilise sur une machine virtuelle KVM. La version 1.1 est le résultat des spécifications de la JSR 139 : une des améliorations les plus importantes est le support des nombres flottants.

La CDC est spécifié dans la JSR 036 : elle concerne des appareils possédant des ressources plus importantes (au moins 2Mb de RAM, un processeur 32 bits, une meilleure connexion au réseau), par exemple un settop box ou certains PDA "haut de gamme". Elle s'utilise sur une machine virtuelle CVM


55.3. Les profiles

Les profiles se composent d'un ensemble d'API particulieres à un type de machines ou à une fonctionnalité spécifique. Ils permettent l'utilisation de fonctionnalités précises et doivent être associés à une configuration. Ils permettent donc d'assurer une certaine modularité à la plate-forme J2ME.

Il existe plusieurs profiles :

Profil Configuration JSR  
MIDP 1.0 CLDC 37 Package javax.microedition.*
Foundation Profile CDC 46  
Personal Profile CDC 62  
MIPD 2.0 CLDC 118  
Personal Basis Profile CDC 129  
RMI optional Profile CDC 66  
Mobile Media API (MMAPI) 1.1 CLDC 135 Permet la lecture de clips audio et vidéo
PDA 75  
JDBC optional Profile CDC 169  
Wireless Messaging API (WMA) 1.1 CLDC 120 Permet l'envoi et la réception de SMS
Les utilisations possibles des profils sont :

Application Midlet
MIDP
CLDC
KVM
Application pour Palm
MIDP for Palm OS
CLDC
KVM
Application
Personnal Profile
Personal Basis Profile
Foundation Profile
CDC
CVM
MIDP est un profile standard qui n'est pas défini pour une machine particulière mais pour un ensemble de machines embarquées possédant des ressources et une interface graphique limitée.

Sun a développé un profil particulier nommé KJava pour le développement spécifique sur Palm. Ce profile a été remplacé par un nouveau profil nommé MIDP for Palm OS.

Le Foundation Profile est un profil de base qui s'utilise avec CDC. Ce profil ne permet pas de développer des IHM. Il faut lui associer un des deux profils suivants :

  • le Personal Basic Profile permet le développement d'application connectée avec le réseau
  • le Personal Profile est un profil qui permet le développement complet d'une IHM et d'applet grace à AWT.
PersonalJava est remplacé par le Personal Profile.

Le choix du ou des profils utilisés pour les développements est important car il conditionne l'exécution de l'application sur un type de machine supporté par le profil.

Cette multitude de profils peut engendrer un certain nombre de problème lors de l'exécution d'une application sur différents périphériques car il n'y a pas la certitude d'avoir à disposition les profils nécessaires. Pour résoudre ce problème, une spécification particulière issue des travaux de la JSR 185 et nommée Java Technology for the Wireless Industry (JTWI) a été développée. Cette spécification impose aux périphériques qui la respectent de mettre en oeuvre au minimum : CLDC 1.0, MIDP 2.0, Wireless Messaging API 1.1 et Mobile Media API 1.1. Son but est donc d'assumer une meilleure compatibilité entre les applications et les différents téléphones mobiles sur lesquelles elles s'exécutent.


55.4. J2ME Wireless Toolkit 1.0.4

Sun propose un outil pour développer des applications J2ME utilisant CLDC/MIDP. Cet outil peut être téléchargé à l'url suivante : http://java.sun.com/products/j2mewtoolkit/index.html

La version 1.0.4 de cet outil permet de développer des applications utilisant MIDP 1.0.


55.4.1. Installation du J2ME Wireless Toolkit 1.0.4

L'installation ci dessous concerne la version 1.0.4.

Il faut exécuter le fichier j2me_wireless_toolkit-1_0_4_01-bin-win.exe


Il faut suivre les instructions suivantes, guidées par l'assistant d'installation :

  • sur la page d'accueil (welcome) , cliquez sur "Suivant"
  • sur la page d'acception de la licence, lire la licence et l'approuver en cliquant sur "Yes"
  • sur la page de sélection de localisation de la JVM, cliquez sur "Next" (sélectionner l'emplacement si aucune JVM n'a été détectée automatiquement)
  • sélectionner l'emplacement de l'installation de l'outil et cliquez sur "Next"
  • cliquez sur "Next" pour accepter le menu par défaut dans le menu "Démarrer/Programme"
  • sur la page de résumé des opérations, cliquez sur "Next"
  • sur le dernière page (Complete), cliquez sur "Finish"

55.4.2. Premiers pas

Il faut exécuter l'outil KToolBar.

Pour créer un projet, il faut cliquer sur le bouton "New Project" ou sur l'option "New Project" du menu "File".

Il faut saisir le nom du projet et le nom qualifié de la midlet puis cliquer sur "Create Project".

Il faut ensuite créer la ou les classes dans le répertoire src de l'arbrorescence du projet.

Pour construire le projet, il faut cliquer sur le bouton "Build".

Pour exécuter le projet, il suffit de choisir le type d'émulateur à utiliser et cliquer sur le bouton "Run".

Exemple : avec l'émulateur de téléphone par défaut.

Cliquer sur l'application "Test"

puis cliquer sur le bouton entre les flèches

Il est aussi possible d'utiliser l'émulateur Palm POSE (Palm O.S. Emulator). L'outil demande le chemin d'accès à POSE,

Puis l'outil génère un fichier .prc.

Enfin, il lance l'émulateur et installe le fichier pour l'exécuter.

Pour plus de détails, voir la section sur MIDP for Palm OS.


55.5. J2ME wireless toolkit 2.1

La version 2.0 permet d'utiliser MIDP 1.0 ou 2.0 ainsi que les API optionnels Mobile Media et Wireless Messaging . Il peut être intégré dans d'autres IDE tel que Sun Studio Mobile Edition ou JBuilder.

La version 2.1 permet d'utiliser CLDC 1.1 et l'API J2ME Web service et de développer des applications pour des périphériques qui respectent les spécifications JTWI.


55.5.1. Installation du J2ME Wireless Toolkit 2.1

La version 2.1 du J2ME Wireless Toolkit nécessite la présence sur le système d'un J2SE 1.4 minimum.

Elle permet le développement d'applications répondant aux spécifications de la JSR-185 (Java Technology for the Wireless Industry) qin inclue : CLDC 1.1, MIDP 2.0, WMA 1.1 MMAPI 1.1.

Elle permet aussi l'utilisation de la JSR-172 (J2ME Web Services Specification).

Lancer l'application j2me_wireless_toolkit-2_1-windows.exe. Un assistant guide l'utilisateur dans les différentes étapes de l'installation :

  • sur la page d'accueil, cliquez sur le bouton « Next »
  • sur la page « License Agreement » : lire la licence et si vous l'acceptez, cliquez sur le bouton « Yes »
  • sur la page « Java Virtual Machine Location » : le programme détecte automatiquement la présence d'un JDK 1.4 ou supérieure, cliquez sur le bouton « Next »
  • sur la page « Choose Destination Location » : sélectionnez le répertoire d'installation de l'application et cliquez sur le bouton « Next »
  • sur la page « Select Program Folder » : saisissez ou sélectionner le dossier du menu démarrer qui va contenir les raccourcis vers l'application si celui par défaut ne convient pas. Cliquez sur le bouton « Next »
  • sur la page « Start Copying files » : un résumé des options d'installation est affiché. Cliquez sur le bouton « Next »
  • les fichiers de l'application sont copiés. Une fois celle ci terminée, la page « Installshield Wizard Complete » s'affiche. Cliquez sur le bouton « Finish ».
L'installation créé les répertoires suivants :

appdb\ contient les bases de données de type RMS des applications
apps\ contient les applications développées comme applications de démo
bin\ contient les outils du WTK
docs\ contient la documentation du WTK et des API
lib\ contient les bibliothèques des API

55.5.2. Premiers pas

L'outil Ktoolbar est un petit IDE qui permet de compiler, pré-vérifier, packager et exécuter des applications utilisant le profile MIDP. Il ne permet pas l'édition du code des applications : il faut utiliser un éditeur externe pour réaliser cette tâche.

La première chose à faire pour créer une application est de créer un nouveau projet. Pour cela, il faut sélectionner l'option « File/New Project » du menu ou cliquer sur le bouton « New Project » dans la barre d'outils.

Il faut saisir le nom du projet et le nom de la classe de la Midlet.

La création du projet permet la création d'une structure de répertoires dans le sous répertoire apps du répertoire du WTK. Dans ce répertoire apps, un répertoire est créé nommé du nom du projet. Ce répertoire contient lui même plusieurs sous répertoires :

%WTK%/apps/nom_projet/bin contient le fichier jar, jad et le fichier manifest
%WTK%/apps/nom_projet/classes contient les classes compilées
%WTK%/apps/nom_projet/lib contient les bibliothèques utiles à l'application
%WTK%/apps/nom_projet/res contient les ressources utiles à l'application
%WTK%/apps/nom_projet/src contient les sources des classes
La page des propriétés du projet est différente de celle proposée dans la version 1.0. Pour l'utiliser, il faut utiliser l'option « Project/settings » ou cliquer sur le bouton « Settings » de la barre d'outils.

L'onglet « API sélection » permet de sélectionner la plateforme cible ainsi que les API particulières qui vont être utilisées par l'application.

Le « target plateform » permet de sélectionner le type de plate-forme cible utilisée :

  • JTWI : plate-forme répondant aux spécifications de la JSR-185
  • MIDP 1.0 : plate-forme composée de CLDL 1.0 et MIDP 1.0
  • Custom : plate-forme personnalisée pour laquelle il faut préciser toutes les API utilisées
L'onglet « Required », « Optionnal » et « User defined » permet de préciser les attributs respectivement obligatoires, optionnels et particuliers à l'application dans le fichiers manifest sous la forme de paire clé/valeur.

L'onglet « Midlets » permet de saisir les Midlets qui composent la suite de Midlets de l'application.

Pour créer et éditer le code des classes qui composent l'application, il faut utiliser un outil externe dans le répertoire %WTK%/apps/nom_projet/src, en respectant la structure des répertoires correspondant aux packages des classes.

La compilation et la pré-vérification des sources se fait en utilisant l'option « Build » du menu « Project » ou en cliquant sur le bouton « Build » .

Si aucune erreur de compilation n'est détectée, il est possible d'exécuter le code en utilisant l'option « Run » du menu « Project » ou en cliquant sur le bouton « Run » de la barre d'outils.

Avant de lancer l'exécution, il est possible de sélectionner l'émulateur de périphérique (device) utilisé pour exécuter le code. Le J2ME Wireless Toolkit 2.1 est fourni avec quatre émulateurs :

  • DefaultColorPhone : un téléphone mobile avec un écran couleur. C'est l'émulateur par défaut.
  • DefaultGrayPhone : un téléphone mobile avec un écran monochrome
  • MediaControlSkin : un téléphone mobile avec des capacités multimédia accrues (video et audio)
  • QwertyDevice : un périphérique avec un clavier Qwerty
L'option « Clean » du menu « Project » permet de faire du ménage dans les fichiers temporaires générés lors des différents traitements.

Le bouton « Clear console » permet d'effacer le contenu de la console.

L'option « Package » du menu « Project » propose deux options pour packager l'application une fois celle ci mise au point :

  • « Create package » : permet de créer un package sous la forme d'un fichier .jar et .jad
  • « Create obfuscated package » : permet de créer un package sous la forme d'un fichier .jad et d'un fichier .jar plus compact et grâce à un outil tiers non fourni réalisant l'opération d'obscurcissement

56. CLDC

La suite de ce chapitre sera développée dans une version future de ce document

L'API du CLDC se compose de quatres packages :

  • java.io : classes pour la gestion des entrées / sorties par flux
  • java.lang : classes de base du langage java
  • java.util : classes utilitaires notamment pour gérer les collections, la date et l'heure, ...
  • javax.microedition.io : classes pour gérer des connections génériques
Ils ont des fonctionnalités semblables à ceux proposés par J2SE avec quelques restrictions, notamment il n'y a pas de gestion des nombres flottants dans CLDC 1.0.

De nombreuses classes sont définies dans J2SE et J2ME mais souvent elles possèdent moins de fonctionnalités dans l'édition mobile.

La version courant de CLDC est la 1.1 dont les spécifications sont le résultats des travaux de la JSR 139.

Ce chapitre contient plusieurs sections :

  • Le package java.lang
  • Le package java.io
  • Le package java.util
  • Le package javax.microedition.io

56.1. Le package java.lang

Il définit l'interface Runnable.

Il définit les classes suivantes :

Nom Rôle
Boolean Classe qui encapsule une valeur du type booleen
Byte Classe qui encapsule une valeur du type byte
Character Classe qui encapsule une valeur du type char
Class Classe qui encapsule une classe ou une interface
Integer Classe qui encapsule une valeur du type int
Long Classe qui encapsule une valeur du type long
Math Classe qui contient des méthodes statiques pour les calculs mathématiques
Object Classe mère de toutes les classes
Runtime Classe qui permet des intreaction avec le système d'exploitation
Short Classe qui encapsule une valeur du type short
String Classe qui encapsule une chaîne de caractères immuable
StringBuffer Classe qui encapsule une chaîne de caractère
System  
Thread Classe qui encapsule un traitement executé dans un thread
Throwable Classe mère de toutes les exceptions et les erreurs
Il définit les exceptions suivantes : ArithmeticException, ArrayIndexOutOfBoundsException, ArrayStoreException, ClassCastException, ClassNotFoundException, Exception, IllegalAccessException, IllegalArgumentException, IllegalMonitorStateException, IllegalThreadStateException, IndexOutOfBoundsException, InstantiationException, InterruptedException, NegativeArraySizeException, NullPointerException, NumberFormatException, RuntimeException, SecurityException, StringIndexOutOfBoundsException

Il définit les erreurs suivantes : Error, OutOfMemoryError, VirtualMachineError


56.2. Le package java.io

Il définit les interfaces suivantes : DataInput, DataOutput

Il définit les classes suivantes :

Nom Rôle
ByteArrayInputStream Lecture d'un flux d'octets bufférisé
ByteArrayOutputStream Ecriture d'un flux d'octets bufférisé
DataInputStream Lecture de données stocké au format java
DataOutputStream Ecriture de données stockées au format java
InputStream Classe abstraite dont hérite toutes les classes gérant la lecture de flux par octets
InputStreamReader Lecture d'octets sous la forme de caractères
OutputStream Classe abstraite dont hérite toutes les classes gérant lécriture de flux par octets
OutputStreamWriter Ecriture de caractères sous la forme d'octets
PrintStream  
Reader Classe abstraite dont hérite toutes les classes gérant la lecture de flux par caractères
Writer Classe abstraite dont hérite toutes les classes gérant l'écriture de flux par caractères
Il définit les exceptions suivantes : EOFException, InterruptedIOException, IOException, UnsupportedEncodingException, UTFDataFormatException


56.3. Le package java.util

Il définit l'interface Enumeration

Il définit les classes suivantes :

Nom Rôle
Calendar Classe abstraite pour manipuler les éléments d'une date
Date Classe qui encapsule une date
Hashtable Classe qui encapsule une collection d'éléments composés d'une par paire clé/valeur
Random Classe qui permet de générer des nombres aléatoires
Stack Classe qui encapsule une collection de type pile LIFO
TimeZone Classe qui encapsule un fuseau horaire
Vector Classe qui encapsule une collection de type tableau dynamique
Il définit les exceptions EmptyStackException et NoSuchElementException


56.4. Le package javax.microedition.io

Il définit les interface suivantes :

Nom Rôle
Connection Interface pour une connexion générique
ContentConnection  
Datagram Interface pour un paquet de données
DatagramConnection Interface pour une connexion utilisant des paquets de données
InputConnection Interface pour une connexion entrante
OutputConnection Interface pour une connexion sortante
StreamConnection Interface pour un connexion utilisant un flux
StreamConnectionNotifier  

57. MIDP

C'est le premier profile qui a été développé dont l'objectif principal est le développement d'application sur des machines aux ressources et à l'interface limitées tel qu'un téléphone cellulaire. Ce profil peut aussi être utilisé pour développer des applications sur des PDA de type Palm.

L'API du MIDP se compose des API du CDLC et de trois packages :

  • javax.microedition.midlet : cycle de vie de l'application
  • javax.microedition.lcdui : interface homme machine
  • javax.microedition.rms : persistance des données
Des informations complémentaires et le téléchargement de l'implémentation de référence de ce profil peuvent être trouvées sur le site de Sun : http://java.sun.com/products/midp/

Il existe deux versions du MIDP :

  • 1.0 : la dernière révision est la 1.0.3 dont les spécifications sont issues de la JSR 37
  • 2.0 : c'est la version la plus récente dont les spécifications sont issues de la JSR 118
Ce chapitre contient plusieurs sections :

  • Les Midlets
  • L'interface utilisateur
  • La gestion des évenements
  • Le Stockage et la gestion des données
  • MIDP for Palm O.S.

57.1. Les Midlets

Les applications créées avec MIDP sont des midlets : ce sont des classes qui héritent de la classe abstraite javax.microedition.midlet.Midlet. Cette classe permet le dialogue entre le système et l'application.

Elle possède trois méthodes qui permettent de gérer le cycle de vie de l'application en fonction des trois états possibles (active, suspendue ou détruite) :

  • startApp() : cette méthode est appelée à chaque démarrage ou redémarrage de l'application
  • pauseApp() : cette méthode est appelée lors de la mise en pause de l'application
  • destroyApp() : cette méthode est appelée lors de la destruction de l'application
Ces trois méthodes doivent obligatoirement être redéfinies.

Exemple ( MIDP 1.0 ) :
package perso.jmd.test.j2me; import javax.microedition.midlet.*; import javax.microedition.lcdui.*; public class Test extends MIDlet { public Test() { } public void startApp() { } public void pauseApp() { } public void destroyApp(boolean unconditional) { } }
Le cycle de vie d'une midlet est semblable à celui d'une applet.


57.2. L'interface utilisateur

Les possiblités concernant l'IHM de MIDP sont très réduites pour permettre une exécution sur un maximum de machines allant du téléphone portable au PDA. Ces machines sont naturellement et physiquement pourvues de contraites forte concernant l'interface qu'ils proposent à leurs utilisateurs.

Avec le J2SE, deux API permettent le développement d'IHM : AWT et Swing. Ces deux API proposent des composants pour développer des interfaces graphiques riches de fonctionnalités avec un modèle de gestion des événements complet. Ils prennent en compte un système de pointage par souris, avec un écran couleur possèdant de nombreuses couleurs et une résolution importante.

Avec MIDP, le nombre de composants et le modèle de gestion des événements sont spartiates. Il ne prend en compte qu'un écran tactile souvent monochrome ayant une résolution très faible. Avec un clavier limité en nombres de touches et dépourvu de système de pointage, la saisie de données sur de tels appareils est particulièrement limité.

L'API pour les interfaces utilisateurs du MIDP est regroupée dans le package javax.microedition.lcdui.

Elle se compose des éléments de haut niveaux et des éléments de bas niveaux.


57.2.1. La classe Display

Pour pouvoir utiliser les éléments graphiques, il faut obligatoirement obtenir un objet qui encapsule l'écran. Un tel objet est du type de la classe Display. Cette classe possède des méthodes pour afficher les éléments graphiques.

La méthode statique getDisplay() renvoie une instance de la classe Display qui encapsule l'écran associé à la midlet fournie en paramètre de la méthode.

Exemple ( MIDP 1.0 ) :
package perso.jmd.test.j2me; import javax.microedition.midlet.*; import javax.microedition.lcdui.*; public class Hello extends MIDlet { private Display display; public Hello() { display = Display.getDisplay(this); } public void startApp() { } public void pauseApp() { } public void destroyApp(boolean unconditional) { } }
Les éléments de l'interface graphique appartiennent à une hiérarchie d'objets : tous les éléments affichables héritent de la classe abstraite Displayable.

La classe Screen est la classe mère des éléments graphiques de haut niveau. La classe Canvas est la classe mère des éléments graphiques de bas niveau.

Il n'est pas possible d'ajouter directement un élément graphique dans un Display sans qu'il soit inclus dans un objet héritant de Displayable.

Un seul objet de type Displayable peut être affiché à la fois. La classe Display possède la méthode getCurrent() pour connaître l'objet courant affiché et la méthode setCurrent() pour afficher l'objet fourni en paramètre.


57.2.2. La classe TextBox

Ce composant permet de saisir du texte.

Exemple ( MIDP 1.0 ) :
package perso.jmd.test.j2me; import javax.microedition.midlet.*; import javax.microedition.lcdui.*; public class Hello extends MIDlet { private Display display; private TextBox textbox; public Hello() { display = Display.getDisplay(this); textbox = new TextBox("", "Bonjour", 20, 0); } public void startApp() { display.setCurrent(textbox); } public void pauseApp() { } public void destroyApp(boolean unconditional) { } }
Résultat :

sur l'émulateur Palm

sur l'émulateur de téléphone mobile


57.2.3. La classe List

Ce composant permet la sélection d'un ou plusieurs éléments dans une liste d'éléments.

Exemple ( MIDP 1.0 ) :
package perso.jmd.test.j2me; import javax.microedition.midlet.*; import javax.microedition.lcdui.*; public class Test extends MIDlet { private Display display; private List liste; protected static final String[] elements = {"Element 1", "Element 2", "Element 3", "Element 4"}; public Test() { display = Display.getDisplay(this); liste = new List("Selection", List.EXCLUSIVE, elements, null);; } public void startApp() { display.setCurrent(liste); } public void pauseApp() { } public void destroyApp(boolean unconditional) { } }
Résultat :

sur l'émulateur Palm

sur l'émulateur de téléphone mobile

La suite de cette section sera développée dans une version future de ce document


57.2.4. La classe Form

La classe From permet d'insérer dans l'élément graphique qu'elle représente d'autres éléments graphiques : cette classe sert de conteneurs. Les éléments insérés sont des objets qui héritent de la classe abstraite Item.

Exemple ( MIDP 1.0 ) :
package perso.jmd.test.j2me; import javax.microedition.midlet.*; import javax.microedition.lcdui.*; public class Hello extends MIDlet { private Display display; private Form mainScreen; public Hello() { display = Display.getDisplay(this); } public void startApp() { mainScreen = new Form("Hello"); mainScreen.append("Bonjour"); display.setCurrent(mainScreen); } public void pauseApp() { } public void destroyApp(boolean unconditional) { } }

57.2.5. La classe Item

La classe javax.microedition.lcdui.Item est la classe mère de tous les composants graphiques qui peuvent être insérés dans un objet de type Form.

Cette classe définit seulement deux méthodes, getLabel() et setLabel() qui sont le getter et le setter pour la propriété label.

Il existe plusieurs composants qui héritent de la classe Item

Classe Rôle
ChoiceGroup sélection d'un ou plusieurs éléments
DateField affichage et saisie d'une date
Gauge affichage d'une barre de progression
ImageItem affichage d'une image
StringItem affichage d'un texte
TextField saisie d'un texte
Exemple ( MIDP 1.0 ) :
package perso.jmd.test.j2me; import javax.microedition.midlet.*; import javax.microedition.lcdui.*; public class Hello extends MIDlet { private Display display; private Form form; private ChoiceGroup choiceGroup; private DateField dateField; private DateField timeField; private Gauge gauge; private StringItem stringItem; private TextField textField; public Hello() { display = Display.getDisplay(this); form = new Form("Ma form"); String choix[] = {"Choix 1", "Choix 2"}; stringItem = new StringItem(null,"Mon texte"); choiceGroup = new ChoiceGroup("Sélectionner",Choice.EXCLUSIVE,choix,null); dateField = new DateField("Heure",DateField.TIME); timeField = new DateField("Date",DateField.DATE); gauge = new Gauge("Avancement",true,10,1); textField = new TextField("Nom","Votre nom",20,0); form.append(stringItem); form.append(choiceGroup); form.append(timeField); form.append(dateField); form.append(gauge); form.append(textField); } public void startApp() { display.setCurrent(form); } public void pauseApp() { } public void destroyApp(boolean unconditional) { } }
Résultat sur l'émulateur de téléphone mobile :

Résultat sur l'émulateur Palm OS :


57.2.6. La classe Alert

Cette classe permet d'afficher une boite de dialogue pendant un temps déterminé.

Elle possède deux constructeurs :

  • un demandant le titre de l'objet
  • un demandant le titre, le texte, l'image et le type de l'image
Elle possède des getters et des setters sur chacun de ces éléments.

Pour préciser le type de la boîte de dialogue, il faut utiliser une des constantes définies dans la classe AlertType dans le constructeur ou dans la méthode setType() :

Constante type de la boite de dialogue
ALARM informer l'utilisateur d'un événement programmé
CONFIRMATION demander la confirmation à l'utilisateur
ERROR informer l'utilisateur d'une erreur
INFO informer l'utilisateur
WARNING informer l'utilisateur d'un avertissement
Pour afficher un objet de type Alert, il faut utiliser une version surchargée de la méthode setCurrent() de l'instance de la classe Display. Cette version nécessite deux paramètres : l'objet Alert à afficher et l'objet de type Displayable qui sera affiché lorsque l'objet Alert sera fermé.

La méthode setTimeout() qui attend un entier en paramètre permet de préciser la durée d'affichage en milliseconde de la boîte de dialogue. Pour la rendre modale, il faut lui passer le parametre Alert.FOREVER.

Exemple ( MIDP 1.0 ) :
package perso.jmd.test.j2me; import javax.microedition.midlet.*; import javax.microedition.lcdui.*; public class Test extends MIDlet { private Display display; private Alert alert; private Form form; public Test() { display = Display.getDisplay(this); form = new Form("Hello"); form.append("Bonjour"); alert = new Alert("Erreur", "Une erreur est survenue", null, AlertType.ERROR); alert.setTimeout(Alert.FOREVER); } public void startApp() { display.setCurrent(alert, form); } public void pauseApp() { } public void destroyApp(boolean unconditional) { } }
Résultat sur l'émulateur de téléphone mobile:

Résultat sur l'émulateur Palm OS:


57.3. La gestion des évenements

Les interactions entre l'utilisateur et l'application se concrétisent par le traitement d'événements particuliers pour chaque action.

MIDP définit interface de type Listener pour la gestion des événements :

Interface Rôle
CommandListener Listener pour une activation d'une commande
ItemStateListener Listener pour un changement d'état d'un composant(modification du texte d'une zone de texte, ...)
Cette section sera développée dans une version future de ce document


57.4. Le Stockage et la gestion des données

Avec MIDP, le méchanisme pour la persistance des données est appellé RMS (Record Management System). Il permet le stockage de données et leur accès ultérieur.

RMS propose un accès standardisé au système de stockage de la machine dans lequel s'exécute le programme. Il n'impose pas aux constructeurs la façon dont les données doivent être stockées physiquement.

Du fait de la simplicité des mécanismes utilisés, RMS ne définit qu'une seule classe : RecordStore. Cette classe ainsi que les interfaces et les exceptions qui composent RMS sont regroupées dans le package javax.microedition.rms.

Les données sont stockées dans un ensemble d'enregistrements (records). Un enregistrement est un tableau d'octets. Chaque enregistrement possède un identifiant unique nommé recordId qui permet de retrouver un enregistrement particulier.

A chaque fois qu'un ensemble de données est modifié (ajout, modification ou suppression d'un enregistrement), son numéro de version est incrémenté.

Un ensemble de données est associé à un unique ensemble composé d'une ou plusieurs Midlets (Midlet Suite).

Un ensemble de données possède un nom composé de 32 caractères maximum.


57.4.1. La classe RecordStore

L'accès aux données se fait obligatoirement en utilisant un objet de type RecordStore.

Les principales méthodes sont :

Méthode Rôle
int addRecord(byte[],int, int) Ajouter un nouvel enregistrement
void addRecordListener(RecordListener)  
void closeRecordStore() Fermer l'ensemble d'enregistrement
void deleteRecord(int) Supprimer l'enregistrement dont l'identifiant est fourni en paramètre
static void deleteRecordStore(String) Supprimer l'ensemble d'enregistrements dont le nom est fourni en paramètre
Enumeration enumerateRecords(RecordFilter , RecordComparator, boolean) Renvoyer une énumaration pour parcourir tout ou partie de l'ensemble
String getName() Renvoyer le nom de l'ensemble d'enregistrements
int getNextRecordID() Renvoyer l'identifiant du prochain enregistrement créé
int getNumRecords() Renvoyer le nombre d'enregistrement contenu dans l'ensemble
byte[] getRecord(int) Renvoyer l'enregistrement dont l'identifiant est fourni en paramètre
int getRecord(int, byte[], int ) Obtenir les données contenues dans un enregistrement dont l'identifiant est fourni en paramètre. Renvoie le nombre d'octets de l'enregistrement
int getRecordSize(int) Renvoyer la taille en octets de l'enregistrement dont l'identifiant est fourni en paramètre
int getSize() Renvoyer la taille en octets occupée par l'ensemble
static String[] listRecordStores() Renvoyer un tableau de chaîne de caractères contenant le nom des ensembles de données associées à l'ensemble de Midlet courant
static RecordStore openRecordStore(String, boolean) Ouvrir un ensemble de données dont le nom est fourni en paramètre. Celui ci est créé s'il n'existe pas et que le booléen est à true
void setRecord(int, byte[], int, int) Mettre à jour l'enregistrement précisé avec les données fournies en paramètre
Pour pouvoir utiliser un ensemble d'enregistrements, il faut utiliser la méthode statique openRecordStore() en fournissant le nom de l'ensemble et un booléen qui précise si l'ensemble doit être créé au cas ou celui ci n'existe pas. Elle renvoie un objet RecordStore qui encapsule l'ensemble d'enregistrements.

L'appel de cette méthode peut lever l'exception RecordStoreNotFoundException si l'ensemble n'est pas trouvé, RecordStoreFullException si l'ensemble de données est plein ou RecordStoreException dans les autres cas problématiques.

La méthode closeRecordStore() permet de fermer un ensemble précédemment ouvert. Elle peut lever les exceptions RecordStoreNotOpenException et RecordStoreException.

La suite de cette section sera développée dans une version future de ce document


57.5. MIDP for Palm O.S.

MIDP for Palm O.S. est une implémentation particulière du profile MIPD pour le déploiement et l'exécution d'applications sur des machines de type Palm. Elle permet d'exécuter des applications écrites avec MIDP sur un PALM possédant une version 3.5 ou supérieure de cet O.S.

Cette implémentation remplace l'ancienne implémentation développé par Sun nommé KJava.


57.5.1. Installation

MIPD for Palm O.S. peut être téléchargé à l'URL suivante : http://java.sun.com/products/midp4palm/download.html. Il faut télécharger le fichier midp4palm-1_0.zip et le fichier midp4palm-1_0-doc.zip qui contient la documentation.

L'installation comprend une partie sur le poste de développement PC et une partie sur la machine Palm pour les tests d'exécution.

Pour pouvoir utiliser MIDP for Palm O.S., il faut déjà avoir installé CLDC et MIDP.

Il faut commencer l'installation sur le PC en dézipant les deux fichiers dans un répertoire.

Pour pouvoir exécuter les applications sur le Palm, il faut installer le fichier MIPD.prc contenu dans le répertoire PRCFiles sur le Palm en procédant comme pour toute application Palm.

En cliquant sur l'icône, on peut régler différents paramètres.

Un clic sur le bouton "Preferences" permet de modifier ces paramètres.


57.5.2. Création d'un fichier .prc

MIPD for Palm O.S. fourni un outil pour transformer les fichier .jad et .jar qui composent une application J2ME en un fichier .prc directement installable sur un Palm.

Sous Windows, il suffit d'exécuter le programme converter.bat situé dans le sous répertoire Converter du répertoire d'installation.

Il faut que la variable d'environnement JAVA_PATH pointe vers le répertoire d 'installation d'un JDK 1.3. minimum. Si ce n'est pas le cas, un message d'erreur est affiché.

Error: Java path is missing in your environment Please set JAVA_PATH to point to your Java directory e.g. set JAVA_PATH=c:\bin\jdk1.3\
Si tout est correct, l'application se lance.

Il est possible de préciser le répertoire du ou des fichiers .prc généré en utilisant l'option "Preference" du menu "File" :

Une boîte de dialogue permet de choisir entre le même répertoire que celui qui contient le fichier .jad ou de sélectionner un répertoire quelconque.

Il suffit de cliquer sur l'icône en forme de répertoire dans la barre d'îcone pour sélectionner le fichier .jad. Les fichiers .jad et .jar de l'application doivent obligatoirement être ensemble dans le même répertoire.

Un clic sur le bouton "Convert", lance la conversion.

Si la conversion échoue, un message d'erreur est affiché. Exemple, si le fichier .jar correspond au fichier .jad est absent, alors le message suivant est affiché :

Si toutes les opérations se sont correctement passées, alors un message récapitulatif est affiché :


57.5.3. Installation et exécution d'une application

Une fois le fichier .prc créer, il suffit d'utiliser la procédure standard d'installation d'un tel fichier sur le Palm (ajouter le fichier dans la liste avec "l'outil d'installation" du Palm et lancer une synchronisation).

Une fois l'application installée, l'icône de l'application apparaît.

Pour exécuter l'application, il suffit comme pour une application native, de cliquer sur l'îcone.

Lors de la première exécution, il faut lire et valider la licence d'utilisation.

Une splash screen s'affiche durant le lancement de la machine virtuelle.

Puis l'application s'exécute.


58. CDC

La suite de ce chapitre sera développée dans une version future de ce document

Cette configuration se destine à l'utilisation de Java sur des machines mobiles possédant un processeur 32 bits, au moins 2Mo de RAM et une connexion au réseau.

CDC est une spécification définit par la JSR numéro 036.

La machine virtuelle utilise par le CDC est nommé CVM. Elle respecte intégralement les spécifications de la plate-forme Java 2 version 1.3.

Le CDC ne peut être utilisé seul : il faut lui adjoindre un ou plusieurs profiles qui lui sont spécifiques.

Le CDC définit aussi un ensemble d'API de base :

  • java.lang
  • java.util
  • java.net
  • java.io
  • java.text
  • java.security
Le contenu de ces packages est très proche de celui de la plate-forme J2SE excepté quelques exceptions et surtout la suppression de toutes les API dépréciée (deprecated).

La version 1.1 du CDC est en cours de spécification dans la JSR 218


59. Les profils du CDC

La suite de ce chapitre sera développée dans une version future de ce document

Ce chapitre contient plusieurs sections :

  • Foundation profile
  • Personal Basis Profile (PBP)
  • Personal Profile (PP)

59.1. Foundation profile

Ce profile sert de base pour le developpement d'application sur des outils mobiles utilisant la configuration CDC tel que des Pockets PC ou des Tablets PC.

Il sert de base pour d'autres profiles.

Une partie importante de ce profil concerne les différentes formes de connection au réseau.


59.2. Personal Basis Profile (PBP)

Ce profil contient les éléments de bases pour développer une interface graphique avec le CDC et le Foundation profil.

Ce profile a été développé sous la JSR 129.


59.3. Personal Profile (PP)

Ce profile se destine au développement d'applications sur des PDA disposant de ressources importantes tel que les Pockets PC. Ce profil permet notamment le développement d'IHM évoluée.

Le Personal Basis Profile est un sous ensemble du Personal Profile.


Ce profile a été développé sous la JSR 62.


60. Les autres technologies pour les applications mobiles

La suite de ce chapitre sera développée dans une version future de ce document

Ce chapitre contient plusieurs sections :

  • KJava
  • PDAP (PDA Profile)
  • PersonalJava
  • Java Phone
  • JavaCard
  • Embedded Java
  • Waba, Super Waba, Visual Waba

60.1. KJava

Ce n'est pas un profil officiel mais un développement proposé par Sun pour réaliser des développements sur des machines de type Palm.

KJava n'est plus supporté par Sun. Il faut utiliser MIDP for Palm O.S. à la place.


60.2. PDAP (PDA Profile)

Ce profile permet le développement d'application sur PDA en tenant compte notamment de l'accès aux données. Il utilise la configuration CLDC.

Il propose deux packages optionels :

  • Personal Information Management (PIM) : pour standardiser l'accès aux données personnelles stockées dans la plupart des PDA tels que le carnet d'adresse, l'agenda, le boc-notes,
  • ......
  • File Connection (FC) : pour permettre l'accès aux données stockées dans un système de fichiers externe tel que les cartes mémoires
Les spécifications de ce profile sont en cours de développement sous la JSR 075 : http://jcp.org/en/jsr/detail?id=075 (PDA Optional Packages for the J2ME Platform)


60.3. PersonalJava


La dernière version de ces spécifications est la 1.2.

PersonalJava est composé de packages obligatoires et facultatifs.

Sun propose un outil pour émuler un environnement d'exécution pour des applications développer avec PersonalJava : PJEE (PersonalJava Emulation Environment).

Ce profile a été abandonné au profit d'un ensemble de profils qui respecte mieux le découpage des rôles de J2ME : CDC, Foundation profile et Personal Profile.


60.4. Java Phone



60.5. JavaCard



60.6. Embedded Java

Cette technologie n'est plus supportée par Sun qui propose en remplacement CLDC et MIDP de la plate-forme J2ME.



60.7. Waba, Super Waba, Visual Waba



Copyright (C) 1999-2004 DOUDOUX Jean Michel Vous pouvez copier, redistribuer et/ou modifier ce document selon les termes de la Licence de Documentation Libre GNU, Version 1.1 ou toute autre version ultérieure publiée par la Free Software Foundation; les Sections Invariantes étant constitués du chapitre Préambule, aucun Texte de Première de Couverture, et aucun Texte de Quatrième de Couverture. Une copie de la licence est incluse dans la section GNU FreeDocumentation Licence. La version la plus récente de cette licence est disponible à l'adresse : GNU Free Documentation Licence.

Responsable bénévole de la rubrique Java : Mickael Baron -