Développement des applications Mobiles

I. Introduction au développement des applications Mobiles :

Pour développer une application Mobile, on peut le faire en deux manières : soit développer en
code native ou mobile ou bien développer en code hybride (Html, Css, Javascript) qui sera
ensuite porté sur chaque plateforme.

1. C’est quoi Android ?

Android est un système d'exploitation open source et gratuit pour smartphones, PDA,
tablettes (systèmes légers) basé sur une version légère de Linux.

Android est le résultat de deux competitions organisées par GOOGLE « Android

Developer Challenge » en 2008 et 2009

Il a été conçu pour intégrer les applications Google : Gmail, Google Maps, Google Agenda,
YouTube et la géolocalisation.

Android est déployé en plusieurs versions qui ont des noms de dessert suivant l'ordre alphabétique,
de A à Z. Chaque version est sculptée et affichée devant le siège social de Google (Mountain
View) :

2. Versions d’Android ?
• 1.0 : sortie avant le premier téléphone Android (fin 2007)
• 1.1 : Version incluse dans le premier téléphone, le HTC Dream
• 1.5 : Cupcake (Petit Gâteau), sortie en avril 2009
• 1.6 : Donut (Beignet), sortie en septembre 2009
• 2.0 (2.0.1) : A cause de nombreux bugs, remplacée par la version 2.1
• 2.1 : Eclair, sortie en janvier 2010
• 2.2 : FroYo (Frozen Yogourt : Yaourt glacé), sortie en mai 2010
• 2.3 : Gingerbread (Pain d'épice), sortie le 6 décembre 2010
• 3.0 : Honeycomb10 (Rayon de miel), sortie le 26 janvier 2011

1
Mme JAKJOUD
• 4.0 : Ice Cream Sandwich (Sandwich à la crème glacée), version unifiée pour Smartphone,
Tablette et GoogleTV, combinant Gingerbread et Honeycomb, sortie le 19 octobre 2011
• 4.2.2 : API 17 sortie le 11 février 2013

3. Ecosystème :
L'écosystème d'Android s'appuie sur deux piliers:

• le langage Java

• le SDK qui permet d'avoir un environnement de développement facilitant la tâche du

développeur

Le kit de développement donne accès à des exemples, de la documentation mais surtout à l'API
de programmation du système et à un émulateur pour tester ses applications.

Stratégiquement, Google utilise la licence Apache pour Android ce qui permet la redistribution
du code sous forme libre ou non et d'en faire un usage commercial.

Le SDK était anciennement manipulé par un plugin d'Eclipse (obsolète), maintenant, elle est
intégrée à Android Studio (IntelliJ).

Android est en fait un système de la famille des Linux sans les outils GNU, il comporte :

• un noyau Linux (et ses drivers)

• une couche d'abstraction pour l'accès aux capteurs (HAL)
• une machine virtuelle: Dalvik Virtual Machine
• un compilateur de bytecode vers le natif Android Runtime
• des applications (navigateur, gestion des contacts, application de téléphonie...)
• des bibliothèques (SSL, SQLite, OpenGL ES, etc...)
• des API d'accès aux services Google

4. Développement des applications pour Android :

Les développeurs d'applications payantes reçoivent 70 % du prix du logiciel, 30 % allant à
Google (redistribués aux développeurs via Google Check out). Chaque nouveau développeur
paie $25 comme frais de dossier (une seule fois)

5. Particularité d’Android
Android tire parti des particularités des Smartphones, à savoir : l’interface homme machine
adapté (tactile, widget), Les divers modes (vibreur, sonnerie, silencieux, alarme), les
notifications (d'applications, d'emails, de SMS, d'appels en instance) , le GPS les divers capteurs
(gyroscope, gravité, accélération linéaire, baromètre), la téléphonie (GSM) et réseau 3G…

2
Mme JAKJOUD
Ceci en plus de ce qu'on peut avoir sur un ordinateur : navigateur, bibliothèques graphiques 2D,
3D, base de données (SQLite), applications de rendu multimédia (audio, vidéo, image) de divers
formats, réseau Bluetooth et Wi-Fi, caméra

II. Architecture générale des applications Android

Android est une pile applicative pour les appareils mobiles qui comprend un système
d'exploitation, middleware et des applications clés.

Le SDK Android fournit les outils et les API nécessaires pour commencer à développer des
applications sur la plate-forme Android en utilisant le langage de programmation Java.

Le schéma suivant illustre les principaux composants du système d'exploitation Android :

6. La couche Application :

Android est fourni avec un ensemble de programmes de base (également nommés applications
natives) permettant d'accéder à des fonctionnalités comme par exemple : les courriels, les SMS,
le téléphone, le calendrier, les photos, les cartes géographiques, le Web.

3
Mme JAKJOUD
Ces applications sont développées à l'aide du langage de programmation Java. Pour l'utilisateur
final, c'est la seule couche accessible et visible :

7. Le framework : Application Framework:

Cette couche permet de développer des applications riches et innovantes et ce grâce à une
plateforme de développement ouverte.

Les développeurs sont libres de profiter du matériel périphérique, les informations de localisation
d'accès, exécuter les services d'arrière-plan, définir des alarmes, ajouter des notifications de la
barre d'état, ….

Le framework offre, entre autre, des gestionnaires pour les applications : Gestion des fenêtres,
des activités, des ressources …

8. La couche Librairies : Bibliothèques :

Cette couche inclut un ensemble de bibliothèques C et C++ utilisées par de nombreux
composants de la plateforme Android.

En effet, le framework Android utilise, implicitement, des appels à des fonctions C/C++ parce
que c’est beaucoup plus rapides à exécuter que des méthodes Java standard. La technologie Java
Native Interface (JNI) permet d'effectuer des échanges entre le code Java et le code C et C++.

9. Le moteur d’exécution Android (Android Runtime) :

Un moteur d'exécution « runtime system » est un programme qui permet l’exécution d'autres
programmes :

En effet, pour exécuter des applications JAVA sur un ordinateur, il faut absolument un moteur
d’exécution qu’on appelle JRE « Java Runtime Environment ».

Pour les applications Android, on utilise une version de Java réduite qui ne contient pas les
fonctionnalités qui n'ont rien à faire dans un environnement mobile (La bibliothèque graphique
Swing par exemple). La machine virtuelle utilisée est développée spécialement pour les

4
Mme JAKJOUD
systèmes embarqués et elle s'appelle « Dalvik ». Elle est optimisée pour mieux gérer les
ressources physiques à savoir la mémoire, la batterie,…

Le code source Jave est convertit, après la compilation, en un bytecode java (.class) puis, une
deuxième compilation va générer un autre bytecode (.dcx) qui est exécuté par la machine
virtuelle Dalvik.

Cette particularité d'Android en fait un système unique, loin des systèmes Linux traditionnels
que beaucoup avaient pu rencontrer auparavant.

10. Le noyau Linux: Linux Kernel

Android repose sur un noyau Linux (version 2.6) qui joue le rôle d’une couche d’abstraction
entre e matériel et le logiciel. Le noyau gère les services du système, comme la sécurité, la
gestion de la mémoire et des processus, la pile réseau et les pilotes.

5
Mme JAKJOUD
 III. Architecture d’une application Android:
1. Architecture d’un projet Android Studio :

• app: le code de l’application

• build: le code compilé
• lib: les librairies natives
• src: les sources de l’application
• main/java: les classes
• main/res: les ressources (XML, images, ...)
• test: les tests unitaires
• Des fichiers de configuration:
• build.gradle (2 instances): règles de dépendance et de compilation
• settings.gradle: liste de toutes les applications à compiler (si plusieurs)

2. Les composants d’une application :

Une application Android peut être composée de quatre composants principaux :

• des activités (android.app.Activity): il s'agit de parties de l'application présentant une vue à

l'utilisateur.

• des services (android.app.Service): il s'agit des activités sans vue associée

• des fournisseurs de contenus (android.content.ContentProvider): permettent le partage

d'informations au sein ou entre applications

• des notifications (android.app.Notifications): permettent de notifier l'utilisateur de la

survenue d'événements

Activity (les activités) : Une activité représente un morceau de l’application (fonctionnalité) qui
a une interface avec l’utilisateur. Par exemple, une application de messagerie peut avoir une
activité qui assure l’authentification (login/mot de passe), une autre activité qui affiche une liste
de nouveaux mails, une troisième activité pour composer un nouveau mail et une autre activité
pour lire les mails.

6
Mme JAKJOUD
Si une application comporte plus d’une activité, l’une d’entre elles doit être marquée comme
l’activité présentée lors du lancement de l’application.

Une activité est implantée sous forme d’une sous classe de la classeAppCompact Activity (qui
remplace la classe Activity à partir de la version 3.0 de AndroidStudio) :

Public Class MainActivity extends AppCompatActivity{…}

Services :Un service est un composant qui s’exécute en arrière-plan pour effectuer des
opérations à long terme. Par exemple, un service peut jouer de la musique en arrière-plan
lorsque l’utilisateur se trouve dans une autre application, ou il peut récupérer des données sur
le réseau sans bloquer l’interaction de l’utilisateur avec une activité.

Un service est mis en œuvre come sous classe de la classe Service comme suit :

Public class MyService extends Service{…}

Récepteurs de diffusion (Broadcast Receivers) : Les récepteurs de diffusion permettent à une

application de récupérer des informations générales par exemple la réception d’un SMS,
batterie faible, …

Les récepteurs de diffusion répondent simplement aux messages diffusés provenant d’autres
applicatifs ou du système. Par exemple, les applications peuvent également déclencher des
émissions pour permettre aux autres applications de savoir si certaines données ont été
téléchargées sur le périphérique et qu’elles sont disponibles pour qu’elles puissent être
utilisées, donc c’est un récepteur qui intercepte cette communication et lancera une action
appropriée.

Un récepteur de diffusion est implanté sous la forme d’une sous classe de la classe
BroadcastReceiver et chaque message est un diffuseur comme objet Intent.

Public Class MyReceiver extends BroadcastReceiver{….}

Fournisseurs de contenu (Contents providers) : Un fournisseur de contenu fournit des données

d’une application à d’autres sur demande. De telles requêtes sont traitées par les méthodes de
la classe ContentResolver. Les données peuvent être stockées dans le système de fichiers, la
base de données ou ailleurs.

Un fournisseur de contenu est implanté comme une sous classe de la classe ContentProvider et
doit implanter un ensemble standard d’API permettant à d’autres applications d’effectuer des
transactions :

7
Mme JAKJOUD
 Public Class MyContentProvider extends ContentProvider{….}

Le fichier de configuration AndroidManifest : Pour développer des applications Android, il faut

respecter un certain nombre de règles.

La configuration d’une application Android ainsi que l’ensemble des composants sont définis
dans le fichier AndroidManifest.xml : Par exemple, l’ensemble des Activités et des Services de
l’application doivent y être répertoriées.

Ce fichier doit également contenir l’ensemble des permissions de l’application : Par exemple si
l’application a besoin d’un accès à internet, ceci doit être spécifié dans le fichier
AndroidManifest.xml.

Exemple d’un fichier AndroidManifest.xml :

<?xml version="1.0" encoding="utf-8"?>

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.istantic.android.temperature"
android:versionCode="1" android:versionName="1.0">

<application android:icon="@drawable/icon" android:label="@string/app_name">

<activity android:name=".Convert"
android:label="@string/app_name">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
</application>
<uses-sdk android:minSdkVersion="9" />
</manifest>
• L’attribut package définit le package de base des objets Java de l’application. Google
Play exige que chaque application Android utilise un package unique. Ainsi, c’est une
bonne habitude à prendre d’utiliser son nom de domaine inversé comme nom de
package. Ceci évitera les collisions avec d’autres applications Android.

• andoid:versionName et android:versionCode spécifient la version de l’application.

versionName représente ce que l’utilisateur peut voir). versionCode doit être un
nombre (Integer). Google Play détermine en fonction de ce versionCode, s’il doit réaliser
une mise à jour de l’application sur les terminaux qui ont installé l’application. Ainsi,
pour ce versionCode, on commence généralement à 1 et on incrémente cette valeur de
1 lorsque l’on livre une nouvelle version de l’application.

