Introduction Mobile Phone

Programmation en Java ME
(prpar pour CS / ECE 707, UW-Madison)
Auteur: Leszek Wiland
Suman et Banerjee
1
content
1. Introduction
2. Mise en place d'un environnement de programmation
3. Bonjour demande mondiale
4. GUI et l'interaction utilisateur
5. Rseautage
2
1. Introduction
Dans ce tutoriel, je vais vous expliquer les principaux concepts de
dveloppement d'applications mobiles en Java moi. je
commencera par la mise en place environnement de programmation en systme
d'exploitation Windows, puis
procder montrer modle de programmation Java ME sur l'exemple d'un certain
nombre de mobiles
applications
Java Me est une spcification d'un sous-ensemble de plate-forme Java qui fournit
un ensemble d'API Java pour
dveloppement pour les petites et ressources limites dispositifs. Puisque cela
peut inclure plusieurs technologiquement
diffrents dispositifs, Java ME est en outre diviss en configurations et profils qui
dfinissent
certains certaine partie des API Java ME qui sont aptes tre excut sur un
dispositif particulier. mobile
Tlphones doivent mettre en uvre CLDC (Connected Limited Device
Configuration) avec MIDP
(Mobile Information Device Profile), qui la fois dfinir API que nous, les
programmeurs peuvent utiliser pour
construire des applications mobiles. Toutefois, les deux CLDC et MIDP viennent
dans diffrentes versions adaptes
diffrents tlphones mobiles. A partir de maintenant, Nokia N95 met en uvre
la nouvelle version de fois CLDC
qui est 1,1 et qui est MIDP 2.0. Il est important de mentionner qu'une nouvelle
version de 3me MIDP est actuellement en cours de dveloppement. Machine
virtuelle Java pour les appareils mobiles a t rcrit et il est
ne est plus celui qui a faim de mmoire bien connu de PC, mais a t
spcialement optimis pour
petits appareils tels que les tlphones mobiles.
2. Mise en place d'un environnement de programmation
Il existe quatre principaux composants installer pour commencer la
programmation en Java pour mobile dispositifs. La premire Java SE (Standard
Edition) Kit de dveloppement est que vous pourriez dj avoir install sur votre

machine; la version recommande est 1.5.0. Ensuite, vous devez tlcharger 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=JSC
Faites dfiler vers le bas de la page pour trouver le fichier. Ensuite, installez
Nokia SymbianOS / S60 SDK pour
Java. Il existe plusieurs versions de ce SDK chacun pour un autre groupe de
dispositifs. Nokia N95
soutient la nouvelle version du SDK: S60 3me dition, Feature Pack 2, qui se
trouve sous
le lien suivant:
http://www.forum.nokia.com/info/sw.nokia.com/id/6e772b17-604b
4081999c31f1f0dc2dbb /
S60_Platform_SDKs_for_Symbian_OS_for_Java.html
3
Rechercher sur le ct droit et a choisi 3e dition FP2v1.1 (455 Mo) fichier pour le
tlchargement.
La dernire chose installer est Eclipse ou un autre environnement de
dveloppement intgr capable de
travailler avec Java ME Edition (Java Micro Edition), par exemple avec NetBeans
Mobility Pack. en
ce document, je vais vous montrer comment mettre en place un projet avec
Eclipse, donc si vous ne avez pas dj Eclipse
install sur votre machine, vous pouvez le trouver :
http://archive.eclipse.org/eclipse/downloads/drops/R-3.2.2200702121330/index.php
Un montant supplmentaire de Me Eclipse plug-in serait ncessaire pour Eclipse
pour fonctionner correctement avec Java ME et
il peut tre consult l'adresse suivante:
http://sourceforge.net/project/showfiles.php?group_id=86829
Dcompressez le fichier zip et copier tous les fichiers dans les plug-ins et dispose
rpertoires correspondant
rpertoires dans votre dossier Eclipse. Ayant fait cela, nous pouvons procder
configurer Eclipse pour travailler
correctement avec Java ME et l'mulateur de tlphone. Tout d'abord,
slectionnez Window-> Prfrences et a choisi
Noeud de J2ME et slectionnez Gestion des priphriques. Appuyez sur
l'importation et recherchez
C: \ S60 \ devices \ S60_3rd_MIDP_SDK_FP2_Beta ou tout autre rpertoire que
vous avez install le S60
SDK, cliquez sur Actualiser et assurez-vous que les cases cocher des deux
appareils sont S60Emulator et S60Device
vrifie. Appuyez sur Terminer puis importez nouveau. Cette navigation de
temps pour C: \ WTK2.5.2 rpertoire, cliquez sur
rafrachir et se assurer que tous les quatre priphriques sont slectionns, puis
cliquez sur Terminer. Retour dans la bote de dialogue principale
slectionnez DefaultColorPhone comme priphrique par dfaut.

