Développement Android

Développement pour Android
version support : 1.9

antislashn.org Android - Objectifs 0 - 2/7
Objectifs
● Présenter la plateforme Android
● Utiliser l'environnement de développement Android
avec Eclipse
● Présenter les composants d'une application
Android
● Créer une application Android
● Présenter certaines fonctionnalités avancées de la
plateforme Android

Chapitres
1.Présentation de la plateforme
2.Les outils de développement
3."Hello, world" expliqué
4.Architecture et développement d'une application
5.Composants graphiques de base
6.Les intentions
7.Les activités
8.ListView
9.Autres composants graphiques
10.Les menus

Chapitres
11.Les notifications
12.Persistance de données
13.Les services
14.Les fournisseurs de contenu
15.Le BroadcastReceiver
16.Les processus et threads
17.Les applications widgets
18.Les fragments
19.Graphisme
20.Gestion de équipements
21.Géolocalisation et Google Map

Annexes
A.Publier avec Google Play
B.Développer en code natif : le NDK
C.Input Method Editor
D.Persistance avec OrmLite

copyleft
Support de formation créé par
Franck SIMON
http://www.franck-simon.com

copyleft
Cette œuvre est mise à disposition sous licence
Attribution
Pas d'Utilisation Commerciale
Partage dans les Mêmes Conditions 3.0 France.
Pour voir une copie de cette licence, visitez
http://creativecommons.org/licenses/by-nc-sa/3.0/fr/
ou écrivez à
Creative Commons, 444 Castro Street, Suite 900,
Mountain View, California, 94041, USA.

antislashn.org Android - Présentation de la plateforme 1 - 1/15
Présentation de la plateforme
Android

Matériels sous Android

Généralités
● Android est issu du travail d'une startup
● racheté par Google en 2005
● Création le 7 Novembre 2007 de l'OHA
● Open Handset Alliance
● consortium créé par Google réunissant des acteurs du
marché de la mobilité
– constructeurs, opérateurs en téléphonie, éditeurs de logiciels
● annonce officielle de la plateforme Android le même
jour
● sortie du premier SDK le 12 Novembre 2007

Généralités
● Le source du SDK est mis à disposition sous licence Apache
2.0
● le 21 Octobre 2008
● lien : http://source.android.com/
● Android Market est lancé en Novembre 2008
● lien : https://market.android.com
● Octobre 2008 : sortie du premier samrtphone Android aux
Etats-Unis
● Mars 2009 en France
● 2009 : premières tablettes Android
● vrai succès à partir de début 2011, avec la version Android 3.0

● Principales caractéristique
● environnement de développement complet
– émulateur de téléphone, outils de débogage, mesure des performances, …
● framework applicatif
● machine virtuelle Dalvik
– optimisée pour les appareils nomades
● navigateur intégré
– WebKit
● graphisme 2D et 3D
● base de données SQLite
● CODEC audio et vidéo (MPEG4, MP3, AAC, PNG, …)
●
options matérielles : téléphonie GSM, caméra, GPS, accéléromètre,
boussole, EDGE, Wifi, Bluetooth, …

Application Android
● Langage de développement : Java
● attention, toutes les classes du JDK ne sont pas disponibles
– Swing par exemple
● possibilité d'utiliser du C pour certaines parties critiques
– utilisation du NDK (Native Development Kit)
● Les outils du SDK compilent le code Java et les ressources
associées
● création d'un fichier .apk qui contient toute l'application et ses
ressources
– c'est ce fichier qui sera installé sur la plateforme Android
● Toutes les applications Android ont les même droits
● même pied d'égalité que les applications natives

Application Android
● Une fois installée, une application Android est exécutée au sein d'un
sandbox
● Le système d'exploitation Android est basé sur Linux
● une application Android est un utilisateur du système d'exploitation
● chaque application reçoit par défaut un identifiant unique
– user ID, seulement connu par Linux, pas par l'application
– l'OS positionne les permissions sur les fichiers de l'application afin que seule celle-
ci puisse les utiliser
● une application est exécutée dans sa propre VM (Virtual Machine)
● par défaut une application est exécutée dans un process Linux
– le process est démarré par Android si un composant de l'application doit être
exécuté
– le process est tué lorsque l'application se termine ou si d'autres applications ont
besoin de mémoire

Application Android
● Il existe 4 types de composant applicatif
● dont les objectifs et cycles de vie sont différents
● activité (activity) : interface graphique pour l'utilisateur
– classe Activity
● service (service) : composant exécuté en tâche de fond, sans interface
graphique
– exemple : écoute de musique
– classe Service
● fournisseur de données (content provider) : gère et partage des données
applicatives
– exemple : les contacts
– classe ContentProvider
● récepteur broadcast (broadcast receiver) : réagit à des messages, systèmes
ou applicatifs
– mise hors tension, baterie faible, …
– classe BrodcastReceiver

Application Android
● Une application Android n'a accès qu'à ses propres ressources
● politique "principe of least privilege"
● environnement sécurisé qui interdit à l'application d'utiliser le
système sans en avoir la permission
● Il est possible de donner le même user ID à plusieurs
applications
● les applications sont exécutées dans le même process Linux
● les application partage la même VM
● permet de partager des ressources
● Une application doit posséder les permissions adéquats pour
accéder aux composants du système
● liste des contacts, APN (Appareil Photo Numérique), SMS, ...

Versions Android et SDK
● Le système Android évolue très vite
● ce qui est une marque de dynamisme
● ce qui provoque une fragmentation importante des plateformes
● nécessite un développement basé sur une version minimale
répandue
● Pour les développeurs, Google met à disposition un SDK
(Software Development Kit)
● lien : http://developer.android.com/sdk/index.html
● En plus du SDK il existe des bibliothèques tiers
● leur support n'est pas obligatoire par les intégrateurs
● exemples : API Google, Samsung, LG, ...

● La version 1.0 est sortie en septembre 2008
● c'est la version 1.1 qui fut commercialisée en France
– sortie en Février 2009
● Passage direct à la version 1.5
● prise en charge de la détection de rotation, de
l'accéléromètre, enregistrement vidéo, App Widgets
● La version 1.6 apporte le support de plusieurs résolutions
● Les versions 2 se sont succédées rapidement
● HTML5, Wifi, stockage externe, NFC, VoIP, SIP, …
● Étape importante : la version 3, conçue spécifiquement
pour les tablettes

● Il coexistait deux branches de versions
● version 3 pour les tablettes
– version 3.2 actuellement
● version 2 pour les smart phones
– version 2.3.4 actuellement
● Depuis la version 4
● fusion entre téléphones, tablettes et télévisions

Historique des versions
Plateforme Nom API Level Date
Android 1.1 2
Android 1.5 Cupcake 3 Avril 2009
Android 1.6 Donet 4 Septembre 2009
Android 2.1 Eclair 7 Janvier 2010
Android 2.2 Froyo 8 Mai 2010
Android 2.3 Gingerbread 9 Décembre 2010
Android 3.0 Honeycomb 11 Janvier 2011
Android 4.0 Ice Cream Sandwich 14 Octobre 2011
Android 4.1 Jelly Bean 16 Juillet 2012
Android 4.4 KitKat 19 Octobre 2013
Android 5.0 L ????? 20 courant 2014

Quelle cible choisir ?
● Google publie la répartition d'utilisation des versions
● informations collectées via Google Play
– lien : http://developer.android.com/about/dashboards/index.html
● ici en date du 21/03/2014

antislashn.org Android - Outils de développement 2 - 1/48
Outils de développement

Outils du développeur
● Présentation des outils
● Eclipse avec ADT
– ADT : Android Development Tools
● le SDK
● le SDK et AVD Manager
– AVD : Android Virtual Device
● le ADB : Android Debug Bridge
● le DDMS : Dalvik Debug Monitor Server
● Android Studio : autre outil mis à disposition par
Google, basé sur IntelliJ IDEA
● http://developer.android.com/sdk/index.html

Installation du plugin ADT
● Prérequis
● JDK 1.6 installé
● Eclipse installé
– la version pour le développement Java de base suffit
● Installer le SDK
● télécharger l'archive de démarrage
– contient les outils de base, pas les APIS
– http://developer.android.com/sdk/index.html
● décompresser l'archive dans un répertoire
– nous y ferons référence sous l'appellation SDK_HOME

● Démarrer Eclipse
● Sélectionner l'installation de nouveaux plugins
● Help → Install New Software

● Cliquer sur le bouton Add de l'assistant
d'installation
● Ajouter le repository
● remplir les deux champs
– Name : ADT Plugin
– Location : https://dl-ssl.google.com/android/eclipse/
– puis OK