8
Mme JAKJOUD
 • Le tag <Activity> définit une Activity : Dans cet exemple, on définit la classe « Convert ».
On définit alors un « intent filter » pour cette classe, ce qui permet de déterminer que
cette Activity est lancée au démarrage de l’application
(action android:name= »android.intent.action.MAIN »).

• La définition de la catégorie (category android:name

= »android.intent.category.LAUNCHER ») définit que l’application est ajoutée au
répertoire contenant l’ensemble des applications sur le terminal Android.

• La valeur @string/app_name fait référence au fichier de ressources qui contient la

valeur actuelle du nom de l’application. L’utilisation de fichiers de ressources rend facile
le fait de définir plusieurs ressources comme des strings, des couleurs, des icônes. Ceci
permet alors de s’adapter plus facilement aux différents types de terminaux mais
également de réaliser l’internationalisation d’une application.

• Le tag <uses-sdk> définit la version minimale du SDK android pour laquelle l’application
est valide. Ceci empêchera l’installation de l’application sur des terminaux qui ont une
version du SDK Android plus ancienne.

Récapitulation :

• Une activité = un programme + une interface

• Un service = un programme sans interface
• Une application =
o Une activité principale
o Eventuellement une ou plusieurs activités secondaires
o Eventuellement un ou plusieurs services
o Eventuellement un ou plusieurs récepteurs de diffusion
o Eventuellement un ou plusieurs fournisseurs de contenu

