Utilisation des Resources

 Outre les ressources que vous fournissez, la plate-forme Android inclut plusieurs ressources système que vous pouvez utiliser dans vos applications. Toutes les ressources peuvent être utilisées dans le code de votre application et peuvent également être référencées à partir d'autres ressources. Par exemple, une ressource de dimension ou de chaîne peut être référencée dans une définition de présentation.Plus loin dans ce chapitre, vous apprendrez à définir d'autres valeurs de ressources pour différentes langues, emplacements et matériels. Il est important de noter que lorsque vous utilisez des ressources, vous ne choisissez pas d’alternative particulière. Android sélectionne automatiquement la valeur correcte pour un identifiant de ressource donné en fonction des configurations matérielles, de périphérique et de langue actuelles.

 Utilisation de ressources dans le code

 Au sein de votre application, vous accédez aux ressources en code à l'aide de la classe statique R. R est une classe générée, créée lors de la construction de votre projet, qui vous permet de référencer toutes les ressources que vous avez incluses pour offrir une vérification de la syntaxe au moment du design.

La classe R contient des sous-classes statiques pour chacune des ressources disponibles, telles que les sous-classes R.string et R.drawable.

 Remarque

Si vous utilisez Android Studio, la classe R est créée automatiquement lorsque vous créez votre application après avoir modifié un fichier ou un dossier de ressources externe. N'oubliez pas que R est une classe générée par la construction. N'effectuez aucune modification manuelle, car elles seront perdues lors de la régénération du fichier.

 Chacune des sous-classes de R expose ses ressources associées en tant que variables, les noms de variables correspondant aux identificateurs de ressource, par exemple, R.string.app_name ou R.mipmap.ic_launcher.

La valeur de ces variables est un entier représentant l’emplacement de chaque ressource dans la table des ressources, et non une instance de la ressource elle-même.

Lorsqu'un constructeur ou une méthode, tel que setContentView, accepte un identificateur de ressource, vous pouvez transmettre la variable de ressource, comme indiqué dans le fragment de code suivant:

 // Inflate a layout resource. setContentView(R.layout.main); // Display a transient dialog box that displays the // app name string resource.

Toast.makeText(this, R.string.app_name, Toast.LENGTH_LONG).show();

 Lorsque vous avez besoin d'une instance de la ressource elle-même, vous devez utiliser des méthodes d'assistance pour les extraire de la table des ressources. La table de ressources est représentée dans votre application en tant qu'instance de la classe Resources.

Ces méthodes effectuent des recherches sur la table de ressources en cours de l’application, elles ne peuvent donc pas être statiques. Utilisez la méthode getResources sur le contexte de votre application, comme indiqué dans l'extrait de code suivant, pour accéder à l'instance Resources de votre application:

 Resources myRes = getResources();

 La classe Resources inclut des getters pour chacun des types de ressources disponibles et fonctionne généralement en transmettant l'ID de ressource dont vous êtes une instance.

La bibliothèque de support Android comprend également une classe ResourcesCompat qui offre des fonctions de lecture rétrocompatibles lorsqu'une classe Framework est obsolète (telle que getDrawable).

L'extrait de code suivant montre un exemple d'utilisation des méthodes d'assistance pour renvoyer une sélection de valeurs de ressources:

 CharSequence styledText = myRes.getText(R.string.stop_message); float borderWidth = myRes.getDimension(R.dimen.standard_border);

Animation tranOut; tranOut = AnimationUtils.loadAnimation(this, R.anim.spin_shrink_fade);

ObjectAnimator animator =

  (ObjectAnimator)AnimatorInflater.loadAnimator(this,

  R.animator.my_animator);

String[] stringArray; stringArray = myRes.getStringArray(R.array.string_array); int[] intArray = myRes.getIntArray(R.array.integer_array);

 Android 5.0 Lollipop (API niveau 21) a ajouté la prise en charge de la thématique Drawable. Vous devez donc utiliser la bibliothèque ResourcesCompat pour obtenir les ressources Drawable et Color, comme indiqué dans l'extrait de code suivant. Notez que les deux méthodes acceptent les valeurs NULL pour les thèmes:

 Drawable img = ResourcesCompat.getDrawable(myRes, R.drawable.an_image, myTheme);

