Introduction à la programmation sous Android
3 August 2010 par Benbourahla NazimAndroid, c'est quoi ?
Android est un système d'exploitation Open Source pour smartphones, PDA...etc. Conçu par Google, c'est le principal concurrent de Apple avec son Iphone. Android peut aussi équiper des tablettes tactiles, netbooks...etc. Dans ce tutoriel, nous allons apprendre les bases de la programmation à l'aide du SDK Android, la configuration de l'environnement de développement et la réalisation d'un "Hello World".
Composantes d'une application Android
Voici les composantes de base d'une application Android:
Activities (Activités en Français)
Une activité est la composante principale pour une application Android. L'activité est ce qui représente l'implémentation métier dans une application et une vue au minimum. Par exemple dans une application qui liste des utilisateurs, on pourrait avoir une activité qui liste tous les contacts, une autre pour ajouter un contact et une dernière qui affiche les détails d'un contact. Le tout est un ensemble cohérent, mais chaque partie peut fonctionner indépendamment.
Services
Un service, à la différence d'une activité, ne possède pas d'interface graphique mais permet de dérouler un algorithme sur un temps indéfini. Il s'arrêtera lorsque sa tâche est finie ou que son exécution est arrêtée. Il peut être lancé au démarrage du téléphone (arrivée d'un appel, d'un SMS, mail, etc) ou de votre application, soit au cours d'une action particulière dans votre application via un broadcast receivers.
Broadcast and Intent Receivers
Un Broadcast Receiver permet d'écouter ce qui se passe sur le système ou sur votre application et éventuellement de déclencher une action que vous aurez définie. C'est souvent par ce mécanisme que les services sont lancés.
Les "content providers" servent à accéder à un ensemble de données depuis votre application. Vous pouvez par exemple accéder aux contacts, à l'agenda, aux photos et d'autres données depuis votre application grâce aux content providers. Vous pouvez également définir vos propres content providers pour accéder à vos objets ou pour que d'autres applications utilisent vos données.
Cycle de vie d'une application Android
onCreate
Appelée quand votre première activité est créée. Elle sert à initialiser votre activité. Quand OnCreate est appelée, on lui passe un Bundle qui contient l'état de sauvegarde précédent de l'activité s'il existe.
onStart
Appelée juste avant que votre activité passe en avant plan (ne soit visible à l'écran). Si votre activité ne peut pas aller en avant plan pour n'importe quelle raison, l'activité sera transférée à OnStop, sinon elle passe après à OnResume.
onResume
Appelée après OnStart si votre activité est en avant plan, à ce stade de l'exécution votre activité est en cours d'exécution et l'interaction avec l'utilisateur est possible. Vous recevez des entrées par l'écran tactile ou / et le clavier. OnResume est aussi appelée quand votre activité passe en arrière plan à cause d'une autre application.
onPause
Appelée juste avant qu'une autre activité que la votre passe en OnResume. A ce stade, votre activité n'a plus accès à l'écran, vous devez arrêter de faire toutes les actions qui consomment de la batterie ou du CPU. Par exemple si vous affichez une animation, il faut absolument l'arrêter quand on passe en OnPause car plus personne ne peut la voir par contre vous pouvez exécuter des algorithmes qui ne consomment pas beaucoup, comme ça quand votre application repasse en avant plan, le calcul sera déjà effectué mais attention le calcul doit être léger.
onStop
Appelée quand votre activité n'est plus visible, soit parce qu'une autre application à pris l'avant plan ou parce que votre application est terminée.
onDestroy
Appelée juste avant la fermeture de l'activité.
Installer votre environnement de développement.
Installation du SDK Android
- Afin de pouvoir installer le SDK Android il suffit d'aller sur http://developer.android.com/sdk/index.html et télécharger la version du SDK qui convient à votre OS. (Pour cet partie on va supposer que vous êtes sous Windows, pour les autres OS l'installation n'est pas très différente)
- Une fois le SDK téléchargé, allez dans le dossier où se trouve le Zip et l'extraire dans le dossier où vous voulez.
- Lancez l'exécutable "SDK Setup".
- La fenêtre suivante apparait (La dernière version actuelle du SDK est 2.1) :
Choisissez ce que vous voulez installer :
- SDK Platform Android 2.1, API 7 : Correspond tout simplement au SDK Android basique en version 2.1.
- Samples for SDK API 7 : Correspond à quelques exemples
- Android + Google APIs : Correspond au SDK Android (1ère option) + Google Api qui inclut différentes fonctions comme GoogleMap...etc
- Cliquez sur "Install". En cas de problème d'installation, allez dans "Settings" et cochez "Force https://... sources to be fetched using http://..."
Installation du plugin ADT sous Eclipse
Pour commencer il faut :
- Installer Eclipse : http://www.eclipse.org/downloads/ (Téléchargez une version comprenant Java) : Version installée pour ce tutoriel : 3.5 Galileo
- Il faut aussi installer JDK (Java Development Kit) et JRE (Java Runtime Environement) : http://java.sun.com/javase/downloads/index.jsp
- Lancez votre Eclipse, Allez dans le menu "Help and Install New Software"
- Dans la partie "Available Software", cliquez sur "Add"
- Rajoutez le nom du site ("ADT plugin" par exemple). Dans la location rajoutez : https://dl-ssl.google.com/android/eclipse/, puis cliquez sur OK
- Revenez dans "Available Software", vous devez voir "Developer Tools". Sélectionnez-le et appuyez sur "Next"
- Cliquez sur "Next" pour lire et accepter la licence et puis cliquez sur "Finish"
- Pour finir l'installation relancez Eclipse
Voilà votre environnement de développement est prêt.
Configuration de votre environnement de développement
Lancez votre eclipse, un nouvel élément apparaitra dans votre menu :
Cliquez sur l'icône en question (en rouge ci-dessus), une nouvelle fenêtre va apparaitre
Cet écran vous permettra de créer votre émulateur Android et cela grâce à l'onglet "Virtual Devices". Cliquez sur le bouton "New" ; une nouvelle fenêtre pour la création de votre émulateur apparaîtra.
- Name : Le nom que vous souhaitez donner à votre émulateur (sans espace).
- Target : Choisissez la version du SDK Android sur lequel l'émulateur doit fonctionner.
- SD Card : Configuration de la SD Card (Taille...etc). Ce champ est facultatif.
- Skins : Choisissez la taille, résolution...etc de votre émulateur, des émulateurs pré configurés se trouvent dans Built-in
- Hardware : Cette partie permet de rajouter le matériel, et de le personnaliser. Par exemple vous pouvez rajouter un GPS, configurer le clavier, l'accéléromètre...Etc
L'écran suivant devrait apparaitre et votre émulateur s'afficher dans la liste :
Voilà la configuration est terminée.
Mon premier programme sous Android.
Création de mon premier projet "HelloAndro"
Dans éclipse, cliquez sur "File >> New >> Android Project". La fenêtre ci-dessous apparaitra :
Remplissez les champs :
- Project name : Le nom du projet. Pour notre exemple on choisira HelloAndro
- Build Target : Cochez la SDK que vous souhaitez. On prendra Google Apis 2.1
- Properties :
- Application name : Le nom de l'application, ce sera son nom sur votre bureau Android. On choisira Hello Andro
- Package name : Le nom du package principal de l'application. Il faut que ce dernier comporte au moins deux identifiants séparés par des points. On prendra com.mti.android
- Create Activity : Si vous laissez coché, vous devez spécifier un nom. Pour notre exemple, nous utiliserons HelloAndroActivity
- Min SDK Version : Vous pouvez spécifier quelle version minimum du SDK est nécessaire pour que votre application fonctionne correctement. Ce champ est facultatif, pour notre Hello Andro nous allons le laisser vide, ce qui signifie qu'il n'y a pas de version minimum du SDK nécessaire
Explication de l'arborescence du projet
Voici à quoi ressemble l'arborescence du projet "HelloAndro" que l'on a crée précédemment :
|
Nom du Fichier / Dossier |
Utilité / Explications |
| src | Le dossier de source, dans lequel vous mettrez vos packages et votre code Java |
| com.mti.android | Package dont on a demandé la création quand on a crée le projet et qui contient notre principale activité, vous pouvez en créer d'autre. |
| HelloAndroActivity.java | Notre principale activité |
| gen | Dossier qui contiendra le R.java |
| R.java | Ce fichier est automatiquement généré par le SDK Android à chaque compilation, il contient la version java de toutes les ressources (dossier res) que vous avez déclaré. |
| Google APIs (android.jar, maps.jar) | Googles APIs Bibliothèque, elle contient le SDK ainsi que la bibliothèque qui permet d'utiliser Google Map |
| assets | Contient des données qui seront chargées sur le mobile lors de la compilation de votre projet. Cela peut, par exemple, être des fichiers texte décrivant la licence de votre application, des fichiers audio ou vidéo, etc. |
| res | C'est le dossier ressources cité précédemment |
| drawable-hpdi | Contient toutes images, bitmaps dont vous avez besoin pour votre application en haute résolution. |
| drawable-ldpi | Contient toutes images, bitmaps dont vous avez besoin pour votre application en basse résolution. |
| Icon.png | L'icône de votre application, cette icône sera affichée sur le bureau de votre émulateur ou téléphone Android. |
| layout | Le SDK Android offre une technique de création d'interfaces graphiques à l'aide de fichiers XML. C'est dans ce dossier que vous inclurez l'ensemble des fichiers décrivant vos interfaces. |
| Main.xml | Le fichier principal de votre interface. |
| values | Ce dossier contient un ensemble de fichiers décrivant les valeurs (pseudo variable) utilisées par votre application. On peut, par exemple, y mettre des chaines de caractères (strings.xml), des tableaux (arrays.xml), des entiers, des couleurs, etc.... |
| Strings.xml | Fichier qui contient vos déclarations de chaines de caractère. |
| AndroidManifest.xml | Définit le comportement de votre application au système Android. Ce fichier définit par exemple
- Le nom. - L'icône (par défaut - Le thème. - La version minimale du SDK. - Les activités. - Les services ...etc. |
"Hello, Andro !"
Le projet créé représente un "Hello World!". Vous pouvez le lancer en tant qu'une application Android.
L'application prendra du temps à se lancer, plusieurs écrans vont s'afficher.
Voilà le deuxième écran qui devrait s'afficher si tout se passe bien (Le premier est pareil mais avec Android juste écrit)
L'application s'ouvrira automatiquement et vous obtiendrez l'écran suivant :
Notre Hello Word est fonctionnel mais a été créé automatiquement, allons voir le code pour comprendre ce qui se passe.
- AndroidManifest.xml
- La balise manifest à la ligne deux contient plusieurs arguments, le plus important est package, qui donne le nom du package dans lequel se trouve votre main activité.
- La balise application sert à la déclaration de votre application :
- android:icon : L'emplacement où se trouve l'icône de votre application.
- android:label : Le nom de votre application (il se trouve dans strings.xml).
- La balise activity permet de déclarer une activité, à chaque nouvelle activité il faut remettre cette balise
- android:name : le nom de la classe java qui représente l'activité. Le nom doit commencer par un . et on ne met pas le .java a la fin.
- android:label : le label de l'activité en question
- intent-filter : c'est pour spécifier une action.
- la sous balise action est pour spécifier l'action à exécuter, dans notre cas c'est le main
- la sous balise category est là pour spécifier la catégorie de l'action
- Voici un lien qui explique les différents types d'actions et de catégories : http://developer.android.com/guide/topics/intents/intents-filters.html
- strings.xml
<?xml version="1.0" encoding="utf-8"?> <resources> <string name="hello">Hello World, HelloAndroActivity!</string> <string name="app_name">Hello Andro</string> </resources>
- dans les balises resources, on met une balise string à chaque fois que l'on a besoin de déclarer une chaine de caractères.
- on déclare deux chaines :
- La chaine hello qui contiendra "Hello World, HelloAndroActivity!" qui est le message qui sera affiché dans l'application
- La chaine app_name qui contient "Hello Andro" qui représente le nom de l'application
- main.xml
- On dispose de deux modes de visualisation.
- Onglet Layout : Mode visualisation et édition d'interface

- On commence par une balise qui définit le layout : ici LinearLayout.
- Voici un lien pour la liste des différents layout : http://developer.android.com/reference/android/view/ViewGroup.html.
- On déclare une composante TextView pour afficher du texte et on lui dit qu'elle doit afficher le contenu de @string/hello, donc de la variable hello qui est déclarée dans strings.xml c'est-à-dire "Hello World, HelloAndroActivity!".
package com.mti.android; import android.app.Activity; import android.os.Bundle; public class HelloAndroActivity extends Activity { /** Called when the activity is first created. */ @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); } }
- Notre main activité. Elle doit hériter de la classe Activity ou d'une sous classe de cette dernière
- http://developer.android.com/reference/android/app/Activity.html
- La méthode "OnCreate" est équivalente au main
- On appelle simplement le OnCreate de la classe mère puis on initialise la vue. Puis, on met dedans R.layout.main, c'est-à-dire la vue déclarée dans le fichier main.xml
/* AUTO-GENERATED FILE. DO NOT MODIFY. * * This class was automatically generated by the * aapt tool from the resource data it found. It * should not be modified by hand. */ package com.mti.android; public final class R { public static final class attr { } public static final class drawable { public static final int icon=0x7f020000; } public static final class layout { public static final int main=0x7f030000; } public static final class string { public static final int app_name=0x7f040001; public static final int hello=0x7f040000; } }
- Vous ne devez pas toucher à ce fichier, il est géneré automatiquement à partir de vos fichiers qui se trouvent dans le dossier des ressources (res).
- Vous remarquez que toutes les variables déclarées dans strings.xml sont présentes, que l'interface déclarée dans main.xml aussi (Ce qui explique l'utilisation de la ligne R.layout.main dans le HelloAndroActivity.java) ainsi que l'icône de l'application.
Conclusion
Voilà le tutoriel s'arrête là. En espérant qu'il vous aura aidé à comprendre comment fonctionne le SDK Android ainsi qu'à commencer la programmation Android. D'autres tutoriels plus avancés devraient suivre.
Tags: android, Developpement Android, eclipse ADT Android, Hello World Android, Introduction à la programmation Android, Programmation Android, SDK Android, Tutoriel Android









