Sommaire - WordPress.com

Sommaire
Choix des outils de travail....................................................................................................................2
Outil de développement...................................................................................................................2
Outil de gestion de la base de données............................................................................................2
Android et les bases de données...........................................................................................................3
Avec SQLite.....................................................................................................................................3
Avec des scripts en PHP..................................................................................................................3
Avec MySQL Connector/J...............................................................................................................4
Tâches asynchrones (AsyncTask).........................................................................................................5
Présentation......................................................................................................................................5
Structure...........................................................................................................................................5
Utilisation dans le projet..................................................................................................................6
Les interfaces graphiques.....................................................................................................................7
Présentation......................................................................................................................................7
Structure...........................................................................................................................................7
Les activités..........................................................................................................................................8
Présentation......................................................................................................................................8
Cycle de vie.....................................................................................................................................8
Schéma du cycle de vie....................................................................................................................9
Android Manifest................................................................................................................................10
Présentation....................................................................................................................................10
Structure.........................................................................................................................................10
Page 1 sur 10
Choix des outils de travail
Outil de développement
En ce qui concerne l'outil de développement, deux choix s'offraient à moi, Eclipse et Android
Studio. J'ai choisi Android Studio pour les raisons suivantes :
•
Ecplise doit être couplé avec des ADT (Android Developer Tools) qui ne sont plus mis à
jour depuis la sortie d'Android Studio. Il est donc limité au développement d'applications sur
des versions antérieures d'Android.
•
Android Studio intègre directement tous les outils dont on a besoin et permet le
développement sur les dernières versions d'Android en date.
Outil de gestion de la base de données
Pour la gestion de la base de données je me suis orienté vers MySql Control Center que j'ai eu
l'occasion de découvrir pendant mon stage de première année. Ce logiciel convient à mes besoins,
son interface est simple et rapide d'utilisation.
Page 2 sur 10
Android et les bases de données
Avec un système Android il existe trois différentes façons de communiquer avec une base de
données.
Avec SQLite
SQLite est un système de gestion de base de données intégré dans chaque appareil Android. Il ne
nécessite pas de serveur pour fonctionner, car son exécution se fait dans le même processus que
celui de l'application (la base de données est créée en interne). De ce fait, si une opération trop
lourde est lancée sur la base de données, l'application serait victime de ralentissement.
Pour ce projet l'utilisation de SQLite est impossible pour deux raisons :
•
La base de données est hebergée sur un serveur auquel il faut être connecté.
•
Certaines opérations efféctuées sur l'application sont lourdes, car la base de données est
volumineuse.
Avec des scripts en PHP
Pour l'utilisation de cette méthode nous avons besoin de scripts PHP (fichiers .php) et d'un serveur
de base de données. Les scripts PHP doivent se situer sur le serveur qui contient notre base de
données.
Le fonctionnement de cette méthode est le suivant :
•
Le client Android envoie les commandes HttpClient au serveur en indiquant le chemin du
script PHP à interroger pour obtenir le résultat voulu.
•
Le script PHP se connecte à la base de données et exécute les requêtes SQL qu'il contient.
•
Il récupère le résultat des requêtes et l'encode en JSON (format léger d'échange de données)
avant de le retourner au client Android.
•
Le client récupère le résultat sous format JSON et le décode.
Une fois les données décodées on peut les manipuler à notre guise dans notre application.
Page 3 sur 10
Ce système de communication entre le client et la base de données est le plus utilisé. Mais il ne
convient pas à mon projet, car le code des requêtes SQL se trouve dans des fichiers PHP stockés sur
le serveur de la base de données. Or, dans les contraintes de mon cahier des charges, il est précisé
que les requêtes SQL doivent se trouver dans le code de l'application.
Avec MySQL Connector/J
MySQL Connector/J est un driver JDBC (Java DataBase Connectivity) pour MySQL. Pour l'utiliser
il faut télécharger l'archive sur le site de MySQL, en extraire le fichier "mysql-connector-java-xxxbin.jar" et l'ajouter dans le répertoire "/lib" de notre projet.
Ce driver va nous permettre de manipuler les requêtes SQL et leurs résultats directement dans le
code de l'application. J'ai donc opté pour cette méthode, car elle correspondait aux contraintes de
mon cahier des charges.
Nous verrons dans une partie suivante comment se connecter à la base de données et manipuler des
requêtes SQL à l'aide de ce driver.
Page 4 sur 10
Tâches asynchrones (AsyncTask)
Présentation
Les AsyncTask permettent de réaliser des opérations de manière asynchrones donc quand on lance
une AsyncTask, elle execute du code en arrière plant.
De ce fait, ont utilise les AsyncTask pour exécuter des opérations qui consomment beaucoup de
ressources (requêtes SQL, calculs, etc.).
Example :
Si on a un calcul lourd à effectuer et qu'on l'exécute dans notre Thread1 principal, il va bloquer notre
application le temps que l'opération se termine. Si l'application reste bloquée trop longtemps, le
système va la fermer et nous afficher un message d'erreur.
Ainsi, en utilisant une AsyncTask, on effectue notre calcul qui est consommateur de ressources dans
un Thread séparé et on fait évoluer le Thread principal en fonction de l'avancement du calcul.
Structure
Une AsyncTask dispose de plusieurs méthodes, voici les principales :
•
onPreExecute : appelée avant le traitement.
•
onProgressUpdate : appelée lorsqu'on souhaite afficher sa progression (example : barre de
chargement de 0% à 100%).
•
doInBackground : réalise le traitement de manière asynchrone dans un Thread séparé.
•
onPostExecute : rppelée après le traitement.
La méthode doInBackground est la seule qui doit obligatoirement être implémentée pour
l'utilisation d'une AsyncTask.
1
Un thread est une unité d'exécution faisant partie d'un programme.
Page 5 sur 10
Utilisation dans le projet
Dans ce projet, j'utilise des AsyncTask pour créer une connexion à la base de données et pour
exécuter mes requêtes SQL.
J'utilise les trois méthodes suivantes :
•
onPostExecute : pour afficher un "ProgressDialog". C'est un chargement circulaire, qui
tourne en boucle (on ne voit pas la progression du traitement en cours), c'est pour cela que je
n'utilise pas la méthode onProgressUpdate.
Example de chargement "PregressDialog" :
•
doInBackground : pour me connecter à la base de données ou exécuter une ou plusieures
reqêtes SQL.
•
onPostExecute : pour désactiver (éteindre) ma fenêtre de chargement et faire réagir
l'application si le résultat du traitement est positif ou au contraire afficher un message
d'erreur.
Page 6 sur 10
Les interfaces graphiques
Présentation
Sur Android les interfaces graphiques sont créées à l'aide de fichiers XML appelés des "layouts".
Chaque fenêtre est ainsi constituée d'un ou plusieurs layouts. Ils sont tous stockés dans le répertoire
"res/layout" de notre projet.
(Quelques layouts du projet)
Structure
Un layout contient le code qui définit le type du layout (linéaire, relatif, ...), la création des
différends composants, leur emplacement sur la fenêtre, leur taille, ...
Exemple : (En vert les commentaires)
<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent" android:layout_height="match_parent">
<--!On définit le type du layout (ici relatif), sa hauteur et sa largeur qui correspondent à la totalité l'écran du
smartphone.-->
<TextView <!--Ici on a créé une zone qui va contenir du texte.-->
android:layout_width="fill_parent" <!--La largeur de cette zone correspond à la largeur de l'écran.-->
android:layout_height="wrap_content" <!--La hauteur va s'adapter à la hauteur de son contenu.-->
android:text="Bonjour" <!--La zone de texte va contenir le mot "Bonjour".-->
android:id="@+id/textView_bonjour" <!--Le nom de la variable (l'identifiant) sera
"textView_bonjour".-->
android:textSize="20dp" <!--La taille du texte sera de 20dp.-->
android:textAlignment="center" <!--Le texte sera au centre.-->
android:layout_centerVertical="true" /> <!--La zone de texte sera placée au centre de l'écran.-->
</RelativeLayout> <!--Ici on referme le layout relatif.-->
Page 7 sur 10
Les activités
Présentation
Sur Android on appelle les fenêtres des activités. C'est la composante principale d'une application
Android, c'est elle qui gère les interactions avec l'utilisateur et implémente notre interface.
Cycle de vie
Une application Android est soumise à un cycle de vie, voici les différentes méthodes appelées lors
des différents états de l'application :
•
onCreate : Elle est appelée au lancement de l'activité. Cette méthode nous permet
d'initialiser toutes les données nécessaires au fonctionnement de notre activité.
•
onStart : Elle est appelée directement après la méthode "onCreate", elle correspond au
début de l'exécution de l'activité (quand elle devient visible à l'écran).
•
onResume : Elle est appelée lorsque notre activité passe au premier plan.
Exemple : si l'application est en pause parce qu'on en a lancé une autre, au moment où on
revient sur notre application (elle repasse au premier plan) la méthode "onResume" est
appelée. On peut donc de nouveau interagir avec.
•
onPause : Elle est appelée lorsqu'une autre activité passe au premier plan. Dans cette
méthode on doit sauvegarder toutes les données saisies par l'utilisateur sur l'activité
courante, car le système peut par la suite décider de mettre fin à l'activité s'il manque de
ressources.
Dans ce cas, le système appelle la méthode "onStop". Dans le cas contraire, si l'application
revient au premier plan, c'est la méthode "onResume" qui sera appelée.
Dans cet état, on peut néanmoins continuer à exécuter des traitements nécessaires tant qu'ils
n'utilisent pas trop de ressources.
•
onStop : Elle est appelée lorsque l'activité n'est plus du tout visible. L'application va être
endormie et les ressources libérées.
Dans cet état, l'utilisateur peut revenir sur l'activité, la méthode "onRestart" sera appelée
pour réveiller l'activité. Ou alors, l'activité n'a plus lieu d'être et la méthode "onDestroy" sera
appelée.
•
onRestart : Elle lance la méthode "onStart".
•
onDestroy : Elle met fin au cycle de vie de l'activité, elle est donc totalement fermée et les
données non sauvegardées sont perdues.
Page 8 sur 10
Schéma du cycle de vie
Voilà le schéma qui décrit le cycle de vie vu précédemment :
Source : https://openclassrooms.com/courses/creez-des-applications-pour-android/votre-premiereapplication-1
Page 9 sur 10
Android Manifest
Présentation
L'AndroidManifest est un fichier "XML", il contient :
•
Une description de l'application (nom, icône, ...).
•
Ses différentes caractéristiques (activité principale, version de l'application, version
minimale nécessaire pour utiliser l'application, ...).
•
Les différentes permissions d'accès au ressources du smartphone (Wi-Fi, internet, capteur
photo, ...).
Structure
Voici un exemple simplifié (en vert les commentaires) d'une partie de mon fichier
"AndroidManifest.xml" :
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.example.gwen.vfacture"> <!--Chemin du package qui contient toutes nos activités, ressources, ...-->
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" /> <!--On demande la
permission d'accéder au réseau internet.-->
<uses-permission android:name="android.permission.INTERNET" /> <!--On demande la permission d'aller sur
internet.-->
<application
android:icon="@mipmap/ic_launcher" <!--On renseigne le chemin de la ressource où se trouve l'icône de
l'application.-->
android:label="@string/app_name" <!--On renseigne le chemin de la ressource où se trouve le nom de
l'application.-->
android:theme="@style/MyMaterialTheme"> <!--On renseigne le chemin de la ressource où se trouve le thème à
utiliser.-->
<activity <!--On déclare une activité.-->
android:name=".LoginActivity" <!--Le nom du fichier qui lui correspond.-->
android:label="@string/title_activity_login" <!--Chemin où se trouve le nom de l'activité.-->
android:screenOrientation="portrait"> <!--L'orientation de l'écran pour cette activité.-->
<intent-filter>
<action android:name="android.intent.action.MAIN" /> <!--C'est notre activité d'entrée (activité
principale).-->
<category android:name="android.intent.category.LAUNCHER" /> <!--C'est cette activité qui va s'afficher
dans notre lanceur d'application.-->
</intent-filter>
</activity>
<activity <!--On déclare une autre activité avec le même procédé que la précédente.-->
android:name=".MenuTriActivity"
android:label="@string/title_activity_menu_tri"
android:screenOrientation="portrait" />
</application>
</manifest>
Page 10 sur 10