Didacticiel J2ME MIDP "Conversion de devises" pour l'EDI NetBeans IDE 4.0 Bêta 2

Feedback

L'application de Conversion de devises (Currency Converter en anglais) que nous allons construire doit permettre de:

  • démarrer un projet J2ME MIDP
  • développer une application fonctionnelle J2ME MIDP aussi appelée MIDlet, en utilisant l'EDI
  • définir des configurations de projet pour tester la performance de l'application sur deux émulateurs différents

l'application de Conversion de devises permet de convertir une somme d'argent exprimée dans une devise vers deux autres devises. Il est possible d'afficher trois devises différentes: l'euro, le yen ou le dollar. L'utilisateur peut également saisir la valeur d'une devise pour l'utiliser lors des conversions vers les deux autres devises.

Cette application d'exemple contient trois fichiers source java:

  • ConvertisseurMIDlet.java. Contient la classe de la MIDlet.
  • Convertisseur.java. Un formulaire MIDP qui définit l'écran principal de l'application tel qu'il apparaît sur un périphérique mobile.
  • SelectionDevises.java. Une liste MIDP qui maintient les taux de change.

La première partie de ce didacticiel permet de montrer comment installer, exécuter et tester rapidement l'application de Conversion de devises qui se trouve déjà au sein de l'EDI sous forme de projet d'exemple. Dans la deuxième partie de ce didacticiel, nous allons créer un nouveau projet et rajouter du code pour créer et tester nous même l'application.

Ce didacticiel doit prendre environ une heure de votre temps.

Pré-Requis

Vous devez avoir l'EDI NetBeans 4.0 ainsi que le NetBeans Mobility Pack 4.0 installés avant de pouvoir démarrer vos développements J2ME MIDP. Les instructions pour télécharger et installer se trouvent sur la page J2ME MIDP Development Download.

Installation et test de l'exemple de projet Conversion de devises

Dans cette première partie, nous allons voir à quelle vitesse il est possible de mettre en place et d'exécuter une application dans deux émulateurs différents.

Création du projet
  1. Choisir File > New Project. Dans Categories, sélectionner Samples > Mobile. Dans Projects, choisir Currency Converter. Appuyer sur Next
  2. Le nom du projet et son emplacement sont renseignés dans la page Project Name and Location. Il y est possible de spécifier qu'il s'agit de votre projet principal. Choisir Next pour accepter les choix par défaut.
  3. La page de sélection de la plate-forme permet de choisir l'environnement d'exécution par défaut du projet (emulator platform). La plate-forme d'émulation par défaut est le J2ME Wireless Toolkit et le périphérique par défaut est un périphérique générique appelé DefaultColorPhone. Choisir Finish pour conclure le travail de l'assistant.
    Le projet Conversion de devises "Currency Converter" apparaît dans la fenêtre des projets.
Exécution du projet
  1. Choisir Run > Run Main Project.
    L'application de conversion de devises apparaît dans le périphérique émulé DefaultColorPhone.
  2. Il est alors possible de tester l'application dans cet émulateur.
Test de l'application
  1. Dans l'émulateur DefaultColorPhone, appuyer sur le bouton qui se trouve sous "Launch".
  2. Sélectionner la devise à convertir en appuyant sur les flèches vers le haut et le bas et sur le bouton "Select". Les choix possibles sont Dollars, Euros ou Yen.
  3. Saisir un montant à convertir en utilisant les touches numériques de l'émulateur.
    L'application applique le taux de conversion et affiche le résultat.
  4. Le bouton situé sous "Exit" permet de quitter l'application.
  5. le bouton rouge en haut à droite de l'émulateur permet de fermer celui-ci.
Modification du périphérique émulé par défaut

