Implémentation d'une application Météo avec android
←
→
Transcription du contenu de la page
Si votre navigateur ne rend pas la page correctement, lisez s'il vous plaît le contenu de la page ci-dessous
Implémentation d’une application
Météo avec android
Réaliser par :
BOUHAJJA Lamia
MP1-SSICE 1
Année universitaire : 2011-2012
Implémentation d’une application Météo avec ANDROID MP1SSICE1
Page 2
Implémentation d’une application Météo avec ANDROID MP1SSICE1
Table des matières
I. Introduction .................................................................................................................... 4
II. Plateforme Android et outils de développement ........................................................... 4
II.1. Le SDK Android ............................................................................................................ 4
II.2. L’Emulateur Android ................................................................................................... 5
II.2.1. Présentation de l’émulateur.................................................................................... 5
II.2.2. Méthode de configuration d’un AVD : .................................................................... 6
II.3. Système d’exploitation Android .................................................................................. 8
II.3.1. Présentation du système d’exploitation Android ................................................... 8
II.3.2. Architecture du système d’exploitation Android .................................................... 8
II.4. Autres outils utilisés .................................................................................................. 10
II.4.1. Environnement de développement Eclipse IDE .................................................... 10
II.4.2. Langage de programmation JAVA ......................................................................... 10
III. Les Web Services : ..................................................................................................... 11
III.1. Le protocole SOAP ..................................................................................................... 12
III.2. SOAP et XML.............................................................................................................. 12
IV. Application Réalisée .................................................................................................. 14
IV.1. Introduction............................................................................................................... 14
IV.2. Implémentation......................................................................................................... 14
V. Test de l’application ...................................................................................................... 21
VI. Conclusion Générale ................................................................................................. 22
Page 3
Implémentation d’une application Météo avec ANDROID MP1SSICE1
I. Introduction
Les appareils mobiles d'aujourd'hui sont allés au-delà de leur rôle primitif d'outils de
communication. En effet ils présentent de plus en plus de fonctionnalité afin de suivre
l’évolution des besoins des consommateurs. C’est le cas des Smartphones.
Aujourd’hui on parle plus des Systèmes d’exploitations dédié a des Smartphone, tel que le
IOS, BADA, BlackBerry OS et ANDROID…
Dans notre projet nous intéressant au system d’exploitation mobile ANDROID où nous
essayerons d’implémenté une application android qui peut se connecté a un web-service et
nous rendre les informations nécessaire concernant la météo et la température.
II. Plateforme Android et outils de développement
II.1. Le SDK Android
Le SDK (Software Developpement kit) est un ensemble d’outils de développement qui
permet de créer des nouvelles applications. Son installation se fait en lançant le SDK-
Manager.exe, téléchargé du site officiel d’Android, la fenêtre suivante s’ouvre :
Figure1 : Choix de la version de SDK
Page 4
Implémentation d’une application Météo avec ANDROID MP1SSICE1
Figure2 : Installation des packages
II.2. L’Emulateur Android
II.2.1. Présentation de l’émulateur
Le SDK Android inclut un émulateur d’appareil mobile, c’est un dispositif mobile virtuel qui
s'exécute sur l’ordinateur et permet de développer et de tester des applications Android sans
l'aide d'un dispositif physique.
Lorsque l'émulateur est lancé, il nous permet d’interagir avec le périphérique mobile émulé.
Nous utilisons également le pointeur de la souris pour "toucher" l'écran tactile et nous
pouvons utiliser certaines touches du clavier pour invoquer certaines touches sur l'appareil.
L'émulateur Android imite toutes les fonctionnalités matérielles et logicielles d'un dispositif
mobile typique, tel que la lecture des fichiers audio et vidéo, stockage des données, sauf qu'il
ne peut pas passer des appels réels.
L'émulateur Android est une application basée sur le QEMU qui fournit un dispositif mobile
virtuel ARM sur lequel nous pouvons exécuter notre application Android. Il fonctionne
comme un système Android complet.
L'image du système Android distribué dans le SDK contient le code machine ARM du noyau
Linux d’Android, les librairies natives, la machine virtuelle Dalvik, et les différents package
Android. Les couches de l'émulateur QEMU fournissent une traduction dynamique binaire du
code machine ARM à l'OS et à l'architecture du processeur de notre machine de
développement.
L’émulateur Android supporte de nombreuses fonctionnalités du matériel susceptible de se
trouver sur des appareils mobiles, y compris:
Page 5
Implémentation d’une application Météo avec ANDROID MP1SSICE1
Le CPU ARMv5, l'unité correspondante de gestion mémoire (MMU), un écran LCD, un ou
plusieurs claviers, partitions de mémoire Flash (émulé par le biais des fichiers images disque
sur la machine de développement), un modem GSM, et une simulation de carte SIM.
Pour utiliser l'émulateur, nous devons d'abord créer une configuration AVD (Android Virtual
Device). Nous spécifions la plateforme Android à exécuter dans l'émulateur et l'ensemble des
options matérielles.
II.2.2. Méthode de configuration d’un AVD :
L'émulateur utilise un AVD configurée (Android Virtual Device) selon le choix du
programmeur pour permettre de modéliser et de tester notre application plus facilement.
Les AVDs permettent de définir les aspects matériels de certains téléphones émulés et de
créer de nombreuses configurations pour tester des différentes versions de la plateforme
Android.
La meilleure façon est de créer et configurer un AVD en utilisant l’outil graphique « AVD
Manager », qui est lancé à partir d'Eclipse en cliquant sur « Fenêtre » puis « Android SDK
and AVD Manager ».
La fenêtre de la figure suivante s’affiche.
Figure3 : Outil graphique « AVD manager »
Pour créer un nouvel AVD, il suffit de cliquer sur le bouton « New », une fenêtre de
configuration de l’AVD se lance. Où nous pouvons donner un nom à notre AVD, choisir la
version du système d’exploitation Android à utiliser, la taille de la carte SD, et le type
d’écran.
Page 6
Implémentation d’une application Météo avec ANDROID MP1SSICE1
Figure 4: Outil de configuration de l’AVD
Nous pouvons également ajouter autant de matériels dont on aura besoin dans notre
application à partir de la zone « hardware », en cliquant sur le bouton « New » comme le
montre la figure 5.
Figure 5: Fenêtre de choix du matériel ajouter à l’AVD
Page 7
Implémentation d’une application Météo avec ANDROID MP1SSICE1
II.3. Système d’exploitation Android
II.3.1. Présentation du système d’exploitation Android
L’Android est un système d'exploitation open source pour Smartphones, PDA et les
terminaux mobiles conçu par Android qui est une startup rachetée par Google.
Le Système d’exploitation Android est fondé sur un noyau Linux. Il comporte une interface
spécifique développée en java. Les programmes sont exécutés via un interpréteur JIT (Just in
time).
Parmi les caractéristiques de notre système d’exploitation adopté, une machine virtuelle «
Dalvik » optimisé pour les appareils mobiles, un navigateur intégré basé sur l'open source «
WebKit », aussi une transition graphique optimisée et alimenté par une bibliothèque
graphique 3D (OpenGL ES 2.0).
De plus, Android contient l’outil « SQLite » pour stocker des données structurées, il soutien
des médias pour l'audio, la vidéo et des formats d'images telles que : MPEG4, H.264, MP3,
AAC, AMR, JPG, PNG, GIF.
II.3.2. Architecture du système d’exploitation Android
Les principales composantes du système d'exploitation Android sont organisées sous formes
de couches décrites ci-dessous.
La couche Application :
Android est livré avec un ensemble d'applications de base, dont un client de messagerie, un
programme des SMS, un calendrier, un navigateur, la liste des contacts. Toutes les
applications sont écrites en utilisant le langage de programmation Java.
La couche Application Framework :
En fournissant une plateforme de développement ouverte, Android offre aux développeurs la
possibilité de créer des applications extrêmement riches et innovantes. Les développeurs sont
libres de profiter du matériel périphérique. En effet, ils peuvent exécuter les services d'arrière
plan, définir des alarmes, ajouter des notifications de la barre d'état et beaucoup plus de
fonctionnalité.
Les développeurs ont un accès complet aux APIs utilisés par les applications de base.
L'architecture d'application est conçue pour simplifier la réutilisation des composants.
N'importe quelle application peut publier ses capacités pouvant être utilisé par une autre. Cet
héritage de capacité entre les applications est soumis à des contraintes de sécurité imposées
par la couche.
La couche Libraires :
Page 8
Implémentation d’une application Météo avec ANDROID MP1SSICE1
Android inclut un ensemble des librairies utilisées telles que la librairie Open GL ES utilisée
dans notre application et décrite dans le chapitre précédent. Ces bibliothèques sont accédées à
travers la couche application d’Android.
La couche Android Runtime :
Un ensemble de bibliothèques de base inclut par le système d’exploitation Android. Ces
bibliothèques fournissent la plupart des fonctionnalités disponibles dans les bibliothèques
basiques du langage de programmation Java.
Chaque application Android s'exécute dans son propre processus avec sa propre instance dans
la machine virtuelle « Dalvik ». Cette dernière a été fait de sorte qu'un dispositif peut
fonctionner plusieurs tâches de manière efficace. Elle exécute les fichiers avec l'exécutable de
Dalvik (. Dex) qui est un format optimisé pour une utilisation minimale de mémoire. Dalvik
est composée de registres de bases et des classes compilées par un compilateur Java. De plus
elle s'appuie sur le noyau Linux pour les fonctionnalités de base telles que le filtrage et la
gestion de la mémoire de bas niveau.
La couche Linux Kernel :
Android se base sur le noyau Linux 2.6 pour les services système de base tels que la sécurité,
la gestion de la mémoire, la gestion des processus, la pile réseau et le modèle de pilote, ce qui
permet une meilleure gestion des caractéristiques des appareils mobiles.
Le noyau agit également comme une couche d'abstraction entre le matériel et le reste de la
pile logicielle.
Le noyau linux est choisi car il représente un système de gestion mémoire et de processus
reconnu par sa stabilité et ses performances, avec un model de sécurité, basé sur un système
de permission reconnu par sa robustesse et sa performance. Ainsi le noyau linux fournit un
système de driver permettant une abstraction avec le matériel. Il permet également le partage
de librairies entre différents processus.
La figure ci-dessous représente les couches disponibles dans l'écosystème d’une application
Android.
Page 9
Implémentation d’une application Météo avec ANDROID MP1SSICE1
Figure 6 : Différentes couches du système Android
II.4. Autres outils utilisés
A part le kit de développement Android, nous avons utilisé les outils décrites ci-dessous.
II.4.1. Environnement de développement Eclipse IDE
L’environnement que nous avons utilisé pour développer notre application est « Eclipse ».
Eclipse IDE (Integrated Development Environment) est un environnement de développement
intégré, permettant de créer des projets de développement. Il est principalement programmer en
Java, créé par la firme Sun Microsystems.
Le développement de l’architecture Eclipse IDE est basé sur la notion de plug-in. Le plug-in
ADT (Android Developpement Tools) est conçu pour l’Eclipse IDE afin d’avoir un
environnement intégré dans lequel on crée des applications Android. Ce plug-in sert également à
l’utilisation des éditeurs XML personnalisés et le débogage.
II.4.2. Langage de programmation JAVA
Vu que notre application est destinée à être utiliser avec les Smartphones sous le système
d’exploitation Android développé en JAVA et que le SDK Android (software development
Page 10Implémentation d’une application Météo avec ANDROID MP1SSICE1
kit) est en fait un ensemble d’API programmé en JAVA. Nous avons recours à utiliser ce
langage de programmation, le JAVA.
Les principales caractéristiques de ce langage de programmation sont sa flexibilité, son
efficacité et sa portabilité, qui font de JAVA un outil indispensable permettant d'écrire des
applications puissantes et efficaces pour les multiplateformes embarquées ayant un JRE (Java
Runtime Environment) telles que les téléphones portables et les processeurs à distance.
III. Les Web Services :
Un Web service est un mécanisme qui tend à donner plus d’interactions pour permettre à
deux entités hétérogènes (entreprises, clients, applications, etc. ...) de dialoguer au travers du
réseau Internet. Les logiciels écrits dans divers langages de programmation (C#, Visual
Basic, Java, etc.), sur diverses plateformes (Linux, Windows, etc.) et avec diverses
architectures peuvent employer des services Web pour échanger des données à travers des
réseaux informatique. Chaque Web service doit pouvoir être découvert et invoqué
dynamiquement par les applications.
Selon la définition du W3C (World Wide Web Consortium), un Web service (ou service
Web) est une application appelable via Internet par une autre application d’un autre site
Internet permettant l’échange de données (de manière textuelle) afin que l’application
appelante puisse intégrer le résultat de l’échange à ses propres analyses. Les requêtes et les
réponses sont soumises à des standards et normalisées à chacun de leurs échanges.
Si l’on devait résumer les raisons de la création des services Web, les qualificatifs tels que la
simplicité des échanges, l’amélioration de la communication entre les applications en seraient
les points principaux. En ajoutant à cela l’interopérabilité des programmes indifféremment de
leur langage et de leur plateforme, les services Web nous prouvent une nouvelle fois que leur
technologie est très attrayante. Le véritable point fort du concept c’est la normalisation des
données au travers de standards connus et acceptés par tous.
Figure 7 : Fonctionnement globale d’un échange de données grâce aux services Web
Page 11Implémentation d’une application Météo avec ANDROID MP1SSICE1
1) L’application construit sa requête et la normalise grâce aux standards.
2) Le service Web traduit la requête, recherche l’application nécessaire.
3) Les données sont traitées.
4) Le service Web normalise la réponse de la requête et envoie le résultat vers
l’application appelante.
5) Les données réponses sont reçues par l’application. Elles peuvent directement être
interprétées.
III.1. Le protocole SOAP
C’est un protocole de dialogue par appels de procédures à distance entre objets logiciels. Sa
syntaxe d’utilisation est fondée sur XML et ses commandes sont envoyées sur Internet par
l’intermédiaire du protocole HTTP mais aussi SMTP et POP sous forme de texte structuré.
Il permet aux systèmes objets distribués de solliciter et d’obtenir des services rendus par
d’autres objets, il est moins lourd à mettre en œuvre que d’autres protocoles et c’est pour cela
qu’il est de plus en plus adopté.
Le protocole SOAP est une note du Consortium W3C dont Microsoft fait partie, mais qui
n’est pas spécifique à Microsoft et Windows. IBM a également participé à l’élaboration de ce
protocole.
De plus il existe des implémentations Java, et Borland vient déjà d’implémenter SOAP sous
Windows dans Delphi 6 et sous Linux avec Kylix.
Bien qu’il soit utilisable avec d’autres protocoles de transport, HTTP est le plus couramment
utilisé. Le deuxième standard, XML, utilisé pour la structuration des données sous forme de
messages est quand à lui le seul utilisé.
III.2. SOAP et XML
SOAP repose sur une approche RPC, basée donc sur des messages dont le contenu est
structuré en XML.
SOAP est un protocole de communication d’ordinateur à ordinateur sous HTTP très simple,
écrit en XML. Il permet l’échange de données, quelque soit les systèmes d’exploitation.
Exemple de requête HTTP contenant du code SOAP :
L’envoi d’un message SOAP correspond à une requête HTTP POST
red POST /StockQuote HTTP/1.1
Host : www.stockquoteserver.com
Content-Type : text/xml ; charset="utf-8"
Content-Length : nnnn
Page 12Implémentation d’une application Météo avec ANDROID MP1SSICE1
SOAPAction : "Some-URI"
red
DIS
Réponse HTTP correspondante
redHTTP/1.1 200 OK
Content-Type : text/xml ; charset="utf-8"
Content-Length : nnnn
red
34.5
Il s’agit ici de répondre à une requête SOAP (un message contenu dans une requête HTTP,
donc) demandant au serveur le montant d’un prix.
La définition d’une "enveloppe" SOAP est obligatoire : elle caractérise le message SOAP.
Une "enveloppe" SOAP se subdivise en un en-tête facultatif et un corps obligatoire.
Page 13Implémentation d’une application Météo avec ANDROID MP1SSICE1
Les messages SOAP sont des transmissions en sens unique d’un émetteur vers un récepteur.
C’est maintenant un standard stabilisé et déjà employé.
IV. Application Réalisée
IV.1. Introduction
Notre application consiste a nous donnez la météorologiques du pays en question, et ce par
l’envoi des requêtes SOAP vers un web service.
Notre application permet de rendre la météo pour ce jour là où nous la sommes utilisés, ainsi
que pour trois jours après.
Donc notre application comporte trois view : la premier nous permet de tapez la ou les noms
des pays dont on veut savoir leurs météorologiques, la deuxième view nous présente la météo
d’aujourd’hui avec quelque détails tel que l’heur, la température et l’humidité… Et
finalement la troisième view présente la météo des trois jours suivantes.
IV.2. Implémentation
La première chose à faire lors de l’implémentation c’est de préparé les interfaces
d’interaction avec l’utilisateur, pour cela nous avons préparé les fichiers XML suivant :
Days.xml :
Ce fichier contiendra la météo des trois jours :Implémentation d’une application Météo avec ANDROID MP1SSICE1 android:textColor="@color/Black" android:paddingBottom="20px" android:id="@+id/foreUpdate" android:text="HH:MM:SS">
Implémentation d’une application Météo avec ANDROID MP1SSICE1
Figure 8 : L’allure du view « 3Days »
Page 16Implémentation d’une application Météo avec ANDROID MP1SSICE1
Lview.xml :
Ce fichier xml contient une listeview où l’application va stocké les différent pays dont
l’utilisateur veut savoir des informations concernant leurs météo :
Figure 9 : l’allure du view « MyLocations »
Page 17Implémentation d’une application Météo avec ANDROID MP1SSICE1
Now.xml :
Ce fichier contiendra les informations en temps réel détaillé de la météorologiques :
Page 18Implémentation d’une application Météo avec ANDROID MP1SSICE1
Figure 10 : l’allure du view « Now »
Apres avoir préparer les view de l’application nous intéressant au développement des
fichier.java :
Page 19Implémentation d’une application Météo avec ANDROID MP1SSICE1
Le fichier « AndroidWeatherTab.java » :
C’est dans ce fichier que nous stockant les informations que nous avons pris a partir du web
service. Donc c’est ici que nous avons fait la connexion au web service : http://tempuri.org/
en précisant les constantes suivante :
private static final String SOAP_ACTION = "http://tempuri.org/GetWeather";
private static final String METHOD_NAME = "GetWeather";
private static final String SOAP_ACTION2 = "http://tempuri.org/getStringWeather";
private static final String METHOD_NAME2 = "getStringWeather";
private static final String NAMESPACE = "http://tempuri.org/";
private static final String URL =
"http://student.labs.ii.edu.mk/ii11532/Service.asmx";
public static boolean chk_useSIformat=true;
Le fichier « Broadt3DaysActivity.java » :
Ce fichier est responsable au retour des informations météorologiques des tous les trois jours
en spécifiant l’image correspondante.
Le fichier « MyLocationActivity.java » :
Ce fichier permet de lire les noms de pays écrite par l’utilisateur, les stocké dans sous forme
des listes view tel que le fichier « MyLocations.xml » est désigné, et nous permet aussi de
sélectionne la quel des pays déjà sauvegardé nous voulons consulter.
Les restes des fichiers java sont des activités de liaison entre les fichiers déjà décrit ci-
dessus qui comportent des fonctions utilisé par ces derniers.
Le fichier « Android Maniferst.XML » :
C’est là que nous devons ajouter les différent permissions a l’application pour qu’elle réussi a
se connecté a internet, s’interrogé avec le web service et nous rendre les information
nécessaire.
Voilà le code de « Android Manifest.XML » :
Page 20Implémentation d’une application Météo avec ANDROID MP1SSICE1
Ne nous devons pas oublier de précisé que pour pouvoir utilisé les différents fonctions de
connexion au web services, tels que : « SoapObject » ; « request.addProperty »,
« SoapSerializationEnvelope », « SoapSerializationEnvelope », « HttpTransportSE » etc. il
faut que nous téléchargeons ajoutons la bibliothèque « ksoap2 » a notre projet.
V. Test de l’application
Une fois, nous avons terminé l’implémentation de notre application. Nous allons recours à la
tester en utilisant l’émulateur « Android 4.0.3 » avec la version d’API 15.
Mais lors du teste nous avons eux un problème avec la réception des informations depuis le
web service que nous n’avons pas encore fixé
Figure 11 : les trois view de notre application AndroidWeather
Page 21Implémentation d’une application Météo avec ANDROID MP1SSICE1
VI. Conclusion Générale
Le présent travail, nous a été confié dans le cadre d’un mini projet. Nous avons abordé la
technologie du développent Android qui offre multiples applications dont l’objectif est de
rependre a l’évolution des besoins des consommateurs.
Durant nos travaux de conception et de développement, nous avons appris le concept du
développement Android ainsi que l’utilisation des web services et les diffèrent protocoles de
dialogues avec eux. Ce qui était enrichissant pour notre binôme
Page 22Vous pouvez aussi lire
