Pratique Android Cadre de développement

1.3 Gestion d'une application

1. Un premier projet...
Il est temps maintenant d'écrire la véritable première application Android avec l'inévitable affichage du mot
bonjour, ce qui évidemment pour un développement d'essence anglo-saxonne se traduit par Hellow
World...

Rappel : on suppose la bonne installation du SDK 2.3.3 (API 10) et d'un AVD de type Nexus S correspondant
avec l'image système ARM EABI v7a et le SDK 2.2 (installé) comme base minimale.

 Lancez un émulateur « à vide » de type Nexus S, celui lié au SDK 2.3.3 par l'AVD Manager

• Processus de création d'une application

La méthode classique de création d'un projet Android sous Eclipse passe le menu général :

 Cliquez sur File → New → Android Application Project

Une variante : on peut, par un clic droit de la souris dans le cadre Package Explorer aboutir au même
résultat.

 Au niveau de la fenêtre de création, renseignez les éléments suivants :

✗ Application Name : Premier test

✗ Project Name : PremierTest
✗ Package Name : org.chamedu.premiertest
✗ Minimum Required SDK : API 8: Android 2.2 (Froyo)
✗ Target SDK : API 10: Android 2.3.3 (Gingerbread)
✗ Compile Width : API 17: Android 4.2 (Jelly Bean)
✗ Theme : None

Le nom du paquetage représente l'identifiant (qui doit être unique) dans le Market Android car une
application Android est destinée normalement à être publiée, qu'elle soit payante ou gratuite. La structure
conventionnelle du nom (en minuscules et sous forme d'arborescence) se définit par :

– org pour les organisations non-commerciales (ou com : principe commercial intrinsèque du Market
Android)
– chamedu : identifiant de l'organisme/entreprise émetteur
– premiertest : nom donné au projet (reprise du nom sans espace ni majuscules)

 Après Next, décochez la case Create custom launcher icon (on garde celle par défaut) puis à
nouveau Next

 Laissez les renseignements par défaut sur une BlankActivity (les autres sont incompatibles avec ce
niveau de SDK), puis Next

 Terminez avec Finish sur le dernier écran avec une navigation de type None

• Structure d'un projet Android

Vous disposez dans Eclipse de toute la structure d'un projet pour Android :

Page 1 sur 6
 Pratique Android Cadre de développement

Explications (partielles) :

– src : sources JAVA du projet

– gen : sources générées à partir des ressources XML
– Android 4.2 : sources au format JAR de l'API utilisée pour la
compilation
– assets : dossier contenant des fichiers statiques destinés à
l'application
– res : ressources XML de l'application

Plus spécialement, ce dernier répertoire contient :

– les répertoires drawable-* avec les icônes de l'application

– le répertoire layout avec le fichier XML décrivant l'interface en
relation avec la classe JAVA (pour l'instant uniquement
activity_main.xml)
– le répertoires values avec le fichier strings.xml contenant des
variables réutilisables globalement au programme et styles.xml
pour le thème

Pour finir, il reste le fichier AndroidManifest.xml qui décrit l'application et ses composants, permissions,
etc... et le fichier project.properties, fichier utilisé par le fichier XML avec par exemple la cible ou
version du SDK pour la compilation.

• Lancement de l'application

D'ores et déjà l'application est opérationnelle et l'on peut la voir grâce à l'émulateur... Mais avant de la lancer,
une pratique simple permet d'éviter de lancer une émulateur non désiré :

 Positionnez-vous sur la ligne Test dans le cadre Package Explorer

 Choisissez par un clic droit, la ligne Run As , Run Configurations

 Par l'onglet Target, choisissez Always prompt to pick device puis validez par le bouton Apply
et enfin Run

 Choisissez alors l'émulateur adéquat, celui qui est déjà lancé soit ici le NexusS_A233 :

Page 2 sur 6
 Pratique Android Cadre de développement

L'inévitable « Hello world ! » s'affiche :

Notes :

– L'appui sur la touche ronde représentant une flèche retournant sur la gauche fait revenir à l'écran
principal
– L'appui sur le launcher d'applications apparaître une série d'icônes ou celle s'intitulant Premier
test représente évidemment votre application
– Le lancement de l'application au sein d'Eclipse correspond à l'installation de cette même application
sur le téléphone mobile, ici représenté par l'émulateur.

Dans les sources JAVA, la deuxième méthode du fichier MainActivity.java crée un menu par défaut :

@Override
public boolean onCreateOptionsMenu(Menu menu) {
// Inflate the menu; this adds items to the action bar if it is present.
getMenuInflater().inflate(R.menu.activity_main, menu);
return true;
}

Son fonctionnement se vérifie par l'appui de la touche MENU de l'émulateur. Apparaît alors la dénomination
Settings (Paramètres) définie dans l'arborescence par le sous-répertoire menu et par le fichier de
description xml activity_main.xml :

<menu xmlns:android="http://schemas.android.com/apk/res/android" >

<item
android:id="@+id/menu_settings"
android:orderInCategory="100"
android:title="@string/menu_settings"/>
</menu>

Page 3 sur 6
 Pratique Android Cadre de développement

Note : cette référence à cette ressource se retrouve dans la méthode par R.menu.activity_main et sera
vue plus en détail dans la prochaine partie.

2. L'application et son environnement

• Le principe d'une activité Android

La première chose à garder en mémoire

est que, Android ou pas, vous évoluez sur
un téléphone... Cela implique plusieurs
choses :

- une mémoire plutôt faible par

rapport à un ordinateur, ce qui
obligera à libérer les ressources
utilisées
- des événements à priorités
supérieures à votre application,
ce qui oblige une cycle de vie
particulier
- une programmation
événementielle et non linéaire

Schématiquement, et fournit par l'API

Google), voici le cycle de vie d'une activité
avec on le voit les méthodes normalement
présentes :

