Introduction à Mobile PhoneProgrammation en Java ME(préparé pour CS / ECE 707, UW-Madison)Auteur: Leszek WilandSuman et Banerjee1content1. Introduction2. Mise en place d'un environnement de programmation3. Bonjour demande mondiale4. GUI et l'interaction utilisateur5. Réseautage21. IntroductionDans ce tutoriel, je vais vous expliquer les principaux concepts de développement d'applications mobiles en Java moi. jecommencera par la mise en place environnement de programmation en système d'exploitation Windows, puisprocéder à montrer modèle de programmation Java ME sur l'exemple d'un certain nombre de mobilesapplicationsJava Me est une spécification d'un sous-ensemble de plate-forme Java qui fournit un ensemble d'API Java pourdéveloppement pour les petites et ressources limitées dispositifs. Puisque cela peut inclure plusieurs technologiquementdifférents dispositifs, Java ME est en outre divisés en configurations et profils qui définissentcertains certaine partie des API Java ME qui sont aptes à être exécuté sur un dispositif particulier. mobileTéléphones doivent mettre en œuvre CLDC (Connected Limited Device Configuration) avec MIDP(Mobile Information Device Profile), qui à la fois définir API que nous, les programmeurs peuvent utiliser pourconstruire des applications mobiles. Toutefois, les deux CLDC et MIDP viennent dans différentes versions adaptées àdifférents téléphones mobiles. A partir de maintenant, Nokia N95 met en œuvre la nouvelle version de fois CLDCqui est 1,1 et qui est MIDP 2.0. Il est important de mentionner qu'une nouvelle version de 3ème MIDP est actuellement en cours de développement. Machine virtuelle Java pour les appareils mobiles a été réécrit et il estne est plus celui qui a faim de mémoire bien connu de PC, mais a été spécialement optimisé pourpetits appareils tels que les téléphones mobiles.2. Mise en place d'un environnement de programmationIl existe quatre principaux composants à installer pour commencer la programmation en Java pour mobile dispositifs. La première Java SE (Standard Edition) Kit de développement est que vous pourriez déjà avoir installé sur votre machine; la version recommandée est 1.5.0. Ensuite, vous devez télécharger et Installer Toolkit Sun Java sans fil pour CLDC; version actuelle 2.5.2 qui peut être trouvé

à la lien suivant:http://java.sun.com/products/sjwtoolkit/download.html?feed=JSCFaites défiler vers le bas de la page pour trouver le fichier. Ensuite, installez Nokia SymbianOS / S60 SDK pourJava. Il existe plusieurs versions de ce SDK chacun pour un autre groupe de dispositifs. Nokia N95soutient la nouvelle version du SDK: S60 3ème édition, Feature Pack 2, qui se trouve sousle lien suivant:http://www.forum.nokia.com/info/sw.nokia.com/id/6e772b17-604b 4081999c31f1f0dc2dbb /S60_Platform_SDKs_for_Symbian_OS_for_Java.html3Rechercher sur le côté droit et a choisi 3e édition FP2v1.1 (455 Mo) fichier pour le téléchargement.La dernière chose à installer est Eclipse ou un autre environnement de développement intégré capable detravailler avec Java ME Edition (Java Micro Edition), par exemple avec NetBeans Mobility Pack. ence document, je vais vous montrer comment mettre en place un projet avec Eclipse, donc si vous ne avez pas déjà Eclipseinstallé sur votre machine, vous pouvez le trouver à:http://archive.eclipse.org/eclipse/downloads/drops/R-3.2.2-200702121330/index.phpUn montant supplémentaire de Me Eclipse plug-in serait nécessaire pour Eclipse pour fonctionner correctement avec Java ME etil peut être consulté à l'adresse suivante:http://sourceforge.net/project/showfiles.php?group_id=86829Décompressez le fichier zip et copier tous les fichiers dans les plug-ins et dispose répertoires correspondantrépertoires dans votre dossier Eclipse. Ayant fait cela, nous pouvons procéder à configurer Eclipse pour travaillercorrectement avec Java ME et l'émulateur de téléphone. Tout d'abord, sélectionnez Window-> Préférences et a choisiNoeud de J2ME et sélectionnez Gestion des périphériques. Appuyez sur l'importation et recherchezC: \ S60 \ devices \ S60_3rd_MIDP_SDK_FP2_Beta ou tout autre répertoire que vous avez installé le S60SDK, cliquez sur Actualiser et assurez-vous que les cases à cocher des deux appareils sont S60Emulator et S60Devicevérifiée. Appuyez sur Terminer puis importez à nouveau. Cette navigation de temps pour C: \ WTK2.5.2 répertoire, cliquez surrafraîchir et se assurer que tous les quatre périphériques sont sélectionnés, puis cliquez sur Terminer. Retour dans la boîte de dialogue principalesélectionnez DefaultColorPhone comme périphérique par défaut. Malheureusement, le choix de ne importe quel autre seraitfaire la demande sûr. Après avoir fait cela, allez à Fenêtre-> Préférences, développez noeud Java-> Chemin de compilation, puis Pour item Source et le dossier de sortie, sélectionnez les dossiers de boutons radio, et de garder lepar défaut (src et Bin). Suivant élargir noeud Java-> Debug et décochez suspendre l'exécution surexceptions non interceptées et suspendre l'exécution sur les erreurs de compilation, et à l'ensemble de fin Debugger

