Explication sur Mon premier programme
Voici enfin les explications sur ce que vous avez fait dans le projet HelloWorld:
Principes généraux
Avant de commencer à détailler les fichiers qui ont été générés, voici les principes généraux de fonctionnement d'une application Android:
D'abord que veut faire l'utilisateur d'un appareil sous Android ?
Prenons le cas d'un utilisateur qui veut prendre une photo: Il se dit "je veux prendre une photo". Ce qui se traduit sous Android par "j'ai l'intention de lancer une activité spécialisée dans la prise de photo".
Ce que veut donc faire un utilisateur de façon générale, c'est lancer une activité qui répond à son intention du moment.
Pour un développeur, cela se traduira donc par:
- développer des activités, une activité qui restera très spécialisée pour faire une chose très spécifique. D'où la nécessité de faire plusieurs activités pour traiter de façon globale ce que veut faire un utilisateur (c'est l'application, qui rassemble une ou plusieurs activités).
- Déclarer un fichier de configuration qui recense l'ensemble de ses activités pour l'application. Pour chacune des activités, le développeur précisera des filtres d'intentions afin qu'Android sâche à quoi peuvent servir ses activités et ainsi pouvoir proposer à l'utilisateur l'activité correspondant au mieux à son intention...du moment.
...du moment, ce qui signifie que selon l'humeur de l'utilisateur, ses intentions peuvent changer. Une activité peut en effet être stoppée pour pouvoir en lancer une autre. C'est le cas par exemple, avec notre utilisateur qui voulez prendre une photo. Après avoir pris cette photo, il peut avoir l'intention de voir le résultat. Il faut donc mettre en pause temporairement l'activité prise de photo et lancer une activité "visualisation de la photo prise".
L'utilisateur pourra enfin mettre fin à toutes les activités ou revenir à la précédente pour continuer ce qu'il faisait. Les activités ont donc un état qui variera dans le temps (en fonctionnement, mis en sommeil ou mort). Une activité suit donc un cycle de vie que le développeur devra prendre en compte.
Maintenant que les idées principales sont données, voici les explications:
Les fichiers générés
- Première fichier important, à la racine de votre projet, le fichier de ressources AndroidManifest.xml qui contient actuellement ceci:
- le nom de package que vous avez saisi lors de la création de votre projet,
- des informations sur votre application comme l'icone (paramètre android:icon) ou le titre (paramètre android:label) de celle-ci,
- la version actuelle de votre application,
- le SDK minimum avec lequel votre application fonctionnera (Dans mon exemple ci-dessus, j'avais indiqué 10 pour android 2.3.3): <uses-sdk android:minSdkVersion="10" />
- Eventuellement le target SDK (la version avec laquelle votre application a réellement été testée). Par contre, vous pouvez oublier Max. sdk puisqu'il doit y avoir compatibilité ascendante...,
- et surtout, ici, une seule activité (déclaré dans
la balise activity) avec un filtre d'intentions (intent-filter) qui indique
qu'il s'agit du point d'entrée de l'application (action android:name...MAIN)
et qu'elle sera lancée lorsque l'utilisateur va appuyer sur l'icone
représentant l'application (category...LAUNCHER).
Par la suite, vous pourrez avoir une liste plus ou moins longue d'activités dans ce fichier pour votre application. Pour ces activités, seront définies un ou des filtres d'intentions par activité. Ce qui permettra à Android de connaître l'activité à lancer pour répondre au mieux à l'intention de l'utilisateur. Les filtres d'intentions étant un sujet assez vaste et compliqué pour ne pas en parler plus tout de suite !
Vous trouverez la
correspondance des versions SDK et des systèmes android sur http://developer.android.com/guide/appendix/api-levels.html#fc
et comment gérer ces versions dans votre
application.
Le fichier est assez simple pour le moment. Mais vous pourrez trouvez des fichiers AndroidManifest.xml bien plus importants: des déclarations de receivers, services ou encore des permissions utilisées par l'application (permissions qui seront présicées à l'utilisateur lors de l'installation de votre application, afin que celui sache à quelles ressources l'applications pourra faire appel).
- Les sources
Lors de la création du projet, vous avez indiqué un nom de package. Celui-ci a été créé sous src de votre projet et contiendra dans cet exemple un fichier .java qui doit normalement se nommer HelloWorldActivity.java. Il s'agit du code généré automatiquement lorsque vous avez demandé de créer une activité.
Pour rappel:
- Les ressources
Il existe un autre répertoire tout aussi important, il s'agit de res pour "resource". Si vous regardez son contenu, vous y trouverez des fichiers .xml.
Les plus importants des xml seront layout/main.xml et values/strings.xml.
Toujours dans le répertoire res, vous trouverez des répertoires drawable (sufixés en h pour hight, m pour medium et l pour low dpi, ...). D'autres répertoires drawable peuvent être créés:-small (écrans QVGA basse densité), -normal écrans par défaut) -large (écrans large). Il s'agit tout simplement des répertoires contenant les images de votre application dans différentes résolutions.
Ici, une image qui sera l'icone qui représentera votre application. Cette image se retrouve sous différentes résolutions de la plus haute à la plus basse. Ce nom d'image étant aussi déclaré dans le fichier androidmanifest.xml sous la section application pour le paramètre android:icon. Le choix de l'icone étant dépendant de la résolution graphique de l'appareil qui lancera l'application. Mais rassurez vous, c'est Android qui se dépatouille pour afficher l'icone la plus adaptée à la résolution de l'appareil !
Le programme JAVA
Première chose qui choque par rapport à ce que l'on connait en JAVA, c'est qu'il n'y a pas de main ! En fait, vous avez indiqué le programme à lancer en stipulant dans le projet Create Activity le nom de votre classe.
Il n'y a
donc pas de 'main' dans le code. La déclaration de l'activité
principale à lancer se fait dans le fichier AndroidManifest.xml
vu précédemment. Il contient le nom de la classe qui doit démarrer
votre application sous la forme android:name=".Nomclasse" (ou NomClassse
est le nom de votre classe se terminant généralement par Activity)
avec sous la balise <intent-filter> un élément (ces fameux
filtres d'intentions dont je parlais précédemment) qui indique
qu'il s'agit de la classe principale ou point d'entrée de l'application
via l'attribut action android:name=”android.intent.action.MAIN".
Risque de
problème, si vous faîtes un refactor sur votre classe (si vous
la renommer), le fichier AndroidManifest.xml ne sera pas forcement mis à
jour (suivant vos manipulations). Sans modification de votre part, le système
ne sait plus quel instance de classe lancer pour votre application sur votre
appareil ou émulateur et vous obtiendrez
dans le log quelque chose comme ceci:
02-16 22:13:38.563: E/AndroidRuntime(578): at android.app.ActivityThread.performLaunchActivity(ActivityThread.java:1561)
02-16 22:13:38.563: E/AndroidRuntime(578): ... 11 more
En plus d'un message peu parlant vous demandant de forcer l'arrêt du programme (soit un bon vieux Sigkill sur votre processus...).
La classe Activity
Une application peut avoir plusieurs activités. Une activité est la plus petite entité d'une application qui va effectuer des actions. L'utilisateur ne pourra cependant accéder qu'à une activité à la fois. Généralement, on simplifie la définition de l'activité à: une activité correspond un écran de l'application (évidemment, il ne faut pas prendre cette phrase à la lettre, d'autant plus comme vous le verrez plus tard avec les tablettes qui ont de grands écrans peuvent permettre de multiplier les activités).
Une activité pourra être lancée depuis votre application mais aussi par n'importe quelles autres applications via l'intention passée à Android et suivant les filtres d'intentions que vous aurez indiqué.
La classe HelloWorldActivity est donc simplement une extension de la classe Activity.
Lorsque Dalvik lance l'application Hello World, il va instancier la classe HelloWorldActivity. Puis il exécute une méthode onCreate pour initialiser (car en fait, déjà créé) cette activité. Il restera à redéfinir cette méthode pour lancer la méthode standard de création de l'activité et initialiser ensuite tout ce dont vous aurez besoin.
TextView
Dans cette activité, vous trouverez un textView...
Il s'agit d'un objet permettant d'afficher du texte que vous allez mettre à l'écran (par défaut en haut à gauche). Vous allez utiliser un setter pour lui indiquer le texte à afficher, puis demandez l'affichage de cet objet à l'écran via setContentView.
setContentView
L'activité aura besoin d'interagir avec l'utilisateur (ici pour afficher notre beau message de bienvenue). Le dessin de la vue est fait dans un fichier XML: main.xml, expliqué plus loin. Cette méthode va permettre d'interpréter le contenu de ce fichier XML.
Les fichiers XML
Hé oui, c'est du JAVA, vous n'allez donc pas échapper à ces fichiers XML, ces fichiers de ressources, pour configurer vos applications !
Le fichier strings.xml
Celui-ci se trouve sous res/values de votre projet.
Il contient pour le moment ceci:
Avec app_name qui est tout simplement le nom de l'application saisi lors de la création du projet et qui est affiché dans la barre de titre. Il suffit donc de changer la valeur par un autre titre pour que votre application change de nom.
Et Hello qui est ... Tien, c'est quoi ???
Il s'agit d'une chaîne de caractères qui sera utilisée dans le code. En fait, le fichier strings.xml sert dans le cas d'un usage internationale de votre application.
A savoir que ce fichier
est exploité par défaut s'il n'existe pas d'autres fichiers correspondant
à la langue utilisée sur l'appareil.
Ici, pour que cela soit facilement compréhensible, j'ai volontairement modifié le code JAVA qui a été généré par Eclipse afin d'afficher un texte d'une façon plus traditionnelle, càd en mettant du texte en dur dans le code JAVA, mais sans toucher aux autres fichiers qui ont été générés. La propriété hello n'est donc plus utilisée dans ce code...
Mais, si vous avez compris l'idée générale de ce code, revenons donc au code initialement généré par Eclipse et utilisons la ressource strings.xml:
Lancez le et...le code fait la même chose ou pratiquement, car celui-ci affiche Hello World, HeloWorldActivity!
Miraculeux ! Non, pas vraiment. Vous aurez donc compris que la propriété hello est utilisée quelque par pour afficher le texte à l'écran. N'oublions pas que vous êtes dans un repertoire de ressources. En principe, il ne faut jamais mettre de texte en "dur" dans du code. Le fichier strings.xml permet donc de regrouper tous ces textes. Facilitant ainsi la maintenance, ...
Mais comment cela marche ? Et bien la suite devrait mieux vous faire comprendre ce qui se passe !
Le fichier main.xml (ou main_activity.xml - suivant les versions de dev)
Le fichier main.xml est dans le répertoire res/layout (soit conteneur en français). Ce conteneur étant affiché à l'écran, il contient donc tout ce qui sera affiché sur le portable. Double cliquez sur ce fichier et...l'écran suivant s'affiche:
Déjà, super, il existe un émulateur sous eclipse capable d'afficher le contenu de main.xml comme si vous étiez sur portable ! Cependant, ne criez pas trop vite hourra, car hélas, il n'est pas très pratique. Et vous le constaterez rapidement lorsque vous ferez des écrans un peu complexes !
Vous constatez à gauche qu'il existe quelques widgets qu'il suffira de déposer simplement sur l'écran, ce qui mettra à jour automatiquement le fichier ! Super !
Mais pour comprendre ce qui se passe, double clique sur l'émulateur ou clique en bas sur main.xml
Cette fois-ci, Eclipse affiche le contenu du fichier main.xml...c'est beaucoup plus austère, je sais:
Sans entrer dans les détails, vous constatez effectivement une balise TextView qui a une propriété text utilisant une annotation: @string/hello càd votre fichier strings.xml avec la propriété hello...D'où le texte affiché à l'écran.
Pour utiliser le fichier main.xml comme layout, il reste à indiquer dans le setContentView le fichier main.xml du répertoire layout...Bon d'accord, l'écriture est assez étrange...
En fait, lorsque vous allez générer le code binaire de votre projet, il y aura génération d'une nouvelle classe nommée R.java dans le répertoire 'gen' sous votre projet et dans les sous-répertoires représentant le package que vous aurez défini pour votre projet. Si vous regardez ce qu'il y a dedans, vous constaterez des références à main, app-name et hello. Cette classe reprend donc les informations de vos différents fichiers XML.
D'où le R.layout.main pour indiquer le fichier main.xml sous layout.
Vous trouverez aussi différents classes R$ générées dans le répertoire 'bin' dans les sous répertoires de votre package...
Fichiers .apk, .dex, ...
Sous bin, vous ne trouverez pas un fichier .jar, mais un fichier .apk qui est équivalant au jar mais pour android. En effet, il ne faut pas oublier que vous ne lançez pas votre application JAVA dans une JVM, mais dans Dalvik, une sorte de JVM pour android.
Il sera donc possible, tout comme un jar, d'ouvrir ce fichier sous Winzip, 7Zip, ou autres utilitaires équivalent:
Dedans se trouve un répertoire META-INF, un répertoire res avec les images et le fichier main.xml et à la racine le fichier AndroidManifest.xml ainsi qu'un étrange fichier .dex. Il s'agit en fait de l'exécutable pour Dalvik (Dalvik EXecutable). Ce qui est important de noter, c'est que contrairement à JAVA où pour tous les fichiers .java il y a génération d'un fichier .class correspondant, ici toutes les classes se retrouveront dans un seul et même fichier DEX. De plus, le bytecode JAVA n'est pas le même que celui de Dalvik (on parlera de Dalvik bytecode).
A noter que le fichier .dex est bien généré à partir des fichiers .class (donc les exécutables JAVA) mais ceux-ci sont traités d'abord par un outils nommé dx qui transforme le bytecode JAVA en bytecode Dalvik. En gros, il s'agis de recoder les fichiers class de java pour qu'ils prennent encore moins de place sur l'appareil qui peut être très limité en taille mémoire par rapport à un ordinateur.
Voilà pour l'idée générale.
Et ensuite...
Il y a encore d'autres répertoires. Si vous voulez en savoir plus, c'est par là !
Pour les explications plus détaillées sur les TextView, ... il faut lire les chapitres suivants !