Android, c’est quoi ?

Android est un OS mobile Open Source pour smartphone, PDA, MP3 et tablette. Conçu initialement par Android Inc. Android a été racheté par Google en 2005.

Pour commencer la programmation Android, il faut d’abords installer le SDK Android et comprendre les bases de la programmation sous Android. Puis nous allons faire notre premier programme sous Android c’est-à-dire le bien connu “Hello Word” pour bien comprendre ces bases.

Composantes d’une application Android

Une application Android est composée d’éléments de base :

Activities (Activités en Français)

Une activité est la composante principale pour une application Android. Elle représente l’implémentation et les interactions de vos interfaces.

Prenant l’exemple d’une application qui liste toutes les images présentes dans votre téléphone, le projet pourrait se décomposer comme çi-dessous :

  • Une vue pour afficher la liste des images.
  • Une activité pour gérer le remplissage et l’affichage de la liste.
  • Si l’on veut pouvoir rajouter, supprimer des images, on pourrait rajouter d’autres activités.

Services

Un service, à la différence d’une activité, ne possède pas de vue mais permet l’exécution d’un algorithme sur un temps indéfini. Il ne s’arrêtera que lorsque la tâche est finie ou que son exécution est arrêtée.

Il peut être lancé à différents moments :

  • Au démarrage du téléphone.
  • Au moment d’un événement (arrivée d’un appel, SMS, mail, etc…).
  • Lancement de votre application.
  • Action particulière dans votre application.

Broadcast and Intent Receivers

Un Broadcast Receiver comme son nom l’indique permet d’écouter ce qui se passe sur le système ou sur votre application et déclencher une action que vous aurez prédéfinie. C’est souvent par ce mécanisme que les services sont lancés.

Content providers

Les “content providers”servent à accéder à des données depuis votre application. Vous pouvez accéder :

  • Aux contacts stockés dans le téléphone.
  • A l’agenda.
  • Aux photos.
  • Ainsi que d’autres données depuis votre application grâce aux content providers.

Cycle de vie d’une application Android

onCreate

Cette méthode est appelée à la création de votre activité  (Activity). Elle sert à initialiser votre activité ainsi que toutes les données nécessaires à cette dernière.

Quand la méthode OnCreate est appelée, on lui passe un Bundle en argument. Ce Bundle contient l’état de sauvegarde enregistré lors de la dernière exécution de votre activité.

onStart

Cette méthode est pour signifié le début d’éxecution de votre activité (début du passage au premier plan).

Si votre activité ne peut pas aller en avant plan quelque soit la raison, l’activité sera transférée à OnStop.

onResume

Cette méthode est appelée après OnStart (au moment où votre application repasse en foreground). à la fin de l’appel à la méthode onResume votre application se trouve au premier plan et reçoit les interactions utilisateurs.

onPause

Si une autre activité passe au premier plan, la méthode onPause est appelée sur votre activité. Afin que vous sauvegardiez l’état de l’activité et les différents traitements effectués par l’utilisateur.
A ce stade, votre activité n’a plus accès à l’écran, vous devez arrêter de faire toute action en rapport avec l’interaction utilisateur (désabonner les listeners). Vous pouvez par contre continuer à exécuter des algorithmes nécessaires mais qui ne consomment pas trop de CPU.

onStop

Appelée quand votre activité n’est plus du tout visible quelque soit la raison. Dans cette méthode vous devez arrêter tous les traitements et services exécutés par votre application.

onDestroy

Appelée quand votre application est totalement fermée (Processus terminé). Toutes les données non sauvegardées sont perdues

Installer votre environnement de développement.

Installation du SDK Android

  1. Pour commencer allez sur le lien suivant : http://developer.android.com/sdk/index.html et téléchargez la version du SDK qui convient à votre OS. (Pour la suite on est sur un Mac).
  2. Une fois le SDK téléchargé, allez dans le dossier où se trouve le fichier zip et l’extraire dans le dossier de votre choix.
  3. Installer Eclipse : http://www.eclipse.org/downloads/ (Téléchargez une version comprenant Java, Soit la version pour les développeurs Java ou la version pour les développeurs J2EE) : Version installée pour ce tutoriel : 3.6.1 Helios.
  4. Il faut aussi installer JDK (Java Development Kit) et JRE (Java Runtime Environement) si c’est pas déjà fait : http://java.sun.com/javase/downloads/index.jsp.
  5. Maintenant, il faut installer le plugin ADT (Android Developpment Tools) permettant d’intégrer l’environnement de développement Android dans Eclipse
  6. Lancez votre Eclipse, Allez dans le menu “Help and Install New Software”
  7. Dans la partie “Available Software”, cliquez sur “Add”.
  8. Rajoutez le nom du site (“ADT plugin” par exemple). Dans la location rajoutez : https://dl-ssl.google.com/android/eclipse/, puis cliquez sur OK.
  9. Revenez dans “Available Software”, vous devez voir “Developer Tools”. Sélectionnez-le et appuyez sur “Next”.
  10. Cliquez sur “Next” pour lire et accepter la licence et puis cliquez sur “Finish”.
  11. Pour finir l’installation relancez Eclipse.