timeout (ms) à 15000 Ce est assez pour commencer à programmer pour les appareils mobiles et puisque nous avonsl'émulateur de téléphone, il est facile de tester tout ce que nous avons écrit. Toutefois, afin de se déplacerapplications facilement à partir de l'ordinateur à un vrai téléphone nous aurions besoin de Nokia PC Suite qui fait quepour nous. Il peut être trouvé à:http://europe.nokia.com/pcsuite3. Bonjour demande mondialeUne fois tous les éléments de l'environnement de programmation sont installés, nous sommes prêts pour créer une premièreApplication Java moi. Commencez par ouvrir Eclipse puis sélectionnez Fichier-> Nouveau-> Projet. Développer J2Menoeud et choisissez J2ME MIDlet Suite. Appuyez sur à côté, donner au projet un nom unique et cliquez sur Suivantencore une fois, assurez-vous également que dans le "Groupe:" menu, Sun Java Wireless Toolkit est choisi etMenu "Device" DefaultColorPhone est sélectionné. Appuyez sur suivant et sélectionnez "Permettre des dossiers de sortie pourdossiers source "et appuyez sur la finition. Une fois le projet Java ME est créé, nous devons ajouter une classe MIDletle projet qui est le cœur de chaque application Java ME. Pour ce faire, cliquez droit sur le projet,sélectionnez New-> Autres et choisissez J2ME MIDlet. Cela va créer un squelette d'application Java ME.En règle générale, tout programme Java ME pour les appareils embarqués tels que les téléphones intelligents Nokia est appelé4MIDlet. Il ya peu de différences entre la classe principale d'une application Java standard et un principalclasse d'une application Java ME. Tout d'abord, la classe Java ME principal n'a pas la fonction main (), maisa lieu trois méthodes vides et qui est dérivé de la classe MIDlet (est une sous-classe de la classe MIDlet).Chaque application Java ME doit avoir une classe principale qui est dérivé de MIDlet et contenir lestrois méthodes suivantes:1. protected void destroyApp (arg0 booléen);2. protected void pauseApp ();3. protected void startApp ();Un MIDlet est simplement une épine dorsale de l'application et quand il est lancé, la machine virtuelle Javaserait charger cette classe principale et commencer sa méthode startApp () qui agit dans ce cas comme l'ancienfonction main () connu de Java SE. La méthode destroyApp (arg0 booléenne) est appelé à chaque foisnous voulons l'application de mettre fin, alors que le pauseApp () est appelée par l'exploitation sous-jacent

