Magmatique

Allez, on va se faire un prog Android de base afin de s'initier. Se sera juste une appli qui, lorsqu'on clique sur un bouton affichera bonjour. Je me suis inspiré d'autres tuto afin de rédiger celui-ci car j'avais la flemgme d'écrire sur le sujet. Je ne suis pas calé sur le sujet et je suis loin d'avoir tout compris. Mais, j'avais envie de faire un ptit effort pour ceux qui seraient intéressés. Allez, on commence.

Android
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. Il est basé sur un noyau Linux. Google fournit un kit de développement très simple d'utilisation et très complet s'appuyant sur la plateforme Java. Il comprend plusieurs bibliothèques, un débogueur, un profileur, un émulateur et des exemples de code pour pouvoir démarrer. Par contre, l'utilisation du langage C est fortement déconseillée sur ce système car Android utilise une bibliothèque C non standard (on peut s'en sortir avec GCC) et Google ne supporte officiellement pas cette voie.

Dans ce tutoriel, nous allons apprendre les bases de la programmation à l'aide du SDK Android. Pour cela, on va configurer notre environnement de développement en ligne de commande afin de réaliser notre première application : Le fameux "Hello World" sur Android. Avant, essayons de comprendre en
quoi consiste la programmation sur Android.

Voici les composantes de base d'une application Android

Activities (Activités en Français)
La brique de base de l’interface utilisateur s’appelle activity (activité). C'est l’équivalent Android de la fenêtre ou de la boîte de dialogue d’une application classique. Une activité est la composante principale pour une application Android. Elle 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.

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 notre application, soit au cours d'une action particulière dans notre application via un broadcast receivers.

Il existe deux types de services :

• LocalService : Services qui s’exécutent dans le même processus que votre application.
• RemoteService : Ils s’exécutent dans des processus indépendants de votre application.

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.

Content providers
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.

Suivant

Cycle de vie d'une application Android

