Adaptation multi-réseaux pour applications Mobiles

Transcription

Institut National Des
Télécommunications d’Evry
Option ASR
Année scolaire : 2004/2005
Rapport du projet de fin d’études :
Adaptation multi-réseaux pour applications Mobiles
Réalisé par : Anis Damak
Yosra Haddar
Encadré par : M. Guy Bernard
M. Slim Benatallah
Contact: [email protected]
[email protected]
1
Sommaire
1- Introduction…………………………………………………..…………page 3
2- Etude technique de l’environnement de travail ……………………..….page 3
2.1- API et outils utilisés ………………………………..………….page 3
2.2- Communication via Wifi ………………………………………page 4
2.3- Communication via Bluetooth ………………………..………..page 5
3- Conception………………………………………………………………page 5
3.1- Contrôle de l’application.………………………...…………….page 6
3.2- Adaptation multi-réseaux.………………………...…………....page 7
4- Réalisation………………………………………………………………page 8
4.1- Environnement du développement……………………………page 8
4.1.1- Java 2, Micro Edition (J2ME) Wireless Toolkit 2.2…………..page 8
4.1.2- Installation de la JVM sur le PDA ……………………………page 12
4.1.3- Installation des cartes Wifi et Bluetooth sur le PC…………...page 12
4.2- Développement………………………………………….......page 12
Guide d’utilisation……………………………………….….page 13
5- Conclusion …………………………………………………………….page 14
Annexes…………………………………………………………………..page 15
Diagramme de cas d’utilisation
Diagramme de classes
Diagrammes de séquence
Bibliographie……………………………………………………………...page 20
2
1- Introduction :
Notre projet fait partie d’un sujet de recherche au sein du département informatique
INF de l’INT. Il s’inscrit dans le cadre de l’amélioration de la qualité des applications
déployées sur les équipements mobiles en particulier les PDA.
Il s’agit en effet de développer un service multi-réseaux mettant en œuvre l’adaptation
dynamique des applications dans les environnements mobiles. Cette adaptation est fonction de
plusieurs paramètres dont le besoin de l’utilisateur qui peut être motivé par des raisons
financières (préférer par exemple une connexion wifi gratuite à une connexion GPRS
coûteuse…). La nature de l’application utilisée peut aussi intervenir dans le choix du réseau
de communication qui est fortement dépendant du type et du contenu des médias acheminés
(format de l’image, texte, format de la vidéo…). Un dernier facteur d’adaptation multiréseaux des communications est le hardware utilisé. En effet les ressources de traitement et
de communication (exemples : énergie, charge cpu, occupation mémoire, le débit réseau, la
connectivité…) sont d’une importance capitale pour le choix du réseau approprié.
Diverses stratégies d'adaptation peuvent ainsi être définies. Ces stratégies permettent
d'associer des règles de configuration aux valeurs pouvant être prises par les paramètres
introduits plus haut.
Dans ce travail, nous illustrons ces possibilités d'adaptation multi-reseaux par la définition
d'un sous ensemble de règles de configuration tenant compte de l'état de connexion d'une
interface réseau et du type du media acheminé.
L’exemple concret sur lequel nous avons travaillé est une application de chat entre deux
terminaux mobiles équipés de bluetooth et wifi. Les données échangées sont soit des
messages textuels soit des images. que nous avons développée recommande l'utilisation de
l'interface "active" pour les deux médias en cas de panne sur la deuxième interface …en
donnant la priorité au wifi.
Nous développons dans ce qui suit les étapes de la réalisation de la solution que nous
proposons, l’environnement technologique de notre travail ainsi que les résultats que nous
avons obtenus.
2- Etude technique de l’environnement de travail :
Nous avons commencé par la réalisation de l’application de chat via wifi et bluetooth
sans prendre en compte l’adaptation multi réseaux dans un premier temps.
Il était donc indispensable de fixer les outils qu’on va utiliser et de comprendre les principes
de fonctionnement de wifi et bluetooth.
2.1 API et outils utilisés :
Javax.microedition.midlet (Mobile Information Device Profil) :
3
Ce package définit les interactions d’une application avec l’environnement dans lequel
elle tourne. Il contient en particulier une classe MIDlet qui définit le cycle de vie d’une midlet
en implémentant les méthodes:
• Public void startApp()
• Public void pauseApp()
• Public void destroyApp()
Javax.microedition.lcdui (user interfaces):
Ce package se charge de l’interaction avec l’utilisateur en définissant des composants
graphiques et en gérant les évènements.
Javax.microedition.io :
Ce package gère les connexions et des flux I/O.
Javax.bluetooth (JSR-82) :
Il gère les canaux de communications via BT.
2.2- Communication via Wifi :
La communication se fait le moyen d’une socket que le serveur commence par ouvrir.
Cette socket peut gérer l’échange de données dans les deux sens entre client et serveur.
Voici un exemple basique de communication via Wifi utilisant TCP :
Partie Serveur :
----------------------------------------------------------------------------------------------------------------try {
scn = (ServerSocketConnection) Connector.open("socket://:5000");
// Wait for a connection.
sc = (SocketConnection) scn.acceptAndOpen();
is = sc.openInputStream();
os = sc.openOutputStream();
String message = “Hello”;
os.write(message.getBytes());
}
------------------------------------------------------------------------------------------------Æ Le seveur ouvre la socket avec un numéro de port en utilisant la méthode open de la classe
Connector se trouvant sous javax.microedition.io. L’appel de la méthode acceptAndOpen()
est une attente bloquante à la connexion d’un client.
Enfin l’envoie d’un message se réduit à l’écriture sur l’objet OutputStream
(java.io.OutputStream).
Partie Client :
----------------------------------------------------------------------------------------------------------------sc = (SocketConnection) Connector.open("socket://192.168.1.1:5000");
si.setText("Connected to server");
4
while (true) {
StringBuffer sb = new StringBuffer();
int c = 0;
while (((c = is.read()) != '\n') && (c != -1)) {
sb.append((char) c);
}
if (c = = -1) {
break;
}
// Display message to user
si.setText("Message received - " + sb.toString());
}
ÆLe serveur se connecte sur la socket du serveur en fournissant l’adresse de ce dernier ainsi
que le numéro de port approprié. Il récupère un InputStream et un OutputStream. La réception
d’un message est une simple lecture sur le InputStream.
2.3- Communication via Bluetooth :
Javax.bluetooth est une API qui permet:
•
•
•
D’enregistrer des services : Register Services(UUID)
De découvrir des services et des devices
D’établir des connexions.
Offrir un service Bluetooth :
Le Service sera enregistré dans la SDDB (Service Discovery Data Base), ServiceRecord
contient des informations sur le service (attributes) sous la forme (ID,Value)
ID:16bits unsigned integer
Value : DataElement
2 attributs sont necessaires:
• ServiceRecordHandle: identifie l’instance courante du SDP (Service discovery
Protocol) server
• Service ClassIDList: liste des UUDI associés au service offert
Un service est identifié par un UUDI : 128 bits ->32 char
Le serveur récupère le LocalDevice et le mets accessible par les autres devices : il utilise
l’URL pour ouvrir une connexion (StreamConnectionNotifier) permettant de publier le
service.
----------------------------------------------------------------------------------------------------------------Exemple :URL (utilisant le protocole btspp par exemple)
localDevice = LocalDevice.getLocalDevice();
url=“btspp://localhost:” + UUDI.toString() + “;name=btChat”
notifier = (StreamConnectionNotifier) Connector.open(url.toString());
ServiceRecord = localDevice.getRecord(notifier);
5
------------------------------------------------------------------------------------------------Utiliser un service Bluetooth :
• Comment retrouver un remote device?
Æ Implémenter DiscoveryListener qui offre les méthodes (il faut redéfinir ces méthodes)
•
•
•
•
public void deviceDiscovered(RemoteDevice btDevice, DeviceClass cod)
public void inquiryCompleted(int discType)
public void servicesDiscovered(int transID, ServiceRecord[] servRecord)
public void serviceSearchCompleted(int transID, int respCode)
Æ Faire appel à la méthode « startInquiry(int accessCode, DiscoveryListener listener) »
qui est invoquée par l’agent de discovery. Puis on récupère l’url du service et on ouvre la
connexion qui sera le support de transmission des données désirées.
3- Conception :
Cette application est composée de deux modules interconnectés, le premier contrôle
l’envoie et la réception des messages et le deuxième prend en charge le choix du canal de
communication et l’acheminement des données.
Chaque utilisateur dispose d’une liste de contacts enregistrée dans un fichier contenant tous
les paramètres de connexions pour chaque contact. Pour un correspondant disposant d’une
interface wifi et une autre Bluetooth le fichier indiquera alors son adresse IP et le port de
connexion pour définir les paramètres de connexion wifi et le nom de l’équipement mobile
ainsi que le l’identifiant du service offert pour définir les paramètres de la connexion
bluetooth.
L’application commence par afficher tous les contacts de l’utilisateur que peut en sélectionner
un et entamer avec lui une discussion.
1. contrôle de l’application :
Notre application doit permettre d’envoyer des images et des messages, elle doit gérer
aussi l’état des connexions Wi-Fi et bluetooth et afficher leurs caractéristiques. C’est pour
cela qu’on a jugé utile de deviser ce module en trois parties ou bien trois contrôleurs dont
chacun s’occupe des tâches bien précises.
¾ ChatController et ChatView: permettent de visualiser la discussion, d’inviter
l’utilisateur à saisir ses messages. Ils disposent des méthodes qui permettent d’ajouter
un message reçu ou envoyé dans la zone de conversation.
¾ ImageController et ImageView : deux classes qui permettent d’inviter le client à
choisir une image pour qu’elle soit publiée. Les images qui peuvent être envoyées sont
enregistrées dans le répertoire
:
‘C:\WTK22\appdb\DefaultColorPhone\filesystem\root1\images’, elles fournissent
aussi des méthodes pour la construction d’une image à partir d’un chemin et la sa
reconstruction et son affichage à partir d’un tableau de bytes.
¾ ConnectionController : permet d’afficher les caractéristiques et les disponibilités de
chaque interface de communication.
6
2. Adaptation multi réseaux
Le module d’adaptation multi réseaux est composé de deux classes (Bluetooth et Wireless)
présentant les deux types de connexions qu’on envisage d’utiliser pour l’acheminement de
données. Chacune de ces deux implémente l’interface Connection qui définit les méthodes
communes à ces deux connexions. Chaque classe alors fournit les méthodes suivantes :
¾ scanConnection qui vérifie la disponibilité de la connexion,
¾ send (byte [] data) qui se charge d’envoyer des bytes pour assurer l’acheminement
des messages et des images convertis en tableau de bytes.
¾ receive ( ) qui attend des messages de la part des clients, vérifie s’il s’agit d’une
image ou d’un message par le premier byte du tableau reçu et met le contrôleur au
courant de la réception des nouvelles données pour que ce dernier puisse les afficher
à l’utilisateur.
¾ releaseRessources ( ) qui ferme toutes les connexions et les flux d’entrée et de sortie
déjà ouverts.
¾ setupConnection ( ) : est appelée pour lancer la communication elle ouvre une
connexion avec le contact choisi et appelle la méthode receive pour l’attente des
messages.
Le choix du type de connexion selon des règles bien définies est réalisé dans la classe
Decision. Cette classe se charge de choisir le canal de communication à chaque envoie de
données tout en prenant en compte des règles enregistrées dans un fichier de configuration.
Cette classe fournit les méthodes suivantes :
¾ setupConnection prend en paramètres un Hashtable contenant toutes les connexions
que nous devons ouvrir afin d’attendre des messages en écoutant sur toutes les
interfaces possibles. Cette méthode récupère la liste de toutes les clés qui représentent
le type de connexion (wifi, bt) et les paramètres correspondants à chacune de ces clés.
Pour une connexion wifi, une adresse IP et un port sont exigés. Alors que pour une
connexion bluetooth le nom de l’équipement mobile et l’identifiant UUID du service
sont nécessaires à l’établissement de la connexion. Toutes ces données sont
récupérées, setupConnection ouvre toutes les connexions souhaitées et chargent des
threads de l’attente des messages venant des clients.
¾ Send(byte[]data ) : prend en paramètre le type de données et les données sous forme
d’un tableau de bytes. A partir de ces paramètres on construit un nouveau tableau de
bytes dont le premier élément est un byte égal à 0 s’il s’agit d’un message et à 1 en cas
d’une image. Avant d’acheminer des données vers l’autre bout du canal de
communication, cette méthode appelle la méthode chooseConnection qui selon les
règles de choix décrites dans le fichier de configuration et les disponibilités des
connexions fait le choix entre Wi-Fi et Bluetooth. Le choix est effectué, on envoie les
données en utilisant la méthode send de Bluetooth ou Wireless.
7
4- Réalisation :
4.1- Environnement du développement :
4.1.1- Java 2, Micro Edition (J2ME) Wireless Toolkit 2.2:
Nous avons commencé par télécharger et installer Java 2, Micro Edition (J2ME)
Wireless Toolkit 2.2 à partir du site
http://java.sun.com/products/j2mewtoolkit/download-2_2.html
sur l’ordinateur portable. Vous avez ci-dessous un aperçu général sur les fonctionnalités de
J2ME Wireless Toolkit 2.2. Il s’agit d’un émulateur offrant un environnement d’exécution
d’applications destinées à des terminaux mobiles.
Plusieurs exemples d’applications sont fournis avec J2ME Wireless Toolkit. Nous avons donc
commencé par explorer ces applications afin de découvrir les services qu’elles offrent.
Comme nous travaillons sous Windows, pour lancer l’émulateur il faut cliquer sur :
Start > Programs > J2ME Wireless Toolkit 2.2 > KToolbar.
La fenêtre suivante apparaît:
On clique sur open Project pour avoir la liste des projets déjà fournis :
Enfin il suffit de sélectionner un projet, l’ouvrir et lancer l’application avec ‘run’.
Pour un nouveau projet il faut :
8
¾ Créer le package en cliquant sur :
Project > Package > Create Package à partir du menu KToolbar. Un
descripteur du MIDlet ainsi des fichiers .jar sont placés dans le répertoire bin
du projet.
¾ Installer l’application en cliquant sur Project > Run via OTA.
¾ Lancer enfin l’application en suivant les instructions.
Nous nous sommes en particulier intéressés à deux applications que nous avons jugées utiles
pour notre projet à savoir NetworkDemo et BluetoothDemo.
NetworkDemo :
Il s’agit d’une application de chat via des Scokets en utilisant une connexion TCP. On
lance l’émulateur deux fois pour simuler les deux PDA : un serveur et un client.
9
Il est à noter qu’il faut commencer par lancer le serveur car c’est lui qui va ouvrir la
connexion et se mettra en attente pour recevoir le client. Cette partie du code du serveur
explique plus en détails l’établissement de la connexion.
----------------------------------------------------------------------------------------------------------------si.setText("Waiting for connection");
scn = (ServerSocketConnection) Connector.open("socket://:5000");
// Wait for a connection.
sc = (SocketConnection) scn.acceptAndOpen();
si.setText("Connection accepted");
----------------------------------------------------------------------------------------------------------------Ainsi, le serveur ouvre la connexion sur le port 5000 et il effectue l’instruction
bloquante :acceptAndOpen jusqu’à ce que un client se connecte.
Puis, le serveur ouvre aussi un InputStream et un OutputStream qui ont le rôle de canaux de
flux entrant et sortant.
De la même façon, le client se connecte à son tour à ce serveur et effectue la même
démarche :
----------------------------------------------------------------------------------------------------------------sc = (SocketConnection) Connector.open("socket://localhost:5000");
si.setText("Connected to server");
----------------------------------------------------------------------------------------------------------------Une fois la connexion établie, le serveur et le client peuvent échanger des messages textuels :
10
BluetoothDemo :
Il s’agit d’une application qui utilise bluetooth pour envoyer des images d’un serveur à
un client. On commence toujours par lancer le serveur qui enregistre et publie son service
offrant des images. Il ouvre ensuite un StreamConnection avec l’URL qui décrit le protocole,
le serveur et le nom du service. Enfin il prépare un InputStream et un OutputStream qui ont le
rôle de canaux de flux entrant et sortant, comme pour le cas du wifi.
Le serveur affiche la liste des images dont il dispose. On choisie une image et on la
publie. Le client découvre le service publié par le serveur et trouve les images disponibles.
Enfin quand le client choisit de télécharger l’image cette image lui apparaît à l’écran.
11
4.1.2- Installation de la JVM sur le PDA :
Nous avons installé WebSphere Micro Environment MIDP 2.0 pour Windows Mobile
2003 version 5.7.1 dont la taille est 4,7 Mo. Pour ce faire nous avons utilisé l’outil
ActiveSync qui assure la synchronisation entre le PC et le PDA facilitant ainsi l’installation
sur le PDA.
4.1.3- Installation des cartes Wifi et Bluetooth sur le PC :
Nous disposons d’une carte Wifi Compaq et d’une carte bluetooth Toshiba qui nous
ont été fournies avec leurs CD d’installation. L’installation de la carte Wifi a été immédiate,
alors que pour la carte bluetooth, nous étions obligés de chercher sur Internet les drivers
correspondant à cette carte qui est un modèle assez ancien.
4.2- Développement :
A partir de ces deux exemples (NetworkDemo et BluetoothDemo) nous avons
développé une application qui envoie des images d’un serveur à un client via Wifi, ainsi
qu’une application de chat (envoie de messages textuels) sur bluetooth.
Ensuite nous avons crée une application qui unit envoie de texte et d’images via Wifi.
Après avoir réalisé ces tests unitaires, nous nous sommes intéressés à l’application en entier
pour ajouter une fonctionnalité extérieure chargé du control des réseaux disponibles et du
choix du réseau approprié à l’application de chat.
12
Guide d’utilisation
Dans cette partie nous allons vous décrire toutes les étapes de l’utilisation de notre
application.
Dès le début du lancement de l’application vous etes invités à choisir le contact avec qui vous
désirez avoir une discussion.
La sélection d’un contact lancera une connexion avec ce dernier en essayant de se connecter à
son équipement tout d’abord, si’il n’arrive pas à se connecter il ouvre une connexion en tant
que serveur et attend le client désiré. Un TextBox apparaît pour vous afficher la discussion et
un menu peut être utilisé pour envoyer des messages ou des images
Pour vous envoyer un message, l’application vous invite à saisir votre message et se charge
d’envoyer ce dernier vers votre correspondant et pour envoyer une image vous devez
sélectionner une image et la publier.
13
5- Conclusion :
Au cours de ce projet, nous avons développé d’une part une application de
communication via bluetooth et wifi et d’autre part un module d’adaptation muti-réseaux qui
gère le choix du réseau approprié à l’application.
Nous avons ainsi travaillé sous un nouvel environnement de développement : J2ME et
nous avons aussi appris à manipuler des applications utilisant des connexions Wifi et
bluetooth.
Certes la solution que nous proposons résout en partie le problème d’adaptation multi
réseaux, mais il reste des améliorations à faire surtout en cas de déconnexion. En effet, s’il y a
interruption du réseau wifi par exemple au cours de l’envoie d’un fichier, la solution idéale
serait de continuer à envoyer la partie manquante de ce fichier, via bluetooth. Ceci permet de
gagner un temps considérable surtout s’il s’agit d’un gros fichier.
14
Annexes :
Total Size =17 MB
The J2ME Wireless Toolkit is a set of tools for creating Java applications that run on devices compliant
with the Java Technology for the Wireless Industry (JTWI, JSR 185) specification. It consists of build
tools, utilities, and a device emulator.
The J2ME Wireless Toolkit implements impressive capabilities which are exposed through standard APIs.
The APIs are defined through the Java Community Process (JCP):