Voilà votre environnement de développement est prêt à être utilisé.

Configuration de votre environnement de développement

Vous avez dû remarquer que six petites icones sont apparues dans le menu du haut d’eclipse dans le menu du haut :

  • Permet de lancer le SDK Manager afin de mettre à jour les différents SDK et outils installés ou installer de nouvelles versions
  • Permet de lancer un outil servant à gérer les différents émulateurs d’un appareil
  • Permet d’utiliser l’outil Android Lint (qui sera présenté dans le chapitre …).
  • Permet de créer un nouveau projet Android
  • Permet de créer un nouveau projet de test Android
  • Permet de créer un fichier XML Android

Cliquez sur la premiére icône (SDK Manager), une nouvelle fenêtre va apparaître

Cet écran vous permettra de :

  • Installer de nouvelle version du SDK ou d’outils.
  • Mettre à jour des versions ou des outils.

Pour commencer, installer le contenu d’Android 4.0.3 et 4.1.

La deuxième icone, vous permet de créer et gérer des émulateurs :

Pour créer un nouvel émulateur, cliquez sur le bouton “New”

  • Name : Le nom de votre émulateur (sans espace).
  • Target : Version du SDK Android de l’émulateur.
  • SD Card (Facultatif) : Configuration de la SD Card (Taille…etc).
  • Skins : Choisissez la taille, résolution de votre émulateur. Des émulateurs pré-configurer se trouve dans la partie Built-in.
  • Hardware : Cette partie permet de rajouter le matériel spécifique à votre émulateur. Par exemple vous pouvez rajouter un GPS, configurer le clavier, l’accéléromètre, etc…

L’émulateur apparaîtra maintenant dans la liste des émulateurs disponibles.

Maintenant on va passer à la partie la plus intéressante.

Ma première application sous Android

Création du projet “Hello World”

Dans éclipse, cliquez sur l’icone permettant de créer un nouveau projet (présenté dans la partie précédente).
La création de projet s’effectue en suivant 3 écrans :

  • Le premier permet de spécifier de nom de l’application (Application Name), le nom du projet (Project Name – affiché uniquement dans Eclipse), le nom du paquet (Package Name – Utilisé comme identifiant de l’application sur Google Play).
  • Ainsi que la version du SDK utilisé pour développer l’application et la version minimum permettant de faire fonctionner correctement l’application.
  • Vous pouvez aussi créer l’icone de votre application dans l’écran suivant et cela en laissant la case “Create Custom Icon Launcher” cochée

Puis cliquez sur “Next”, le prochain écran permet de créer l’icone de l’application

Puis cliquez sur “Next”, afin d’arriver sur l’écran vous permettant de choisir un template de départ pour votre application. Choisissez l’option “Blank activity afin de créer une nouvelle activité vide”, puis cliquez sur “Next”.

Le dernier écran permet de configurer les spécificités de l’activité qui sera créé :

  • Nom de l’activité
  • Nom de la vue representant l’activité
  • Type de navigation choisi dans l’application (Tabulation, Tabulation + Scroll, Scroll avec un titre sur chaque page – Exemple de Google Play, Dropdown sur la barre d’action – Exemple de l’application Gmail)
  • La classe mère de l’activité à creer (Activity par défaut)
  • Titre de l’activité

Puis cliquez sur Finish pour terminer. Le projet “Hello World” va maintenant apparaître dans l’arborescence d’eclipse.

Explication de l’arborescence du projet