9
Mme JAKJOUD
IV. Les activités :

Une activité est une classe qui peut avoir plusieurs états :

o Démarrage -> Active: L’activité est démarrée et elle détient le focus

o Active -> Suspendue: L’activité active perd le focus et devient suspendue
o Suspendue -> active: L’active suspendue reprend le focus et redevient active.
o Suspendue -> Détruite: Destruction d’une activité suspendue
o Active -> Détruite : Destruction d’une activité active.

Pour chaque état, une méthode est surchargée :

o onCreate lors de la création

o onDestroy lorsque l’activité se termine
o onStart lorsque l’activité démarre ou redémarre
o onPause lorsque l’activité n’est plus en premier plan
o onResume lorsque l’activité revient en premier plan
o onStop lorsque l’activité n’est plus visible
o onRestart lorsque l’activité redevient visible

10
Mme JAKJOUD
 1. Cycle de vie d’une activité :

11
Mme JAKJOUD
 o onCreate() / onDestroy(): permet de gérer les opérations à faire avant l'affichage de
l'activité, et lorsqu'on détruit complètement l'activité de la mémoire. On met en général
peu de code dans onCreate() afin d'afficher l'activité le plus rapidement possible.
o onStart() / onStop(): ces méthodes sont appelées quand l'activité devient visible/
invisible pour l'utilisateur.
o onPause() / onResume(): une activité peut rester visible mais être mise en pause par le
fait qu'une autre activité est en train de démarrer, par exemple B. onPause() ne doit pas
être trop long, car B ne sera pas créé tant que onPause() n'a pas fini son exécution.
o onRestart(): cette méthode supplémentaire est appelée quand on relance une activité
qui est passée par onStop(). Puis onStart() est aussi appelée. Cela permet de différencier
le premier lancement d'un relancèrent.