Connected Limited Device Configuration (CLDC) 1.1 (JSR 139)
Mobile Information Device Profile (MIDP) 2.0 (JSR 118)
Java Technology for the Wireless Industry (JTWI) 1.0 (JSR 185)
Wireless Messaging API (WMA) 2.0 (JSR 205)
Mobile Media API (MMAPI) 1.1 (JSR 135)
PDA Optional Packages for the J2ME Platform (JSR 75)
Java APIs for Bluetooth (JSR 82)
J2ME Web Services Specification (JSR 172)
Mobile 3D Graphics API for J2ME (JSR 184)
System Requirements - Software

Microsoft Windows XP or (unsupported) Linux-x86
JavaTM 2 SDK, Standard Edition (J2SE SDK), version 1.4.2 - if you plan to do actual
development, or JavaTM 2, Standard Edition Runtime Environment (JRE), version 1.4.2 - if you
only plan to run the demonstration applications.
To download the SDK or JRE you want, go to http://java.sun.com/j2se/downloads.html
System Requirements - Hardware
Minimum hardware requirements are:

50 MB hard disk space
128 MB system RAM
800 MHz Pentium III CPU
15
Diagramme de cas d’utilisation
16
Diagramme de classes
17
Diagramme de séquences
18
19
Bibliographie :
•
•
•
J2ME Applications Java pour terminaux mobiles; par Bruno Delb.
http://bluetooth.com
http://www.ibm.com/software/wireless/wme
20