Il est possible de créer différentes configuration de projet pour tester une MIDlet dans des environnements d'émulation différents ou simplement en modifiant le périphérique par défaut de l'application.

  1. Avec un click droit sur le nœud "Currency Converter", choisir Properties. Dans le dialogue qui s'affiche sélectionner le nœud Platform. Le menu déroulant en face de "Device" permet de sélectionner le périphérique par défaut.
  2. Choisir QwertyDevice dans ce menu déroulant et cliquer sur OK.
  3. Choisir Run > Run Main Project pour exécuter de nouveau l'application, cette fois-ci dans le nouvel émulateur QwertyDevice (en attendant l'AzertyDevice...).

Dans la suite de ce didacticiel, nous allons partir d'un nouveau projet vierge. Ceci doit vous permettre de comprendre l'organisation du code de l'application et la manière dont l'EDI peut vous aider à développer et tester vos propres applications.

Création de l'application Conversion de devises

Création du projet
  1. Choisir File > New Project. Dans Categories, choisir Mobile. Sous Projects, sélectionner Mobile Application et cliquer sur Next.
  2. Dans l'écran suivant, nommer le projet ConvertisseurDevises et accepter le choix par défaut pour la propriété Project Home. S'assurer que la boîte à cocher Set as Main Project est sélectionnée puisqu'il doit s'agir de notre nouveau projet par défaut.
  3. Accepter les choix par défaut dans l'écran Platform et choisir Finish.
    La nouvelle application ConvertisseurDevises apparaît dans la fenêtre des applications.

Création de la MIDlet ConvertisseurMIDlet.java

  1. Choisir File > New File. Dans Categories, choisir MIDP. Dans File Types, choisir MIDlet et appuyer sur Next.
  2. Dans l'écran Name and Location page, saisir Convertisseur de devises en guise de nom de MIDlet, ConvertisseurMIDlet pour le nom de la classe MIDP (MIDP Class Name) et monconvertisseur pour le nom de paquetage.

Code de la MIDlet

Il existe deux moyens d'écrire le code de la MIDlet: soit en saisissant directement le code dans l'éditeur de source, soit en utilisant les fonctions add method, add field, add constructor, add initializer, add classe et add interface de l'EDI. Habituellement le meilleur moyen est d'utiliser l'EDI pour rajouter de nouveaux attributs et de nouvelles méthodes dans une classe (ou de modifier ceux qui existent), puis d'utiliser l'éditeur de source pour procéder à des réglages plus fins.
la procédure qui suit vous présente comment utiliser l'outil et son éditeur de source pour saisir ou modifier du code source. Ceci-dit, vous pouvez également reprendre le code qui se trouve dans le projet initialement exécuté (et traduire ce qui doit l'être en français avec les capacité de refactoring de NetBeans par exemple!) pour gagner du temps.