● Une fois que les outils sont affichés
● sélectionner Select All
– attention : il faut que CDT soit installé pour que le NDK puisse
être installé
● cf annexe A
● puis Next

● Cliquer sur Next dans la fenêtre suivante
● Accepter les licences
● puis cliquer sur Finish

● Accepter l'alerte de sécurité
● Puis redémarrer Eclipse

● Au redémarrage la version du plugin est vérifié
● accepter l'éventuelle mise à niveau
● ou sélectionner le répertoire d'installation du plugin
● puis Finish

● Les plate-formes cibles ne sont pas installées
● une fenêtre peut le signaler
● Installation des API
● dans la barre d'outils sélectionner le "SDK Manager"
● Dans la fenêtre suivante, sélectionner les niveaux
d'API souhaités

● Cliquer sur le bouton Install xx packages
● Accepter toutes les licences puis cliquer sur Install

● le téléchargement des plate-formes démarre
● cette étape peut être assez longue

Le SDK
● Une fois l'installation terminée le
répertoire d'installation du SDK
comporte l'ensemble des outils,
documentations, exemples,
plateformes cibles
● L'installation étant relativement lente,
ce répertoire peut être copier sur les
autres machines

Émulateur AVD
● AVD : Android Virtual Device
● émulateur de matériel
● complètement configurable
● Avant d'utiliser un émulateur il faut le créer

Émulateur AVD
● L'émulateur Android peut être lancé
● via Eclipse
● via la ligne de commande

Émulateur AVD
● L'émulateur se comporte (presque) comme un
téléphone
● possibilité de changer les réglages de base
– langue, format date et heure, …
● d'ajouter des contacts
● de supprimer des applications
● de recevoir des SMS et des appels téléphoniques
– depuis l'onglet "Emulator Control"
– depuis un autre émulateur
● en précisant le numéro d'écoute de l'émulateur au lieu d'un numéro de
téléphone

Émulateur AVD
● Ligne de commande
● dans le répertoire tools
● emulator -avd <avd_name> [-<option> [<value>]] …
– exemple : emulator -avd Samsung_S
● documentation des options de la ligne de commande
– http://developer.android.com/tools/help/emulator.html
● Utilisation de l'émulateur derrière un proxy
● en ligne de commande ajouter l'option
– -http-proxy <proxy>
● le proxy peut-être réglé dans l'émulateur lui-même

Émulateur AVD
● Réglage du proxy dans l'émulateur
● Applications … Paramètres … Sans fils et réseaux
– Réseaux mobiles ... Nom des points d'accès … TelKila

Émulateur AVD
● L'émulateur peut être contrôlé
● par le clavier du PC pour certaines opérations
– Ctrl-F11 et Ctrl-F12 pour le mode portrait / paysage par
exemple
– l'ensemble des raccourcis est disponible à
● http://developer.android.com/tools/help/emulator.html
● par la vue "Emulator Control" dans Eclipse

Outil adb
● adb : Android Debug Bridge
● Permet de se connecter sur l'émulateur
● ou sur un téléphone réel connecté en mode debug
● Programme articulé autour de 3 composants
● un client exécuté sur la machine de développement
– lancé par la console ou le plugin ADT
● un serveur qui s'exécute en arrière plan sur la machine
de développement
● un démon exécuté sur chaque émulateur

Outil adb
● Le serveur maintient un client adb liée à un démon
adb
● émulateur 1 en 5554, client adb 1 en 5555
● émulateur 2 en 5556, client adb 1 en 5557
● adb permet
● de connaître la liste des émulateur
● d'installer des applications
● adb emulator-5556 install hello.apk
● de copier des fichiers vers/depuis l'émulateur
● d'exécuter des commandes shell sur l'émulateur
– se connecter à la base de données SQL par exemple

Outil adb
● Quelques commandes adb
● adb start-server
– démarre le serveur adb s'il ne l'est pas
– eclipse peut être configuré pour utiliser un serveur externe
● adb kill-server
– arrête le serveur
● adb devices
– liste les matériels et émulateurs attachés

Outil adb
● Quelques commandes adb
● adb [-d | -e | -s <serialNumber>] command
– envoie d'une commande adb
● -d : vers le seul matériel connecté
● -e : vers le seul émulateur connecté
● -s <serialNumber> : vers un matériel ou émulateur connecté
● command : une commande adb
● si un seul matériel ou émulateur est connecté -d, -e ou -s peut être
omis
● adb -e shell
– passage en mode shell
● ici sur le seul émulateur connecté

DDMS
● Dalvik Debug Monitor Server
● outil de debug
● Intégré à Eclipse
● perspective DDMS
● Ligne de commande
● tools/ddms

DDMS
● DDMS permet
● de suivre l'utilisation du tas
● de suivre les allocations d'objets et mémoire
● de travailler sur le système de fichier de l'émulateur
● de voir les threads executés sur l'émulateur
● d'effectuer du profiling de méthode
– nombre d'appels, temps d'exécution, …
● Debug.startMethodTracing() et Debug.stopMethodTracing()
– à partir d'Android 2.1
● 2.1 : doit avoir une carte SD et la permission d'écriture sur la carte SD
● à partir de 2.2 : plus de SD nécessaire, les traces de logs sont
envoyés vers l'environnement de développement

DDMS
● Vue File Explorer
mouvements de fichiers entre
l'équipement et le PC
suppression et ajout dans
le système de fichier de l'équipement

DDMS
● Vue des threads actifs
● il faut d'abord lancer la capture
thread de l'application
thread du garbage collector
thread dédié à la réception des signaux Linux
threads systèmes
● ID : identifiant du thread dans la VM
● Tid : identifiant du thread Linux
● Status
● running, sleeping, monitor, wait, native, vmwaait, zombie, init, starting
● * si deamon
● utime : durée cumulée de l'exécution du code utilisateur (en "jiffies", 10ms)
● stime : durée cumulée de l'exécution du code système (en "jiffies", 10ms)
● Name : nom du thread

DDMS
● Vue Emulator Control
● envoi de SMS
● émulation d'appel
téléphonique
● envoi de points de
géolocalisation

DDMS
● DDMS permet aussi d'interagir avec l'émulateur
● envoi de SMS
● émulation d'appel téléphonique vers un émulateur
● mise à jour de la géolocalisation du téléphone
– manuellement ou par fichier
● GPX : GPS eXchange file
● KML : Keyhole Markup Language

Débogage
● Le débogage sous Eclipse est effectué de manière
classique
● par utilisation de traces dans les sources
– classe Log
● par mise en place de points d'arrêts
– lancer alors l'application
en mode debug

Gestion des logs
● L’outil logcat permet de visualiser les logs du
système de logs Android
● logcat est utilisable via adb ou DDMS
● Par défaut les logs sont dirigés vers /dev/log/main
● deux autres journaux de logs existent
– /dev/log/radio pour les activité réseau et téléphone
– /dev/log/events pour les événements système
● Les sorties vers les flux out et err sont redirigés
vers /dev/null
● utilisation de System.out ou System.err

Gestion des logs
source : elinux.org/Android_Logging_System

Gestion des logs
● Classe Log
● ne comporte que des méthodes statiques
● signatures des méthodes raccourci
● d(...) pour DEBUG, e(...) pour ERROR
– static int method(String tag, String msg)
– static int method(String tag, String msg,
Throwable tr)
● tag : identificateur du message
● msg : message
● tr : exception
● méthode générique
– static int println(int priority, String tag,
String msg)
● priority : DEBUG, ERROR, etc.

Gestion des logs
● Niveaux de log
● VERBOSE – méthode Log.v(...)
● DEBUG – méthode Log.d(...)
● INFO – méthode Log.i(...)
● WARN – méthode Log.w(...)
● ERROR – méthode Log.e(...)
● ASSERT
● méthode Log.wtf(...)
– "What a Terrible Failure" : erreur ne devant jamais arriver

Gestion des logs
● Tag d'identification
● souvent le nom de la classe
● bonne pratique : déclarer une constante dans la classe
private static final String tag = SensorListActivity.class.getCanonicalName();

Documentation de référence
● Disponible en ou hors connexion
● sur internet :http://developer.android.com/reference/packages.html
● dans le répertoire doc du SDK

● Possibilité de tri par classe
● Champ de recherche

● Niveau d'API à partir de laquelle la classe peut-être
utilisée

Développer sur un équipement réel
● La plupart des équipement tournant sous Android
peuvent être utilisés pour tester et déboguer une
application
● certains fabricants bride le support sur leur matériel
– Archos, autres ???
– voir sur le site du fabricant pour la procédure à suivre
● http://www.archos.com/support/support_tech/updates_adb.html?country=fr&lang=fr
● Configuration du développement sur le matériel
● l'application doit être déclarée comme "débogable"
– dans l'élément <application>, ajouter l'attribut
android:debuggable="true"
● le téléphone doit être configuré en mode USB
Debugging