onCreate - L'activité est en cours de création
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 - L'activité est sur le point de devenir visibles
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 - L'activité est devenue visible (il est maintenant «repris»)
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 - Une autre activité a pris le focus (cette activité est en passe d'être "pause")
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 - L'activité n'est plus visible (il est désormais «arrêté»)
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 - L'activité est en passe d'être détruites
Appelée juste avant la fermeture de l'activité.

Précédent   Suivant

Pour construire notre projet, il faut avant tout installer l'environnement Java et Android SDK.

Installation du SDK

Commençons par télécharger le SDK pour Linux sur le site d'Android :

http://developer.android.com/sdk/index.html

Puis décompressons le tout dans un dossier à la racine de notre "home" et installons les composants supplémentaires qui nous permettrons d'exécuter les diverses commandes de base tel que "adb",
"fastboot", etc...

Ensuite, il nous faut sélectionner les composants à installer (SDK Platform-tools revision xx, Documentation, SDK Platform Android 3.x ..., et les composants tiers, en fonction du matériel pour lequel nous souhaitons développer) et choisir "Install Selected". Cela peut prendre un peu de temps.
Editons notre fichier ~/.bash_profile ou ~/.bashrc file et recherchons une ligne qui définit la variable d’environnement PATH puis ajoutons y le chemin absolu vers tools/ de notre répertoire SDK. Si aucune ligne n’est présente, vous pouvez ajouter :

Autre méthode : Tout en restant dans le répertoire "tools", mettons ensuite à jour la variable d'environnement PATH pour accéder au programme du SDK :

Ces commandes ajoutent le chemin courant (pwd) au PATH et permettent d'exécuter les binaires qui se trouvent dans "android-sdk-linux_x86/tools" et "android-sdk- linux_x86/platform-tools.

Ensuite mettez à jour le SDK :

Il vous faudra alors mettre à jour la liste des paquets et choisir ceux que vous voulez installer. Les paquets appelés "Target" correspondent à la version d'Android cible (1.5, 1.6, 2.0...) sous laquelle vous souhaitez développer.

Ensuite, plus loin il nous faudra configurer des machines virtuelles (AVD) afin de tester l'exécution de notre programme dans différents environnements.

Créons notre project

android create project On crée notre projet

--target ? (version du SDK Android sur lequel l'émulateur doit fonctionner.

--name (Le nom de notre projet. Paramètre optionnel. S’il est spécifié, ce sera le nom du paquet “.apk” généré ultérieurement)

--path chemin/vers/mon/projet (il sera créer s'il n'existe pas)

--activity NomDeMonActivitée (nom de la composante principale de notre application Android)

--package com.monActivité.android (Le nom du package principal de l'application qui doit comporter au moins deux identifiants séparés par des points)

Voici les dossiers et fichiers crées dans le dossier de notre projet :

AndroidManifest.xml est un fichier XML qui décrit l’application à construire et les composants, activités, services, etc..., fournis par celle-ci.
build.xml est un script Ant1 permettant de compiler l’application et de l’installer sur le terminal (ce fichier n’est pas présent avec un environnement de programmation adapté, tel Eclipse).
default.properties ou local.properties sont des fichiers de propriétés utilisés par le script précédent.
src/ ce dossier contient les sources de notre application.
Com/monActivité/android/notre activité principale : dossiers de notre application.
Hello.java : notre principale activité.
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 inclurons l'ensemble des fichiers décrivant nos interfaces (main.xml).
main.xml : le fichier principal de votre interface.
values/ ce dossier contient un ensemble de fichiers décrivant les valeurs utilisées par notre application. On peut, par exemple, y mettre des chaînes de caractères (strings.xml), des tableaux (arrays.xml), des entiers, des couleurs, etc.
Strings.xml : fichier qui contient nos déclarations de chaînes de caractères.
Gen/ dossier qui contiendra le fichier R.java (ce fichier est généré automatiquement à partir de nos vues et fichiers de ressource).
R.java : ce fichier est automatiquement généré par le SDK Android à chaque précompilation.
assets : contient des données qui pourront être utilisées dans notre application (images, vidéos, licence, etc.).
res/ c'est le dossier qui contiendra les ressources de notre application (images, vidéos, styles).
drawable-hpdi/ contient toutes les images, bitmaps dont nous avons besoin pour notre application en haute résolution.
drawable-ldpi/ contient toutes les images, bitmaps dont nous avons besoin pour votre application en basse résolution.
drawable-mdpi/ contient toutes les images, bitmaps dont nous avons besoin pour notre application en moyenne résolution.
Icon.png : l'icône de notre application, cette icône sera affichée sur le bureau.

Précédent  Suivant

Comme son nom l’indique, un AVD (Android Virtual Device), est un terminal virtuel par opposition aux vrais terminaux Android. Les AVD sont utilisés par l’émulateur fourni avec le SDK et nous permettent de tester nos programmes avant de les déployer sur les véritables terminaux. Nous devez indiquer à l’émulateur un terminal virtuel afin qu’il puisse prétendre qu’il est bien le terminal décrit par cet AVD.

Créons notre AVD

Lançons la commane suivante :

Le manager de SDK se lance et charge les mises à jours des versions disponibles. Une fois que notre choix est fait, on clique sur Tools pour configurer nos AVD et on arrive sur la fenêtre suivante :

J'ai installé la version 1.5 et 1.6 seulement pour l'exemple de ce tuto. On clique sur New pour configurer notre phone virtuel :

On y met les renseignements suivants :

Ensuite, on valide en cliquant sur Create AVD et on e retrouve sur la fenêtre précédente. On clique sur Start et notre téléphone virtuel se lance.

Une méthode plus rapide sans passer par la fenêtre SDK manager serait de lancer en ligne de commande:

qu'on lancerait par la commande :

et on aurait le même résultat.

Précédent  Suivant

On se place dans notre Projet et on ouvre les fichiers suivants :

– AndroidManifest.xml (racine de notre projet)
– Hello.java (notre_projet/src/com/monActivite/Android/)
– main.xml (notre_projet/res/layout/)
– strings.xml (notre_projet/res/values/)

On modifie le fichier Hello.java de cette façon :

J'y ai inclus les 6 états, onCreate() , onStart(), onResume(), onPause(), onStop() et onDestroy() pour se faire une idées de leur emplacements.

(setContentView(R.layout.main) Lorsque l'application est lancée (onCreate), le contenu main sera affiché. Pour être plus précis, (R.layout.main) va afficher le contenu qui est défini dans le fichier R.java sous la classe Layout qui s'identifie par le nom main. Ce main définissant la page xml main.

Les Intents sont des objets permettant de faire passer des messages contenant de l’information entre composants principaux. La notion d’Intent peut être vue comme une demande de démarrage d’un autre composant, d’une action à effectuer. La raison d’être des Intents provient du modèle de sécurité d’Android. Chaque application est en effet sandboxée. Cela veut dire qu’une application A ne peut accéder aux données d’une application B. Grâce aux Intents, les applications ont la possibilité de fournir leurs services ou données si elles le souhaitent.

On crée un deuxième Hello.java que l'on nommera Hello2.java :

On modifie notre fichier main.xml de cette façon :

On crée un deuxième main.xml que l'on nomme main2.xml :

Ensuite, on modifie notre fichier string.xml de cette façon :

On termine en modifiant notre fichier AndroidManifest.xml de cette façon :

Construire notre appli.apk en mode Debug.

Pour tester une application, on peut passer par le mode débogage et l'installer directement sur notre émulateur. On va pour cela utiliser le mode debug.

On ouvre une ligne de commande et on accède à la racine de notre projet. On utilise Ant pour compiler notre projet en mode debug (Le Android SDK utilise Ant pour automatiser la compilation des projets. C’est une alternative orientée Java à Makefile. )

Cela crée à l'intérieur du dossier /bin, un packet nommé <le_nom_de_notre_projet>-debug.apk. Le fichier est en quelque sorte signé avec une clé de débogage et a été optimisé avec zipalign dont j'expliquerai l'usage plus tard.
Chaque fois que l'on modifie un fichier source ou de ressources, on doit exécuter Ant à nouveau afin de mettre à jour l'application.

On lance notre AVD si on l'a éteint auparavant :

On clique sur l'onglet gris au dessus du menu :

 On peut voir notre projet Activité principale en haut à gauche.  On clique dessus :

Voilà notre 1ère interface de notre main.xml.

On clique sur le bouton comme il nous est spécifié :

Et voilà notre 2ième interface de notre main2.xml. Notre programme s'est bien déroulé.

Précédent