• 20 heures
  • Moyenne

Ce cours est visible gratuitement en ligne.

Ce cours existe en livre papier.

Vous pouvez être accompagné et mentoré par un professeur particulier par visioconférence sur ce cours.

J'ai tout compris !

Mis à jour le 26/02/2019

Les ressources

Connectez-vous ou inscrivez-vous gratuitement pour bénéficier de toutes les fonctionnalités de ce cours !

Nous allons désormais parler des ressources. Les ressources sont des fichiers qui contiennent des informations qui ne sont :

  • Pas en Java (ce n'est donc pas du code).

  • Pas dynamique (le contenu d'une ressource restera inchangé entre le début de l'exécution de votre application et la fin de l'exécution).

Android est destiné à être utilisé sur un très grand nombre de supports différents, et il faut par conséquent s'adapter à ces supports.  L'avantage des ressources, c'est qu'elles nous permettent de nous adapter facilement à toutes ces situations différentes.

Prenons quelques exemples concrets :

  • Votre application affiche une image. Si cette image est matricielle, c'est-à-dire qu'elle est constituée de pixels comme une photo par exemple, alors il faudra adapter sa taille à l'écran du terminal. Si la photo est petite, il faudra agrandir l'image. Et qu'est-ce qui se passe quand on agrandit une image matricielle ? Elle perd en qualité. L'idéal sera donc de préparer à l'avance plusieurs images à afficher en fonction de la résolution de l'écran.

  • Votre application fonctionne super bien en français, vous avez donc décidé de la traduire en anglais. Aïe, tous vos textes se trouvent dans le code, comment allez-vous faire pour retrouver chaque texte et le traduire efficacement en anglais ? Heureusement avec les ressources, vous pouvez organiser facilement les chaînes de caractères pour plus facilement travailler avec.

Pour déclarer des ressources, on passe très souvent par le format XML, c'est pourquoi un point sur ce langage est nécessaire.

Le format XML

Les langages de balisage

Le XML est un langage de balisage un peu comme le HTML — le HTML est d'ailleurs indirectement un dérivé du XML. Le principe d'un langage de programmation (Java, C++, etc.) est de donner des ordres à l'ordinateur pour qu'il puisse effectuer des calculs, puis éventuellement de mettre en forme le résultat de ces calculs dans une interface graphique.

À l'opposé, un langage de balisage (comme le XML) n'a pas pour objectif de donner des ordres à l'ordinateur, il se contente de définir une façon de mettre en forme l'information de façon à ce qu'on sache comment lire cette information.

Et si on connaît l'architecture d'un fichier, alors il est très facile de retrouver l'emplacement des informations contenues dans ce fichier et de pouvoir les exploiter. Ainsi, il est possible de développer un programme appelé interpréteur qui récupérera les données d'un fichier (structuré à l'aide d'un langage de balisage).

Par exemple pour le HTML, c'est un navigateur qui interprète le code afin de donner un sens aux instructions ; si vous lisez un document HTML sans interpréteur, vous ne verrez que les sources, pas l'interprétation des balises.

Un exemple pratique

Imaginons un langage de balisage très simple, que j'utilise pour stocker mes contacts téléphoniques :

Anaïs Romain Thomas Xavier

Ce langage est très simple : les prénoms de mes contacts sont séparés par une espace. Ainsi, je peux dire à mon ordinateur "Ce texte ne contient que des prénoms. Si tu trouves un espace, c'est qu'on est arrivé à la fin d'un prénom et qu'on va en trouver un autre". Quand je demanderai à mon interpréteur de lire le fichier, il saura que j'ai 4 contacts parce que les prénoms sont séparés par des espaces. Il lit une suite de caractères et dès qu'il tombe sur une espace, il sait qu'on va passer à un autre prénom.

On va maintenant rendre les choses plus complexes pour introduire les numéros de téléphone :

Anaïs : 1111111111
Romain: 2222222222
Thomas: 3333333333
Xavier: 4444444444

Là, l'interpréteur sait que pour chaque ligne, la première suite de caractères correspond à un prénom qui se termine par un deux-points, puis on trouve le numéro de téléphone qui se termine par un retour à la ligne. Et, si j'ai bien codé mon interpréteur, il sait que le premier prénom est « Anaïs » sans prendre l'espace à la fin, puisque ce n'est pas un caractère qui rentre dans la composition d'un prénom.

Si j'avais écrit mon fichier sans syntaxe particulière à respecter, alors il m'aurait été impossible de développer un interpréteur qui puisse retrouver les informations.

Anaïs11111111Romain 2222222222,thomas   3333333333





Xa
vier!!!!!


4444444444

Il vous est impossible de coder un interpréteur qui sache comment récupérer un prénom et l'associer à un numéro de téléphone dans ces conditions.

La syntaxe XML

Comme pour le format HTML, un fichier XML débute par une déclaration qui permet d'indiquer qu'on se trouve bien dans un fichier XML.

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

Cette ligne permet d'indiquer que :

  • On utilise laversion 1.0de XML.

  • On utilise l'encodage des caractères qui s'appelleutf-8; c'est une façon de décrire les caractères que contiendra notre fichier.

Je vais maintenant vous détailler un fichier XML :

<?xml version="1.0" encoding="utf-8"?>
<bibliotheque>
  <livre style="fantaisie">
    <auteur>George R. R. Martin</auteur>
    <titre>A Song Of Ice And Fire: A Game Of Thrones</titre>
    <langue>Klingon</langue>
    <prix>10.17</prix>
  </livre>
  <livre style="aventure">
    <auteur>Alain Damasio</auteur>
    <titre>La Horde Du Contrevent</titre>
    <prix devise="euro">9.40</prix>
    <recommandation note="20"></recommandation>
  </livre>
</bibliotheque>

L'élément de base du format XML est la balise. Elle commence par un chevron ouvrant < et se termine par un chevron fermant >. Entre ces deux chevrons, on trouve un mot. Par exemple<bibliotheque>. Cette balise s'appelle balise ouvrante, et autant vous le dire tout de suite : il va falloir la fermer !

Il existe deux manières de fermer une balise ouvrante :

  • Soit par une balise fermante (dans notre cas</bibliotheque>), auquel cas vous pourrez avoir du texte ou d'autres balises entre la balise ouvrante et la balise fermante. Étant donné que notre bibliothèque est destinée à contenir plusieurs livres, nous avons opté pour cette solution.

  • Soit on ferme la balise directement dans son corps :<bibliotheque />. La seule différence est qu'on ne peut pas mettre de contenu entre deux balises… puisqu'il n'y en a qu'une. Dans notre exemple, nous avons mis la balise<recommandation note="20"/>sous cette forme par choix, mais nous aurions tout aussi bien pu utiliser<recommandation>20</recommandation>, cela n'aurait pas été une erreur.

Ce type d'informations, qu'il soit fermé par une balise fermante ou qu'il n'en n'ait pas besoin, s'appelle un nœud. Vous voyez donc que l'on a un nœud appelébibliotheque, deux nœuds appeléslivre, etc.

Le nœud<bibliotheque>, qui est le nœud qui englobe tous les autres nœuds, s'appelle la racine. Il y a dans un fichier XML au moins une racine et au plus une racine. Oui ça veut dire qu'il y a exactement une racine par fichier. ;)

On peut établir toute une hiérarchie dans un fichier XML. En effet, entre la balise ouvrante et la balise fermante d'un nœud, il est possible de mettre d'autres nœuds. Les nœuds qui se trouvent dans un autre nœud s'appellent des enfants, et le nœud encapsulant s'appelle le parent.

Les nœuds peuvent avoir des attributs pour indiquer des informations. Dans notre exemple, le nœud<prix>a l'attributdeviseafin de préciser en quelle devise est exprimé ce prix :<prix devise="euro">9.40</prix>pour La Horde Du Contrevent, qui vaut donc 9€40. Vous remarquerez que pour A Game Of Thrones on a aussi le nœudprix, mais il n'a pas l'attributdevise! C'est tout à fait normal : dans l'interpréteur, si la devise est précisée, alors je considère que le prix est exprimé en cette devise ; mais si l'attributdevisen'est pas précisé, alors le prix est en dollars. A Game Of Thrones vaut donc $10.17. Le format XML en lui-même ne peut pas détecter si l'absence de l'attributdeviseest une anomalie, cela retirerait toute la liberté que permet le format.

En revanche, le XML est intransigeant sur la syntaxe. Si vous ouvrez une balise, n'oubliez pas de la fermer par exemple !

Les différents types de ressources

Les ressources sont des éléments capitaux dans une application Android. On y trouve par exemple des chaînes de caractères ou des images. Comme Android est destiné à être utilisé sur une grande variété de supports, il fallait trouver une solution pour permettre à une application de s'afficher de la même manière sur un écran 7" que sur un écran 10", ou faire en sorte que les textes s'adaptent à la langue de l'utilisateur. C'est pourquoi les différents éléments qui doivent s'adapter de manière très précise sont organisés de manière tout aussi précise, de façon à ce qu'Android sache quels éléments utiliser pour quels types de terminaux.

On découvre les ressources à travers une hiérarchie particulière de répertoires. Vous pouvez remarquer qu'à la création d'un nouveau projet, Android Studio crée certains répertoires par défaut, comme le montre la figure suivante.

L'emplacement des ressources au sein du projet
L'emplacement des ressources au sein du projet

Je vous ai déjà dit que les ressources étaient divisées en plusieurs types. Pour permettre à Android de les retrouver facilement, chaque type de ressources est associé à un répertoire particulier. Voici un tableau qui vous indique les principales ressources que l'on peut trouver, avec le nom du répertoire associé. Vous remarquerez que seuls les répertoires les plus courants sont créés par défaut.

Type

Description

Présence de fichiers XML

Dessin et image
(res/drawable)

On y trouve les images matricielles (les images de type PNG, JPEG ou encore GIF) ainsi que des fichiers XML qui permettent de décrire des dessins (ce qui donne des images vectorielles qui ne se dégradent pas quand on les agrandit).

Oui

Mise en page ou interface graphique
(res/layout)

Les fichiers XML qui représentent la disposition des vues (on abordera cet aspect, qui est très vaste, dans la prochaine partie).

Exclusivement

Menu
(res/menu)

Les fichiers XML pour pouvoir constituer des menus.

Exclusivement

Donnée brute
(res/raw)

Données diverses au format brut. Ces données ne sont pas des fichiers de ressources standards, on pourrait y mettre de la musique ou des fichiers HTML par exemple.

Le moins possible

Différentes variables
(res/values)

Il est plus difficile de cibler les ressources qui appartiennent à cette catégorie tant elles sont nombreuses. On y trouve entre autre des variables standards, comme des chaînes de caractères, des dimensions, des couleurs, etc.

Exclusivement

La colonnePrésence de fichiers XML  indique la politique à adopter pour les fichiers XML de ce répertoire. Elle vaut :

  • Exclusivement, si les fichiers de cette ressource sont tout le temps des fichiers XML.

  • Oui, si les fichiers peuvent être d'un autre type que XML, en fonction de ce qu'on veut faire. Ainsi, dans le répertoiredrawable/, on peut mettre des images ou des fichiers XML dont le contenu sera utilisé par un interpréteur pour dessiner des images.

  • Le moins possible, si les fichiers doivent de préférence ne pas être de type XML. Pourquoi ? Parce que tous les autres répertoires sont suffisants pour stocker des fichiers XML. Alors, si vous voulez placer un fichier XML dans le répertoireraw/, c'est qu'il ne trouve vraiment pas sa place dans un autre répertoire.

Il existe d'autres répertoires pour d'autres types de ressources, mais je ne vais pas toutes vous les présenter, les principales sont déjà là.

L'organisation

Si vous êtes observateurs, vous avez remarqué sur l'image précédente que nous avions quatre répertoiresres/drawable/, alors que dans le tableau que nous venons de voir, je vous disais que les drawables allaient tous dans le répertoireres/drawable/et point barre ! C'est tout à fait normal et ce n'est pas anodin du tout.

Comme je vous le disais, nous avons plusieurs ressources à gérer en fonction du matériel. Les emplacements indiqués dans le tableau précédent sont les emplacements par défaut, c'est-à-dire qu'il s'agit des emplacements qui visent le matériel le plus générique possible. Par exemple, vous pouvez considérer que le matériel le plus générique est un système qui n'est pas en coréen, alors vous allez mettre dans le répertoire par défaut tous les fichiers qui correspondent aux systèmes qui ne sont pas en coréen (par exemple les fichiers de langue). Pour placer des ressources destinées aux systèmes en coréen, on va créer un sous-répertoire et préciser qu'il est destiné aux systèmes en coréen. Ainsi, automatiquement, quand un utilisateur français ou anglais utilisera votre application, Android choisira les fichiers dans l'emplacement par défaut, alors que si c'est un utilisateur coréen, il ira chercher dans les sous-répertoires consacrés à cette langue.

En d'autres termes, en partant du nom du répertoire par défaut, il est possible de créer d'autres répertoires qui permettent de préciser à quels types de matériels les ressources contenues dans ce répertoire sont destinées. Les restrictions sont représentées par des quantificateurs et ce sont ces quantificateurs qui vous permettront de préciser le matériel pour lequel les fichiers dans ce répertoire sont destinés. La syntaxe à respecter peut être représentée ainsi :
res/<type_de_ressource>[<-quantificateur 1><-quantificateur 2>…<-quantificateur N>]

Autrement dit, on peut n'avoir aucun quantificateur si l'on veut définir l'emplacement par défaut, ou en avoir un pour réduire le champ de destination, deux pour réduire encore plus, etc. Ces quantificateurs sont séparés par un tiret. Si Android ne trouve pas d'emplacement dont le nom corresponde exactement aux spécifications techniques du terminal, il cherchera parmi les autres répertoires qui existent la solution la plus proche. Je vais vous montrer les principaux quantificateurs (il y en a quatorze en tout, dont un bon paquet qu'on utilise rarement, j'ai donc décidé de les ignorer).

Langue et région

Priorité: 2
La langue du système de l'utilisateur. On indique une langue puis, éventuellement, on peut préciser une région avec « -r ».
Exemples :

  • enpour l'anglais ;

  • frpour le français ;

  • fr-rFRpour le français mais uniquement celui utilisé en France ;

  • fr-rCApour le français mais uniquement celui utilisé au Québec ;

  • Etc.

Taille de l'écran

Priorité: 3
Il s'agit de la taille de la diagonale de l'écran :

  • smallpour les écrans de petite taille ;

  • normalpour les écrans standards ;

  • largepour les grands écrans, comme dans les tablettes tactiles ;

  • xlargepour les très grands écrans, là on pense carrément aux téléviseurs.

Orientation de l'écran

Priorité: 5
Il existe deux valeurs :

  • port: c'est le diminutif de portrait, donc quand le terminal est en mode portrait ;

  • land: c'est le diminutif de landscape, donc quand le terminal est en mode paysage.

Résolution de l'écran

Priorité: 8

  • ldpi: environ 120 dpi ;

  • mdpi: environ 160 dpi ;

  • hdpi: environ 240 dpi ;

  • xhdpi: environ 320 dpi (disponible à partir de l'API 8 uniquement) ;

  • nodpi: pour ne pas redimensionner les images matricielles (vous savez, JPEG, PNG et GIF !).

Version d'Android

Priorité: 14
Il s'agit du niveau de l'API (v3, v5, v7, v13, etc.).

Regardez l'image précédente (qui de toute façon représente les répertoires créés automatiquement pour tous les projets), que se passe-t-il si l'écran du terminal de l'utilisateur a une grande résolution ? Android ira chercher dansres/drawable-hdpi! L'écran du terminal de l'utilisateur a une résolution moyenne ? Il ira chercher dansres/drawable-mdpi/! L'écran du terminal de l'utilisateur a une petite résolution ? Eh bien… il ira chercher dansres/drawable-ldpi‌puisqu'il s'agit de la solution la plus proche de la situation matérielle réelle.

Exemples et règles à suivre

  • res/drawable-smallpour avoir des images spécifiquement pour les petits écrans.

  • res/drawable-largepour avoir des images spécifiquement pour les grands écrans.

  • res/layout-frpour avoir une mise en page spécifique destinée à tous ceux qui ont un système en français.

  • res/layout-fr-rFRpour avoir une mise en page spécifique destinée à ceux qui ont choisi la langue Français (France).

  • res/values-fr-rFR-portpour des données qui s'afficheront uniquement à ceux qui ont choisi la langue Français (France) et dont le téléphone se trouve en orientation portrait.

  • res/values-port-fr-rFRn'est pas possible, c'est à ça que servent les priorités : il faut impérativement mettre les quantificateurs par ordre croissant de priorité. La priorité de la langue est 2, celle de l'orientation est 5, comme 2 < 5 on doit placer les langues avant l'orientation.

  • res/layout-fr-rFR-enn'est pas possible puisqu'on a deux quantificateurs de même priorité et qu'il faut toujours respecter l'ordre croissant des priorités. Il nous faudra créer un répertoire pour le français et un répertoire pour l'anglais.

Tous les répertoires de ressources qui sont différenciés par des quantificateurs devront avoir le même contenu : on indique à Android de quelle ressource on a besoin, sans se préoccuper dans quel répertoire aller le chercher, Android le fera très bien pour nous. Sur l'image précédente, vous voyez que l'icône se trouve dans les quatre répertoiresdrawable/, sinon Android ne pourrait pas la trouver pour les quatre types de configuration.

Ajouter une ressources avec Android Studio

Heureusement, les développeurs d'Android Studio ont pensé à nous en créant un petit menu qui vous aidera à créer des répertoires de manière simple, sans avoir à retenir de syntaxe. En revanche, il vous faudra parler un peu anglais, je le crains. Faites un clic droit surres . Vous aurez un menu un peu similaire à celui représenté à l'image suivante, qui s'affichera.

Ce menu vous permet d'ajouter une ressource facilement
Ce menu vous permet d'ajouter une ressource facilement

Dans le sous-menuNew, cliquez surAndroid resource file. Cette opération ouvrira un assistant visible sur la figure suivante.

L'assistant de création de ressources
L'assistant de création de ressources

Le premier champ vous permet de donner un nom à votre ressource.

Le second vous permet de sélectionner le type de ressources désiré. À chaque fois que vous changez de type de ressources, le contenu du troisième champ s'adapte afin que vous puissiez indiquer le nom de la racine du fichier XML qui sera créé.  

Le champ suivant vous permet de sélectionner soitmain (pour que la ressource soit disponible à chaque moment), soitdebug (pour que la ressource ne soit disponible qu'en debug), soitrelease (pour que l'application ne soit disponible qu'à la version finale de votre application).

Le dernier champ indique le répertoire dans lequel sera créé le fichier, avec ses qualificateurs.

La partie du bas vous permet de sélectionner facilement les qualificateurs.

Mais il y a beaucoup plus de quantificateurs et de ressources que ce que tu nous as indiqué !

Oui. Je n'écris pas une documentation officielle pour Android. Si je le faisais, j'en laisserais plus d'un confus et vous auriez un nombre impressionnant d'informations qui ne vous serviraient pas ou peu. Je m'attelle à vous apprendre à faire de jolies applications optimisées et fonctionnelles, pas à faire de vous des encyclopédies vivantes d'Android. ;)

Quand vous sélectionnez des qualificateurs, vous pouvez avoir un aperçu en temps réel de ce répertoire. Si vous avez commis une erreur dans les qualificateurs, par exemple choisi une langue qui n’existe pas, le quantificateur ne s'ajoutera pas dans le champ du répertoire. Si ce champ ne vous semble pas correct vis-à-vis des quantificateurs sélectionnés, c'est que vous avez fait une faute d'orthographe. 

Récupérer une ressource

Comment accéder à nos ressources depuis notre code Java ? Tout simplement grâce à la classe R.

La classeR

Cette classe se trouve dans le fichier R.java. Je ne vais pas vous indiquer comment accéder à ce fichier parce que c'est compliqué et que le parcourir ne serait pas vraiment très intéressant. Je vais plutôt vous donner l'exemple d'un fichier R.java même s'il n'existe pas, c'est juste pour que vous puissiez comprendre l'idée.

Voici son contenu:

public final class R {
  public static final class attr {
  }
  public static final class dimen {
    public static final int padding_large=0x7f040002;
    public static final int padding_medium=0x7f040001;
    public static final int padding_small=0x7f040000;
  }
  public static final class drawable {
    public static final int ic_action_search=0x7f020000;
    public static final int ic_launcher=0x7f020001;
  }
  public static final class id {
    public static final int menu_settings=0x7f080000;
  }
  public static final class layout {
    public static final int activity_main=0x7f030000;
  }
  public static final class menu {
    public static final int activity_main=0x7f070000;
  }
  public static final class string {
    public static final int app_name=0x7f050000;
    public static final int hello_world=0x7f050001;
    public static final int menu_settings=0x7f050002;
    public static final int title_activity_main=0x7f050003;
  }
  public static final class style {
    public static final int AppTheme=0x7f060000;
  }
}

Décryptons certaines lignes de ce code.

La classelayout
public static final class layout { 
  public static final int activity_main=0x7f030000; 
}

Il s'agit d'une classe déclarée dans une autre classe : c'est ce qui s'appelle une classe interne. La seule particularité d'une classe interne est qu'elle est déclarée dans une autre classe, mais elle peut agir comme toutes les autres classes. Cependant, pour y accéder, il faut faire référence à la classe qui la contient. Cette classe est de typepublic static finalet de nomlayout.

  • Un élémentpublicest un élément auquel tout le monde peut accéder sans aucune restriction.

  • Le mot-cléstatic, dans le cas d'une classe interne, signifie que la classe n'est pas liée à une instanciation de la classe qui l'encapsule. Pour accéder àlayout, on ne doit pas nécessairement créer un objet de typeR. On peut y accéder parR.layout.

  • Le mot-cléfinalsignifie que l'on ne peut pas créer de classe dérivée delayout.

Cette classe contient un uniquepublic int, affublé des modificateursstaticetfinal. Il s'agit par conséquent d'une constante, à laquelle n'importe quelle autre classe peut accéder sans avoir à créer d'objet de typelayoutni de typeR.

Cet entier est de la forme0xZZZZZZZZ. Quand un entier commence par0x, c'est qu'il s'agit d'un nombre hexadécimal sur 32 bits. Si vous ignorez ce dont il s'agit, ce n'est pas grave, dites-vous juste que ce type de nombre est un nombre exactement comme un autre, sauf qu'il respecte ces règles-ci :

  • Il commence par0x.

  • Après le0x, on trouve huit chiffres (ou moins, mais on préfère mettre des 0 pour arriver à 8 chiffres) :0x123est équivalent à0x00000123, tout comme123est la même chose que00000123.

  • Ces chiffres peuvent aller de 0 à… F. C'est-à-dire qu'au lieu de compter « 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 » on compte « 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F ». A, B, C, D, E et F sont des chiffres normaux, banals, même s'ils n'en n'ont pas l'air, c'est juste qu'il n'y a pas de chiffre après 9, alors il a fallu improviser avec les moyens du bord . ^^ Ainsi, après 9 on a A, après A on a B, après E on a F, et après F on a 10 ! Puis à nouveau 11, 12, 13, 14, 15, 16, 17, 18, 19, 1A, 1B, etc.

Regardez les exemples suivants :

int deuxNorm = 2; // Valide !
int deuxHexa = 0x00000002; // Valide, et vaut la même chose que « deuxNorm »
int deuxRed = 0x2; /* Valide, et vaut la même chose que « deuxNorm » et 
                    « deuxHexa » (évidemment, 00000002, c'est la même chose que 
                    2 !) */

/* Ici, nous allons toujours écrire les nombres hexadécimaux avec huit chiffres, 
même les 0 inutiles ! */
int beaucoup = 0x0AFA1B00; // Valide !
int marcheraPas = 1x0AFA1B00; /* Non ! Un nombre hexadécimal commence toujours 
                              par « 0x » ! */
int marcheraPasNonPlus = 0xG00000000; /* Non ! Un chiffre hexadécimal va de 0 à 
                                      F, on n'accepte pas les autres lettres !*/
int caVaPasLaTete = 0x124!AZ5%; /* Alors là c'est carrément n'importe quoi, 
                                va falloir consulter mon pauvre /*

Cet entier a le même nom qu'un fichier de ressources (activity_main), tout simplement parce qu'il représente ce fichier (activity_main.xml). On ne peut donc avoir qu'un seul attribut de ce nom-là dans la classe, puisque deux fichiers qui appartiennent à la même ressource se trouvent dans le même répertoire et ne peuvent par conséquent pas avoir le même nom. Cet entier est un identifiant unique pour le fichier de mise en page qui s'appelleactivity_main. Si un jour on veut utiliser ou accéder à cette mise en page depuis notre code, on y fera appel à l'aide de cet identifiant.

La classedrawable
public static final class drawable { 
  public static final int ic_action_search=0x7f020000; 
  public static final int ic_launcher=0x7f020001; 
}

Contrairement au cas précédent, on a un seul entier pour plusieurs fichiers qui ont le même nom ! On a vu dans la section précédente qu'il fallait nommer de façon identique ces fichiers qui ont la même fonction, pour une même ressource, mais avec des quantificateurs différents. Eh bien, quand vous ferez appel à l'identificateur, Android saura qu'il lui faut le fichieric_launcheret déterminera automatiquement quel est le répertoire le plus adapté à la situation du matériel parmi les répertoires des ressources drawable, puisqu'on se trouve dans la classedrawable.

La classestring
public static final class string {
  public static final int app_name=0x7f050000; 
  public static final int hello_world=0x7f050001; 
  public static final int menu_settings=0x7f050002; 
  public static final int title_activity_main=0x7f050003;
}

Cette fois, si on a quatre entiers, c'est tout simplement parce qu'on a quatre chaînes de caractères dans le fichierres/values/strings.xml, qui contient les chaînes de caractères (qui sont des données). Vous pouvez le vérifier par vous-mêmes en fouillant le fichierstrings.xml.

Il existe d'autres variables dont je n'ai pas discuté, mais vous avez tout compris déjà avec ce que nous venons d'étudier.

Application

Énoncé

J'ai créé un nouveau projet pour l'occasion, mais vous pouvez très bien vous amuser avec le premier projet. L'objectif ici est de récupérer la ressource de type chaîne de caractères qui s'appellehello_world(créée automatiquement par Eclipse) afin de la mettre comme texte dans unTextView. On affichera ensuite leTextView.

On utilisera la méthodepublic final void setText (int id)(idétant l'identifiant de la ressource) de la classeTextView.

Solution
import android.app.Activity;
import android.os.Bundle;
import android.widget.TextView;

public class MainActivity extends Activity {
    private TextView text = null;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        text = new TextView(this);
        text.setText(R.string.app_name);

        setContentView(text);
    }
}

Comme indiqué auparavant, on peut accéder aux identificateurs sans instancier de classe. On récupère dans la classeRl'identificateur de la ressource du nomapp_name qui se trouve dans la classestring, puisqu'il s'agit d'une chaîne de caractères, doncR.string.app_name.

Et si je mets à la place de l'identifiant d'une chaîne de caractères un identifiant qui correspond à un autre type de ressources ?

Eh bien, les ressources sont des objets Java comme les autres. Par conséquent ils peuvent aussi posséder une méthodepublic String toString()! Pour ceux qui l'auraient oublié, la méthodepublic String toString()est appelée sur un objet pour le transformer en chaîne de caractères, par exemple si on veut passer l'objet dans unSystem.out.println. Ainsi, si vous mettez une autre ressource qu'une chaîne de caractères, ce sera la valeur rendue par la méthodetoString()qui sera affichée.

Essayez par vous-mêmes, vous verrez ce qui se produit. ;) Soyez curieux, c'est comme ça qu'on apprend !

Application

Énoncé

Je vous propose un autre exercice. Dans le précédent, leTextViewa récupéré l'identifiant et a été chercher la chaîne de caractères associée pour l'afficher. Dans cet exercice, on va plutôt récupérer la chaîne de caractères pour la manipuler.

Instructions
  • On va récupérer le gestionnaire de ressources afin d'aller chercher la chaîne de caractères. C'est un objet de la classeResourceque possède notre activité et qui permet d'accéder aux ressources de cette activité. On peut le récupérer grâce à la méthodepublic Resources getResources().

  • On récupère la chaîne de caractèreshello_worldgrâce à la méthodestring getString(int id), avecidl'identifiant de la ressource.

  • Et on modifie la chaîne récupérée.

Solution
import android.app.Activity;
import android.os.Bundle;
import android.widget.TextView;

public class MainActivity extends Activity {
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        String applicationName = getResources().getString(R.string.app_name);
        // Au lieu d'afficher "My Application" on va afficher "My way !"
        applicationName = applicationName.replace("Application", "way !");

        TextView view = new TextView(this);
        view.setText(applicationName);

        setContentView(view);
    }
}

Récapitulatif

  • Au même titre que le langage Java est utile pour développer vos application, le langage XML l'est tout autant puisqu'il a été choisi pour mettre en place les différentes ressources de vos projets.

  • Il existe 5 types de ressources que vous utiliserez majoritairement :

    • drawablequi contient toutes les images matricielles et les fichiers XML décrivant des dessins simples.

    • layoutqui contient toutes les interfaces que vous attacherez à vos activités pour mettre en place les différentes vues.

    • menuqui contient toutes les déclarations d'éléments pour confectionner des menus.

    • rawqui contient toutes les autres ressources au format brut.

    • valuesqui contient des valeurs pour un large choix comme les chaînes de caractères, les dimensions, les couleurs, etc.

  • Les quantificateurs sont utilisés pour cibler précisément un certain nombre de priorités ; à savoir la langue et la région, la taille de l'écran, l'orientation de l'écran, la résolution de l'écran et la version d'Android.

  • Chaque ressource présente dans le dossierresde votre projet génère un identifiant unique dans le fichierR.javapour permettre de les récupérer dans la partie Java de votre application.

Exemple de certificat de réussite
Exemple de certificat de réussite