● L'activation du mode développeur dépend du
niveau d'API
● < Android 4
– l'activation du mode développeur se trouve dans la gestion
des applications
● < Android 4.2
– entrée "Options pour les développeurs" dans les paramètres
● > Android 4.2
– le menu "Options pour les développeurs" doit être activée
● taper 7 fois sur l'item "Numéro de build" du menu "A propos du
téléphone"
● le mode développeur est alors activé, et l'entrée "Options pour les
développeurs" est affichée

● Passage en mode USB debugging sur Android 1.x
et 2.x
● Settings → Applications → Development

et 2.x
● puis activer le débogage USB

● Passage en mode USB debugging sur Android 3.0
● Settings → Applications → Development

● puis activer le debogage USB

● Settings → Developer options
● attention depuis Android 4.2 l'entrée est cachée
– l'activation est effectuée en tapant 7 fois sur le numéro de
build du téléphone

● puis activer le débogage USB
● De très nombreux outils
sont disponibles pour
aider le développeur

● Paramétrer le poste de développement
● Windows
– installer le driver USB du matériel
– ce driver est fourni par le constructeur
– cf : http://developer.android.com/tools/extras/oem-usb.html
● Mac, CentOS
– rien à faire
● Ubuntu
– ajouter une règle au fichier /etc/udev/rules.d/51-android.rules
● SUBSYSTEM=="usb", ATTR{idVendor}=="0bb4", MODE="0666", GROUP="plugdev"
● où {idevendor} correspond à un identifiant
– http://developer.android.com/tools/device.html
● exécuter
– chmod a+r /etc/udev/rules.d/51-android.rules

● Déboguer via le Wifi
● les appareils ne possédant qu'un seul port USB il est
parfois nécessaire de déboguer via le réseau WIFI
● étapes à suivre
– activer le WIFI
● récupérer l'adresse TCP IP du matériel dans les propriétés WIFI
– connecter le matériel en USB
– vérifier que le débogage fonctionne bien mode USB
– lancer la commande : adb tcpip 5555
– puis lancer : adb connect <ip_matériel>:5555
– pour revenir au mode usb : adb usb

antislashn.org Android - Hello, world 3 - 1/20
Application
Hello, world

"Hello, world"
● création du projet
● liaison avec l'architecture de l'application
● Activity
● fichier de AndroidManifest.xml
● utilisation d'un émulateur

"Hello, world"
● Création du projet
● File...New...Project
● la fenêtre de choix de projet s'affiche
– choisir un nouveau projet Android

"Hello, world"
● L'assistant de création de projet s'affiche
● donner un nom au projet, puis Next

"Hello, world"
● Dans l'écran suivant choisir le SDK cible
● ici le SDK version 1.6, puis Next

"Hello, world"
● Donner un nom à l'application, et choisir un
package

"Hello, world"
sources de notre application
activité (écran) de l'application
répertoire où sont déposés les
ressources générées
fichier R.java généré par les outils Android
bibliothèques du SDK cible
répertoire des ressources
fichier de configuration de l'application
répertoire des données brutes : MP3, ...
propriétés du projet

"Hello, world"
● Certains fichiers sont maintenus par le plugin ADT
● il ne faut pas les éditer, ils sont mis à jour automatiquement
– R.java
– default.properties
● Les ressources contenues dans le répertoire res peuvent
être modifiées lors la compilation
● pour optimisation
● se retrouvent dans les ressources R.java
● Les ressources du répertoire assets ne sont pas
impactées par la compilation
● possibilité de les lire en tant que flux d'octets

"Hello, world"
● Pour exécuter l'application sélectionner le projet
● puis avec un click droit, sélectionner
– Run As … Android Application
● Si un émulateur est configuré il est
automatiquement chargé
● l'application est lancée
● si aucun émulateur n'est configuré l'écran de gestion
des émulateurs est affichée
● si plusieurs émulateurs sont configurés, en choisir un
● Une fois l'émulateur chargé il est préférable de ne
pas le fermer

Ressources de l'application
● Les ressources sont des données utilisables par l'application
● elles sont intégrées au binaire de l'application
● res/anim : animations de transition au format XML
● res/color : couleurs définis dans des fichiers XML
● res/drawable : images, plusieurs densités d'écran sont disponibles
(hdpi, mdpi et ldpi)
● des ressources images peuvent être spécifiées pour une configuration
matérielle et/ou logicielle précise, le nom du dossier de ressource est
alors complété par des qualificatifs séparés par des traits d'union
– largeur d'écran, orientation de l'écran, langue système, ...
● res/layout : interfaces graphiques
● res/values : valeurs utilisées par l'application
● les valeurs sont définies dans un fichier XML

● Chaque ressource du dossier res possède un identifiant entier
unique
● permet d'atteindre depuis le code Java, ou XML, une ressource
– cette valeur peut changer au grès des ajouts et suppression de
ressources
● pour éviter le codage en dur de ces valeur, des constantes sont
créées dans une classe R.java
public final class R {
public static final class attr {
}
public static final class drawable {
public static final int ic_launcher=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;
}
}

● Le nom complet de la constante est composé :
● du nom du package
– facultatif car il s'agit du package courant
● du type de ressource
– correspond au sous dossier res
● du nom de la ressource
– pour les ressources situées dans res/values, le nom est celui défini dans
le fichier xml
<?xml version="1.0" encoding="utf-8"?>
<resources>
<string name="hello">Hello World, HelloActivity!</string>
<string name="app_name">Hello</string>
</resources>

● syntaxe Java pour accéder à une ressource :
[package.]R.type.nom
R.string.app_name
● syntaxe XML pour accéder à une ressource :
@[package:]type/nom
@string/app_name

Structure de l'application "Hello, world"
● Le fichier AndroidManifest.xml
● contient la configuration principale de l'application
– composants applicatifs, point d'entrée principal, sécurité et droits,
etc.
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="org.antislashn.android.hello"
android:versionCode="1"
android:versionName="1.0" >
<uses-sdk android:minSdkVersion="4" />
<application
android:icon="@drawable/ic_launcher"
android:label="@string/app_name" >
<activity
android:label="@string/app_name"
android:name=".HelloActivity" >
<intent-filter >
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
</application>
</manifest>

"Hello, world" - AndroidManifest.xml
● Les balises et attributs de ce fichier XML sont très
nombreux
● beaucoup sont facultatifs
● Certains seront détaillées au cours de cette
formation
● au fur et à mesure de leur utilisation
● Balise racine : manifest
● attributs
– package : package de l'application
– versionCode : version de l'application (numérique)
– versionName : version de l'application (string)

● Balise uses-sdk
● indique les versions de SDK pour que l'application
puisse être exécutée
● attributs
– minSdkVersion : niveau minimum pour que l'application
puisse être utilisée
– targetSdkVersion : niveau de l'API utilisé lors du
développement – utilisé par Android pour ajouter si nécessaire
des mécanismes de compatibilité : thèmes graphiques,
densité écran, ...

● Balise application
● informations sur l'application
● attributs
– icon : icône de l'application
● valeur : @drawable/ic_launcher qui référencie la ressource
ic_launcher.png située dans un des répertoire res/drawable, en
fonction de la densité d'écran
– label : titre de l'application – il est préférable d'utiliser des
références à des ressources plutôt qu'une chaine de
caractères
● valeur : @strinf/app_name qui référencie la ressource de type
string contenue dans le fichier res/values/string.xml
● application contient des balises enfants

● Balises filles
● elles seront vues en détails lors des prochains chapitres
● activity
– défini une activité (écran)
– l'activité est lancée par une intention (intent)
● service
– défini un service
● provider
– défini un fournisseur de données
● reicever
– défini un récepteur de messages
● uses-library
– librairies utilisées

"Hello, world" - activity
● Le nom (attribut name) de l'activité (balise
activity) référencie la classe HelloActivity
● préfixée par le point, car appartenant au package
courant
– la méthode onCreate(...) est le point d'entrée de
l'application
● invoque la méthode onCreate() de la classe mère
● charge l'écran de l'activité
public class HelloActivity extends Activity {
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
}
}

"Hello, world" - IHM
● L'écran de l'application est décrite dans un fichier
XML
● ici le fichier res/layout/main.xml
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:orientation="vertical" >
<TextView
android:layout_height="wrap_content"
android:text="@string/hello" />
</LinearLayout>
gestionnaire de positionnement
composant de type texte
ressource définie dans res/values/string.xml

antislashn.org Android - architecture et développement 4 - 1/17
Application Android
architecture et développement