système quand il a besoin de libérer des ressources supplémentaires et souhaite notre application pour arrêterl'exécution d'un certain temps. Cela peut se produire, par exemple, se il ya un appel entrant et lesystème d'exploitation a besoin de libérer autant de ressources que possible pour faire face à cette tâche. Par conséquent, sinotre application utilise beaucoup de ressources système que ce serait l'endroit pour les libérer. Toutefois, sinous laissons cette méthode vide, alors pas de ressources seront libérés par le système d'exploitation.Le MIDlet simple suivante, ne fait rien en particulier. Il ne est pas capable de ne importe quel utilisateurinteraction que ce soit, et ne peut donc être résilié si commencé sur le téléphone mobile. Si fonctionner surl'ordinateur peut être facilement tué par la fermeture de la fenêtre du simulateur. le"System.out.println (" Bonjour tout le monde ");" déclaration ne aura aucun effet lorsqu'il est exécuté sur le téléphonesimulateur ou sur l'appareil lui-même, et ne peut donc être utilisé pour la sortie d'impression .. Il seraitimprimé, cependant, sur la console Eclipse et il est donc très utile pour le débogage.Code 1public class principale se étend MIDlet {Principal publique () {// TODO généré automatiquement stub constructeur}destroyApp protected void (arg0 booléen) {// TODO méthode d'auto-généré stub}vide pauseApp protégé () {// TODO méthode d'auto-généré stub}vide startApp protégé () throws MIDletStateChangeException {System.out.println ("Hey");}}5L'étape finale du processus de développement est d'installer au-dessus de moi application Java sur l'appareil mobile.Pour ce faire, nous avons besoin de générer un fichier jar qui est ensuite copié dans le téléphone. Faites un clic droit sur leprojet et sélectionnez J2ME-> Créer un package (sur le très bas). Cela va générer un pot et uneJAD Fichier, deux qui sont stockés sous le répertoire déployé dans le projet Java ME. Une fois que la sortiefichiers sont prêts, nous allons les installer sur l'appareil de téléphone en utilisant l'application Nokia PC Suite. premièreconnecter l'appareil à l'ordinateur de préférence par câble USB et choisissez parmi les options

PCSuiteaffichée sur l'écran de l'appareil. Puis démarrer l'application PC Suite sur votre machine et sélectionnez InstallerPoint d'application qui se trouve sur la partie inférieure gauche de la fenêtre d'application. Parcourir pour le pot de projetdéposer et en appuyant sur une flèche d'installation entre mon ordinateur et mon fenêtre Téléphone copier lefichier jar au dispositif sur lequel vous pouvez terminer le processus d'installation.4. GUI et l'interaction utilisateurIl ya deux façons de construire une interface utilisateur avec Java ME. Premier et le plus facile est d'utiliser de haut niveau API qui est constitué de composants déjà créés qui peuvent être mélangés ensemble dans ne importe quel mode. L'API de haut niveau ne se occupe également de l'afficher correctement sur l'écran, le défilement à travers les menus si nécessaire et, fondamentalement, rendre notre vie beaucoup plus facile. Tous les composants doivent éventuellement être attaché à un objet qui est dérivée de la classe affichable à afficher sur la écran. Alors, quand en utilisant l'API de haut niveau pour construire une interface utilisateur nous finissons fixer GUI différentedes éléments tels que TextField, boutons, des listes ou TextString à un objet qui est dérivé deAffichable tels que formulaire, puis nous avons mis que affichable à afficher sur l'écran, et ce est tout.Cela signifie que nous pouvons nous préparer de nombreuses interfaces utilisateur différentes ou des menus et basculer entre eux aussi facilement que ce est d'établir un nouveau affichable à afficher sur l'écran. Une fois que nous avons l'interface graphique prêts, nous devons prendre soin de l'interaction de l'utilisateur, et ceci est fait en faisant une de nos classes, MIDlet préférence, de mettre en œuvre l'interface CommandListener qui consiste d'une méthode:commandAction public void (Command c, g affichable);Code 2public class principale se étend MIDlet implémente CommandListener {6Principal publique () {// TODO généré automatiquement stub constructeur}destroyApp protected void (arg0 booléen) {// TODO méthode d'auto-généré stub}vide pauseApp protégé () {// TODO méthode d'auto-généré stub}vide startApp protégé () throws MIDletStateChangeException {System.out.println ("Hey");}public void commandAction (Command c, g affichable) {// TODO méthode d'auto-généré stub}}Chaque fois qu'il ya un événement généré par l'utilisateur la méthode commandAction () est appelée avec commande

et les arguments affichables qui lui est passé. Nous pouvons répondre à l'entrée de l'utilisateur en vérifiant ce quecommande a été généré et réagir en conséquence. Les outils de MIDlets ci-dessusInterface CommandListener mais ne peut pas traiter ne importe quelle entrée de l'utilisateur puisque nous ne avons pas défini deles commandes qui permettre à l'utilisateur d'interagir avec l'application. Avant de procéder à expliquercomment faire je vais bientôt écrire sur la seconde façon de construire l'interface graphique qui est faible API de niveau. ilnous permet traitons directement avec ce qui est affiché sur l'écran en définissant une méthode paint () qui estappelé chaque écran de temps doit être rafraîchi. Il fournit également un moyen de capturer ne importe quelle entrée d'utilisateur,tandis que l'API de haut niveau peut capturer seulement ceux qui sont directement événement généré par l'interactionavec des boutons affichés sur l'écran, par conséquent, il manque toutes les touches alphanumériques. Pour utiliserAPI de bas niveau l'une des classes doit être dérivé de classe Canvas et met en œuvre la peintureProcédé.peinture protected void (Graphics g);L'objet de toile définit plusieurs autre méthode en dehors de la peinture () qui sont utilisés principalement pourmanipulation interface basse utilisateur de niveau je vais me concentrer principalement sur la peinture () et keyPressed (). ce qui suitMIDlet démontrer l'utilisation des API de bas niveau:Code 3LowLevelAPI public class étend Canvas {7peinture protected void (arg0 Graphics) {// TODO méthode d'auto-généré stub}protected void keyPressed (int keyCode) {}}Comme commandAction () méthode d'API de haut niveau, nous vérifions l'keyCode et selon lecode clé prenne certaines actions spécifiques.Jusqu'à présent, nous savons qu'il ya deux types de API disponibles pour la construction de l'interface graphique et que l'entrée de l'utilisateur peutêtre traitées par soit la méthode ou les deux de leur mise en oeuvre commandAction () ou keyPressed ().Maintenant, je vais procéder à montrer comment construire une interface graphique simple à l'aide de haut niveau API. Comme je le mentionnaisavant que les éléments qui sont dérivés de affichable ou écran peuvent être affichés sur leappareil. Écran dispose de 4 sous-classes principales dont chacun peut être utilisé pour construire des GUI, et lorsque vous êtes prêt, être