2. Sauvegarde des interfaces d’activité :

L'objet Bundle passé en paramètre de la méthode onCreate permet de restaurer les valeurs des
interfaces d'une activité qui a été déchargée de la mémoire.
En effet, lorsque l'on appuie par exemple sur la touche Home, en revenant sur le bureau,
Android peut être amené à déchargé les éléments graphiques de la mémoire pour gagner des
ressources.
Si on revient à l'application, il se peut qu’elle perde les valeurs saisies dans les zones de texte.
Mais grâce au Bundle, les valeurs importantes seront toujours restaurées.
Mais si une zone de texte n'a pas d'identifiant, Android ne pourra pas la sauver et elle ne pourra
pas être restaurée à partir de l'objet Bundle.
Si l'application est complètement détruite (tuée), rien n'est restauré.

12
Mme JAKJOUD
 ATELIER 1 : Installation de
Android studio et prise en main
1. Prérequis :
Afin de développer convenablement des applications Android, il faut :

• Une bonne maitrise du langage JAVA

• Une bonne configuration matérielle : Machine avec Windows 7 minimum et 4 GO Ram
• Une machine virtuelle JAVA (JDK)
• Android SDK qui comporte les plateformes et outils nécessaires pour le développement
Mobile à savoir les APIs de Google, Les versions de Android, les outils comme :
o Adb : qui permet la connexion au smartphone o au simulateur.
o Dx qui transforme le bytecode java (.class) en code Dalvik
o Apkbuilder qui constitue un fichier apk téléchargeable sur le terminal.
o …

Même si les EDIs de développement Mobiles (Eclipse (obsolète), Android Studio, Netbeans,…)
utilisent ces outils implicitement mais, on se trouve parfois obligés d’y recourir (transfert de
fichier, installations directes d’applications,…).

• Android Studio Version 3.0 ou plus