Cycle de développement
● création du projet
● codage
● compilation
● effectuée en deux étape
– java vers .class avec l'outil javac
– .class vers .dex avec l'outil dx
● création de l'archive apk
● clé pour le développement

Architecture d'une application
● Une application Android est constituée d'un ou
plusieurs modules applicatifs :
● Activity : code de gestion d'une IHM
● Service : traitement exécuté en tâche de fond
● ContentProvider : exposition de données à d'autres
applications
● BroadcastReceiver : récepteur de messages
● Les modules applicatifs communiquent entre eux
par des messages
● de type Intent

● Le contexte applicatif est accessible par la classe
Context
● les types Activity et Services dérivent de Context
● permet de lancer des intentions vers un autre
composant
– qui appartient à l'application ou non
● permet de récupérer les ressources de l'application
– répertoire, base de données, ...

● La configuration de l'application est décrite dans le
fichier AndroidManifest.xml
● nom de l'application
● icônes
● compatibilité : SDK, écrans, présence d'un clavier, ...
● déclaration des modules applicatifs
● déclarations des filtres de messages
● déclaration des permissions : utilisation GPS, internet,
etc.
● classe d'instrumentation de l'application

● Fichier AndroidManifest.xml
package="org.antislashn.android.hello"
<application
<activity
android:name=".HelloActivity" >
<intent-filter >
</intent-filter>
</activity>
</application>
</manifest>

Les ressources
● Les ressources nécessaires à l'application
sont intégrées dans le répertoire res du
projet
● ses ressources seront compilées avec
l'application
● un identifiant unique est associé à chacune
des ressources
– voir la classe générée R.java
– un fichier ic_launcher.png placé dans un répertoire
(ou sous-répertoire) de res/drawable sera utilisable
par :
● R.drawable.ic_launcher en java
● @drawable/ic_launcher en XML

Les données brutes
● Les données brutes (audio, vidéo, …) sont placées
dans le répertoire assets
● la taille maximale autorisée est de 1 Mo
– pour les fichiers compressé par APK (csv, txt,...)
– pas pour les fichiers binaires (mp3, png, ...)
● elles sont accessible via un AssetManager
– une instance d'AssetManager peut être récupérée par le
Context
● méthode getAssets()
– la méthode open(String fileName) renvoie un
InputStream sur la ressource désirée

Le bus de message
● Les différents modules applicatifs ne sont pas
directement instanciés par le développeur
● Un bus de messages permet au système de choisir
le composant à monter en mémoire
● les messages sont de type Intent
● les intentions décrivent quelle est l'opération qui devra
être effectuée
– plusieurs composants applicatifs peuvent répondre à un
même Intent
● l'utilisateur aura alors le choix

Le bus de messages
● Un message est principalement constitué
● d'une action
– affichage, composition d'un numéro de téléphone, démarrage
d'un module, ...
● d'une catégorie
– informations supplémentaires pour l'action à mener
● préférences utilisateur, affichage dans les applications, …
● d'autres données : type MIME, composant à invoquer,
données supplémentaires, URI

Le bus de message
● Un composant décrit une configuration de
messages auxquels il est susceptible de répondre
● dans le fichier AndroidManifest.xml
● balise <intent-filter>
– exemple : point d'entrée d'un application
<intent-filter>
</intent-filter>

Le bus de message
Producteur
Système Android
Module applicatif
Intent
IntentResolver
Application 2
Activité
Activité
IntentFilter
IntentFilter
Application 1
Activité
Service
IntentFilter
IntentFilter
Le composant dont le filtre
d'intention correspond est
activé

Bonnes pratiques
● Le développement sous Android est différent d'un
développement Java classique
● Il existe des bonnes pratiques liées à la plateforme
Android
● codage
● ergonomie
● compatibilité entres matériels
● design

Bonnes pratiques de codage
● Ne pas perdre de vue que l'application est
exécutée sur une plateforme dont les ressources
sont limitées
● Minimiser la création d'objets
● Ne pas utiliser les getteurs / setteurs au sein de la
classe
● préférer la lecture ou l'affectation directe des propriétés
● Déclarer static les méthodes qui peuvent l'être
● Préférer les constantes plutôt que les énumération
● enum est une classe

Bonnes pratiques d'ergonomie
● Souvent sans clavier et dispositif de pointage
● le doigt est utilisé sur l'écran
● Ne pas dessiner des widgets trop petits
● taille recommandée aux alentour de 9mm, soit 48dp
– dp : density-independant pixels
– http://developer.android.com/design/style/metrics-grids.html

Bonnes pratiques d'ergonomie
● Utiliser le retour haptique et le changement de
couleur des boutons
● attribut android:hapticFeedbackEnable
●

Bonnes pratiques de design
● Les icônes de lancement d'applications font une
taille de 48x48 dp
● les icônes de Play Store font 512 x 512 px
● Utiliser les icônes prédéfinies pour la barre d'action
● téléchargement :
https://dl-ssl.google.com/android/design/Android_Design_Icons_20120229.zip

antislashn.org Android - composants graphiques de base 5 - 1/56
Composants graphiques
de base

Les écrans Android
● En général, une application Android possède une
interface utilisateur (IHM, GUI)
● La configuration matérielle exacte sur laquelle sera
exécutée l'application n'est pas connue
● taille écran, densité, profondeur de couleur, …
● Caractéristiques d'un écran
● taille : diagonale de 6,5 cm à 30 cm
– 1 pouce = 2,54 cm
● résolution
– QVGA : 240 x 320 pixels
– WXGA 16/9 : 1366 x 768 pixels
– WXGA 16/10 : 1280 x 800 pixels

Les barres système
● La barre d'état résume l'état du matériel et affiche
certaines notifications
● La barre de navigation permet de naviguer entre
les applications / pages / accueil
source : Google

Les écrans Android
● Les écrans Android sont classés en :
● petit (small) : diagonale de 2,5"
● normal (normal) : diagonale de 4"
● grand (large) : diagonale de 7"
● très grand (xlarge) : diagonale de 10"
– depuis API 9
● La résolution est exprimée en points par pouce
● dpi : dots per inch
● mesure la densité de pixels sur l'écran

Les écrans Android
● La densité de pixels est classée en :
● faible (ldpi) : 120 dpi
● moyenne (mdpi) : 160 dpi
● haute (hdpi) : 240 dpi
● très haute (xhdpi) : 320 dpi
– depuis API 8
● Les caractéristiques d'un écran peuvent être
récupérées via une instance de WindowManager
DisplayMetrics displayMetrics = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(displayMetrics);
Log.d("WindowManagerActivity", "Density DPI : "+displayMetrics.densityDpi);
Log.d("WindowManagerActivity", "Resolution X : "+displayMetrics.widthPixels);
Log.d("WindowManagerActivity", "Resolution Y : "+displayMetrics.heightPixels);

Les écrans Android
● Si les résolutions sont différentes pour une même
taille d'écran les composants graphiques
s'afficheront avec une taille différente
● Google préconise l'utilisation de l'unité dp
– appelée aussi dip (density independent pixel)
● ne pas confondre avec dpi
● il existe aussi une métrique pour les polices de
caractères : sp (ou sip pour scale independent pixel)
● Il existe aussi :
● px pour le pixel
● in pour inch
● mm pour millimètre

Les écrans Android
source : Google

Les écrans Android
● Pour les images
● Android recherche d'abord une ressource
correspondant à la densité utilisé par le matériel
– dans res/drawable-hdpi, ldpi, mdpi
● sinon une ressource dans la densité la plus proche est
utilisée et l'image est retaillée
– ration 3 – 4 – 6 – 8 pour ldpi, mdpi, hdpi et xdpi
– si une image existe en mdpi de 100x100 px
● un ratio 6/4 est utilisé pour un écran hdpi soit 150x150 px
● un ratio ¾ est utilisé pour un écran ldpi soit 75x75 px

Les écrans Android
● Balise support-screens
● depuis Android 1.6 (level 4)
● balise fille de la balise manifest
● permet d'indiquer les écrans supportés au système et
Android Market
<supports-screens
android:smallScreens="true"
android:normalScreens="true"
android:largeScreens="true"
android:xlargeScreens="true"
android:anyDensity="true"
/>

Interface graphique
● Les interfaces graphiques sont réalisées dans une activité
(activity) ou un fragment (fragment)
● un écran peut alors être composé de plusieurs fragments
● sera vu plus tard
● La réalisation de l'IHM peut être faite de manière
● programmée : les composants graphiques sont créés par le
code Java et ajoutés à la vue
– permet de générer une vue dynamiquement
● déclarée : dans des fichiers XML
– séparation du code de la présentation
● les deux modes peuvent être utilisés
– manipulation en java des composants déclarés en XML

Interface graphique
● Eclispe : plugin ADT
● permet de créer la vue via un éditeur XML ou par
l'éditeur graphique (Graphical Layout)