int opaqueBlue = ResourcesCompat.getColor(myRes, R.color.opaque_blue, myTheme);

 Les ressources animées image par image sont gonflées dans AnimationResources. Vous pouvez renvoyer la valeur à l'aide de getDrawable et en convertissant la valeur de retour, comme indiqué ci-dessous:

 AnimationDrawable androidAnimation;

androidAnimation =

  (AnimationDrawable)ResourcesCompat.getDrawable(R.myRes, drawable.frame_by_frame, myTheme);

 Référencement des ressources dans les ressources

 Vous pouvez également utiliser des références de ressources en tant que valeurs d'attributs dans d'autres ressources XML.

Ceci est particulièrement utile pour les mises en page et les styles, vous permettant de créer des variations spécialisées sur des thèmes et des chaînes localisées et des ressources d'image. C’est également un moyen utile de prendre en charge différentes images et espacements pour une mise en page afin de s’assurer qu’elle est optimisée pour différentes tailles d’écran et résolutions.

 Pour référencer une ressource d'une autre, utilisez la notation @, comme indiqué dans l'extrait de code suivant:

 attribute="@[packagename:]resourcetype/resourceidentifier"

 Remarque

Android suppose que vous utilisez une ressource du même package. Vous ne devez donc qualifier complètement le nom du package que si vous utilisez une ressource provenant d'un package différent.

 Le Listing 4-3 montre une mise en page qui utilise des ressources de dimension, couleur et chaîne.

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

< RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"

  xmlns:tools="http://schemas.android.com/tools"

  android:id="@+id/activity_main"   android:layout_width="match_parent"   android:layout_height="match_parent"

  android:paddingBottom="@dimen/activity_vertical_margin"   android:paddingLeft="@dimen/activity_horizontal_margin"   android:paddingRight="@dimen/activity_horizontal_margin"   android:paddingTop="@dimen/activity_vertical_margin"   tools:context="com.professionalandroid.apps.helloworld.MainActivity">

  <TextView

    android:id="@+id/myTextView"     android:layout_width="wrap_content"     android:layout_height="wrap_content"     android:textColor="@color/colorAccent"     android:text="@string/hello"

  />

</RelativeLayout>

Utilisation des Resources Systèmes

 La structure Android met à votre disposition de nombreuses ressources natives et vous fournit diverses chaînes, images, animations, styles et mises en page à utiliser dans vos applications.

L'accès aux ressources système dans le code est similaire à l'utilisation de vos propres ressources. La différence est que vous utilisez les classes de ressources Android natives disponibles sur android.R, plutôt que la classe R spécifique à une application. L'extrait de code suivant utilise la méthode getString disponible dans le contexte de l'application pour extraire un message d'erreur disponible à partir des ressources système:

 CharSequence httpError = getString(android.R.string.httpErrorBadUrl);

 Pour accéder aux ressources système au format XML, spécifiez android en tant que nom de package, comme indiqué dans cet extrait de code XML:

 < EditText

  android:id="@+id/myEditText"   android:layout_width="match_parent"   android:layout_height="wrap_content"   android:text="@android:string/httpErrorBadUrl"   android:textColor="@android:color/darker_gray"

/>

 Vous pouvez trouver la liste complète des ressources Android disponibles sur developer.android.com/reference/android / R.html.

 Référence aux styles du thème actuel

 L'utilisation de thèmes est un excellent moyen de garantir la cohérence de l'interface utilisateur de votre application. Plutôt que de définir complètement chaque style, Android propose un raccourci vous permettant d’utiliser les styles du thème actuellement appliqué.

Pour ce faire, utilisez? Android: plutôt que @ comme préfixe de la ressource que vous souhaitez utiliser. L’exemple suivant montre un extrait du code précédent mais utilise la couleur du texte du thème actuel plutôt qu’une ressource système:

 < EditText

  android:id="@+id/myEditText"   android:layout_width="match_parent"   android:layout_height="wrap_content"   android:text="@android:string/httpErrorBadUrl"   android:textColor="?android:textColor" />

 Cette technique vous permet de créer des styles qui changent si le thème actuel change, sans que vous ne modifiiez chaque ressource de style. Notez que la valeur de la ressource textColor doit être définie dans le thème actuel. Vous en apprendrez plus sur l’utilisation des thèmes et des styles au chapitre 13.

 Création de ressources pour différents langages et matériels

 Vous pouvez créer différentes valeurs de ressources pour des langues, des emplacements et des configurations matérielles spécifiques à l'aide d'une structure de répertoires parallèles au sein du dossier res.

