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 :
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 :
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>
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
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.
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 ?