Voici le résultat de la création de votre projet et l’arborescence de ce dernier

  • src : Ce dossier contient les sources de votre application (code JAVA) et les packages.
    • com.tuto.android.helloworld : un package de votre application. Bien sûr vous pouvez avoir plusieurs packages dans votre application.
    • HelloWorldActivity.java : Notre principale activité.
  • gen : Dossier qui contiendra les fichiers R.java (ce fichier est généré automatiquement à partir de vos ressource) et BuildConfig.java (permettant de gérer l’affichage des logs uniquement pendant les phases de développement et tests et non dans la version finale. Ce qui réduit les interactions entre votre application et l’appareil).
    • R.java : Ce fichier est automatiquement généré par le SDK Android à chaque pré-compilation.
    • BuildConfig.java: Sera automatiquement mis à jour lors de la création de la version finale de l’Apk afin de desactive les logs.
  • assets : Contient des données non internationalisées qui seront utilisées dans votre application (images, vidéos, licence…etc).
  • res : C’est le dossier qui contiendra les ressources de votre application (images, vidéos, styles).
    • drawable-xxx : Contient vos images dans les différentes résolutions (basse, moyenne, haute et trés haute).
    • ic_launcher.png : L’icône de votre application.
    • layout-xxx : 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. Vous pouvez créer d’autres dossiers pour les menus par exemple. Vous pouvez créer différents dossier en fonction de l’orientation, la taille de l’écran et la version d’Android …etc
    • activity_hello_world.xml : Le fichier principal de votre interface.
    • values : Ce dossier contient un ensemble de fichiers décrivant les valeurs (pseudo variables) 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, … Vous pouvez créer différents dossier en fonction de l’orientation, la taille de l’écran (values-large) et la version d’Android (values-v11 et values-v14) …etc
    • strings.xml : Fichier qui contient vos déclarations de chaines de caractères.
    • dimens.xml : Contient toutes les dimensions utilisées dans votre application. Ces dimensions seront surchargés pour les écrans larges (values-large) afin de prendre en compte l’espace disponible
    • styles.xml : Représente le thème par défaut utilisé par votre application. Le thème sera surchargé pour les appareils tournant sous Android 3.0 (values-v11) et 4.0 (values-v14) afin de prendre en compte le nouveau théme Holo
  • AndroidManifest.xml : Définit le comportement de votre application au système Android. Ce fichier définit par exemple (Le nom, l’icône, la version min du SDK, les activités, les services, etc…).

“Hello, World!”

Le projet exemple créé ar eclipse représente un “Hello World!”. Vous pouvez le lancer en tant qu’une application Android (Pour cela, il vous suffit de cliquer droit sur le projet, puis sélectionner l’option « Run As -> Android Application ») et la l’émulateur devrait se lancer.. L’émulateur prendra un peu de temps à se lancer la première fois (ne le fermez pas entre vos différentes modifications).

Le lancement du projet donnera les résultats suivants :
Sur un appareil android 2.3 :

Sur un appareil Android 4.0.3 :

Vous pouvez remarquer que le style de l’application est différents entre les deux appareils (absence de la barre d’action) cela est dû à la surcharge du thème pour les versions 11 et 14.

Notre Hello Word est bien fonctionnel mais reste encore à le comprendre. Allons voir le code pour comprendre ce qui se passe.

  • AndroidManifest.xml
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.tutos.android.helloworld"
    android:versionCode="1"
    android:versionName="1.0" >

    <uses-sdk
        android:minSdkVersion="8"
        android:targetSdkVersion="15" />

    <application
        android:icon="@drawable/ic_launcher"
        android:label="@string/app_name"
        android:theme="@style/AppTheme" >
        <activity
            android:name=".HelloWordActivity"
            android:label="@string/title_activity_hello_word" >
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>
</manifest>
  • 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 activité principale. Les deux autres attributs représente la version du code de l’application (versionCode – non visible à l’utilisateur) ainsi que la version de l’application (versionName – visible sur Google Play)
  • La balise “application” sert à la déclaration de différentes propriétés 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).
    • android:theme=”@style/AppTheme” : Spécifier le thème utilisé par votre application. Ce thème pointe vers le style AppTheme declaré dans le fichier styles.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 à la fin.
    • android:label : le label de l’activité en question
    • intent-filter : c’est pour spécifier une action.
  • strings.xml
  • <resources>
    
        <string name="app_name">Hello World</string>
        <string name="hello_world">Hello world!</string>
        <string name="menu_settings">Settings</string>
        <string name="title_activity_hello_word">HelloWord</string>
    
    </resources>
    
  • dimens.xml
  • <resources>
    
        <dimen name="padding_small">8dp</dimen>
        <dimen name="padding_medium">8dp</dimen>
        <dimen name="padding_large">16dp</dimen>
    
    </resources>
    
    • Représente la taille des différentes marges internes utilisées dans l’application
    • Ces marges sont surchargées pour les grands écrans dans le dossier values-large.
    • <resources>
      
          <dimen name="padding_small">8dp</dimen>
          <dimen name="padding_medium">16dp</dimen>
          <dimen name="padding_large">16dp</dimen>
      
      </resources>
      
  • styles.xml
  • <resources>
    
        <style name="AppTheme" parent="android:Theme.Light" />
    
    </resources>
    
    • Représente le thème appliqué par l’application
    • Par défaut, le thème appliqué correspond au thème clair Android par défaut
    • Le thème utilisé est surchargé pour les versions 3.0 et 4.0 d’android afin d’utiliser les différents thème Holo introduit dans ces versions (vous pouvez remarquer la présence d’une barre d’action dans ce thème ce qui explique sa présence lors de l’exécution sur un appareil tournant sous Android 4)
    • <resources>
      
          <style name="AppTheme" parent="android:Theme.Holo.Light.DarkActionBar" />
      
      </resources>
      


  • activity_hello_world.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" >
    
        <TextView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_centerHorizontal="true"
            android:layout_centerVertical="true"
            android:padding="@dimen/padding_medium"
            android:text="@string/hello_world"
         />
    
    </RelativeLayout>
    
    
    • On dispose de deux modes de visualisation.
      • Onglet Graphical Layout : Mode visualisation et édition d’interface.
      • Onglet activity_hello_world.xml : mode code source
    • On commence par une balise qui définit le layout : ici RelativeLayout.
    • Voici un lien pour la liste des différents layout : http://developer.android.com/reference/android/view/ViewGroup.html. Un tutoriel sur le RelativeLayout est disponible à cette adresse : http://www.tutos-android.com/comprendre-relativelayout-android
    • On déclare une composante TextView pour afficher du texte et on lui indique la chaine de caractère à afficher : @string/hello_world, donc de la variable hello_world qui est déclarée dans strings.xml.
    • Le texte est centré verticalement et horizontalement
    • On utilise les marges internes déclarées dans le fichier dimens.xml
    • Chaque élement doit posséder une autre et une largueur correspond à la taille de son contenu (wrap_content).


  • HelloWorldActivity.java
