Présentation de Java Micro Edition

Transcription

Présentation Java ME
Présentation de Java Micro Edition
Sommaire
1. Généralités............................................................................................................................................................2 2. Vue d’ensemble des packages de CLDC 1.1 et de MIDP 2.0..............................................................................4 2.1. Packages de la configuration CLDC 1.1.......................................................................................................4 2.2. Packages du profil MIDP 2.0 ........................................................................................................................4 2.3. Documentation de référence ........................................................................................................................4 3. Les interfaces graphiques de MIDP 2.0 ...............................................................................................................4 3.1. Architecture des interfaces graphiques ........................................................................................................4 3.2. Hiérarchie des classes graphiques MIDP 2.0...............................................................................................5 3.3. Description des composants graphiques de haut niveau .............................................................................6 3.3.1.1. Les écrans « Alert » ..........................................................................................................................6 3.3.1.2. Les écrans « List »............................................................................................................................6 3.3.1.3. Les écrans « TextBox » ....................................................................................................................6 3.3.1.4. Les écrans « Form » .........................................................................................................................7 3.3.1.5. Les éléments “ChoiceGroup” ............................................................................................................7 3.3.1.6. Les éléments “DateField”..................................................................................................................8 3.3.1.7. Les éléments “Gauge” ......................................................................................................................8 3.3.1.8. Les éléments “ImageItem” ................................................................................................................8 3.3.1.9. Les éléments “StringItem”.................................................................................................................8 3.3.1.10. Les éléments “TextField” ..............................................................................................................8 3.3.1.11. Les éléments “Ticker” ...................................................................................................................8 3.3.1.12. Les éléments “Spacer”..................................................................................................................8 3.3.1.13. Les éléments “CustomItem”..........................................................................................................9 4. Les applications Java ME .....................................................................................................................................9 4.1. Présentation des MIDlets..............................................................................................................................9 4.2. Fichiers JAD et JAR......................................................................................................................................9 5. Exemple de MIDlet simple : HelloWorld. ..............................................................................................................9 5.1. Code source et exécution .............................................................................................................................9 5.2. Définition de la classe HelloWorld ..............................................................................................................11 5.3. Les attributs de la classe ............................................................................................................................12 5.4. Le constructeur ...........................................................................................................................................12 5.5. Les méthodes du cycle de vie ....................................................................................................................12 5.6. La gestion des événements........................................................................................................................13 5.7. Remarques .................................................................................................................................................13 BTS iris - Lycée Eiffel - Armentières
Page 1 sur 13
09/02/2007
1. Généralités
Java existe sous différentes plateformes.
J2ME (Java 2 Micro Edition) est le Java de la mobilité. C'est le Java tournant sur les terminaux légers (systèmes
embarqués comme un téléphone portable ou un PDA). J2ME utilise le même langage et les mêmes outils que les
versions J2SE et J2EE de Java, mais avec un jeu d’API réduit.
La plateforme J2ME est divisée en trois parties : les configurations, les profils et les packages optionnels.
BTS iris - Lycée Eiffel - Armentières
Page 2 sur 13
09/02/2007
Profile
Une configuration définit les
API de base en fonction des
ressources matérielles
disponibles.
Vendor-specific
Classes (OEM)
Un profil définit un ensemble
d’API pour une famille de
périphériques.
Optional packages
Applications
Configuration
JSR
(Java Specification Request)
Native Operating System
Device / Hardware
La configuration représente le socle de J2ME. Elle est constituée de la machine virtuelle KVM (Kilobyte Virtual
Machine) et des librairies bas niveaux pouvant être utilisées sur un certain type de matériel (habituellement un
sous ensemble des API de J2SE). La configuration garantit la portabilité et l'interopérabilité du code entre les
différents types de terminaux mobiles.
Il existe actuellement deux type de configurations : CDC (Connected Device Configuration) et CLDC (Connected
Limited Device Configuration). Leur utilisation est fonction du type de matériel où s’exécutera l’environnement
Java. CLDC est la configuration utilisée sur les petits appareils sans fils avec une connexion réseau intermittente
(téléphones portables, PDA).
Le profil ajoute des API plus spécifiques à la configuration. C'est lui qui prend en charge les fonctionnalités de plus
haut niveau. Les profils incluent des API pour contrôler le cycle de vie d’une application, pour construire l’interface
graphique, … Grâce aux API, de la configuration et du profil, on dispose d’un environnement complet pour
construire des applications.
Les terminaux utilisant la configuration CLDC doivent également utiliser le profil MIDP (Mobile Information Device
Profil). Les appareils « compatibles MIDP » sont les plus courants. De fait, la spécification « Java Technology for
the Wireless Industry » (JSR 185 ou JTWI) assemble CLDC 1.0 ou 1.1 et MIDP 2.0 pour créer un environnement
de développement J2ME standard.
Les packages optionnels fournissent des fonctionnalités supplémentaires non associées à une configuration ou à
un profil. Par exemple, l’API Bluetooth (JSR 82), qui fournit des méthodes pour utiliser le réseau Bluetooth, peut
être implémentée sur n’importe quelle combinaison de configurations et de profils.
Les spécifications de J2ME, comme pour J2SE et J2ME, sont développées sous l’égide de l’organisation JCP
(Java Community Process). Chaque spécification est définie par un numéro de JSR (Java Specification Request).
Par exemple :
¾
¾
¾
API Bluetooth : JSR 82
CLDC 1.1 : JSR 139
MIDP 2.0 : JSR 118
Page 3 sur 13
09/02/2007
2. Vue d’ensemble des packages de CLDC 1.1 et de MIDP 2.0
2.1. Packages de la configuration CLDC 1.1
java.io
java.lang
java.util
javax.microedition.io
Classes d’entrées / sorties à travers des data streams
Classes fondamentales du langage Java, sous-ensemble des classes standards
du package java.lang de J2SE (types de données, …)
Classes utilitaires (Calendar, Date, Vector, …)
Classes générales pour les fonctions réseau (GCF : Generic Connection
framework)
2.2. Packages du profil MIDP 2.0
java.lang
java.util
javax.microedition.io
javax.microedition.lcdui
javax.microedition.media
javax.microedition.midlet
javax.microedition.pki
javax.microedition.rms
Extension de java.lang de CLDC 1.1
Extension de CLDC 1.1
Extension du GCF (communications http, udp, socket, …).
Interface utilisateur (composants graphiques, gestion de l’écran, actions,
listener …)
Gestion du son.
Définition des applications MIDP et leurs interactions avec l’environnement.
Gestion du cycle de vie de l’application.
Certificats pour l’authentification des connexions sécurisées.
Gestion des données persistantes.
2.3. Documentation de référence
Vous trouverez une information détaillée de ces packages (interfaces, classes, méthodes, exceptions, …) dans
les fichiers « javadocs » de MIDP 2.0 et CLDC 1.1.
¾
Documentation officielle sur MIDP 2.0
http://www4.ac-lille.fr/~irisarmentieres/media/terminauxmobiles/midp-2_0-fr-spec.zip
¾
Documentation officielle sur CLDC 1.1
http://www4.ac-lille.fr/~irisarmentieres/media/terminauxmobiles/Appendix2-javadocs.zip
3. Les interfaces graphiques de MIDP 2.0
3.1. Architecture des interfaces graphiques
Les classes graphiques du paquetage javax.microedition.lcdui peuvent se diviser en deux groupes :
les classes de haut niveau et les classes de bas niveau.
Les classes de haut niveau : Screen et toutes les classes qui en dérivent.
Les classes de haut niveau ont un haut niveau d’abstraction par rapport au matériel. Elles sont donc
particulièrement recommandées pour programmer des interfaces utilisateurs compatibles avec tous les
périphériques MIDP 2.0. Evidemment, cela veut dire que le programmeur a peu de contrôle sur le rendu
graphique de ses interfaces. L’aspect visuel dépendra fortement des capacités du périphérique sur lequel
s’exécute le programme.
Les classes de bas : niveau : Canvas et Graphics
Les classes de bas niveau permettent d’avoir un contrôle très précis sur l’affichage : création de dessins,
positionnement précis de tous les éléments graphiques …. Cependant, cette précision sur l’affichage se fait au
détriment de la portabilité, tous les périphériques MIDP 2.0 ne seront pas capables de bien interpréter ces
programmes.
Page 4 sur 13
09/02/2007
3.2. Hiérarchie des classes graphiques MIDP 2.0
Command
0..n
Displayable
1
(from lcdui)
(from lcdui)
CommandListener
(from lcdui)
Screen
Canvas
(from lcdui)
(from lcdui)
List
TextBox
Alert
Form
(from lcdui)
(from lcdui)
(from lcdui)
(from lcdui)
Item StateListener
1
0..n
Item
(from lcdui)
Choice
Item CommandListener
(from lcdui)
(from lcdui)
ChoiceGroup
TextField
StringItem
Gauge
(from lcdui)
(from lcdui)
(from lcdui)
(from lcdui)
Im ageItem
DateField
CustomItem
Spacer
(from lcdui)
(from lcdui)
(from lcdui)
(from lcdui)
Page 5 sur 13
09/02/2007
3.3. Description des composants graphiques de haut niveau
3.3.1.1.
Les écrans « Alert »
Les écrans « Alert » sont employés pour afficher des messages informationnels ou d'erreur. Ces
messages restent sur l'écran pendant un court moment et disparaissent. Le type d’alerte (AlertType)
indique la nature de l’alerte et joue un son approprié.
3.3.1.2.
Les écrans « List »
Les écrans « List » sont employés pour afficher une liste d’éléments à sélectionner. Il existe 3 types de
List :
¾ On ne peut sélectionner qu’un élément (EXCLUSIVE)
¾
On peut sélectionner plusieurs éléments (MULTIPLE)
¾
L’élément en surbrillance est sélectionné (IMPLICIT)
3.3.1.3.
Les écrans « TextBox »
Les écrans « TextBox » sont employés pour permettre à l’utilisateur de saisir du texte. Les TextBox
permettent de restreindre le type de saisie : du texte, que des chiffres, une adresse e-mail, une URL,
etc.
Page 6 sur 13
09/02/2007
3.3.1.4.
Les écrans « Form »
Les écrans « Form » permettent de construire les IHM. Les Forms sont les seuls composants MIDP
qui peuvent contenir d’autres éléments graphiques (Items). Les IHM MIDP ne permettent pas
beaucoup de choix quand au placement des éléments graphiques, on ne peut contrôler que l’ordre
d’apparition de l’élément.
3.3.1.5.
Les éléments “ChoiceGroup”
Les éléments “ChoiceGroup” doivent être utilisés dans une Form.
Ils ont le même rôle que les écrans « List », ils permettent de proposer un choix à l’utilisateur et de
récupérer sa sélection.
Page 7 sur 13
09/02/2007
3.3.1.6.
Les éléments “DateField”
Les éléments “DateField” doivent être utilisés dans une Form.
Ils permettent à l’utilisateur de saisir une date, une heure ou les deux.
3.3.1.7.
Les éléments “Gauge”
Les éléments “Gauge” doivent être utilisés dans une Form.
Ils permettent de simuler une barre de défilement. Les Gauges peuvent aussi être interactives, par
exemple en permettant de contrôler le volume sonore.
3.3.1.8.
Les éléments “ImageItem”
Les éléments “ImageItem” doivent être utilisés dans une Form.
Ils permettent d’afficher une image. Suivant les implémentations de MIDP, seul le format PNG peut
être supporté.
3.3.1.9.
Les éléments “StringItem”
Les éléments “StringItem” doivent être utilisés dans une Form.
Ils permettent d’afficher un label, non modifiable par l’utilisateur. Un StringItem peut comporter un titre
et du texte.
3.3.1.10. Les éléments “TextField”
Les éléments “TextField” doivent être utilisés dans une Form.
Ils ont le même rôle que les écrans « TextBox ». Ils permettent d’afficher un champ de saisie.
3.3.1.11. Les éléments “Ticker”
Les éléments “Ticker” peuvent être attachés à n’importe quel élément dérivant de Displayable.
Les Tickers permettent d’afficher un texte défilant en haut de l’écran.
3.3.1.12. Les éléments “Spacer”
Les éléments “Spacer” doivent être utilisés dans une Form.
Ils permettent de positionner les éléments sur la Form en créant de l’espace entre eux. Ce sont des
éléments invisibles dont on peut contrôler la taille.
Page 8 sur 13
09/02/2007
3.3.1.13. Les éléments “CustomItem”
Les éléments “CustomItem” doivent être utilisés dans une Form.
CustomItem est une classe abstraite qui permet de créer des classes (éléments graphiques) ayant leur
propre apparence, leurs propres intéractions avec l’utilisateur et leurs propres mécanismes de
notification.
La création d’un CustomItem s’apparente beaucoup aux méthodes utilisées pour créer un composant
graphique de bas niveau (dérivant de Canvas), mais avec la particularité de pouvoir être utilisé comme
élément d’une Form.
4. Les applications Java ME
4.1. Présentation des MIDlets
Les applications J2ME sont appelées des MIDlets. En fait, c’est la classe abstraite MIDlet qui est dérivée pour
exécuter le cycle de vie du programme. Cette classe définit notamment 3 méthodes abstraites :
¾ startApp()
¾ pauseApp()
¾ destroyApp(boolean unconditional)
4.2. Fichiers JAD et JAR
Les applications J2ME se présentent sous la forme de deux fichiers. En complément du fichier JAR (Java
ARchive) contenant l’application, on fournit un fichier JAD (Java Archive Descriptor) qui contient des
informations sur l’application (auteur, version, taille, prix, URL de téléchargement). Cette organisation est
nécessaire quand on veut distribuer une application pour les téléphones portables (téléchargement OTA :
« Over The Air »).
5. Exemple de MIDlet simple : HelloWorld.
5.1. Code source et exécution
La structure du code d'un MIDlet est similaire à celle d'une applet : il n'y a pas de méthode main() et les
MIDlets étendent toujours la classe MIDlet. Les composants de l'interface utilisateur se trouvent dans le
package javax.microedition.lcdui.
Voici le listing de notre MIDlet HelloWorld :
001: import javax.microedition.midlet.*;
002: import javax.microedition.lcdui.*;
003:
004: public class HelloWorld extends MIDlet implements CommandListener {
005: private Command objCmdExit;
006: private Display objDisplay;
007: private TextBox objTextBox = null;
008:
009: public HelloWorld () {
010:
objDisplay = Display.getDisplay (this);
011:
objCmdExit = new Command ("Sortie", Command.EXIT, 2);
012:
objTextBox = new TextBox ("HelloWorld", "Bonjour le monde", 256, 0);
013:
objTextBox.addCommand (objCmdExit);
014:
objTextBox.setCommandListener (this);
015: }
016:
Page 9 sur 13
09/02/2007
017: public void startApp() {
018:
objDisplay.setCurrent (objTextBox);
019: }
020:
021: public void pauseApp() {
022: }
023:
024: public void destroyApp (boolean unconditional) {
025: }
026:
027: public void commandAction (Command prmCommand, Displayable prmDisplayable) {
028:
if (prmCommand == objCmdExit) {
029:
destroyApp (true);
030:
notifyDestroyed ();
031:
}
032: }
033: }
Résultat de l'exécution du code de ce MIDlet sur le simulateur de portable générique, fourni avec SUN Wireless
Toolkit.
Titre du Textbox
Texte du Textbox
Textbox
Zone d’affichage des commandes
placées juste au dessus du bouton
correspondant : ici le bouton objCmdExit
Remarque : le listener d’évènements
intercepte les actions venant des
commandes matérielles de l’appareil sur
lequel tournera cette application.
Page 10 sur 13
09/02/2007
Page 11 sur 13
CommandListener
listener
(f rom lcdui)
Command
commands[]
(f rom lcdui)
TextBox
-objTextBox
Command(arg0 : String, arg1 : int, arg2 : int)
-objCmdExit
(f rom lcdui)
Displayab le
-current
(f rom lcdui)
Screen
addCommand(arg0 : Command) : v oid
setCommandListener(arg0 : CommandListener) : v oid
currentDisplay
getDisplay (arg0 : MIDlet) : Display
setCurrent(arg0 : Display able) : v oid
-objDisplay
(f rom lcdui)
Display
(f rom lcdui)
commandAction(arg0 : Command, arg1 : Display able) : v oid
-midlet
TextBox(arg0 : String, arg1 : String, arg2 : int, arg3 : int)
MIDlet()
destroy App(arg0 : boolean) : v oid
pauseApp() : v oid
startApp() : v oid
notif y Destroy ed() : v oid
HelloWorld()
startApp() : v oid
pauseApp() : v oid
destroy App(arg0 : boolean) : v oid
commandAction(arg0 : Command, arg1 : Display able) : v oid
HelloWorld
MIDlet
(f rom midlet)
5.2. Définition de la classe HelloWorld
09/02/2007
La classe HelloWorld étend la classe MIDlet et implémente l'interface CommandListener (ligne 4).
En étendant la classe MIDlet, le programme peut exécuter un cycle de vie complet en implémentant son code
dans les trois fonctions startApp(), pauseApp() et destroyApp().
En implémentant l'interface CommandListener, notre programme peut intégrer un listener d'actions associé à
des événements de commande du matériel.
5.3. Les attributs de la classe
Nous utilisons trois objets :
¾ Command objCmdExit pour conserver l'état de la commande,
¾ Display objDisplay pour gérer l'affichage,
¾ TextBox objTextbox pour gérer la fenêtre de texte.
Ils sont initialisés dans le constructeur (lignes 5 à 7).
Remarque : l’objet de la classe TextBox est en fait une fenêtre ne contenant que du texte. TextBox est une
sous-classe de Screen et peut donc être placée directement sur le Display sans utiliser d’objet Form.
La classe Command permet de définir une commande utilisateur standard des applications J2ME. Elle
possède trois propriétés : le libellé, le type de commande (exemple : retour, annulation, validation, sortie,
aide, …) et le niveau de priorité (qui définit son emplacement et son niveau dans l'arborescence des menus).
5.4. Le constructeur
Le constructeur effectue une succession d'actions.
Ligne 10 : La première est de récupérer l'objet Display associé à cette instante de la classe HelloWorld. L'objet
objDisplay correspond au gestionnaire de l'affichage du terminal. Il comprend des méthodes de récupération
des propriétés du terminal et d'affichage d'objets sur le terminal.
Ligne 11 : Puis il crée une commande de type EXIT avec une priorité de niveau 2. C’est le bouton « Sortie »
qui permettra de quitter le programme.
Ligne 12 : Ensuite, il crée et initialise le seul composant de l'interface utilisateur du MIDlet, à savoir une zone
de saisie (objTextBox) ayant pour titre « HelloWorld » et pour texte « Bonjour le monde ». La longueur
maximale de saisie est de 256 caractères et aucune contrainte de saisie n'est spécifiée (d'où la valeur 0). Ce
composant permet la saisie au clavier. Les éventuelles contraintes de saisie restreignent les caractères qui
peuvent être entrés (alphabétique, numérique, …).
Ligne 13 : La commande de sortie est associée à la zone de saisie parce que c’est une application minimaliste
sans aucun autre composant sur l’interface utilisateur.
Ligne 14 : Le listener d’évènements du MIDlet est mis en place sur le seul composant de l’IHM objTextBox
(Rem : si on utilise une fiche Form, le listener peut être associé à la Form). Ainsi, la méthode
HelloWorld.commandAction() sera appelée dès qu'une commande sur la zone d’affichage génère un
événement.
Ligne 18 : Après l'appel du constructeur, la méthode startApp() est appelée. Dans notre exemple, le
composant objTextBox est passé à l'objet objDisplay pour le rendre visible sur l'affichage du terminal. Tout
MIDlet a un et un seul objet Display.
5.5. Les méthodes du cycle de vie
Lignes 17 à 19 : Le gestionnaire d'application appelle les méthodes associées aux différentes étapes de son
cycle de vie. Il appelle en tout premier la méthode startApp() pour lancer le MIDlet. Dans notre cas, elle rend
le Display courant.
Lignes 21 et 22 : La seconde étape du cycle de vie est la suspension du MIDlet. Cela est fait en appelant la
méthode pauseApp().Cette méthode doit libérer les ressources partagées comme les threads ou les
connexions. Dans notre exemple, nous ne faisons rien.
Page 12 sur 13
09/02/2007
Lignes 24 et 25 : La troisième et dernière étape consiste à terminer et détruire le MIDlet. Pour cela, le
gestionnaire d'applications appelle la méthode destroyApp(). Cette méthode libère toutes les ressources et
sauvegarde toutes les données persistantes. Nous n'utilisons aucune ressource et aucune donnée persistante,
la méthode est donc vide.
5.6. La gestion des événements
Ligne 27 : Les événements sont gérés par la méthode commandAction(). Elle reçoit en paramètre un objet
événement prmCommand qui permet d'identifier la provenance de l'événement survenu.
Ligne 28 : Ensuite, elle détermine l’origine de l’évènement (le composant dans lequel est survenu cet
événement).
Lignes 29 et 30 : Si c'est bien la commande Sortie qui a été activée, alors on détruit l'application (ligne 29) puis
on notifie au gestionnaire d'application que le MIDlet est détruit.
5.7. Remarques
L'interface utilisateur
L'interface utilisateur est basée sur un composant TextBox, similaire aux composants TextArea et TextField de
l'AWT (Abstract Window Toolkit). Il faut savoir que l'interface utilisateur d'un MIDlet est adaptée aux
caractéristiques des terminaux mobiles légers.
Le composant TextBox
Notre interface utilisateur, en dehors d'une commande, ne comprend qu'un seul composant, un TextBox. Ce
dernier possède trois propriétés : un libellé, un contenu initial (c'est la valeur par défaut) et un type. Pour utiliser
cet objet, il vous suffit lors de la création du composant de spécifier le libellé et le contenu initial. Ensuite, vous
ajoutez les commandes à la zone de saisie et demandez au MIDlet d'écouter les événements d'action en
appelant les méthodes objTextBox.setCommand() et objTextBox.setCommandListener().
Dans notre exemple, le texte « HelloWorld » apparaît dans la zone du titre et le texte « Bonjour le monde »
apparaît dans la zone du contenu initial. La commande Sortie apparaît dans la zone de commande et est
associée à la touche juste en dessous (sur un téléphone portable).
L'association des commandes aux touches
L'association des touches aux commandes est dépendante du périphérique. La classe MIDP Command vous
permet de spécifier les types de commande : BACK, CANCEL, EXIT, HELP, ITEM, OK, SCREEN et STOP.
Dans notre exemple, la pression du bouton (juste au dessous du texte « Sortie ») appelle la méthode
commandAction() en lui passant une référence à la commande objCmdExit. La méthode destroyApp(true)
est appelée ensuite. Le MIDlet se termine alors et l'environnement retourne au gestionnaire d'applications.
La priorité
Si plusieurs commandes d'une même application ont un même type de commande, alors la valeur de priorité
fixée détermine la manière dont va se faire l'association des commandes aux touches. Plus la valeur de priorité
est grande, plus importante est la commande.
Concrètement, le terminal choisit l'emplacement d'une commande selon le type de commande de même type
par ordre de priorité. Cela peut signifier que la commande de plus haute priorité est placée de manière à ce
que l'utilisateur puisse la déclencher directement et que les commandes avec une priorité inférieure sont
placées dans un menu.
Page 13 sur 13
09/02/2007

Présentation de Java Micro Edition

Transcription

Documents pareils

Conception et développement Java/J2EE web

Ingénieur Informatique Java-J2EE (HF) Conception et

Java ME - ITFormation

Diplomatic-Cover - Top Interactive Agencies

Procédure d`installation et d`activation de licence : Télécharger la

CV.ROUVIER.F-Info - IUT de Villetaneuse

Comment contourner les blocages de sécurité de Java

Comparatif des intergiciels présentés

Mardi 17 Janvier 19h00 Exia / Cesi de Mont Saint Aignan Des

(H/F) Stagiaire Développement et validation d`outils IT

J2ME : une présentation

1ere partie cours de Frédéric Bertin