De Java à Android

Formation de Java à Android, tutoriel & guide de travaux pratiques en pdf.

1ère application

Nous allons créer notre 1ère application, pour cela, dans Eclipse, dans le menu « File » choisissez « New » -> « Project »
Sélectionnez alors « Android Project », puis cliquez sur « Next > », une autre fenêtre apparaît :
Complétez le champ « Project name : » avec le nom de votre projet (pour nous cela sera « ex2.1 »). Dans « Build Target »: choisissez Android 2.2 (ou plus si un SDK plus récent est sorti !) Dans « Properties » :
« Application name: » : comme son nom l’indique, donnez un nom à votre application
« Package name » : ici, c’est un peu plus compliqué. Imaginez que vous décidiez d’écrire une application qui porte le nom de « Toto », tellement fier de votre oeuvre, vous publiez votre application sur l’Android Market. Mais à l’autre bout du monde (en Australie par exemple, mais bon, cela n’a aucune importance !) Mr Smith, décide lui aussi de publier une application « Toto » (mais qui, à part le nom, n’a aucun rapport avec la vôtre) : Problème ?
Pas vraiment, car, en théorie, vos 2 applications n’auront pas le même « Package name ». Un package name a, en général (mais ce n’est pas une obligation), la forme suivante : org.education.lgf.atelier
Oui, votre première impression est la bonne, cela ressemble beaucoup a une adresse internet à l’envers. A la place de « org », vous auriez pu mettre « fr » ou « com ». Notre package name indique que notre application à un rapport avec l’éducation, avec le lycée G Fichet (lgf) et avec l’atelier scientifique.
Il y a très peu de chances pour que notre ami australien, Mr Smith, ait le même package name. Nos applications pourront donc être distinguées.
La case « Create Activity » doit être cochée, vous devrez donner un nom à votre activité dans le champ qui suit.

Mais, qu’est-ce qu’une activité ?

L’activité (Activity) est l’unité de base des applications sous Android. Pour résumer (un peu brutalement), nous allons dire qu’à un écran correspond une activité (et vice versa). Si une application se compose de plusieurs écrans, en général, on aura une activité pour chaque écran. Une activité est une classe qui étend la classe de base « Activity », nous aurons donc un « extends Activity »
Nous appellerons ici notre activité « Principale ».
Enfin, laissez le champ « Min SDK Version » vide (pour l’instant).
Cliquez sur « Finish », vous venez de créer votre premier projet Android, félicitations ! (en cas d’erreur, fermez et redémarrez Eclipse)

Étude de la première application

Observons attentivement la fenêtre « Package Explorer » d’Eclipse
Eclipse a créé une arborescence (complexe), dans un premier temps, nous allons uniquement nous intéresser à 2 fichiers : « Principale.java » et « main.xml »
Double cliquez sur « Principale.java », vous devriez alors obtenir ceci :
Double cliquez sur « main.xml », vous devriez obtenir ceci :
Comme vous avez pu le remarquer, un projet Android créé par Eclipse n’est pas une coquille vide, il y a déjà du code Java dans le fichier « Principale.java » et XML dans le fichier « main.xml ». Nous allons nous baser sur ce code, écrit par défaut lors de la création d’un projet Android sous Eclipse, pour essayer de comprendre les bases du développement d’applications sous Android.
Par souci de simplification, vous allez légèrement modifier le fichier « main.xml » en remplaçant à la dixième ligne android:text= »@string/hello » par android:text= »Salut à toi ! »
Testez ce projet en cliquant sur « Run » dans le menu « Run » d’Eclipse. Après une attente plus ou moins longue (je vous conseille de ne pas fermer l’émulateur entre 2 tests), et après avoir déverrouillé le « téléphone », vous devriez obtenir ceci :
Commençons par étudier le fichier « main.xml »
Ex 2.1 main.xml
<?xml version= »1.0″ encoding= »utf-8″?>
<LinearLayout xmlns:android= »http://schemas.android.com/apk/res/android »
android:orientation= »vertical »
android:layout_width= »fill_parent »
android:layout_height= »fill_parent »
>
<TextView
android:layout_width= »fill_parent »
android:layout_height= »wrap_content »
android:text= »Salut à toi ! »
/>
</LinearLayout>
Ce fichier va nous permettre de définir l’interface graphique de votre application (les boutons, les textes, les images……). Pour tout vous dire, il est aussi possible de coder cette interface en java, mais nous n’aborderons pas cette possibilité dans ce cours.
Étudions en détail ce fichier:
<?xml version= »1.0″ encoding= »utf-8″?>
Rien à signaler, c’est le prologue
De Java à Andoid 22
<LinearLayout xmlns:android= »http://schemas.android.com/apk/res/android »
android:orientation= »vertical »
android:layout_width= »fill_parent »
android:layout_height= »fill_parent »
>
Nous ouvrons une balise nommée « LinearLayout ». Qu’est-ce qu’un LinearLayout ?