4 October 2010 à 20:39
Super tutoriel, qui ma beaucoup aidé
16 October 2010 à 18:08
Génial, cet article est extraordinaire !!!!
20 October 2010 à 3:01
Cet article est très intéressant, et ma beaucoup apporté !
Je le recommande à tous !
25 November 2010 à 23:20
Je vous remercie pour cet article.
Il est très consistant et performant pour les débutants.
27 November 2010 à 18:47
Merci pour ce tuto qui aide beaucoup le débutant que je suis dans la programmation Android.
Mais j’ai un problème : si tout se passe comme prévu et que les différents fichiers sont bien identique à ceux de ce tuto, l’emulateur se lance mais reste à sa page “menu” sans ouvrir l’application qui n’apparait pas non plus dans les appli installées du téléphone simulé.
Je suis sous Intel core I7 et vista 64b.
Après avoir détecté le PB j’ai installé Java jdk 32 et 64b (je n’avais que les jre), mais sans succès.
La console d’Eclipse me donne les infox suivantes :
“[2010-11-27 16:12:40 - HelloAndro] ERROR: Unable to open class file N:\Android\TravailEclipse\HelloAndro\gen\com\mti\android\R.java: No such file or directory
[2010-11-27 16:17:34 - HelloAndro] ——————————
[2010-11-27 16:17:34 - HelloAndro] Android Launch!
[2010-11-27 16:17:34 - HelloAndro] adb is running normally.
[2010-11-27 16:17:34 - HelloAndro] Performing com.mti.android.HelloAndroActivity activity launch
[2010-11-27 16:17:34 - HelloAndro] Automatic Target Mode: launching new emulator with compatible AVD ‘AndroidEmulator’
[2010-11-27 16:17:34 - HelloAndro] Launching a new emulator with Virtual Device ‘AndroidEmulator’
[2010-11-27 16:25:44 - Emulator] emulator: warning: opening audio input failed”
Je pense que l’erreur de 16h12 vient du fait que je n’avais pas encore compilé ???
Si quelqu’un a une idée, un grand merci d’avance
27 November 2010 à 20:17
Complément de ma question précédente :
Si j’utilise directement les commandes du sdk en ligne de commande, j’obtiens aussi une erreur :
N:\Android\Develop\android-sdk-windows\tools\adb install HelloAndro.apk
error: device not found
Alors que j’ai bien copié le fichier apk dans tools… et qu’il est bien reconnu par la commande DIR
J’espère que ces questions sont bien à leur place sur ce blog, sinon toutes mes excuses et avez vous une idée ou je pourrais les poser ?
28 December 2010 à 20:14
Si cela peut aider quelqu’un, j’ai résolu mon problème et voilà comment.
Après lecture des docs « Android developers », et l’anglais fut dur pour moi…
J’ai réussi à lancer mon programme sur l’émulateur en utilisant uniquement les tools du sdk en ligne de commande : emulator, adb, et ant.
Mais après essai de nouveau infructueux sur Eclipse, mon émulateur n’était plus visible non plus en ligne de commande (par adb devices) LA RAGE…
En fait il faut tuer le serveur adb par la commande « adb kill-server » et alors « adb devices » retrouve l’émulateur, et tout redevient correct en ligne de commande. YES
Sous Eclipse j’ai donc appliqué la même méthode : je tue le serveur adb en ligne de commande et je lance le run sous Eclipse : c’est OK.
En fait je pense que mes différents essais sous Eclipse et en ligne de commande interféraient entre eux par l’intermédiaire des tools du jdk.
Par contre je n’ai toujours pas trouvé comment tuer le serveur adb à partir d’Eclipse, mais ce n’est pas très génant.
Bon, maintenant que les outils fonctionnent je vais enfin m’apprendre à programmer…