Code de la MIDlet ConvertisseurMIDlet.java
  1. Dans l'éditeur de source, rajouter les instructions d'import suivantes au fichier ConvertisseurMIDlet.java (double-cliquer sur le nœud correspondant pour faire apparaître le code source):
    import java.io.*;
    import javax.microedition.rms.*;
  2. Dans l'onglet Projects, ouvrir le nœud ConvertisseurMIDlet et utiliser un click-droit sur le nom de la classe pour choisir Add > Field.
    Cette étape utilise la fenêtre Add New Field pour rajouter l'attribut storedDataStr à la MIDlet. La chaîne de caractères storedDataStr contient le nom de l'enregistrement RMS.
  3. Pour renseigner la fenêtre Add New Field:
    • Saisir le nom du nouvel attribut storedDataStr et sélectionner son type String dans le menu déroulant.
    • Pour le niveau d'accès, choisir le type private pour cet attribut dans le menu déroulant Access.
    • Vérifier que le modificateur d'accès static soit sélectionné pour cet attribut.
    • Positionner la valeur initialle de storedDataStr à "ValeurAConvertir" (avec les guillemets).
    • Cliquer sur OK pour fermer la boîte de dialogue.

    L'attribut est alors rajouté au code et il apparaît dans la fenêtre de l'éditeur de code.

  4. Rajouter les attributs suivants dans la classe ConvertisseurMIDlet.java en utilisant l'éditeur de source.
    Vous pouvez soit utiliser la boîte de dialogue Add Field, soit copier le texte de cette page, soit recopier le code issu de l'application Currency Converter. Attention cependant à ne pas changer le nom de paquetage monconvertisseur.

    public class ConvertisseurMIDlet extends MIDlet {
    private static String storedDataStr = "ValeurAConvertir";
    public String[] devises = new String[] { "US $", "Yen \u00a5", "Euro \u20ac" };
    public boolean[] selection = new boolean[] { true, true, true, true };
    public long[][] taux = {{ 1000000, 117580000, 911079 },
    { 8504, 1000000, 7749 },
    { 1097600, 129056000, 1000000 }};
    private RecordStore storedData;
  5. Rajouter le code suivant dans la méthode startApp(). Cette méthode  est appellée au démarrage de l'application. Elle charge les données (devises, devises sélectionnées et taux de change) depuis la zone de stockage et affiche le formulaire de conversion. Voici à quoi doit ressembler la méthode:
    public void startApp() {
    try {
    storedData = RecordStore.openRecordStore(storedDataStr, true);
    if (storedData.getNumRecords() > 0) {
    DataInputStream in = new DataInputStream(new ByteArrayInputStream(storedData.getRecord(1)));
    try {
    int size = in.readInt();
    devises = new String[size];
    selection = new boolean[size];
    taux = new long[size][];
    for (int i=0; i<size; i++) {
    devises[i] = in.readUTF();
    selection[i] = in.readBoolean();
    taux[i] = new long[size];
    for (int j=0; j<size; j++) {
    taux[i][j] = in.readLong();
    }
    }
    in.close();
    } catch (IOException ioe) {
    }
    }
    } catch (RecordStoreException e) {
    }
    notifieModifParametres();
    }
  6. La méthode destroyApp() est appelée lorsque l'application se termine ou lorsqu'elle est détruite. Voici le code à rajouter à la méthode destroyApp():
    public void destroyApp(boolean unconditional) {
    try {
    ByteArrayOutputStream bytes = new ByteArrayOutputStream();
    DataOutputStream out = new DataOutputStream(bytes);
    try {
    out.writeInt(devises.length);
    for (int i=0; i<devises.length; i++) {
    out.writeUTF(devises[i]);
    out.writeBoolean(selection[i]);
    for (int j=0; j<devises.length; j++) {
    out.writeLong(taux[i][j]);
    }
    }
    out.close();
    if (storedData.getNumRecords() > 0)
    storedData.setRecord(1, bytes.toByteArray(), 0, bytes.size());
    else
    storedData.addRecord(bytes.toByteArray(), 0, bytes.size());
    } catch (IOException ioe) {
    ioe.printStackTrace();
    }
    } catch (RecordStoreException e) {
    e.printStackTrace();
    }
    notifyDestroyed();
    }
  7. Rajouter ensuite les trois méthodes suivantes:
  • afficheParametres()
    Cette méthode créé et affiche la liste SelectionDevise.
      public void afficheParametres() {
    Display.getDisplay(this).setCurrent(new SelectionDevise(this));
    }
  • notifieModifParametres()
    Cette méthode affiche un nouveau formulaire Convertisseur une fois les paramètres modifiés.
     public void notifieModifParametres() {
    Display.getDisplay(this).setCurrent(new Convertisseur(this));
    }
  • conversion()
    Cette méthode effectue la conversion de devises. La valeur en entrée frval est multipliée par le taux d'échange stocké dans la tables des taux et divisée par 1 000 000. Les valeurs fridx et toidx représentent les indices source et cible du taux de conversion à appliquer.
     public long conversion(long frval, int fridx, int toidx) {
    return (frval * taux[fridx][toidx]) / 1000000;
    }
    8. Sauvegarder ConvertisseurMIDlet en sélectionnant File > Save.

Création d'un formulaire MIDP

Maintenant que nous avons terminé de rédiger le code de la MIDlet, nous allons créer l'interface graphique de l'application. Un formulaire (form) est une classe Java susceptible de contenir un nombre quelconque d'éléments: images champ en lecture seule, champ de saisie de texte, groupes de sélection et autres éléments spécifiques. Le formulaire créé ici doit proposer une zone de texte pour chaque devise sélectionnée et spécifier la méthode itemStateChanged()pour surveiller et convertir à la volée une valeur en cours de saisie.

Code du formulaire MIDP  Convertisseur.java

  1. Dans la fenêtre des projets, utilisez un click droit sur le paquetage monconvertisseur pour choisir File > New File/Folder.
    L'assistant New File apparaît.
  2. Dans Categories, ouvrir les nœuds MIDP et MIDP Forms. Choisir MIDP Form dans File Types et cliquer sur Next.
  3. Dans l'écran Name and Location saisir Convertisseur en guise de nom de classe et choisir Finish.
    Un formulaire MIDP est alors créé et rajouté au paquetage monconvertisseur.
  4. Dans l'éditeur de source, rajouter les champs suivants sous la déclaration public class Convertisseur :
    private ConvertisseurMIDlet midlet;
    private int[] translate;
  5. Rajouter le code suivant pour compléter le constructeur afin qu'il contienne exactement le code qui suit :
    public Convertisseur(ConvertisseurMIDlet midlet) {
    super("Convertisseur Devises");
    this.midlet = midlet;
    this.translate = new int[midlet.devises.length];
    int courant = 0;
    for (int i=0; i<translate.length; i++) {
    if (midlet.selection[i]) {
    translate[courant++] = i;
    append(new TextField(midlet.devises[i], "", 12, TextField.NUMERIC));
    }
    }
    try {
    // Mise en place de l'écoute d'événements pour le formulaire
    setCommandListener(this);
    // Mise en place de l'écoute des événements de changement d'état
    setItemStateListener(this);
    // Rajout de la commande Devises
    addCommand(new Command("Devises", Command.OK, 1));
    // Rajout de la commande de Sortie
    addCommand(new Command("Sortie", Command.EXIT, 1));
    } catch(Exception e) {
    e.printStackTrace();
    }
    }
  6. Rajouter le code suivant pour compléter la méthode commandAction() :
 public void commandAction(Command command, Displayable displayable) {
if (command.getCommandType() == Command.EXIT) {
midlet.destroyApp(true);
} else if (command.getCommandType() == Command.OK) {
midlet.afficheParametres();
}
}
  • Rajouter le code suivant pour compléter la méthode itemStateChanged() :
  • public void itemStateChanged(Item item) {
    try {
    long valeur = Long.parseLong(((TextField)item).getString());
    int from = 0;
    while (get(from) != item) from++;
    from = translate[from];
    for (int i=0; i<size(); i++) {
    int to = translate[i];
    if (from != to) {
    ((TextField)get(i)).setString(String.valueOf(midlet.convert(valeur, from, to)));
    }
    }
    } catch (NumberFormatException nfe) {
    for (int i=0; i<size(); i++) {
    ((TextField)get(i)).setString("");
    }
    }
    }
    Ceci termine la rédaction du formulaire Convertisseur.java.

    Création d'une liste MIDP

    Le dernier morceau nécessaire pour compléter l'application Convertisseur de devises est la liste définie dans le fichier SelectionDevise.java. Celui-ci défini la liste des devises qui doivent être proposées à l'affichage.

    Code de la liste MIDP SelectionDevise.java

    1. Dans la fenêtre des projets, utilisez un click droit sur le paquetage monconvertisseur pour choisir File > New File/Folder.
      L'assistant New File wizard apparaît.
    2. Dans Categories, ouvrir les nœuds MIDP et MIDP Forms. Choisir MIDP List dans File Types et cliquer sur Next.
    3. Dans l'écran Name and Location saisir SelectionDevise en guise de nom de classe et choisir Finish.
      Une liste MIDP est alors créée et rajoutée au paquetage monconvertisseur.
    4. Insérer le champ suivant après la ligne public class SelectionDevise extends List implements CommandListener {:
      private ConvertisseurMIDlet midlet;
    5. Rajouter le code suivant pour compléter le constructeur afin qu'il contienne exactement le code qui suit :
         public SelectionDevise(ConvertisseurMIDlet midlet) {
      super("Selection Devise", List.MULTIPLE, midlet.devises, null);
      this.midlet = midlet;
      setSelectedFlags(midlet.selection);
      try {
      // Mise en place de l'écoute d'événements sur la liste
      setCommandListener(this);
      // Rajout de la commande de validation
      addCommand(new Command("Valider", Command.OK, 1));
      } catch(Exception e) {
      e.printStackTrace();
      }
      }
    6. Rajouter le code suivant pour compléter la méthode commandAction():
        public void commandAction(Command command, Displayable displayable) {
    if (command.getCommandType() == Command.OK) {
    getSelectedFlags(midlet.selection);
    midlet.notifieModifParametres();
    }
    }
      Ceci complète la liste du fichier
    SelectionDevise.java.

    Tester son application

    Maintenant que nous avons créé notre application, il est possible de la tester dans différents émulateurs de périphériques comme cela a été fait avec le projet Conversion de devises du début du didacticiel. Cependant, plutôt que de modifier l'émulateur de périphérique dans la configuration par défaut, nous allons créer une deuxième configuration de projet pour l'émulateur QwertyDevice.

    Création d'une nouvelle configuration de projet

    1. Choisir File > "ConvertisseurDevises" Properties.
    2. Appuyer sur le bouton "Manage Configurations..." pour ouvrir le gestionnaire de configurations du projet.
    3. Appuyer sur le bouton "Add".
    4. Saisir le nom de la nouvelle configuration QwertyDevice et appuyer sur "Ok".
    5. Choisir "Close" pour fermer le gestionnaire de configurations.

    Nous avons désormais une deuxième configuration QwertyDevice à disposition dont les propriétés sont exactement celles de DefaultConfiguration.

    Modification de la propriété Device
    1. Toujours dans la fenêtre des propriétés du projet, choisir "Platform" dans l'arbre dans la partie gauche de la fenêtre.
    2. Si "QwertyDevice" n'est pas la configuration active du projet, la choisir dans le menu déroulant qui contient la liste des différentes configurations ("Project Configuration").
    3. Afin de pouvoir définir de nouvelles propriétés pour cette configuration, il est nécessaire de s'assuré que le bouton "Use Values from DefaultConfiguration" n'est pas sélectionné.
    4. Choisir QwertyDevice dans le menu déroulant des périphériques ("Device"). Choisir OK.
    Exécution de l'application dans les deux configurations
    1. Sélectionner la configuration DefaultConfiguration dans la liste des configurations.
    2. Sélectionner le menu Run > Run Main Project (touche F6).
      Le Convertisseur de devises apparaît dans l'émulateur DefaultColorPhone.
    3. Choisir QwertyDevice comme configuration par défaut dans le menu déroulant.
    4. Sélectionner le menu Run > Run Main Project (touche F6).
      Le Convertisseur de devises apparaît cette fois-ci dans l'émulateur QwertyDevice.
    5. Il est désormais possible de tester et comparer en parallèle le comportement et la performance de l'application.

    Project Features

    About this Project

    fr was started in November 2009, is owned by petras, and has 94 members.
    By use of this website, you agree to the NetBeans Policies and Terms of Use (revision 20160708.bf2ac18). © 2014, Oracle Corporation and/or its affiliates. Sponsored by Oracle logo
     
     
    Close
    loading
    Please Confirm
    Close