• Un émulateur pour simuler l’exécution de l’application sous Smartphone.

2. Installation de l’environnement de développement :

1. Installer le JDK
2. Installer l’environnement Android Studio

13
Mme JAKJOUD
 3. Installer l’émulateur GenyMotion :

Android Studio fournit ces propres Emulateurs mais ils partagent l’inconvénient d’être très lents
et de ne pas supporter GooglePlay Services pour tester les applications embarquant par exemple
une carte GoogleMap ou des publicités GoogleAd

Pour l’utiliser, il faut installer la machine virtuelle Oracle VM Virtual Box. Puis il faut créer un
nouvel émulateur.

3. TP 1 : Première application Android

Apres le lancement d’Android Studio, on choisit de créer une nouvelle application Mobile :

14
Mme JAKJOUD
Puis on va fournir le nom de notre application et le chemin du dossier ou l’applicatif sera
sauvegarder. On fournit également le nom du domaine qui doit être unique pour chaque
application. EN effet, il faut pas oublier que ces applications doivent éventuellement être
cataloguées dans Google Play. Pour cela, Google exige de les identifier clairement par ce nom de
domaine.

15
Mme JAKJOUD
On choisit également le type d’appareils auquel est destiné l’applicatif :

On va choisir la nature de l’activité à ajouter à l’application. Une application peut contenir de une
à plusieurs activités.

Pour ce premier test, on va choisir Empty Activity (une activité vide) et on va laisser les valeurs
des champs de configuration par defaut.

16
Mme JAKJOUD
Et voilà le projet se lance avec le rendu suivant :

17
Mme JAKJOUD
 18
Mme JAKJOUD
 4. Le fichier manifest de l'application :
Le fichier AndroidManifest.xml fixe les caractéristiques du binaire de l'application Android. Son
contenu est ici le suivant :

1. <?xml version="1.0" encoding="utf-8"?>

2. <manifest xmlns:android=http://schemas.android.com/apk/res/android
3. package="com.example.widad.HelloWorldTDI">
4. <application
5. android:allowBackup="true"
6. android:icon="@mipmap/ic_launcher"
7. android:label="@string/app_name"
8. android:roundIcon="@mipmap/ic_launcher_round"
9. android:supportsRtl="true"
10. android:theme="@style/AppTheme">
11. <activity android:name=".MainActivity">
12. <intent-filter>
13. <action android:name="android.intent.action.MAIN" />
14. <category
android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
</application>
</manifest>

La ligne 3 représente le paquetage de l’application

La ligne 11 est le nom de l’activité principale, on a laissé le nom par défaut.

La ligne 6 représente l’icône de l’activité qu’on peut bien sûr changer.

La ligne 7 est le label de l’activité, sa valeur se trouve dans le fichier strings.xml qui contient les
différentes chaines de caractères utilisées par l’application.

19
Mme JAKJOUD
La ligne 12 : l'activité est désignée comme étant l'activité principale ;

La ligne 13 : Cette activité doit apparaître dans la liste des applications qu'il est possible de lancer
sur l'appareil Android.

5. L’Activité principale :
Une application Android repose sur une ou plusieurs activités. L’activité générée par l’application
est MainActivity sa classe est la suivante :

1. package com.example.widad.HelloWorldTDI;
2. import android.support.v7.app.AppCompatActivity;
3. import android.os.Bundle;
4. public class MainActivity extends AppCompatActivity {
@Override
5. protected void onCreate(Bundle savedInstanceState) {
6. super.onCreate(savedInstanceState);
7. setContentView(R.layout.activity_main);
8. }}

20
Mme JAKJOUD
La ligne 4 : la classe MainActivity hérite de la classe Android AppCompatActivity. Ce sera le cas de
toutes les activités futures ;

La ligne 5 : la méthode onCreate est exécutée lorsque l'activité est créée et avant l'affichage de
la vue associée à l'activité, c’est une méthode qui redéfinie une autre méthode dans la classe
mère AppCompatActivity. La méthode de base doit être toujours appelée avec le même
paramètre : La ligne 6.

La ligne 7 : le fichier activity_main.xml est la vue associée à l'activité. La définition XML de cette
vue est la suivante :

a) <?xml version="1.0" encoding="utf-8"?>