Hiérarchie des composants graphiques
● les fragments
● les vues
● les gestionnaires de placement
● layout manager
● arbre des composants graphiques

● La vue est l'élément de base de l'IHM
● classe View
– tous les composants graphiques héritent de cette classe
– les classes ViewGroup contiennent plusieurs composants
graphiques
● pattern Composite

● Principaux attributs XML des View
● background : fond de la vue (couleur, image)
● clickable : indique si réaction aux clics
● id : identifiant unique de la vue
● minHeight et minWidth : hauteur et largeur minimales
● onClick : méthode à invoquer lors d'un clic
● padding : dimension de la marge interne pour les 4 côté de
la vue
– cf paddingBottom, paddingLeft, paddingRight,
paddingTop
● tag : associe un objet au composant
● visibility : indique si le composant est visible ou non

Les layouts
● Les layouts sont de type ViewGroup
● conteneurs de composants graphiques
● gèrent le placement des composants
● chaque layout offre une structure de positionnement qui lui
est propre
● Attributs XML obligatoires
● layout_width et layout_heigth : largeur et hauteur
– valeurs possibles
● fill_parent : remplit l'espace du conteneur parent, moins la marge
● wrap_content : se dimensionne en fonction du contenu du composant
● match_parent : est remplacé par fill_parent depuis la version 8 du SDK
● une valeur en dip, px, mm, in, ...

Les layouts
● Divers propriétés sont disponibles sur les layouts
pour paramétrer l'affichage
● voir en fonction des layouts
● Il faut penser en terme
● d'orientation
● modèle de remplissage
● poids
● gravité
● remplissage

Les layouts
● Orientation (android:orientation)
● des layouts, comme LinearLayout, présentent les
widgets en ligne ou en colonne
● l'orientation peut-être modifiée en cours d'exécution
avec setOrientation(...)
● Poids (android:layout_weigth)
● comment deux widgets se partagent l'espace
disponible ?
● layout_weigth indique la proportion par widget
– si 1 pour deux widgets l'espace libre est divisé en 2
– si 1 pour un widget, et 2 pour le second, le second utilisera
deux fois moins d'espaces que le premier

Les layouts
● Modèle de remplissage
● les widgets ont une taille "naturelle" qui repose sur le
texte affiché
– que faire de l'espace restant ?
● les widgets peuvent fournir une valeur pour
layout_width et layout_height
– la valeur peut être
● une dimension précise : 120 dp
● wrap_content pour que le widget occupe sa place naturelle
● fill_parent pour que le widget occupe toute la place disponible

CONTENEUR
Les widgets de base
● Positionnement des widgets
WIDGET
top
padding
layout_margin
left
width
height

Les layouts
● Gravité
● layout_gravity gère le placement du widget dans le
layout
– indique au conteneur et au widget comment l'alignement doit
être effectué
● gravity gère le placement du texte dans le widget
● Remplissage
● les widgets sont par défaut serrés les uns contre les
autres
– padding gère les 4 zones
– paddingTop, paddingBottom, paddingLeft,
paddingRight gèrent le remplissage zone par zone

Les layouts
● Positions relatives par rapport à un conteneur
● layout_alignParentTop : haut du widget aligné avec
celui du conteneur
● layout_alignParentBottom : bas du widget aligné avec
celui du conteneur
● layout_alignParentLeft : bord gauche du widget
aligné avec celui du conteneur
● layout_alignParentRigth : bord droit du widget aligné
avec celui du conteneur
● layout_alignCenterHorizontal : widget centré
horizontalement
● layout_alignCenterVertical : widget centré
verticalement

Les layouts
● Position relative des widgets
● attribuer un identifiant à tous les widgets devant être désignés
(par @+id/... )
● désigner un widget dans un autre avec son identifiant (avec
@id/... )
● le contrôle du placement d'un widget par rapport à un autre est
effectué par :
– android:layout_above le widget doit être placé au-dessus de celui
qu'il désigne
– android:layout_below le widget doit être placé sous celui qu'il
désigne
– android:layout_toLeftOf le widget doit être placé à gauche de celui
qu'il désigne
– android:layout_toRightOf le widget doit être placé à droite de celui
qu'il désigne

Les layouts
● Alignement d'un widget par rapport à un autre
● android:layout_alignTop le haut du widget est
aligné avec le haut du widget désigné
● android:layout_alignBottom le bas du widget est
aligné avec le bas du widget désigné
● android:layout_alignLeft le bord gauche du
widget est aligné avec le bord gauche du widget
désigné
● android:layout_alignRight le bord droit du
widget est aligné avec le bord droit du widget désigné
● android:layout_alignLBaseLine les lignes de
base des deux widgets doivent être alignées

Les layouts
● Le plugin ADT simplifie la mise en place des
layouts
● affiche le résultat

FrameLayout
● Le plus simple des conteneurs
● tous les éléments sont placés les uns au-dessus des
autres à partir du coin haut-gauche
● le dernier élément graphique ajouté vient recouvrir les
autres éléments

LinearLayout
● Les composants sont placés les un après les
autres, selon l'attribut d'orientation
● verticalement : les uns sous les autres
● horizontalement : les un après les autres, à la droite du
précédent

LinearLayout
android:orientation="vertical"
android:layout_height="fill_parent">
<LinearLayout
android:orientation="horizontal"
android:layout_weight="1">
...
</LinearLayout>
<LinearLayout
android:orientation="vertical"
android:layout_weight="1">
...
</LinearLayout>
</LinearLayout>

LinearLayout
● Attributs utilisés dans l'exemple
● orientation : orientation verticale ou horizontale
● layout_width : largeur
● layout_heigth : hauteur
● layout_weight : proportion de la place prise par le
widget dans son parent
● gravity : poisition dans son conteneur
● background : couleur du fond
● text : texte affiché
● textSize : taille du texte

RelativeLayout
● Les positions des composants enfants sont
précisées par rapport à la vue parente ou par
rapport aux autres composants

RelativeLayout
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_height="fill_parent">
<TextView android:id="@+id/label" android:layout_width="fill_parent"
android:text="Type here:"/>
<EditText android:id="@+id/entry" android:layout_width="fill_parent"
android:background="@android:drawable/editbox_background"
android:layout_below="@id/label"/>
<Button android:id="@+id/ok" android:layout_width="wrap_content"
android:layout_below="@id/entry"
android:layout_alignParentRight="true"
android:layout_marginLeft="10dip"
android:text="OK" />
<Button android:layout_width="wrap_content" android:layout_height="wrap_content"
android:layout_toLeftOf="@id/ok"
android:layout_alignTop="@id/ok"
android:text="Cancel" />
</RelativeLayout>

RelativeLayout
● id : identifiant unique
● layout_below : positionne le haut d'un widget en
dessous du widget référencé
● layout_alignParentRight : aligne le côté droit du
widget avec le côté droit de son parent
● layout_marginLeft : espace pour la marge gauche
● layout_toBeLeftOf : positionne le côté droit du
widget à gauche du widget référencer
● layout_alignTop : aligne le haut du widget avec le
haut du widget référencé

TableLayout
● Les composants enfants sont disposés sous forme
de tableau
● les vues enfants sont des lignes de type TableRow
● les composants graphiques sont insérés dans les lignes

TableLayout
<TableLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:stretchColumns="1">
<TableRow>
<TextView android:layout_column="1" android:text="Open..."
android:padding="3dip" />
<TextView android:text="Ctrl-O" android:gravity="right"
</TableRow>
<TableRow>
<TextView android:layout_column="1" android:text="Save..."
<TextView android:text="Ctrl-S" android:gravity="right"
</TableRow>
<TableRow>
<TextView android:layout_column="1" android:text="Save As..."
<TextView android:text="Ctrl-Shift-S" android:gravity="right"
</TableRow>
</TableLayout>

TableLayout
● layout_column : index de la colonne où doit être
positionné le widget
● gravity : position du widget dans son conteneur
● padding : espacement entre la bordure du widget et
son contenu

Autres layout
● Il existent d'autres gestionnaires de positionnement
● seront vu plus tard
● GridView : positionne les éléments dans une grille
– la grille est muni d'ascenseurs
– les éléments sont ajoutés via un ListAdapter
● Mise en place d'onglets
– nécessite une construction spécifique de layouts
● Liste déroulante
– utilise une classe ListView

Mode déclaratif
● Mode le plus simple pour déclarer et réutiliser les
IHM
● les exemples précédents illustrent le mode déclaratif
● Création du fichier XML dans le répertoire
res/layout
● possibilité de fournir des layouts adaptés aux écrans
physiques dans les répertoires res/layout-small,
res/layout-normal, res/layout-large, res/layout-xlarge
● des layouts adaptés à l'orientation de l'écran sont aussi
possibles
– ajouter le qualificatif port pour portrait et land pour paysage
● res/layout-port, res/layout-normal-land, ...