package com.mti.android;

import android.app.Activity;
import android.os.Bundle;

public class HelloWordActivity extends Activity {
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_hello_word);
    }
}
  • Notre activité principale 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 est appelée à la création de votre vue.
  • On appelle simplement le OnCreate de la classe mère puis on initialise la vue en utilisant la méthode setContentView. Cette méthode prends en argument l’interface à charger (ici R.layout.activity_hello_word).
  • A chaque fois que vous voyez “R” , c’est à dire que l’on utilise du code qui a été généré par les différents fichiers xml de ressource.
  • “R.layout” : On va chercher la vue déclarée dans le dossier layout et qui s’appelle activity_hello_worddonc notre activity_hello_word.xml
  • R.java
  • /* 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.tutos.android.helloworld;
    
    public final class R {
        public static final class attr {
        }
        public static final class dimen {
            public static final int padding_large=0x7f040002;
            public static final int padding_medium=0x7f040001;
            public static final int padding_small=0x7f040000;
        }
        public static final class drawable {
            public static final int ic_action_search=0x7f020000;
            public static final int ic_launcher=0x7f020001;
        }
        public static final class id {
            public static final int menu_settings=0x7f080000;
        }
        public static final class layout {
            public static final int activity_hello_word=0x7f030000;
        }
        public static final class menu {
            public static final int activity_hello_word=0x7f070000;
        }
        public static final class string {
            public static final int app_name=0x7f050000;
            public static final int hello_world=0x7f050001;
            public static final int menu_settings=0x7f050002;
            public static final int title_activity_hello_word=0x7f050003;
        }
        public static final class style {
            public static final int AppTheme=0x7f060000;
        }
    }
    
    • Vous ne devez pas toucher à ce fichier, il est généré 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 HelloWorldActivity.java) ainsi que l’icône de l’application.

    Conclusion

    Voilà on s’arrête ici pour ce premier tutoriel, d’autre tutoriels vont suivre très prochainement et aborderont des sujets plus approfondis

Categories: Tutoriels

72 Responses so far.


  1. Mario Cayer dit :

    Ce tutoriel fonctionnait très bien dans les anciennes versions du SDK. Pour ma part, la dernière version (22.6) où on a ajouté les layouts Fragments et modifié le MainActivity.java ne fonctionne plus pour la plupart des tutoriels. Est-il possible de faire un tuto semblable à celui-ci mais avec la dernière version?
    Le fait d’afficher un simple Hello_world fonctionne mais aussitôt que l’on y ajoute un bouton ou autre vue avec des listening, ça ne fonctionne plus.

    Pourriez-vous m’éclairer?
    Un simple tutoriel qui change affiche un Toast ou qui change de vue (fragment) au click d’un bouton me remettrait sur la bonne voie.

  2. [...] Introduction à la programmation sous Android [...]

  3. EGSC dit :

    [...] des interfaces graphiques sous Android. Ce tutoriel nécessite la lecture du tutoriel présentant le développement sous Android. La création d’interfaces est indispensable lors de la conception d’une application dédiée [...]

Leave a Reply


Notifiez-moi des commentaires à venir via email. Vous pouvez aussi vous abonner sans commenter.