b) <android.support.constraint.ConstraintLayout
c) xmlns:android="http://schemas.android.com/apk/res/android"
d) xmlns:app="http://schemas.android.com/apk/res-auto"
e) xmlns:tools="http://schemas.android.com/tools"
f) android:layout_width="match_parent"
g) android:layout_height="match_parent"
h) tools:context="com.example.widad.tp2.MainActivity">

i) <TextView
j) android:layout_width="wrap_content"
k)
l) android:layout_height="wrap_content"
m) android:text="Bonjour TDI"
n) android:textColor="@color/colorAccent"
o) app:layout_constraintBottom_toBottomOf="parent"
p) app:layout_constraintLeft_toLeftOf="parent"
q) app:layout_constraintRight_toRightOf="parent"
r) app:layout_constraintTop_toTopOf="parent" />

</android.support.constraint.ConstraintLayout>

Les lignes b-h représentent le gestionnaire de mise en forme. Ici on voit celui par defaut qui est
ConstraintLayout. Ce conteneur permet de placer les composants les uns par rapport aux autres
(à droite de, à gauche de, dessous, au-dessus) ;

Les lignes i-r introduisent un composant de type TextView qui permet l’affichage du texte dans
une vue.

La ligne m concerne le texte affiché. Il est déconseillé de mettre beaucoup de texte dans les
vues. Il est préférable de déplacer ces textes dans le fichier strings.xml qui se trouve dans le
dossier res/values. Le texte affiché sera donc « Bonjour TDI ».

Si on revient à la classe MainActivity et plus exectement la ligne 7 :

21
Mme JAKJOUD
 setContentView(R.layout.activity_main);
R est une classe générée dans le dossier app/build/generated :

Chaque ressource Android (vues, fragments, composants,…) a un identifiant. Par exemple une
vue V.xml qui se trouve dans le dossier res/layout sera identifiée par : R.layout.V

6. Exécution de l’application :

22
Mme JAKJOUD
 23
Mme JAKJOUD
 7. Manipulation du fichier String.xml :
On modifie le fichier activity_main pour que la valeur de la zone de texte non editable soit
stockée dans le fichier string.xml. Pour cela, on va modifier la ligne android :text
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Bonjour TDI"
android:textColor="@color/colorAccent"
app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintLeft_toLeftOf="parent"
app:layout_constraintRight_toRightOf="parent"
app:layout_constraintTop_toTopOf="parent" />

Pour qu’elle devienne:

<TextView
android:layout_width="wrap_content"

android:layout_height="wrap_content"
android:text="@string/valeurText"
android:textColor="@color/colorAccent"
app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintLeft_toLeftOf="parent"
app:layout_constraintRight_toRightOf="parent"
app:layout_constraintTop_toTopOf="parent" />

On modifie également le fichier string.xml pour ajouter l’entrée suivante :

<string name="valeurText">Bonjour TDI</string>

24
Mme JAKJOUD
V. Les ressources :
Dans une application embarquée toutes les ressources doivent être dans le fichier .apk qu’on
télécharge et l’installe dans le Smartphone. Pour cela, toutes les ressources qui concernent
l’application à développer se trouvent dans le répertoire res qui sera mis dans le apk :
• drawable-hdpi (images en haute définition)
• drawable-ldpi (images en basse définition)
• drawable-mdpi (images en moyenne définition)
• layout (description en XML des interfaces)
• values (définitions en XML de constantes : chaînes, tableaux, valeurs numériques …)
• anim (description en XML d’animations)
• menus (description en XML de menus pour l’application)
• xml (fichiers XML utilisés directement par l’application)
• raw (tous les autres types de ressources : sons, vidéos, …)
On peut ajouter d’autres sous répertoires.

Les ressources du répertoire res sont utilisées dans le code au travers de la classe statique R
régénérée automatiquement à chaque changement dans le projet.

Toutes les ressources sont accessibles au travers de R, dès qu'elles sont déclarées dans le fichier
XML ou que le fichier associé est déposé dans le répertoire adéquat. Les ressources sont
utilisées de la manière suivante:

android.R.type_ressource.nom_ressource

Ce qui retourne une valeur entière (de type int). Il s'agit en fait de l'identifiant de la ressource.
Afin de récupérer les objets graphiques à partir de leur id (widgets du fichier activity_main.xml)
, on utilise la méthode findViewById(identifiant issu de la classe R).

Exemple :

TextView texte = (TextView)findViewById(R.id.le_texte);

texte.setText("Bonjour TDI !");

25
Mme JAKJOUD