Mode déclaratif
● Utilisation du layout
● une activité crée l'interface utilisateur
● utilisation de la méthode setContentView(...) de
la classe Activity
– prend en paramètre un identifiant correspondant à l'identifiant
du composant graphique
● utilisation de la classe R.java
public class FrameLayoutActivity extends Activity {
@Override
}
}

Programmation des IHM
● Mode plus puissants, mais plus complexe
● ne facilite pas la réutilisation des IHM
● n'utilise pas les stratégies de choix de ressource en
fonction du type d'écran
– pas d'utilisation des fichiers XML res/layout-xxx
● Création du layout
● instanciation
– le constructeur prend en argument le contexte de l'application
– Activity hérite de la classe Context
● paramétrage du layout créé
– utilise une instance de ViewGroup.LayoutParams

● Appel de la méthode setContentView(...)
public class LayoutProgrammationActivity extends Activity {
@Override
LinearLayout layout = new LinearLayout(this);
LayoutParams params = new LayoutParams(LayoutParams.MATCH_PARENT,
LayoutParams.MATCH_PARENT);
layout.setLayoutParams(params);
this.setTitle("Exemple instanciation layout");
setContentView(layout);
}
}

● Les modes déclaratif et programmatique sont
souvent utilisés conjointement
● l'IHM est décrite dans le fichier XML
● le code java agit dynamiquement sur l'IHM
● c'est ce mode de développement qui est privilégié
● Interactions entre le mode déclaratif et
programmatique
● le fichier XML déclare les composants graphique
● le code java retrouve le widget qu'il doit manipuler

● Récupération des widgets
● le code java doit récupérer les widgets qui sont déclarés
dans le fichier XML
● un identifiant est associé au widget, par l'attribut id
– id="@[+][package]id/nom_ressource"
● le signe + signifie que l'identifiant doit être ajouté, il apparaîtra dans le
fichier R.java
● la méthode findViewById(...) permet de récupérer
un widget
– public View findViewById(int id)
– l'identifiant est retrouvé par la classe R.java

<TextView
android:id="@+id/text_message"
</LinearLayout>
public class ModeMixteActivity extends Activity {
@Override
TextView text = (TextView) findViewById(R.id.text_message);
text.setText("Comment ça va ?");
}
}
ajout de l'identifiant
récupération du widget

Les widgets de base
● Nous allons présenter quelques widgets de base
● le nombre de composants Android évolue en fonction des
versions
● le nombre de propriétés de chaque composant est
impressionnant
– les propriétés communes à tous les composants, plus les propriétés
spécifiques
● atteint plusieurs dizaines de propriétés par composants
– ce référer à la documentation fournie avec le SDK pour plus de
détails
● tous les composants font partie du package android.widget
● D'autres composants seront présentés au fur et à mesure
des exemples et exercices

Les widgets de base
● Le tiroir "Form Widget" du plugin
ADT permet de choisir les widgets
disponibles en fonction du niveau
de SDK choisi
● attention, sur certaines plateformes
de développement, le rendu ne
correspond pas à l'affichage réel
– l'émulateur permet alors de vérifier les
attributs positionnés

View
● La classe View la classe de base utilisée par tous
les widgets
● View est spécialisée en ViewGroup pour les
conteneurs
● Une vue occupe un rectangle dans l'interface
graphique
● La vue est responsable de son affichage et de la
gestion des événement

View
● De nombreux événements sont exploitables
● clic, survol, création, drag and drop, …
● cf. la documentation
● Un ou plusieurs objets peuvent être attachés à une
vue
● notion de tag
● voir les méthodes setTag(...) et getTag(...)

Les widgets de base
● La documentation permet de connaître, widget par
widget, les attributs XML et les méthodes
équivalentes Java
● onglet "Reference"

TextView
● Affichage d'un texte
● Principales propriétés
● autoLink : convertit les liens HTTP et adresses mails en liens
cliquables
● ellipsize : règle d'affichage du texte si plus long que la zone de
visualisation
● height, width, maxHeight, maxWidth : hauteur et largeur
● lines, minLines, maxLines : nombre de lignes
● text : texte à afficher
● textColor, textSize, textStyle : caractéristiques du texte
●
gravity : endroit où est afficher le texte dans le conteneur si la zone
d'affichage du texte est plus petit que le conteneur
● drawableTop, drawableBottom, drawableLeft, drawableRight
: permet la gestion de l'affichage d'une ressource drawable à côté du
texte

TextView
<TextView
android:layout_width="wrap_content"
android:layout_gravity="center"
android:background="#FFF"
android:textColor="#000"
android:textSize="25sp"
android:textStyle="italic"
</LinearLayout>

EditText
● Permet la saisie d'un texte
● Hérite de TextView
● même propriétés
● Principales propriétés supplémentaires
● inputType : permet d'ajouter un filtre de saisie : email,
mot de passe, numérique, multi-lignes, …
– pas de validation, affiche le clavier adéquat, filtre les touches
● scrollHorizontally : défilement horizontal du texte
si celui-ci est plus grand que la zone de saisie
● La méthode getText() permet de récupérer le
texte saisi

EditText
<LinearLayout
xmlns:android="http://schemas.android.com/apk/res/android"
...
<EditText
android:id="@+id/nom"
android:layout_width="match_parent"
android:inputType="textPersonName" />
...
<EditText
android:inputType="textPassword" >
</EditText>
...
<EditText
android:id="@+id/email"
android:inputType="textEmailAddress" >
</EditText>
</LinearLayout>
Listing incomplet

Button
● Des actions sont souvent utilisés avec le widget
Button
● de manière générale des actions sont utilisables sur
tous les widgets
● Hérite de TextView
● propriétés utiles
– onClick : nom de la méthode de l'activité à exécuter
● la signature de la méthode doit être:
– public void nomMethode(View vue);

Button
● Java peut aussi être utiliser pour lier l'action au
bouton
● appel de listener
– même type de programmation événementielle que Swing
● la mise en place du listener se fait par la méthode
– public void setOnClickListener(View.OnClickListener listener)
– même choix d'implémentation que sous Swing
● doit implémenter View.OnClickListener
– classe anonyme
– méthode de l'activité
– méthode d'une classe de traitement
– l'implémentation doit fournir une méthode
● public void onClick(View v)

Button
● Mise en place de l'action par le fichier XML
● listings incomplets
<Button
android:id="@+id/btnEnvoyer"
android:text="Envoyer"
android:onClick="enregistrerUtilisateur" />
public void enregistrerUtilisateur(View v){
Button b = (Button) v;
EditText nom = (EditText) this.findViewById(R.id.nom);
Toast.makeText(this, b.getText()+"n"+ nom.getText(),
Toast.LENGTH_LONG).show();
}
création et affichage d'un toast
rendu du toast

Button
● Exécution de l'action par utilisation d'un listener
● listings incomplets
<Button
android:id="@+id/btnEnvoyer"
android:text="Envoyer"
/>
final Button b = (Button) findViewById(R.id.btnEnvoyer);
b.setOnClickListener(new View.OnClickListener() {
public void onClick(View v) {
EditText nom = (EditText) findViewById(R.id.nom);
Toast.makeText(v.getContext(), "Bonjour "+ nom.getText(),
Toast.LENGTH_LONG).show();
}
});
}
création d'une classe anonyme

antislashn.org Android - Intent 6 - 1/28
Intent

Bus de messages
● Les modules applicatifs ne sont pas invoqués directement
● ils sont activés via des messages, les "intentions"
– classe Intent
● Le message contient la description de l'opération devant être
exécutée
● sous forme divers
– nom de la classe
– action sous forme de chaîne de caractère
– type MIME
● Les messages sont aussi utilisés pour les retours de résultats
entre modules

Bus de messages
Producteur
Système Android
Module applicatif
Intent
IntentResolver
Application 2
Activité
Activité
IntentFilter
IntentFilter
Application 1
Activité
Service
IntentFilter
IntentFilter
Le composant dont le filtre
d'intention correspond est
activé

Bus de messages
● Activation d'activité
● Context.startActivity()
● Context.startActivityForResult()
– un intention est associée à Activity.setResult()
● Activation de service
● Context.startService()
● Context.bindService()
● Activation de BroadcastReceiver
● Context.sendBroadcast()
● Context.sendOrderedBroadcast()
● Context.sendBroadcast()

