I. Introduction▲
Tout au long de ce tutoriel, nous allons vous détailler comment faire communiquer une application installée sur votre téléphone portable avec un serveur web. Donc, nous aurons deux applications distinctes. La première installée sur votre téléphone portable, et la seconde côté serveur.
Au début nous allons réaliser notre programme côté serveur, avec une Servlet et une classe. Puis pour des besoins de test, nous allons interroger le serveur via un formulaire HTML.
Une fois les tests validés, nous allons remplacer notre formulaire par une application J2ME que nous installerons sur notre mobile.
Le sujet est simple, il s'agit de détailler la procédure d'envoi de mail, par son mobile en passant par son site web.
L'utilisateur saisit ses informations sur un formulaire (sur son téléphone portable bien sûr) puis appuie sur un bouton d'envoi. Vous vous sentez perdu ? On n’a rien fait pour l'instant !
Nous allons vous détailler toute la procédure dans les lignes ci-dessous.
II. Prérequis▲
Nous partons du principe que vous avez Java installé dans votre environnement, ainsi que le serveur Tomcat. Nos tests sont réalisés sous Java 1.5 et Tomcat 6.0. Mais des versions antérieures sont largement suffisantes pour créer des applications semblables à la nôtre.
Les téléphones portables utilisés pour nos tests sont Sony Ericsson K850i et LG KE800. Là aussi, vous pouvez utiliser votre téléphone, pourvu qu'il contienne l'interpréteur Java.
Pour savoir comment installer Tomcat et travailler avec des Servlets, vous pouvez consulter https://lfe.developpez.com/Java/TomCat/ sur le site de developpez.com.
III. Installation des outils▲
Il faut commencer par télécharger Wireless Toolkit (WTK) via le lien suivant: http://java.sun.com/products/sjwtoolkit/download.htm?feed=JSC
Les étapes pour le téléchargement sont claires. Il suffit de suivre les étapes sur le site et de choisir son environnement.
Au moment de la rédaction de ce tutoriel, la version du WTK est 2.5.2
Nos tests sont réalisés sous Linux, mais ce sont les mêmes démarches sous Windows ou autre système. C'est ça la force de Java !
La procédure d'installation est classique. On lance le binaire et on suit les instructions. Une fois l'installation terminée, nous aurons deux répertoires WTK2.5.2 qui contiennent l'outil WTK et un autre répertoire de travail nommé j2mewtk.
Nous avons bien installé notre WTK. Pour le lancer, cliquons sur ktoolbar qui se trouve dans le répertoire WTK2.5.2 /bin
|
|
Mettons en stand-by cette étape, nous y reviendrons lorsque nous aurons besoin de compiler et exécuter le programme. Occupons-nous maintenant des sources cotées serveur et de notre formulaire HTML.
IV. Programmes côté serveur▲
Le principe est simple. Nous allons procéder d'une manière classique. Nous commençons par un formulaire d'envoi d'informations.
Copier coller ce code dans une page HTML que l'on enregistrera sous le nom TelToWeb.html. Pour faciliter nos tests, nous mettons le fichier HTML dans le répertoire WebContent du serveur
IV-A. Formulaire de test▲
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>TelToWeb</title>
</head>
<body>
<center>
<form name="formulaire" method="get" action="ServletWebMail">
To :* <input type="text" name="emailTo" size="30"><br>
Sujet :* <input type="text" name="emailSujet" size="30"><br>
Votre Mail :* <textarea name="emailCorps" rows="6" cols="24"></textarea></br>
<input type="submit" value="envoyer">
</form>
</center>
</body>
</html>Détaillons ce petit script.
C'est un formulaire simple. Il contient trois champs de saisie.
To : pour inscrire les destinataires. S'il y a plusieurs, on les sépare par un point virgule « ; »
Sujet : sujet du mail
Votre Mail : texte du mail.
L'envoi du formulaire se fait via le bouton submit avec la méthode GET ou POST. Toutes ces informations seront envoyées vers la Servlet ServletWebMail, et seront interceptées par la méthode doGet si GET est utilisée dans le formulaire, ou par doPOST si POST est utilisée.
IV-B. Servlet de réception de données▲
Voici le code de la Servlet ServletWebMail:
package mesClasses;
import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class ServletWebMail extends javax.servlet.http.HttpServlet implements javax.servlet.Servlet {
static final long serialVersionUID = 1L;
public ServletWebMail() {
super();
}
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//On récupère les paramètres du formulaire
String emailTo = req.getParameter("emailTo");
String emailSujet = req.getParameter("emailSujet");
String emailCorps = req.getParameter("emailCorps");
//Si aucun des champs n'est vide
if (emailTo!=null && emailSujet != null && emailCorps != null )
{
//on remplit le tableau avec la liste des destinataires
String[] ListDest = emailTo.split(";");
//La classe envoiMailGmail permet d'envoyer un mail via Gmail
EnvoiMailGmail envoiMailGmail = new EnvoiMailGmail();
envoiMailGmail.gererMail(ListDest, emailSujet, emailCorps);
}
resp.setContentType("text/plain");
PrintWriter out = resp.getWriter();
out.print("Mail Transmis ");
out.close();
}
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException
{
//Pour des raisons didactiques la méthode doPost est la même que doGet
//On récupère les paramètres du formulaire
String emailTo = req.getParameter("emailTo");
String emailSujet = req.getParameter("emailSujet");
String emailCorps = req.getParameter("emailCorps");
//Si aucun des champs n'est vide
if (emailTo!=null && emailSujet != null && emailCorps != null )
{
//on remplit le tableau avec la liste des destinataires
String[] ListDest = emailTo.split(";");
EnvoiMailGmail envoiMailGmail = new EnvoiMailGmail();
envoiMailGmail.gererMail(ListDest, emailSujet, emailCorps);
}
//On renvoie la réponse au client.
resp.setContentType("text/plain");
PrintWriter out = resp.getWriter();
out.print("Mail Transmis");
out.close();
}
}Détaillons le code de la Servlet ServletWebMail :
Difficile de faire plus simple. Nous définissons les deux méthodes doGet et doPost. Puisque nous avons la possibilité d'envoyer nos informations via GET ou POST. Pour notre cas, le même traitement sera effectué dans les deux méthodes. Nous procédons à la récupération des valeurs avec la méthode getParameter,
String emailTo = req.getParameter("emailTo");
String emailSujet = req.getParameter("emailSujet");
String emailCorps = req.getParameter("emailCorps");On teste si aucun des champs n'est vide, et puis on fait appel à la classe EnvoiMailGmail en invoquant sa méthode gererMail en lui passant les paramètres récupérés précédemment.
//Si aucun des champs n'est vide
if (emailTo!=null && emailSujet != null && emailCorps != null )
{
//on remplit le tableau avec la liste des destinataires
String[] ListDest = emailTo.split(";");
EnvoiMailGmail envoiMailGmail = new EnvoiMailGmail();
envoiMailGmail.gererMail(ListDest, emailSujet, emailCorps);
}Si nous regardons de plus près la Servlet ServletWebMail, nous constatons que la variable emailTo de type String est transformée en tableau de type String[]. Cela est fait par le moyen de la méthode split(« ; ») qui permet dans notre cas, d'extraire les chaînes séparées par le caractère « ; » et de les placer dans un tableau.
Puis on renvoie au client un message pour l'informer de la réussite de l'opération d'envoi du mail :
out.print("Mail Transmis");IV-C. Classe d'envoi de mail avec authentification SSL▲
Notre but est d'envoyer un mail à partir d'un téléphone portable. Puisque l'on est toujours dans le train, ceci implique que nous sommes à l'extérieur de notre société. Il est fort possible que nous ne puissions pas utiliser notre serveur interne pour l'envoi. Dans ce cas, nous utiliserons une messagerie externe.
On profite de ce tutoriel pour présenter l'envoi de mail par Gmail avec authentification SSL.
Voici le code de la classe EnvoiMailGmail:
import java.io.IOException;
import com.jscape.inet.smtpssl.SmtpSsl;
import com.jscape.inet.email.EmailMessage;;
//Cette classe a besoin de la librairie sinetfactory.jar
public class EnvoiMailGmail {
public void gererMail(String[] ListDest, String cCorps, String cSujet)
{
String EnvoyerA = ""; //un seul Destinataire à la fois
//Pour des raisons de simplicité, les informations du mail
//chargées de l'envoi sont inscrites en dur.
String EnvoieDe = "monMail@Gmail.com"; //Login
String pwd = "monPassWord"; //Password
for(int i = 0; i<ListDest.length ; i++)
{
//On récupère l'élément et on l'envoie
EnvoyerA = ListDest[i];
try{
envoyer(EnvoieDe, pwd, EnvoyerA, cSujet, cCorps);
}catch (IOException ex)
{
System.out.println("L'erreur est "+ex);
}
}
}
public void envoyer (String username,String password,String to, String cSujet, String cCorps ) throws IOException
{
SmtpSsl smtp = null;
try {
//On crée une instance de connexion par SmtpSsl via le port 465
smtp = new SmtpSsl("smtp.gmail.com",465);
// On établit une connexion sécurisée
smtp.connect();
// les coordonnées du compte mail
smtp.login(username,password);
// Création du nouveau message avec le sujet et corps du mail
EmailMessage message = new EmailMessage();
message.setTo(to);
message.setFrom(username);
message.setSubject(cSujet);
message.setBody(cCorps);
//On précise qu'on peut utiliser le format HTML
message.setContentType("text/html");
// Envoi de message
smtp.send(message);
// Enfin, on se déconnecte
smtp.disconnect();
} catch(Exception e) {
System.out.println("Une erreur s'est produite : " + e) ;
}
}
}Pour pouvoir utiliser cette classe, nous aurons besoin de la librairie sinetfactory. Nous pourrions aussi utiliser JavaMail qui est une librairie de Sun, très puissante et qui sert à réaliser des classes permettant de gérer des mails. Avec JavaMail, nous pouvons nous connecter au serveur de mail, envoyer et relever des messages.
Pour notre exemple, nous utilisons sinetfactory qui va nous servir d'envoyer un mail via Gmail avec authentification SSL.
On ne va pas s'attarder sur ces deux librairies. Pour plus d'informations consulter ces deux liens : http://java.sun.com/products/javamail/pour JavaMail et http://www.jscape.com/secureinetfactory/download.html pour sinetfactory.
Pour chaque élément du tableau ListDest, la méthode envoyer est appelée pour l'envoi de mail.
Dans la méthode envoyer, une instance de connexion SSL via le port 465 est créée, puis on se connecte via la méthode connect.
//On crée une instance de connexion par SmtpSsl via le port 465
smtp = new SmtpSsl("smtp.gmail.com",465);
// On établit une connexion sécurisée
smtp.connect();On renseigne les différents paramètres du mail, notamment, le destinataire, le sujet et le corps du message. La méthode setContentType permet de spécifier le format de mail, HTML dans notre tutoriel.
On procède à l'envoi avec la méthode send,
// les coordonnées du compte mail
smtp.login(username,password);
// Création du nouveau message avec le sujet et corps du mail
EmailMessage message = new EmailMessage();
message.setTo(to);
message.setFrom(username);
message.setSubject(cSujet);
message.setBody(cCorps);
//On précise qu'on peut utiliser le format HTML
message.setContentType("text/html");
// Envoi de message
smtp.send(message);et enfin on se déconnecte du serveur tout simplement avec la méthode disconnect.
// Enfin, on se déconnecte
smtp.disconnect();Pour des raisons de simplicité, nous avons codé en dur, le login et le password du mail expéditeur. On peut facilement les récupérer dans une structure de donnée persistante, une table, fichier XML ou autre. Mais cela sort du contexte de ce tutoriel.
//Pour des raisons de simplicité, les informations du mail
//chargées de l'envoi sont inscrites en dur.
String EnvoieDe = "monMail@Gmail.com"; //Login
String pwd = "monPassWord"; //PasswordComme nous l'avons évoqué précédemment, nous pouvons aussi utiliser JavaMail pour envoyer vos mails. Le principe reste le même que dans notre cas.
Il ne nous reste plus qu'à tester nos classes. Essayons d'appeler dans un navigateur le fichier HTML TelToWeb.html
Après avoir cliqué sur envoyer, on contrôle que le(s) destinataire(s) inscrit(s) dans le champ emailTo a (ont) reçu un mail. Si cela est vérifié, nous concluons la validation de nos sources côté serveur.
Nous arrivons enfin au cœur du sujet. Nous allons remplacer notre formulaire TelToWeb.html par une application J2ME que nous allons développer pour notre téléphone portable.
Que les choses sérieuses commencent !
V. Application J2ME▲
V-A. Application sur le téléphone portable▲
C'est quoi J2ME et Java ME ? : Dans la FAQ de developpez.com nous trouvons l'explication suivante : Java ME ou Java Platform, Micro Edition est l'édition de la plateforme Java à destination de l'électronique grand public et des systèmes embarqués. La technologie Java ME fournit une machine virtuelle et un ensemble d'API réparties dans deux composants principaux : les configurations et les profils.
Pour plus d'informations, vous pouvez aussi consulter la FAQ J2ME de developpez.com
Nous allons créer une application J2ME qui nous permettra de communiquer avec notre serveur via HttpConnection. Pour compiler et exécuter notre application, nous aurons besoin de revenir sur WTK(WirelessToolKit).
Une fois WTK lancé, nous créons un nouveau projet. Pour cela, on clique sur le bouton New Project. On appelle notre projet TelVersWeb et notre classe principale EnvoiMailJ2me comme indiqué sur la figure suivante :
|
|
Si nous regardons l'arborescence du répertoire de travail, on remarque un nouveau répertoire, le nôtre qui porte le nom du projet saisi.
On peut ajouter une icône à notre projet. Pour cela il faut créer une image de format png avec une taille de 16X16. Enregistrer cette image dans le répertoire res/icons/ Puis aller dans Projects/ Settings/MIDlets puis edit et enfin renseigner la rubrique Icon avec le nom de l'image que nous avons créée.
Tapez ce code dans votre éditeur préféré, puis enregistrer le dans le répertoire scr de votre application sous le nom EnvoiMailJ2me.java.
import javax.microedition.midlet.MIDlet;
import javax.microedition.midlet.MIDletStateChangeException;
import javax.microedition.lcdui.*;
import java.io.*;
import javax.microedition.io.*;
public class EnvoiMailJ2me extends MIDlet implements CommandListener {
private final Form MailForm; //Formulaire d'envoi de mail
//Champs du formulaire
private final TextField emailTo,emailSujet,emailCorps;
//Bouton Exit
private static final Command exitCommand = new Command("Exit", Command.EXIT,1);
//Bouton d'envoi par méthode GET
private static final Command parGet = new Command("ParGet", Command.ITEM, 1);
//Bouton d'envoi par méthode POST
private static final Command parPost = new Command("ParPost", Command.ITEM, 1);
private Display display; //Display Object
//Affiche le résultat envoyé par le serveur.
private StringItem msgResultat;
public EnvoiMailJ2me()
{
MailForm = new Form("EnvoiMailJ2me");
display = Display.getDisplay(this);
//On initialise les champs à vide
emailTo = new TextField("To ","mailNom@domaine.com",30, TextField.ANY);
emailSujet = new TextField("Sujet ","SUJET",30, TextField.ANY);
emailCorps = new TextField("EMail", "Ici texte de mail",150, TextField.ANY);
msgResultat = new StringItem("Resultat : ", "");
//On attache les champs, boutons et item au formulaire
MailForm.append(emailTo);
MailForm.append(emailSujet);
MailForm.append(emailCorps);
MailForm.append(msgResultat);
MailForm.addCommand(parPost);
MailForm.addCommand(parGet);
MailForm.addCommand(exitCommand);
MailForm.setCommandListener(this);
}
protected void destroyApp(boolean arg0) {
}
protected void pauseApp() {
}
protected void startApp() {
//Au démarrage de l'application on affiche le formulaire
display.setCurrent(MailForm);
}
public void commandAction(Command comd, Displayable disp) {
//Si l'un des boutons parGet ou parPost est cliqué
if (comd==parGet || comd==parPost)
{
try
{
if(comd==parGet)
{
String url= "http://www.monsite.com/ServletWebMail" + "?";
envoiMailGet(url);
}
else
{
String url= "http://www.monsite.com/ServletWebMail";
envoiMailPost(url);
}
} catch (Exception e) {
e.printStackTrace();
}
}
//Bouton Exit est cliqué
else if (comd==exitCommand)
{
//On ferme l'application
destroyApp(false);
notifyDestroyed();
}
}
//Cette méthode gère l'envoi d'informations via la méthode GET
public void envoiMailGet(String url) throws Exception
{
HttpConnection connection = null; //Pour se connecter au serveur
InputStream inStrm = null; //Pour recevoir la réponse du serveur
try
{
//On concatène l'url avec les informations du formulaire.
url = url + "emailTo=" + emailTo.getString();
url = url + "&emailSujet=" + emailSujet.getString();
url = url + "&emailCorps=" + emailCorps.getString();
//Ouverture de la connexion et choix de la méthode GEt
connection = (HttpConnection) Connector.open(url);
connection.setRequestMethod(HttpConnection.GET);
inStrm = connection.openInputStream();
//Appel de la méthode respServeur pour afficher
//les résultats renvoyés par le serveur
respServeur(connection, inStrm);
}
finally
{
// On ferme la connexion et le flux d'entrée
if (inStrm != null)
inStrm.close();
if (connection != null)
connection.close();
}
}
//Cette méthode gère l'envoi d'informations via la méthode POST
public void envoiMailPost(String url) throws Exception
{
HttpConnection http = null; //Pour se connecter au serveur
InputStream inStrm = null; // Flux pour Recevoir la réponse du serveur
OutputStream outStrm = null; //Flux pour envoyer les informations au serveur
try
{
//Ouverture de la connexion et choix de la méthode POST
http = (HttpConnection) Connector.open(url);
http.setRequestMethod(HttpConnection.POST);
// 2) Envoyer les informations de l'entête, nécessaire pour la méthode POST
http.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
outStrm = http.openOutputStream();
// Écriture du mail du destinataire
byte data[] = ("emailTo=" + emailTo.getString()).getBytes();
outStrm.write(data);
// Écriture de sujet du mail
data = ("&emailSujet=" + emailSujet.getString()).getBytes();
outStrm.write(data);
// Écriture de corps du mail
data = ("&emailCorps=" + emailCorps.getString()).getBytes();
outStrm.write(data);
// Pour HTTP 1.0.3 Enlever la commande flush,
//si vous utilisez HTTP 1.1 décomentez la ligne suivante
// outStrm.flush();
//Ouverture du flux d'entrée
inStrm = http.openInputStream();
//Appel de la méthode respServeur pour afficher
//les résultats du serveur
respServeur(http, inStrm);
}
finally
{
// On ferme les connexions et les flux I/O
if (inStrm != null)
inStrm.close();
if (outStrm != null)
outStrm.close();
if (http != null)
http.close();
}
}
//Cette méthode affiche le résultat du serveur
//(Voir la réponse de la Servlet ServletWebMail.java)
public void respServeur(HttpConnection connection,InputStream inStrm) throws IOException
{
//Si le serveur a renvoyé une information ?
if (connection.getResponseCode() == HttpConnection.HTTP_OK)
{
//Longueur du flux
int length = (int) connection.getLength();
String stringRes="";
if (length != -1)
{
//valable que si le flux d'entrée est relativement petit
byte servletData[] = new byte[length];
inStrm.read(servletData);
stringRes = new String(servletData);
}
//On affiche le résultat sur le formulaire, en modifiant
//la valeur de msgResultat
msgResultat.setText(stringRes);
}
}
}Que fait ce code ? Expliquons les grandes lignes du programme.
Le principe est de reproduire le formulaire HTML que nous avons écrit précédemment et procéder à son envoi. De ce fait, nous obtenons les mêmes champs. Sauf que dans notre cas, nous n'utilisons pas de navigateur.
Dans notre application, nous avons besoin d'importer les classes de base javax.microedition.midlet.MIDlet, et les classes javax.microedition.lcdui.* qui nous permettent de réaliser les différents affichages.
Nous commençons par définir les trois champs (emailTo, emailSujet, emailCorps) comme TextField. Trois boutons exitCommand, parGet et parPost afin de gérer les événements sur notre formulaire que nous appelons mailForm.
Pour des raisons didactiques, nous allons réaliser deux méthodes envoiMailGet et envoiMailPost afin d'expliquer les deux façons d'envoi d'informations vers les serveurs.
Dans la méthode public EnvoiMailJ2me nous contentons d'initialiser les différentes valeurs des champs et nous ajoutons tous les composants au formulaire.
MailForm.append(emailTo);
MailForm.append(emailSujet);
MailForm.append(emailCorps);La méthode CommandAction permet de gérer les événements sur les boutons. On fait appel à l'une des méthodes en fonction du bouton pressé. envoiMailGet est appelée quand le bouton parGet est cliqué, envoiMailPost quand le bouton parPost est cliqué. Si exitCommand est pressé nous quittons l'application.
V-B. Envoi de données via la méthode GET▲
Pour envoyer des données via la méthode GET, il suffit de les concaténer à la fin de l'url. La forme du lien ressemble à ceci :
http://www.monserveur.com/nomServlet?champ1=val1&champ2=val2&champ3=val3Pour notre cas, nous concaténons les trois champs avec leurs valeurs l'un après l'autre à la fin de l'url après le caractère « ? ».
url = url + "emailTo=" + emailTo.getString();
url = url + "&emailSujet=" + emailSujet.getString();
url = url + "&emailCorps=" + emailCorps.getString();Puis nous réalisons une connexion avec HttpConnection, et nous choisissons la méthode GET.
connection = (HttpConnection) Connector.open(url);
connection.setRequestMethod(HttpConnection.GET);V-C. Envoi de données via la méthode POST▲
Contrairement à la méthode GET, les informations envoyées via la méthode POST ne sont pas concaténées à la fin de l'url. Mais elles sont envoyées via un flux. C'est pour cette raison qu'on définit le flux de sortie dans envoiMailPost en plus du flux d'entrée et de la connexion Http.
HttpConnection http = null; //Pour se connecter au serveur
InputStream inStrm = null; // Flux pour Recevoir la réponse du serveur
OutputStream outStrm = null; //Flux pour envoyer les informations au serveurNous commençons par écrire nos données dans un tableau, puis on transfère son contenu dans le flux de sortie.
// Écriture du mail du destinataire
byte data[] = ("emailTo=" + emailTo.getString()).getBytes();
outStrm.write(data);On répète la procédure pour chaque champ de notre formulaire
L'envoi des informations de l'entête est nécessaire lors de l'utilisation de la méthode POST, contrairement à GET où on peut se passer de ces informations.
http.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");Quelle que soit la méthode utilisée envoiMailGet ou envoiMailPost, à la fin du traitement, nous fermons les flux d'entrée, la connexion Http et le flux de sortie pour la méthode envoiMailPost.
// On ferme les connexions et les flux I/O
if (inStrm != null)
inStrm.close();
if (outStrm != null)
outStrm.close();
if (http != null)
http.close();V-D. Réception de la réponse du serveur▲
Quand nous envoyons une requête au serveur, dans la plupart des cas, nous attendons une réponse en retour.
Dans notre exemple le serveur (plus précisément la Servlet ServletWebMail) nous renvoie un message pour nous informer que le mail a été transmis.
out.print("Mail Transmis ");Afin d'afficher ce message sur notre téléphone portable, nous avons utilisé l'objet InputStream. La réception de ces informations est gérée par la méthode respServeur. Si le serveur nous renvoie un flux, nous procédons à sa lecture comme suit :
//valable que si le flux d'entrée est relativement petit
byte servletData[] = new byte[length];
inStrm.read(servletData);
stringRes = new String(servletData);Et enfin nous affichons le résultat en ajoutant la chaîne à StringItem
msgResultat.setText(stringRes);Toutefois, cette méthode a ses limites. Si les informations renvoyées par le serveur sont d'une grande taille, nous ne pourrons pas les afficher. Il faut utiliser un autre moyen, comme l'objet ByteArrayOutputStream par exemple.
Avant toute opération, compilation et exécution, nous devons choisir le modèle correspondant à notre téléphone. Dans le menu Préférences / Modèles /API Selection, puis TargetPlatForm on choisit un élément. Pour les nôtres qui sont LG KE800 ou Sony Ericsson K850i, on a sélectionné MIDP 1.0.
Cette API est compatible avec la plupart des téléphones portables.
|
|
Compilons notre programme. Pour cela on clique sur le bouton Build. Si nous obtenons Build succed, on conclut que notre programme est compilé sans erreurs. Pour le lancer nous cliquons sur Run. Le WTK intègre un émulateur de téléphone portable. Les figures suivantes montrent les différents choix entre plusieurs modèles. Il suffit de faire défiler la liste dans la rubrique Device et d'en choisir un.
|
|
Pour lancer notre programme, on clique sur le bouton Launch ou sur OK (le grand bouton au milieu). On obtient notre formulaire, nous saisissons les informations pour l'envoi de mail, et on appuie sur le bouton Menu. Nous obtenons deux éléments de menu correspondant aux méthodes ParGet et parPost que nous avons implémentées. La troisième méthode est exécutée quand on clique sur le bouton Exit.
|
|
|
Toutefois, il faut paramétrer les permissions pour éviter les multiples messages de confirmations, notamment ceux relatifs à airtime. Pour cela, dans le programme WTK, il faut aller dans le menu : Edit/Préférences/Security puis dans la rubrique Security domain et choisir l'option minimum.
Notre programme semble concluant, nous allons le transférer sur notre téléphone portable. On va d'abord créer un package. Dans le menu Préférence, sélectionner Package puis createPackage. Si nous regardons dans le dossier bin du projet, nous trouvons un nouveau fichier .jar au nom de notre projet TelVersWeb.jar
C'est ce fichier que nous allons transférer sur notre téléphone portable. Il suffit de connecter notre mobile via un port USB ou par un autre moyen. Pour le LG KE800 le fichier a été transféré par un câble USB dans le répertoire dénommé Autres.
À présent, nous pouvons débrancher notre téléphone de l'ordinateur. Nous allons parcourir ses dossiers pour lancer l'installation du fichier TelVersWeb.jar
La procédure d'installation est simple, il suffit de sélectionner le fichier et de choisir Install. Toutefois, quelques différences surgissent d'un téléphone à un autre.
Pour lancer notre programme, on ouvre le répertoire destiné aux applications. Nous obtenons notre formulaire semblable au formulaire HTML, comme indiqué sur la figure suivante :
|
|
Pour envoyer notre formulaire, nous actionnons le bouton Options ou Menu (selon les types de téléphones portables). Nous allons choisir l'une des options parGet ou parPost. Bien sûr, nous aurons droit à quelques messages de confirmation. Le premier est un message qui nous avertit que l'application TelVersWeb va procéder à l'envoi ou réception d'informations. Et ceci peut être payant. Les messages de confirmation peuvent être différents d'un téléphone portable à un autre. Ceci est paramétrable. Il suffit d'aller dans le menu Permissions de son téléphone portable et configurer les différents messages liés aux permissions d'accès ou d'envoi de données.
|
|
Important
- - Avant d'envoyer ces informations avec votre téléphone portable, vérifiez bien que votre compte chez votre opérateur permet la communication via httpConnection. En effet, au cours d'un de nos tests, il s'est avéré que le compte utilisé, qui est une mobil carte ne permet pas d'utiliser certains services, sauf appels et SMS. En France, la plupart des comptes abonnement permettent la communication via HttpConnection.
- - Les tests effectués avec l'url de format http://IP:Ports/ServletWebMail n'étaient pas concluants.
Mais en changeant cette url en http://www.domaine.com/ServletWebMail la communication entre le téléphone portable et la Servlet a fonctionné. - - La communication via httpConnection peut être payante, selon votre type d'abonnement.
Et bien ! Vous avez vérifié que votre destinataire a sûrement reçu votre mail. Vous êtes content! Vous venez de réaliser votre première application J2ME.
Maintenant, vous vous rendez compte que votre téléphone portable peut servir à autre chose que ce pour quoi vous l'utilisez habituellement. Vous devez certainement le voir à présent sous un angle différent.
Vous êtes maintenant arrivé au bureau. Vous vous vantez devant vos collègues de la manière que vous avez utilisée pour les informer de votre retard. Hé ! On vous informe que vous n'avez rien inventé, et que cette procédure existe déjà dans la plupart des téléphones portables? Déçu ? Non! Car vous avez néanmoins le mérite d'avoir créé vos propres méthodes, et peut-être faire mieux, pourquoi pas? À présent vous pouvez concurrencer votre opérateur téléphonique!
VI. Téléchargement▲
Vous trouvez les codes sources dans le fichier zip suivant sources.zip
VII. Conclusion▲
Ce tutoriel est loin d'être exhaustif. Il comporte des lacunes au niveau de la sécurité. À aucun moment, nous n'avons vérifié l'intégrité des données, avouons-le ! Toute personne ayant connaissance de votre exploit peut envoyer un mail via votre Servlet, mais aussi avec vos coordonnées. À vous de développer un moyen de chiffrer ou d'authentifier la connexion à votre Serveur.
VIII. Liens▲
https://www.developpez.net/forums/f213/java/general-java/java-me/
http://www.gnulinuxmag.com/
http://www.jscape.com/
http://www.java2s.com/
IX. Remerciements▲
Je remercie Lionel Louveau et Baptiste Wicht pour leurs conseils et leurs propositions, ainsi que Andrea Klindwort pour la relecture de ce tutoriel. Sans oublier evarisnea pour la correction orthographique.