Malheureusement, le choix de ne importe quel autre serait

faire la demande sr. Aprs avoir fait cela, allez Fentre-> Prfrences,
dveloppez noeud Java> Chemin de compilation, puis Pour item Source et le dossier de sortie,
slectionnez les dossiers de boutons radio, et de garder le
par dfaut (src et Bin). Suivant largir noeud Java-> Debug et dcochez
suspendre l'excution sur
exceptions non interceptes et suspendre l'excution 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 avons
l'mulateur de tlphone, il est facile de tester tout ce que nous avons crit.
Toutefois, afin de se dplacer
applications facilement partir de l'ordinateur un vrai tlphone nous aurions
besoin de Nokia PC Suite qui fait que
pour nous. Il peut tre trouv :
http://europe.nokia.com/pcsuite
3. Bonjour demande mondiale
Une fois tous les lments de l'environnement de programmation sont installs,
nous sommes prts pour crer une premire
Application Java moi. Commencez par ouvrir Eclipse puis slectionnez Fichier->
Nouveau-> Projet. Dvelopper J2Me
noeud et choisissez J2ME MIDlet Suite. Appuyez sur ct, donner au projet un
nom unique et cliquez sur Suivant
encore une fois, assurez-vous galement que dans le "Groupe:" menu, Sun Java
Wireless Toolkit est choisi et
Menu "Device" DefaultColorPhone est slectionn. Appuyez sur suivant et
slectionnez "Permettre des dossiers de sortie pour
dossiers source "et appuyez sur la finition. Une fois le projet Java ME est cr,
nous devons ajouter une classe MIDlet
le projet qui est le cur de chaque application Java ME. Pour ce faire, cliquez
droit sur le projet,
slectionnez New-> Autres et choisissez J2ME MIDlet. Cela va crer un squelette
d'application Java ME.
En rgle gnrale, tout programme Java ME pour les appareils embarqus tels
que les tlphones intelligents Nokia est appel
4
MIDlet. Il ya peu de diffrences entre la classe principale d'une application Java
standard et un principal
classe d'une application Java ME. Tout d'abord, la classe Java ME principal n'a pas
la fonction main (), mais
a lieu trois mthodes vides et qui est driv de la classe MIDlet (est une sousclasse de la classe MIDlet).
Chaque application Java ME doit avoir une classe principale qui est driv de
MIDlet et contenir les
trois mthodes suivantes:
1. protected void destroyApp (arg0 boolen);

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 Java
serait charger cette classe principale et commencer sa mthode startApp () qui
agit dans ce cas comme l'ancien
fonction main () connu de Java SE. La mthode destroyApp (arg0 boolenne) est
appel chaque fois
nous voulons l'application de mettre fin, alors que le pauseApp () est appele par
l'exploitation sous-jacent
systme quand il a besoin de librer des ressources supplmentaires et souhaite
notre application pour arrter
l'excution d'un certain temps. Cela peut se produire, par exemple, se il ya un
appel entrant et le
systme d'exploitation a besoin de librer autant de ressources que possible pour
faire face cette tche. Par consquent, si
notre application utilise beaucoup de ressources systme que ce serait l'endroit
pour les librer. Toutefois, si
nous laissons cette mthode vide, alors pas de ressources seront librs par le
systme d'exploitation.
Le MIDlet simple suivante, ne fait rien en particulier. Il ne est pas capable de ne
importe quel utilisateur
interaction que ce soit, et ne peut donc tre rsili si commenc sur le tlphone
mobile. Si fonctionner sur
l'ordinateur peut tre facilement tu par la fermeture de la fentre du simulateur.
le
"System.out.println (" Bonjour tout le monde ");" dclaration ne aura aucun effet
lorsqu'il est excut sur le tlphone
simulateur ou sur l'appareil lui-mme, et ne peut donc tre utilis pour la sortie
d'impression .. Il serait
imprim, cependant, sur la console Eclipse et il est donc trs utile pour le
dbogage.
Code 1
public class principale se tend MIDlet {
Principal publique () {
// TODO gnr automatiquement stub constructeur
}
destroyApp protected void (arg0 boolen) {
// TODO mthode d'auto-gnr stub
}
vide pauseApp protg () {
// TODO mthode d'auto-gnr stub
}
vide startApp protg () throws MIDletStateChangeException {
System.out.println ("Hey");
}
}