Un LinearLayout est un layout, mais qu’est ce qu’un layout ?

Pour répondre à cette question, je pourrai vous renvoyer vers le chapitre 6 de « D’Alice à Java », mais pour résumer, un layout est un conteneur qui va accueillir vos boutons, images, champs de texte,… bref tout ce que l’on appelle des widgets.
Il existe plusieurs types de layout, nous utilisons ici le plus courant le « LinearLayout ».
Le choix du type layout (et des attributs qui lui sont associés) est très important, car c’est lui qui « gère » le positionnement des widgets (bouton, champ de texte,…) sur l’écran.
Nous reviendrons plus en détail dans le prochain chapitre, qui se nomme d’ailleurs « layouts et widgets » (nous expliquerons alors les attributs « orientation », « layout_width » et « layout_height » de la balise ouvrante LinearLayout).
La suite du fichier main.xml :
<TextView
android:layout_width= »fill_parent »
android:layout_height= »wrap_content »
android:text= »Salut à toi ! »
/>
Entre la balise ouvrante et fermante du LinearLayout, nous allons placer des widgets. Ici, nous allons placer un seul widget : TextView. La balise est à la fois ouvrante et fermante.
Comme son nom l’indique, TexView permet d’afficher du texte à l’écran (plus précisément le texte attribué à « text » : text= »Salut à toi ! »)
Comme pour les layouts, nous reviendrons en détail sur les widgets (notamment sur les attributs « layout_width » et « layout_height ») dans le prochain chapitre.
Enfin pour terminer, la dernière ligne du fichier main.xml ne devrait pas vous poser de problème, c’est la balise fermante du LinearLayout.
Passons maintenant à l’étude du fichier « Principale.java »
package org.education.lgf.atelier;
import android.app.Activity;
import android.os.Bundle;
public class Principale extends Activity {
/** Called when the activity is first created. */ @Override
public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main);
}
}
Passons sur les imports et le package, qui sont obligatoires quelque soit votre projet Android (« import android.app.Activity » permet d’utiliser la classe « Activity », « import android.os.Bundle » permet d’utiliser un objet de type « Bundle » comme paramètre de la méthode « onCreate »).
public class Principale extends Activity {
Avec cette ligne nous créons une classe qui se nomme « Principale » (notez que c’est le nom donné à notre activité) qui hérite de la classe Activity.
Je reviendrai un peu plus loin sur le : @Override
public void onCreate(Bundle savedInstanceState) {
« onCreate » est une des méthodes de la classe Activity. Nous avons donc ici affaire à une redéfinition de la méthode « onCreate » (si vous avez besoin de vous rafraîchir la mémoire sur cette notion de redéfinition, consultez le chapitre 5 du document « d’Alice à Java »). A ce propos, nous pouvons maintenant revenir sur le @Override :
Le @override n’est pas vraiment une instruction Java, c’est une annotation.
Avec « onCreate », nous avons bien affaire à une redéfinition pas à une surcharge (nous avons dans les 2 méthodes « onCreate » (celle de la classe parente « Activity » et celle de la classe qui hérite d’Activity, « Principale »), un seul paramètre : une instance (qui se nomme « savedInstanceState ») de la classe « Bundle », nous reviendrons dessus un peu plus loin). Si par hasard, sans le vouloir, en modifiant le nombre ou le type de paramètres de la méthode « onCreate », vous ne faites plus une redéfinition, mais une surcharge, votre programme ne fonctionnera pas normalement, mais comme aucune véritable erreur n’aura était commise, aucun message ne sera renvoyé par le compilateur. @override, évite ce genre de chose : en mettant cette annotation, vous « dites » au compilateur : »Attention, la méthode qui suit (« onCreate » dans notre cas) est une redéfinition, pas une surcharge, si un petit malin s’amuse à faire une surcharge, il faudra lui dire ! ». @override n’est pas obligatoire, mais fortement conseillé !
L’instance « savedInstanceState » de la classe « Bundle » permet de retrouver votre activité dans l’état où vous l’avez laissé. Oui, je sais, ce n’est pas très clair, mais ce n’est pas fondamental pour comprendre la suite, je ne chercherai donc pas à insister là-dessus. Nous nous contenterons de dire que la méthode « onCreate » doit recevoir un objet de type « Bundle » comme paramètre, vous devriez pouvoir vous en sortir uniquement avec cela !
super.onCreate(savedInstanceState);
Ici nous appelons la méthode « onCreate » définie au niveau de la classe parente, « Activity » (toujours avec l’objet de type « Bundle », « savedInstanceState » comme paramètre).
J’attire votre attention sur le fait que la méthode « onCreate » de la classe « Activity » est une méthode
qui comporte sans doute plusieurs dizaines (voir centaines ?) de lignes. Grâce à la ligne
super.onCreate(savedInstanceState);, tout se passe comme si ces dizaines de lignes étaient
insérées dans notre redéfinition de la méthode « onCreate ». Mais « la magie » de la POO permet de ne pas s’en préoccuper.

Mais que fait cette méthode « onCreate » ?

Pour faire simple (nous préciserons les choses dans le chapitre « Cycle de vie d’une activité » dans la 2ème partie), la méthode « onCreate » sera la première méthode exécutée au moment du lancement de notre activité « Principale ».
setContentView(R.layout.main);
« setContentView » est une méthode static de la classe « Activity » (donc ici aussi de la classe « Principale » puisque « Principale » hérite d' »Activity »).
Quelle est le rôle de cette méthode « setContentView » ?
Vous avez sans doute remarqué les mots « layout » et « main » dans le paramètre passé à cette méthode « layout » correspond au répertoire layout de l’arborescence de notre projet Android, « main » correspond au fichier qui se trouve dans ce répertoire layout, c’est-à-dire le fichier « main.xml » que nous avons étudié un peu au-dessus.
Cette méthode indique au système qu’il faudra utiliser le fichier main.xml se trouvant dans le répertoire layout pour « fabriquer » l’interface graphique de notre activité.
En fait les choses sont un peu plus compliquées que cela (avec notamment la présence de ce mystérieux « R »), mais pour l’instant, nous nous contenterons de cette explication : pour indiquer au système que nous voulons utiliser l’interface graphique définie dans le fichier « toto.xml » (ce fichier se trouvant dans le répertoire « res/layout » de l’arborescence de notre projet), il suffira d’écrire :
setContentView(R.layout.toto);

La documentation du SDK

Pour terminer ce chapitre, quelques mots sur la documentation officielle du SDK.
Ce document n’a pas la prétention de faire de vous des pro d’Android, il est même très probable qu’un jour ou l’autre, il ne vous suffira plus pour pouvoir poursuivre votre progression. Vous pourrez alors acheter des livres (je donne une liste d’ouvrage à la fin de ce document), mais il sera aussi très judicieux de consulter la documentation officielle du SDK sur internet (on la trouve aussi « offline » dans le répertoire d’installation du SDK) : http://developer.android.com/sdk/index.html
Vous trouverez sans doute votre bonheur dans cette documentation officielle (en anglais, mais cela ne devrait pas vous poser de problème ;)) . N’hésitez pas à la parcourir dès maintenant pour vous familiariser avec.
J’attire particulièrement votre attention sur l’onglet « Reference » qui référence toutes les classes et toutes les méthodes disponibles.
Vous avez ci-dessus la documentation de la méthode « setContentView ».
Même si cela vous paraît un peu rébarbatif au départ, astreignez-vous à consulter cette documentation à chaque fois que nous rencontrerons une nouvelle méthode.

chapitre I Introduction et installation
chapitre II Première application
chapitre III Les layouts
Chapitre IV Les widgets
chapitre V Les listeners
chapitre VI Les intents