Un trait d'union (-) est utilisé pour séparer les qualificateurs spécifiant les conditions pour lesquelles vous fournissez des alternatives. Android choisit parmi ces valeurs de manière dynamique au moment de l'exécution à l'aide de son mécanisme de sélection dynamique des ressources.

L'exemple de hiérarchie suivant montre une structure de dossiers qui comporte des valeurs de chaîne par défaut, avec des variations d'emplacement en français et au Canada français:

 Project/   res/     values/       strings.xml     values-fr/       strings.xml     values-fr-rCA/       strings.xml

 Si vous utilisez Android Studio, ces dossiers parallèles sont représentés comme indiqué dans la figure 4-4: un dossier portant le nom du fichier,

qui contient chaque version, suivi du qualificatif entre parenthèses.

Vous pouvez créer ces dossiers qualifiés manuellement ou, à l'aide d'Android Studio, vous pouvez créer de nouveaux dossiers selon vos besoins lors de la création des autres fichiers qu'ils contiennent.

Pour ce faire, cliquez avec le bouton droit sur le dossier parent (par exemple, res / values) et sélectionnez «Nouveau fichier de ressources [Valeurs]», ou sélectionnez le dossier parent et sélectionnez Fichier Nouveau Fichier de ressources [Valeurs]. Ceci affiche la boîte de dialogue Nouveau fichier de ressources, comme indiqué dans la figure 4-5, qui fournit toutes les catégories de qualificateurs facultatifs et les options disponibles avant de créer le dossier et d'y placer votre nouveau fichier. Notez que tous les qualificateurs disponibles ne sont pas disponibles dans la boîte de dialogue Android Studio. Dans ce cas, vous devrez créer le dossier manuellement.

La liste suivante répertorie les qualificateurs que vous pouvez utiliser pour personnaliser les valeurs de vos ressources: 

Vous pouvez spécifier plusieurs qualificateurs pour tout type de ressource, en les séparant par un trait d'union. Toute combinaison est prise en charge; Cependant, ils doivent être utilisés dans l'ordre indiqué dans la liste précédente et vous ne pouvez pas utiliser plus d'une valeur par qualificateur.

 L'exemple suivant montre des noms de répertoires valides et non valides pour d'autres ressources de présentation:

Valid     layout-large-land     layout-xlarge-port-keyshidden     layout-long-land-notouch-nokeys

Invalid     values-rUS-en (out of order)

    values-rUS-rUK (multiple values for a single qualifier)

 Lorsque Android récupère une ressource au moment de l'exécution, il trouve la meilleure correspondance parmi les alternatives disponibles. Commençant par une liste de tous les dossiers dans lesquels la valeur requise existe, il sélectionne celui contenant le plus grand nombre de qualificateurs correspondants. Si deux dossiers sont identiques, la condition de départage est basée sur l'ordre des qualificateurs correspondants dans la liste précédente.

 Avertissemnt

Si aucune correspondance de ressource n'est trouvée sur un périphérique donné, votre application lève une exception lors de la tentative d'accès à cette ressource. Pour éviter cela, vous devez toujours inclure les valeurs par défaut pour chaque type de ressource dans un dossier ne contenant aucun qualificateur.

Modifications de la configuration d'exécution

Android gère les modifications d'exécution apportées à la langue, à l'emplacement et au matériel en mettant fin à l'activité active, puis en la redémarrant. Cela force la résolution des ressources pour l'activité à réévaluer et les valeurs de ressources les plus appropriées pour la nouvelle configuration à sélectionner.

Dans certains cas particuliers, ce comportement par défaut peut être gênant, en particulier pour les applications qui ne souhaitent pas modifier l'interface utilisateur en fonction des changements d'orientation de l'écran. Vous pouvez personnaliser la réponse de votre application à de tels changements en les détectant et en y réagissant vous-même.