5
L'tape finale du processus de dveloppement est d'installer au-dessus de moi
application Java sur l'appareil mobile.
Pour ce faire, nous avons besoin de gnrer un fichier jar qui est ensuite copi
dans le tlphone. Faites un clic droit sur le
projet et slectionnez J2ME-> Crer un package (sur le trs bas). Cela va gnrer
un pot et une
JAD Fichier, deux qui sont stocks sous le rpertoire dploy dans le projet Java
ME. Une fois que la sortie
fichiers sont prts, nous allons les installer sur l'appareil de tlphone en utilisant
l'application Nokia PC Suite. premire
connecter l'appareil l'ordinateur de prfrence par cble USB et choisissez
parmi les options PCSuite
affiche sur l'cran de l'appareil. Puis dmarrer l'application PC Suite sur votre
machine et slectionnez Installer
Point d'application qui se trouve sur la partie infrieure gauche de la fentre
d'application. Parcourir pour le pot de projet
dposer et en appuyant sur une flche d'installation entre mon ordinateur et mon
fentre Tlphone copier le
fichier jar au dispositif sur lequel vous pouvez terminer le processus d'installation.
4. GUI et l'interaction utilisateur
Il ya deux faons 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
dj crs qui peuvent tre mlangs ensemble dans ne importe quel mode.
L'API de haut niveau ne se occupe galement de l'afficher correctement sur
l'cran, le dfilement travers les menus si ncessaire et, fondamentalement,
rendre notre vie beaucoup plus facile. Tous les composants doivent
ventuellement tre attach un objet qui est drive 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 diffrente
des lments tels que TextField, boutons, des listes ou TextString un objet qui
est driv de
Affichable tels que formulaire, puis nous avons mis que affichable afficher sur
l'cran, et ce est tout.
Cela signifie que nous pouvons nous prparer de nombreuses interfaces
utilisateur diffrentes 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 prts, nous devons prendre soin de l'interaction de
l'utilisateur, et ceci est fait en faisant une de nos classes, MIDlet prfrence, de
mettre en uvre l'interface CommandListener qui consiste d'une mthode:
commandAction public void (Command c, g affichable);
Code 2
public class principale se tend MIDlet implmente CommandListener {
6
Principal publique () {
// TODO gnr automatiquement stub constructeur
}

destroyApp protected void (arg0 boolen) {

// TODO mthode d'auto-gnr stub
}
vide pauseApp protg () {
// TODO mthode d'auto-gnr stub
}
vide startApp protg () throws MIDletStateChangeException {
System.out.println ("Hey");
}
public void commandAction (Command c, g affichable) {
// TODO mthode d'auto-gnr stub
}
}
Chaque fois qu'il ya un vnement gnr par l'utilisateur la mthode
commandAction () est appele avec commande
et les arguments affichables qui lui est pass. Nous pouvons rpondre l'entre
de l'utilisateur en vrifiant ce que
commande a t gnr et ragir en consquence. Les outils de MIDlets cidessus
Interface CommandListener mais ne peut pas traiter ne importe quelle entre de
l'utilisateur puisque nous ne avons pas dfini de
les commandes qui permettre l'utilisateur d'interagir avec l'application. Avant
de procder expliquer
comment faire je vais bientt crire sur la seconde faon de construire l'interface
graphique qui est faible API de niveau. il
nous permet traitons directement avec ce qui est affich sur l'cran en
dfinissant une mthode paint () qui est
appel chaque cran de temps doit tre rafrachi. Il fournit galement un moyen
de capturer ne importe quelle entre d'utilisateur,
tandis que l'API de haut niveau peut capturer seulement ceux qui sont
directement vnement gnr par l'interaction
avec des boutons affichs sur l'cran, par consquent, il manque toutes les
touches alphanumriques. Pour utiliser
API de bas niveau l'une des classes doit tre driv de classe Canvas et met en
uvre la peinture
Procd.
peinture protected void (Graphics g);
L'objet de toile dfinit plusieurs autre mthode en dehors de la peinture () qui
sont utiliss principalement pour
manipulation interface basse utilisateur de niveau je vais me concentrer
principalement sur la peinture () et keyPressed (). ce qui suit
MIDlet dmontrer l'utilisation des API de bas niveau:
Code 3
LowLevelAPI public class tend Canvas {
7
peinture protected void (arg0 Graphics) {
// TODO mthode d'auto-gnr stub

}
protected void keyPressed (int keyCode) {
}
}
Comme commandAction () mthode d'API de haut niveau, nous vrifions
l'keyCode et selon le
code cl prenne certaines actions spcifiques.
Jusqu' prsent, nous savons qu'il ya deux types de API disponibles pour la
construction de l'interface graphique et que l'entre de l'utilisateur peut
tre traites par soit la mthode ou les deux de leur mise en oeuvre
commandAction () ou keyPressed ().
Maintenant, je vais procder montrer comment construire une interface
graphique simple l'aide de haut niveau API. Comme je le mentionnais
avant que les lments qui sont drivs de affichable ou cran peuvent tre
affichs sur le
appareil. cran dispose de 4 sous-classes principales dont chacun peut tre
utilis pour construire des GUI, et lorsque vous tes prt, tre
affich sur l'cran en le dfinissant comme un cran actuel. Ces sous-classes
sont: Alerte, Liste, TextBox
et la forme.
Alerte: est un cran qui affiche les donnes l'utilisateur et attend pendant une
certaine priode de temps avant
de passer l'cran suivant.
Liste: contient une liste de choix et l'ensemble des mthodes pour interroger
quelle option ont t
slectionn par l'utilisateur.
TextBox: permet l'utilisateur de saisir du texte.
Forme: peut contenir un mlange arbitraire d'lments: images, lecture seule
des champs de texte, texte modifiable
champs, champs ditables de date, les jauges, les groupes choix, et des
lments personnaliss dont chacun peut tre
annexe au formulaire dans ne importe quel mode.
La mise en oeuvre poignes mise en page, et la traverse de dfilement
automatique. En dehors de ces quatre
drive des classes les d'cran il ya un certain nombre de composants provenant
de la classe d'objet, qui
peut tre attach un formulaire et utilis comme blocs de construction de
l'ensemble de l'interface graphique.
Afin de grer l'interface utilisateur, nous devons dfinir un ensemble de
commandes qui sont ensuite attach
l'affichable. Il peut tre ne importe quelle classe qui est drive de affichables,
tels que: Alert, List,
TextBox, Forme et galement la faible classe API de niveau: Toile. Chaque
commande est reprsent par un
objet Command spar avec un nom, type de commande et la priorit. Une fois
que nous avons GUI et
commandes dfinies, nous devons inscrire cet objet affichable avec un