Source : http://developer.android.com/reference/android/app/Activity.html

Ce cycle de vie s'apparente (un peu) à celui d'une applet JAVA. Suffisamment explicite, le schéma montre
une succession d'états logiques de l'activité avec notamment la boucle onRestart lorsque l'activité a été
mise en pause à cause d'un événement prioritaire (exemple : un appel téléphonique) et qui la relance après
un arrêt forcé.

On peut compléter cette introduction sur les activités en ajoutant un classement par type suivant :

– activité au premier plan, c'est à dire en interaction avec l'utilisateur

– activité en arrière-plan, c'est à dire d'un fonctionnement autonome
– activité sans interface graphique (GUI) comme par exemple un service

Si vous regardez le code dans Eclipse (fichier MainActivity.java), une seule méthode semble être
obligatoire : la méthode onCreate(). En fait c'est la seule qu'il soit nécessaire de redéfinir (surcharge en
JAVA).

La classe MainActivity hérite de l'objet Activity, activité standard Android. La méthode onCreate
comporte :

– en paramètre un gestionnaire d'états de type Bundle avec savedInstanceState pour sauver

l'état associé de l'instance de l'activité
– l'appel au constructeur parent (avec la sauvegarde de l'instance)
– le lancement de l'application par le positionnement de la vue
Page 4 sur 6
 Pratique Android Cadre de développement

Par défaut cette vue utilise le layout ou conteneur de base activity_main.xml (répertoire res,
layout, fichier activity_main.xml, onglet inférieur activity_main.xml) :

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
tools:context=".MainActivity" >

<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_centerHorizontal="true"
android:layout_centerVertical="true"
android:text="@string/hello_world" />

</RelativeLayout>

Les définitions XML montrent l'utilisation d'un conteneur de type RelativeLayout, concrètement structure
de présentation de l'activité et d'un label de nom TextView.

On peut :

– soit définir statiquement les éléments dans une ressource XML

– soit définir dynamiquement les représentations des contrôles dans le code Java

En règle générale, c'est la première solution qui prévaut. La deuxième se rencontre lorsque l'on veut
dynamiquement créer une vue à l'instar des pages Web dynamiques. Il ne faut pas cependant oublier la
gestion des ressources, plutôt réduite sur un téléphone portable...

3. Utilisation du Logcat
• LogCat : le journal de l'émulateur

Indépendamment de la perspective Debug, cadre particulier pour la mise au point de programme sous
Eclipse, le développeur sous Android ne se sert pas vraiment de la console d'exécution pour la simple et
bonne raison que son application s'exécute sur l'émulateur et non sur le poste lui-même.

Les messages de l'émulateur par son journal se trouve dans l'onglet Logcat (cadre du bas). Vous avez aussi
la possibilité de les voir en passant par la perspective DDMS ou (si vous les « perdez ») :

 Par les menus Window / Open Perspective / DDMS (Dalvik Debug Monitor Server ou cadre spécifique
Android pour le débogage d'application)

Les niveaux d'alertes diffèrent avec verbose | debug | info | warn | error | assert suivant
que l'on désire plus ou moins d'informations.

Premier conseil : effacez régulièrement le journal et ce juste après le démarrage d'une application car
l'exécution produit beaucoup de messages... (icône représentant un texte à droite avec une petite croix
rouge)

Deuxième conseil : pour faire apparaître des informations spécifiques dans le LogCat (à la manière d'un
System.out.println en mode console) utilisez le code Log.i ou i représente une information.

Page 5 sur 6
 Pratique Android Cadre de développement

 A titre d'exemple, placez le code ci-dessous à la suite de la ligne setContentView dans la méthode
onCreate() du fichier MainActivity.java de l'activité de test précédente :

Log.i("Test", "Voici l'information");

La mise en place de cette ligne entraîne l'apparition d'une erreur (Log cannot be resolved). Pour la
résoudre, il faut importer la librairie adéquate :

 Utilisez la combinaison de touches <Ctrl> + <Shift> + O

 Validez par défaut l'importation proposée (ici android.util.log)

 Effacez le journal par la touche LogCat Clear Log (à droite, avec un x rouge)

 Lancez ou relancez l'application, votre message apparaît dans le LogCat :

A la place du message, on peut évidement mettre à la place une variable afin d'en afficher sa valeur.

• Une utilisation pratique du LogCat

Le LogCat va nous permettre de démontrer le cycle de vie d'une application Android. On a donc six
méthodes suivant le schéma vu plus haut :

– onCreate(Bundle savedInstanceState)
– onStart()
– onResume()
– onPause()
– onStop()
– onDestroy()

Les méthodes sont du type protected, avec appel de la méthode parente dans le cas d'une surcharge.

Exercice :

 Insérez chacune des cinq méthodes avec à chaque fois deux lignes : la première pour l'affichage d'un log
donnant le nom de la méthode, la deuxième faisant appel au constructeur parent (sans paramètre, à la
différence de onCreate)

 Lancez l'application ; quelles sont les méthodes appelées ?

 Fermez l'application ; quelles sont cette fois les méthodes appelées ?

Page 6 sur 6