Bus de messages
● La collaboration entre les applications s'effectue via un
bus de message
● une instance de Intent est le message
● Contient plusieurs champs
● nom du composant qui doit gérer l'Intent
● l'action qui doit être exécutée
– sous forme de String
● une donnée sous forme d'URI et de type MIME
● une catégorie qui correspond au type de composant devant
gérer l'Intent
● des données supplémentaires – les Extras
● des flags utilisés par Android pour gérer le mode de
chargement d'une activité

Bus de messages
Activité principale
Activité A
Intent de lancement
Intent de résultat
Activité BIntent de lancement
extra

Lancement d'un message
● Selon le mode d'instanciation d'un Intent, les
champs précédents peuvent être nuls.
● Deux groupes de messages
● les intentions explicites
– le composant à activé est désigné par son nom
– en général utilisés au sein d'une même application
● les intentions implicites
– le nom du composant à activer n'est pas connu
– permet d'activer des composants d'autres application

Intent
● Intention explicite
● le composant cible est connu
– souvent une activité de la même application
– le composant cible n'a pas besoin de déclarer de filtre
d'intention dans le manifeste
● seulement des iintentions explicites peuvent alors l'invoquer
● syntaxe
● public Intent(Context ctx, Class<?> cls)
● public Intent(String action, Context ctx, Class<?> cls)
Intent intent = new Intent(this,ExplicitActivity.class);
startActivity(intent);

Intent
● Intention implicite
● le composant destinataire n'est pas connu
● le système est chargé de trouver le composant
destinataire
– si plusieurs composants cibles existent, le système demande
à l'utilisateur de choisir
● création d'une intention implicite
– l'action est positionnée
– une donnée associée (URI) peut être ajoutée
● syntaxe
● public Intent(String action)
● public Intent(String action, Uri uri)

Intent
● Intention implicite
● exemple
– le système cherche alors le meilleur composant parmi
ceux ayant déclarés leur capacité à réaliser l'action
● les composants ayant la capacité de réaliser
l'action doivent déclarer un filtre d'intentions
– un filtre d'intention n'a aucune incidence sur les
intentions explicites
Intent intent = new Intent(Intent.ACTION_DIAL, Uri.parse("tel:0102030405"));

Résolution des intentions
● Pour les intentions implicites Android doit trouver le – ou
les – composants susceptibles de gérer l'intention
● L'objet Intent est comparé aux filtres d'intentions
déclarés par les composants prenant en charge le
message
● dans le fichier manifeste
● balise <intent-filter>
● Trois champs sont retenus pour ce test
● l'action
● la donnée : URI et type MIME
● la catégorie

● Test sur l'action
● le test échoue si le filtre ne contient pas l'action de
l'intention
● Test sur la catégorie
● chacune des catégories de l'intention doit correspondre
aux catégories du filtre
● toutes les catégories du filtre n'ont pas a être présentes
dans l'intention
● un objet Intent qui ne possède pas de catégorie
passera donc toujours ce test
– une exception : le démarrage d'une activité nécessite la
catégorie android.intent.category.DEFAULT

● L'élément <data> spécifie une URI et un type
MIME
● l'URI est constituée de schema, host, port et path
– schema://host:port/path
– host:port forme l'authority
● Test sur la donnée
● un Intent qui ne contient pas de data passe le test
● un Intent qui contient une URI sans type de donnée
passe le test si le filtre correspond
● un Intent qui contient un type MIME passe le test si le
type correspond

● Utilisation des types MIME
● par défaut l'application SMS Android récupère
l'ensemble des intentions sur les types MIME
● il faut associer une action propre au composant pour
filtrer sur le type MIME et l'action
● Si plusieurs modules applicatifs peuvent répondre
à l'intention, Android présente une boite de
dialogue de choix à l'utilisateur

Intent
● La méthode getIntent() permet de récupérer
l'intention ayant lancée le composant
● L'action d'une intention peut être mise à jour et
récupérée par
● public Intent setAction(String action)
● public String getAction()
● Des données supplémentaires peuvent être
fournies à l'intention, sous forme de
● de catégories
● de données
● d'extras

Intent
● La catégorie
● utilisée pour déterminer le type de composant qui doit
réaliser l'action
● ajout par la méthode
– public Intent addCategory(String category)
● le paramètre String décrit la catégorie
● Android définie un certains nombre de catégories,
comme CATEGORY_LAUNCH, CATEGORY_HOME
– cf. la documentation

Intent
● Les données
● regroupe l'URI et le type MIME de la données cible
● le format et la signification des données sont
dépendants de l'action spécifiée
● en général le type MIME peut être déduit de l'URI
● méthodes utiles
– public Intent setData(Uri data)
– public Uri getData()
– public Intent setType(String type)
– public String getType()
● l'utilisation de setData et setType sont concurrentes,
elles écrasent leurs données respective

Intent
● Filtre d'intentions
● balise XML : intent-filter
– balise fille de la balise de déclaration du composant applicatif
– attributs
● icon : affichage pour l'utilisateur
● label : affichage pour l'utilisateur
● priority : donne une priorité de choix auprès du système, la valeur
la plus forte est la plus prioritaire
● balises filles principales
– action : nom de l'action sur laquelle réagir
– category : nom de la catégorie sur laquelle réagir
– data : spécifie une URI et/ou un type MIME

● Un composant applicatif peut déclarer plusieurs
filtres d'intention
<activity android:name=".Activity2">
<intent-filter >
<action android:name="org.antislashn.android.action.TOTO" />
<category android:name="android.intent.category.DEFAULT"/>
<category android:name="org.antislashn.android.category.LAUNCH"/>
</intent-filter>
<intent-filter >
<data android:scheme="moncontent" android:host="org.antislashn.android"
android:port="150"/>
</intent-filter>
<intent-filter >
<data android:mimeType="type/antislashn"/>
</intent-filter>
</activity>
nécessaire pour lancer l'activité

● Filtre avec action et catégorie
● appel avec action
● appel avec action et catégorie
<intent-filter >
<category android:name="org.antislashn.android.category.LAUNCH"/>
</intent-filter>
Intent intent = new Intent(Activity2.ACTION);
défini l'action TOTO
intent.addCategory(Activity2.LAUNCH_CATEGORY);
défini l'action TOTO
défini la catégorie LAUNCH

● Filtre avec action et URI
● appel
<intent-filter >
<data android:scheme="moncontent" android:host="org.antislashn.android"
android:port="150"/>
</intent-filter>
Uri uri = Uri.parse("moncontent://org.antislashn.android:150/exemple/toto");
Intent intent = new Intent(Activity2.ACTION,uri);

● Filtre avec action et type MIME
● appel
<intent-filter >
<data android:mimeType="type/antislashn"/>
</intent-filter>
intent.setType("type/antislashn");

Intent
● Exemples d'utilisation d'intentions
● utilisation d'une action et d'une URI
– ACTION_VIEW et content://contacts/people/1
● affichera les informations du contact ayant l'identifiant 1
– ACTION_DIAL et tel:123
● provoque l'affichage du clavier téléphonique avec le numéro de
téléphone
– ACTION_GET_CONTENT et vnd.android.cursor.item/phone
● affiche la liste des numéros de téléphone
● autres exemples
– ACTION_MAIN et CATEGORY_HOME
● affichage de l'écran d'accueil

Intent
● Les Extras
● données applicatives ajoutées à l'intention
● méthodes
– public Intent putExtras(Bundle extra)
– public Bundle getExtras()

Intent
● Bundle
● similaire à la classe Map
– clé : uniquement de type String
– valeur associée à la clé : toute instance, ou tableau
d'instances, de classe implémentant l'interface Parcelable
● mécanisme de sérialisation léger propre à Andoid
● de nombreuses méthodes de la classe Intent
permettent de ne pas instancier directement un Bundle
– public Intent putExtra(String name, int value)
– public int getIntExtra(String name, int defaultValue)
– public Intent putExtra(String name, String value)
– public String getStringExtra(String name, String
defaultValue)
– etc.

Intent
● Des indicateurs (flags, drapeaux) peuvent aussi
être ajouter à l'intention
● public Intent setFlags(int flags)
● public Intent addFlags(int flags)
● public int getFlags()
● Les flags permettent de changer certains
comportements par défaut des activité
● gestion de la pile des activités par exemple

PendingIntent
● Intention en attente
● de type PendingIntent
● contient une instance d'Intent décrivant l'action à
réaliser
● cette action est réalisée ultérieurement
– par une autre application qui reçoit alors les droits de
l'application qui a créée l'intention en attente
● création d'une intention en attente par les méthodes
statique de PendingIntent
– getActivity : lancera une activité
– getService : lancera un service
– getBroadcast : diffuse un événement

PendingIntent
● Avec un Intent, un module applicatif A demande
le lancement d'un module applicatif B
● Avec un PendingIntent, un module applicatif A
demande à un module X de lancer un module B
Activité A Activité BIntent
Activité A Module X Activité BIntentPendingIntent