CommandListener, qui est

fait en appelant la mthode de setCommandListener () sur l'objet affichable.
8
Je vais maintenant montrer comment construire une application qui permet aux
utilisateurs de taper un texte dans une fentre et gravures
dans l'autre. Il dispose de deux boutons, l'un pour la fermeture de l'application et
de l'autre de notifier le
demande que le texte doit tre imprim l'cran. Je vais utiliser les lments
suivants de la
haute API de niveau: Form, TextField, StringItem et deux commandes
d'interaction de l'utilisateur.
Code 4
public class principale se tend MIDlet implmente CommandListener {
Sous forme de formulaire = null;
Entre TextField = null;
StringItem sortie = null;
Affichage d'affichage = null;
Commande prte = null;
La sortie de commande = null;
Principal publique () {
// Donner le nom de forme
form = new formulaire (GUI Demo");
// Arguments TextField: nom, texte par dfaut, la taille des lettres, le type
// D'entre
entre = new TextField ("Input", "Ecrire Sth", 10, TextField.ANY);
// Arguments pour StringItem: tiquette, le nom
sortie = new StringItem ("Sortie", "");
// Arguments pour commande: nom, type, la priorit
ready = nouveau commandement ("Display", Command.SCREEN, 1);
sortie = nouveau commandement ("Exit", Command.EXIT, 1);
// Rcupre l'objet d'affichage pour cette MIDlet
affichage = Display.getDisplay (this);
// Ajouter des commandes la forme
form.addCommand (prt);
form.addCommand (sortie);
// Ajouter d'autres lments la forme
form.append (entre);
form.append (sortie);
// Enregistre le formulaire avec le Commandement Listener
form.setCommandListener (this);
}
destroyApp protected void (arg0 boolen) {
notifyDestroyed ();
}
vide pauseApp protg () {
// TODO mthode d'auto-gnr stub
}

vide startApp protg () throws MIDletStateChangeException {

display.setCurrent (formulaire);
}
9
public void commandAction (Command c, g affichable) {
si (c == sortie)
destroyApp (false);
else if (c == prt) {
output.setText (input.getString ());
}
}
}
La premire tape consiste tous les lments de construction dfinies de
l'interface graphique. Ce est TextField pour l'entre de l'utilisateur,
StringItem pour la sortie, formulaire de lier tous les lments ensemble, et deux
commandes pour l'utilisateur
interaction. La prochaine tape est de rcuprer l'objet d'affichage pour cette
MIDlet, qui est utilis pour basculer
entre les crans affichs sur le dispositif. Ceci est fait en appelant la mthode
statique de la classe d'affichage
qui prend comme un objet argument MIDlet pour laquelle l'affichage doit tre
retourn. Une fois que ce est
fait, nous ajoutons la commande prcdemment dfinie pour le formulaire ainsi
que tous les autres lments en appelant
addCommand () la mthode et append () sur le formulaire respectivement. La
dernire chose faire le
Travaux de GUI est de l'enregistrer (sous cette forme de cas) avec le
CommandListener qui est accompli
en appelant la mthode de setCommandListener () sur l'objet de formulaire. La
mthode startApp () a galement
t lgrement modifi. Lorsqu'il est lanc, MIDlet fixerait notre interface
graphique pour tre affiche sur le dispositif par
appelant la mthode setCurrent (forme) sur l'objet d'affichage qui a t rcupr
au dbut. depuis
l'interface graphique est prt, nous sommes en mesure de remplir la mthode
commandAction () pour rpondre aux gnr par l'utilisateur
vnements. Nous avons deux commandes: Sortie dans ce cas, la mthode
destroyApp () est appele et Prt
qui rcupre une chane de champ de texte modifiable et l'imprime sur dans le
domaine non-modifiable.

5. Rseautage
Java me dfinit une API trs flexible pour les connexions rseau. Il est bas sur un
certain nombre de
Interfaces chaque une pour un type de connexion particulier et une classe de
connecteur qui est une connexion
usine pour crer de nouveaux objets de connexion. Spcification MIDP ncessite
des dispositifs qui

mettre en uvre pour soutenir au moins HttpConnection, cependant, la plupart

des tlphones mobiles de courant
y compris Nokia N95 supporte une gamme de diffrents types de connexion
telles que: CommConnection,
DatagramConnection, SocketConnection, HttpConnection, HttpsConnection (http
scuris) ou
SocketServerConnection. La majorit de ces connexions permet d'crire une
application client,
Cependant en utilisant SocketServerConnection il est galement possible d'crire
une application serveur pour
plate-forme mobile. Cration d'objet Connection est fait en appelant la mthode
open () de la classe Connector.
Il prend argument de chane pour dfinir le type de connexion renvoyer. La
connexion de base
descripteurs sont:
SocketConnection:
socket: // hostip: portno - se connecte hostip: portno
10
SocketServerConnection:
socket: //: portno - coute sur le port: portno
DatagramConnection:
datagramme: //: port - coute sur le port: portno
datagramme: // hostip: portno - envoie des datagrammes hostip: portno
HttpConnection:
URL HTTP
Je vais vous montrer une application de rseautage simple qui se connecte au
serveur de Google via une connexion http
pour tlcharger et afficher la carte Google sur l'cran de l'appareil. Depuis la
mise en rseau API nous utilisons est un
API de blocage, il est important de localiser ce code dans un thread spar afin
de ne pas bloquer l'ensemble
application de sorte qu'un utilisateur peut interagir avec l'application alors que la
carte est en cours.
Code 5
public class principale se tend MIDlet implmente 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 forme
form = 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);
// Rcupre l'objet d'affichage pour cette MIDlet