affiché sur l'écran en le définissant comme un écran actuel. Ces sous-classes sont: Alerte, Liste, TextBoxet la forme.· Alerte: est un écran qui affiche les données à l'utilisateur et attend pendant une certaine période de temps avantde passer à l'écran suivant.· Liste: contient une liste de choix et l'ensemble des méthodes pour interroger quelle option ont étésélectionné par l'utilisateur.· TextBox: permet à l'utilisateur de saisir du texte.· Forme: peut contenir un mélange arbitraire d'éléments: images, lecture seule des champs de texte, texte modifiablechamps, champs éditables de date, les jauges, les groupes choix, et des éléments personnalisés dont chacun peut êtreannexée au formulaire dans ne importe quel mode.La mise en oeuvre poignées mise en page, et la traversée de défilement automatique. En dehors de ces quatredérivée des classes les d'écran il ya un certain nombre de composants provenant de la classe d'objet, quipeut être attaché à un formulaire et utilisé comme blocs de construction de l'ensemble de l'interface graphique.Afin de gérer l'interface utilisateur, nous devons définir un ensemble de commandes qui sont ensuite attaché àl'affichable. Il peut être ne importe quelle classe qui est dérivée de affichables, tels que: Alert, List,TextBox, Forme et également la faible classe API de niveau: Toile. Chaque commande est représenté par unobjet Command séparé avec un nom, type de commande et la priorité. Une fois que nous avons GUI etcommandes définies, nous devons inscrire cet objet affichable avec un CommandListener, qui estfait en appelant la méthode de setCommandListener () sur l'objet affichable.8Je vais maintenant montrer comment construire une application qui permet aux utilisateurs de taper un texte dans une fenêtre et gravuresdans l'autre. Il dispose de deux boutons, l'un pour la fermeture de l'application et de l'autre de notifier ledemande que le texte doit être imprimé à l'écran. Je vais utiliser les éléments suivants de lahaute API de niveau: Form, TextField, StringItem et deux commandes d'interaction de l'utilisateur.Code 4public class principale se étend MIDlet implémente CommandListener {Sous forme de formulaire = null;Entrée TextField = null;StringItem sortie = null;Affichage d'affichage = null;Commande prête = null;La sortie de commande = null;Principal publique () {

// Donner le nom de formeform = new formulaire («GUI Demo");// Arguments TextField: nom, texte par défaut, la taille des lettres, le type// D'entréeentrée = new TextField ("Input", "Ecrire Sth", 10, TextField.ANY);// Arguments pour StringItem: étiquette, le nomsortie = new StringItem ("Sortie", "");// Arguments pour commande: nom, type, la prioritéready = nouveau commandement ("Display", Command.SCREEN, 1);sortie = nouveau commandement ("Exit", Command.EXIT, 1);// Récupère l'objet d'affichage pour cette MIDletaffichage = Display.getDisplay (this);// Ajouter des commandes à la formeform.addCommand (prêt);form.addCommand (sortie);// Ajouter d'autres éléments à la formeform.append (entrée);form.append (sortie);// Enregistre le formulaire avec le Commandement Listenerform.setCommandListener (this);}destroyApp protected void (arg0 booléen) {notifyDestroyed ();}vide pauseApp protégé () {// TODO méthode d'auto-généré stub}vide startApp protégé () throws MIDletStateChangeException {display.setCurrent (formulaire);}9public void commandAction (Command c, g affichable) {si (c == sortie)destroyApp (false);else if (c == prêt) {output.setText (input.getString ());}}}La première étape consiste à tous les éléments de construction définies de l'interface graphique. Ce est TextField pour l'entrée de l'utilisateur,StringItem pour la sortie, formulaire de lier tous les éléments ensemble, et deux commandes pour l'utilisateurinteraction. La prochaine étape est de récupérer l'objet d'affichage pour cette MIDlet, qui est utilisé pour basculer

entre les écrans affichés sur le dispositif. Ceci est fait en appelant la méthode statique de la classe d'affichagequi prend comme un objet argument MIDlet pour laquelle l'affichage doit être retourné. Une fois que ce estfait, nous ajoutons la commande précédemment définie pour le formulaire ainsi que tous les autres éléments en appelantaddCommand () la méthode et append () sur le formulaire respectivement. La dernière chose à faire leTravaux de GUI est de l'enregistrer (sous cette forme de cas) avec le CommandListener qui est accomplien appelant la méthode de setCommandListener () sur l'objet de formulaire. La méthode startApp () a égalementété légèrement modifié. Lorsqu'il est lancé, MIDlet fixerait notre interface graphique pour être affichée sur le dispositif parappelant la méthode setCurrent (forme) sur l'objet d'affichage qui a été récupéré au début. depuisl'interface graphique est prêt, nous sommes en mesure de remplir la méthode commandAction () pour répondre aux généré par l'utilisateurévénements. Nous avons deux commandes: Sortie dans ce cas, la méthode destroyApp () est appelée et Prêtqui récupère une chaîne de champ de texte modifiable et l'imprime sur dans le domaine non-modifiable.

5. RéseautageJava me définit une API très flexible pour les connexions réseau. Il est basé sur un certain nombre deInterfaces chaque une pour un type de connexion particulier et une classe de connecteur qui est une connexionusine pour créer de nouveaux objets de connexion. Spécification MIDP nécessite des dispositifs quimettre en œuvre pour soutenir au moins HttpConnection, cependant, la plupart des téléphones mobiles de couranty compris Nokia N95 supporte une gamme de différents types de connexion telles que: CommConnection,DatagramConnection, SocketConnection, HttpConnection, HttpsConnection (http sécurisé) ouSocketServerConnection. La majorité de ces connexions permet d'écrire une application client,Cependant en utilisant SocketServerConnection il est également possible d'écrire une application serveur pourplate-forme mobile. Création d'objet Connection est fait en appelant la méthode open () de la classe Connector.Il prend argument de chaîne pour définir le type de connexion à renvoyer. La connexion de basedescripteurs sont:· SocketConnection:socket: // hostip: portno - se connecte à hostip: portno10· SocketServerConnection:socket: //: portno - écoute sur le port: portno· DatagramConnection:

datagramme: //: port - écoute sur le port: portnodatagramme: // hostip: portno - envoie des datagrammes hostip: portno· HttpConnection:URL HTTPJe vais vous montrer une application de réseautage simple qui se connecte au serveur de Google via une connexion httppour télécharger et afficher la carte Google sur l'écran de l'appareil. Depuis la mise en réseau API nous utilisons est unAPI de blocage, il est important de localiser ce code dans un thread séparé afin de ne pas bloquer l'ensembleapplication de sorte qu'un utilisateur peut interagir avec l'application alors que la carte est en cours.Code 5public class principale se étend MIDlet implémente CommandListener {Sous forme de formulaire = null;Image GoogleImage = null;Affichage d'affichage = null;Commande displayimage = null;La sortie de commande = null;Principal publique () {// Donner le nom de formeform = new formulaire («GUI Demo");// Arguments pour commande: nom, type, la prioritédisplayimage = nouveau commandement ("Image", Command.SCREEN, 1);sortie = nouveau commandement ("Exit", Command.EXIT, 1);// Récupère l'objet d'affichage pour cette MIDletaffichage = Display.getDisplay (this);// Ajouter des commandes à la formeform.addCommand (displayimage);form.addCommand (sortie);// Enregistre le formulaire avec le Commandement Listenerform.setCommandListener (this);}destroyApp protected void (arg0 booléen) {notifyDestroyed ();}vide pauseApp protégé () {11}vide startApp protégé () throws MIDletStateChangeException {display.setCurrent (formulaire);}public void commandAction (Command c, g affichable) {si (c == sortie)destroyApp (false);else if (c == displayimage) {

Connection con = new Connexion (this);con.start ();}}}Connection public class extends Thread {Principal parent = null;String url = "";Connexion publique (parent principal) {this.parent = parent;}public void run () {DataInputStream réponse = null;byte [] receivedImage = null;url = "http://maps.google.com/staticmap?center=51.510605,-0.130728 & format = format PNG32 & zoom = 8 & size = "+new Integer (parent.form.getHeight ()). toString () + "x" + nouveauEntier (parent.form.getWidth ()). ToString () +"& key = ABQIAAAAnfs7bKE82qgb3Zc2YySoBT2yXp_ZAY8_ufC3CFXhHIE1NvwkxSySz_REpPq-4WZA27OwgbtyR3VcA ";try {HttpConnection c = (HttpConnection) Connector.open (URL);réponse = new DataInputStream (c.openInputStream ());receivedImage = new byte [(int) c.getLength ()];response.readFully (receivedImage);System.out.println («Téléchargement ok");}catch (IOException e) {System.out.println (e);System.out.println («Téléchargement erreur");Alerte Alerte = new alerte ("", "erreur de réseau", null,AlertType.INFO);parent.display.setCurrent (alerte, parent.form);}finally {try {response.close ();} Catch (IOException e) {System.out.println (e);12}}// Image dans un tableau d'octets.// Transformer en un objet LCUI imageSystem.out.println ("commencer à créer l'image");

try {parent.googleImage = Image.createImage (receivedImage, 0,receivedImage.length);System.out.println ("init image ok");}catch (Exception e) {System.out.println (e);System.out.println ("Image initialisation erreur");Alerte Alerte = new alerte ("", "erreur de l'image", null,AlertType.INFO);parent.display.setCurrent (alerte, parent.form);}// image d'affichageparent.form.deleteAll ();parent.form.append (parent.googleImage);}}La classe principale définit l'interface utilisateur de l'application, mais il ne fait pas de réseau. Une fois qu'un utilisateurappuyez sur "Affichage" commander l'application crée objet Connection et l'exécute en tant qu'entité distincteThread. Objet Connection initier la connexion http, télécharge l'image, l'affiche sur leécran et se termine. Il est important de noter que l'objet de connexion ne dispose d'aucun moyen del'affichage du contenu sur l'écran de l'appareil, car il ne définit pas d'interface utilisateur graphique.Cependant, l'interface utilisateur est définie par catégorie principale, donc de référence parent est passé àObjet Connection qui peut utiliser l'interface utilisateur de parent pour afficher l'image sur l'écran.13