antislashn.org Android - Activity 7 - 1/22
Les activités
Activity

Activity
● Composant applicatif
● peut-être constitué de fragments (Fragment)
– sera abordé plus loin
● représente la gestion d'un écran pour l'utilisateur
– une application simple peut être composée d'une seule
activité
– l'écran géré par l'activité est celui qui est vu par l'utilisateur
● s'exécute dans le thread principal de l'application
– ne pas bloquer ce thread principal par des calculs ou attentes
de ressources
● mauvaise expérience utilisateur
● Android peut alors décider de tuer l'activité

Activity
● Une activité spécialise la classe Activity
● Activity hérite de Context
● l'activité est déclarée dans le fichier manifeste
● Possède un cycle de vie qui est géré par Android
● nous avons vu la méthode onCreate(...)
● Une activité est déclenchée par une intention
(Intent)
● intention implicite
● intention explicite

Activity
● Activités et intentions
● une activité qui accepte des intentions implicites doit
déclarer dans ses filtres d'intention la catégorie
– android.intent.category.DEFAULT
● une activité qui est le point d'entrée de l'application doit
déclarer
– l'action : android.intent.action.MAIN
● composant point d'entrée de l'application
– la catégorie : android.intent.category.LAUNCHER
● composant pouvant être lancé par l'utilisateur
– la combinaison MAIN et LAUNCHER ajoutera l'activité au
"Lanceur d'applications" Android
– ne déclare pas android.intent.category.DEFAULT

Activity
● Déclaration dans le manifeste
● attributs courants
– label : nom de l'activité, si non précisé le label de
l'application est utilisé
– icon : icône de l'activité, si non précisé l'icône de l'application
est utilisé
– name : spécifie la classe de l'activité, si le package est le
même que l'attribut package de la balise manifest, il peut
être remplacé par point (.).
– screenOrientation : orientation de l'écran que doit
adopter l'application
● pas recommandé de fixer cette valeur
– hardwareAcceleration : (depuis API 11) demande
d'amélioration des performances d'affichage

Activity
● Exemple de fichier manifeste
package="org.antislashn.android.activity"
<application
<activity
android:name=".AppelactivityActivity" >
<intent-filter >
</intent-filter>
</activity>
<activity
android:label="explicit"
android:name=".ExplicitActivity" >
</activity>
</application>
</manifest>
activité point d'entrée de l'application
activité ne pouvant être appelée que par un intent explicite

Activity
● Cycle de vie
● une activité peut-être détruite par le système à partir du
moment ou cette activité est en pause
● les différentes méthodes du cycle de vie peuvent être
surchargées
– il faut commencer par appeler la méthode du même nom dans
la classe mère
● exemple : super.onCreate(savedInstanceState)
● bien garder à l'esprit que l'activité peut être exécutée en
arrière plan
– l'activité est toujours en mémoire, mais pas d'affichage

Activity

Activity
● onCreate
● appelée à la création de l'activité
● un seul appel lors du cycle de vie
● permet de créer les IHM, initialiser l'activité, …
● reçoit un objet de type Bundle
– récupère des informations sauvegardées précédemment lors de la
dernière exécution
– la sauvegarde est faite par le système
● une fermeture normale de l'activité ne provoque pas de sauvegarde
● si Android ferme l'activité la sauvegarde est effectuée
– les méthodes onSaveInstance et onRestoreInstance
permettent d'ajouter des objets dans Bundle
● ne pas utiliser pour la persistance, car onSaveInstance n'est pas toujours
appelée (arrêt normal de l'application par exemple)

Activity
● onStart
● appelée après la méthode onCreate ou onRestart
● précède l'affichage de la vue de l'activité
● onResume
● appelée après la méthode onStart ou onPause
● après l'affichage de la vue de l'activité

Activity
● onPause
● appelée lorsque une autre activité prend la main pour
passer en premier plan
● l'exécution de la méthode doit être rapide
● sauvegarde des données persistantes, arrêt des tâches
consommatrices de ressources, …
● la méthode isFinishing() permet de savoir si
l'activité va être détruite ou juste mise en pause
● jusqu'à l'API 11 Android peut décider de tuer
l'application à partir de la sortie de cette méthode
● à partir de l'API 11 Android peut décider de tuer
l'application après onStop

Activity
● onStop
● permet de libérer certaines ressources
● jusqu'à l'API 11 l'appel de cette méthode peut ne jamais
être exécutée
● onRestart
● appelée si l'activité revient au premier plan
● suivi d'un appel à onStart
● onDestroy
● appelée après un appel de la méthode finish ou par le
système si celui-ci à besoin de ressources
● permet de libérer des ressources liées à l'activité

Activity
● Des méthodes événementielles permettent de
gérer la persistance de l'instance
● onSaveInstanceState(Bundle) qui est appelée
juste avant que l'activité soit tuée onDestroy()
● onRestoreInstanceState(Bundle) qui est
appelée après la méthode onStart() et avant
onPostCreate(Bundle)

Activity
● lancement d'une activité par la méthode
startActivity
● public void startActivity(Intent intent)
● l'intention peut-être explicite ou implicite
● si l'activité invoquée doit retourner un résultat
● appeler l'activité avec startActivityForResult
● coder une méthode callback onActivityResult

Activity
● startActivityForResult
● public void startActivityForResult(Intent intent,
int requestCode)
● paramètres
– intent : intention envoyée au sysème
– requestCode : si >=0, ce même code sera retourné à la
méthode onActivityResult
–

Activity
● onActivityResult
● public void onActivityResult(int requestCode,
int resultCode,
Intent data)
● paramètres
– requestCode : code utilisé dans
startActivityForResult
– resultCode : résultat de retour de l'activité
● ce code a été positionné par l'activité par la méthode
setResult(int)ou setResult(int,Intent)
– data : intention retournée par l'activité, ce qui permet de
récupérer les extras ajoutés à l'intention par l'activité
● ce code a été positionné par l'activité appelée via sa méthode
setResult(int,Intent)

Activity
● Résumé : appel d'une activité avec retour de résultat
● dans l'activité appelante
– coder la méthode onActivityResult
– lancer l'intention pour démarrer l'activité appelée, celle qui retourne
le résultat
● dans l'activité appelée
– avant de finir l'activité, créer un nouvel Intent
– ajouter un extra
– ajouter à setResult
– puis appeler finish()
● au retour, dans l'activité appelée
– récupérer l'intention et extraire l'extra

Activity
● Exemple de code
● activité appelante
public class ActivityResultActivity extends Activity {
@Override
}
public void appelAutreActivity(View v){
Intent intent = new Intent(this,AutreActivity.class);
startActivityForResult(intent, 0);
}
@Override
public void onActivityResult(int requestCode, int resultCode, Intent data){
int r = data.getIntExtra("resultat", 0);
Toast.makeText(this, "RESULTAT = "+r, Toast.LENGTH_LONG).show();
}
}
appel de l'activité devant retourner
un résultat
récupération du résultat préparé par
l'activité appelée

Activity
● Exemple de code
● activité appelée retournant le résultat
public class AutreActivity extends Activity {
@Override
setContentView(R.layout.autre_activity);
}
public void stopActivity(View v){
Intent intent = new Intent();
intent.putExtra("resultat", 10);
this.setResult(0, intent);
this.finish();
}
}
préparation du résultat renvoyé à
l'activité appelante

Activity
● A chaque application le système associe une pile
LIFO
● la pile d'activités
● empile les activités lancées les une après les autres
● le bouton retour dépile les activités
● si l'utilisateur revient sur la page d'accueil Android
(touche Accueil) la pile est sauvegardée
– elle est restituée lorsque l'application est relancée
– l'activité courante est donc retrouvée

Activity
● Il est possible de changer le mode de
fonctionnement par défaut de la pile
● utilisation des attributs de la balise activity
– alwaysRetainTaskState : (yes | no)
– clearTaskOnLaunch : (yes | no)
– finishOnTaskLauch : (yes | no)
– launchMode : (standard | singleTop | singleTask |
singleInstance)
● ajout du flag Intent.FLAG_ACTIVITY_CLEAR_TOP
pour dépiler la pile jusqu'à l'activité qui doit être lancée

Activity
● Des classes dérivées de Activity permettent de
simplifier la gestion de certains contrôles
graphiques
● ListActivity
● MapActivity
● AccountAthentificationActivity
● ...

antislashn.org Android - ListView 8 - 1/29
Composant ListView

Développement Android

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (20)

Similaire à Développement Android

Similaire à Développement Android (20)

Plus de Franck SIMON

Plus de Franck SIMON (17)

Dernier

Dernier (19)

Développement Android