affichage = Display.getDisplay (this);

// Ajouter des commandes la forme
form.addCommand (displayimage);
form.addCommand (sortie);
// Enregistre le formulaire avec le Commandement Listener
form.setCommandListener (this);
}
destroyApp protected void (arg0 boolen) {
notifyDestroyed ();
}
vide pauseApp protg () {
11
}
vide startApp protg () 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 rponse = 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" + nouveau
Entier (parent.form.getWidth ()). ToString () +
"& key =
ABQIAAAAnfs7bKE82qgb3Zc2YySoBT2yXp_ZAY8_ufC3CFXhHIE1NvwkxSy
Sz_REpPq-4WZA27OwgbtyR3VcA ";
try {
HttpConnection c = (HttpConnection) Connector.open (URL);
rponse = new DataInputStream (c.openInputStream ());
receivedImage = new byte [(int) c.getLength ()];
response.readFully (receivedImage);
System.out.println (Tlchargement ok");

}
catch (IOException e) {
System.out.println (e);
System.out.println (Tlchargement erreur");
Alerte Alerte = new alerte ("", "erreur de rseau", 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 image
System.out.println ("commencer crer 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'affichage
parent.form.deleteAll ();
parent.form.append (parent.googleImage);
}
}
La classe principale dfinit l'interface utilisateur de l'application, mais il ne fait
pas de rseau. Une fois qu'un utilisateur
appuyez sur "Affichage" commander l'application cre objet Connection et
l'excute en tant qu'entit distincte
Thread. Objet Connection initier la connexion http, tlcharge 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 de
l'affichage du contenu sur l'cran de l'appareil, car il ne dfinit pas d'interface
utilisateur graphique.
Cependant, l'interface utilisateur est dfinie par catgorie principale, donc de

rfrence parent est pass

Objet Connection qui peut utiliser l'interface utilisateur de parent pour afficher
l'image sur l'cran.
13