Pour qu'une activité écoute les modifications de configuration à l'exécution, ajoutez un attribut android: configChanges à son nœud manifeste, en spécifiant les modifications de configuration que vous souhaitez gérer.

La liste suivante décrit certaines des modifications de configuration que vous pouvez spécifier:

• mcc et mnc : une carte SIM a été détectée et le pays ou le code du réseau mobile (respectivement) a changé.
• locale : l'utilisateur a modifié les paramètres de langue du périphérique.
• keyboardHidden : le clavier, le D-Pad ou un autre mécanisme de saisie a été exposé ou masqué.
• clavier : le type de clavier a changé. Par exemple, le téléphone peut avoir un clavier à 12 touches qui se glisse pour révéler un clavier complet ou un clavier externe peut avoir été branché.
• fontScale : l'utilisateur a modifié la taille de police préférée. 
• uiMode : le mode de l'interface utilisateur globale a été modifié. Cela se produit généralement si vous basculez entre les modes voiture, jour et nuit, etc.
• orientation : l'écran a pivoté entre portrait et paysage.
• screenLayout : la disposition de l'écran a été modifiée. se produit généralement si un autre écran a été activé.
• screenSize - Se produit lorsque la taille d'écran disponible a été modifiée. par exemple, un changement d'orientation entre paysage et portrait ou en mode multi-fenêtre.
• smallestScreenSize : se produit lorsque la taille de l'écran physique a changé, par exemple lorsqu'un périphérique a été connecté à un écran externe.
• layoutDirection : la direction de la disposition de l'écran / texte a changé; par exemple, basculement entre gauche à droite et droite à gauche (RTL).

 Dans certaines circonstances, plusieurs événements seront déclenchés simultanément. Par exemple, lorsque l'utilisateur glisse un clavier, la plupart des périphériques déclenchent les événements keyboardHidden et orientation, et la connexion d'un écran externe est susceptible de déclencher des événements d'orientation, screenLayout, screenSize et smallestScreenSize.

Vous pouvez sélectionner plusieurs événements que vous souhaitez gérer vous-même en séparant les valeurs par un tuyau (|), comme indiqué dans le Listing 4-4, qui montre un nœud d'activité déclarant qu'il gérera les modifications de la taille et de l'orientation de l'écran, ainsi que l'accès à clavier physique.

 LISTING 4-4: Définition d'activité pour gérer les changements de ressources dynamiques

< activity

  android:name=".MyActivity"   android:label="@string/app_name"

  android:configChanges="screenSize|orientation|keyboardHidden">

  <intent-filter >

    <action android:name="android.intent.action.MAIN" />

    <category android:name="android.intent.category.LAUNCHER" />

  </intent-filter>

< /activity >

L'ajout d'un attribut android : configChanges supprime le redémarrage pour les modifications de configuration spécifiées, mais déclenche le gestionnaire onConfigurationChanged dans l'activité associée. Remplacez cette méthode pour gérer vous-même les modifications de configuration, à l'aide de la méthode transmise

Objet de configuration permettant de déterminer les nouvelles valeurs de configuration, comme indiqué dans le Listing 4-5. Veillez à rappeler la super-classe et à recharger toutes les valeurs de ressources utilisées par l’Activité, au cas où elles auraient été modifiées.

LISTING 4-5: Gérer les changements de configuration dans le code

@Override

public void onConfigurationChanged(Configuration newConfig) {   super.onConfigurationChanged(newConfig);   // [ ... Update any UI based on resource values ... ]

  if (newConfig.orientation == Configuration.ORIENTATION_LANDSCAPE) {

    // [ ... React to different orientation ... ]

  }

  if (newConfig.keyboardHidden == Configuration.KEYBOARDHIDDEN_NO) {

    // [ ... React to changed keyboard visibility ... ]

  }

} 

Lors de l’appel de onConfigurationChanged, les variables de ressources de l’activité ont déjà été mises à jour avec les nouvelles valeurs; elles pourront donc être utilisées en toute sécurité.

Toute modification de configuration que vous n'indiquez pas explicitement comme étant traitée par votre application entraînera le redémarrage de votre activité, sans appel à onConfigurationChanged.