Externaliser Les Ressources

Détails
Catégorie : Le Manifest, Fichier Build, Et Les Resources
Affichages : 21

Externaliser Les Ressources

Il est toujours recommandé de conserver les ressources autres que du code, telles que les images et les constantes de chaîne, à l’extérieur de votre code. Android prend en charge l'externalisation des ressources, allant de valeurs simples telles que des chaînes et des couleurs à des ressources plus complexes telles que des images, des animations, des thèmes et des dispositions d'interface utilisateur. En externalisant les ressources, vous simplifiez leur maintenance, leur mise à jour et leur gestion. Cela vous permet également de créer d'autres valeurs de ressources pour prendre en charge l'internationalisation et d'inclure différentes ressources pour prendre en charge les variations de matériel, notamment la taille et la résolution de l'écran.Lorsqu'une application démarre, Android sélectionne automatiquement les bonnes ressources parmi les alternatives disponibles sans que vous ayez à écrire une ligne de code. Plus loin dans cette section, vous verrez comment Android sélectionne de manière dynamique les ressources à partir d'arborescences de ressources contenant des valeurs différentes pour des configurations matérielles, des langues et des emplacements alternatifs. Entre autres choses, cela vous permet de modifier la disposition en fonction de la taille et de l’orientation de l’écran, d’images en fonction de la densité de l’écran et de personnaliser le texte en fonction de la langue et du pays de l’utilisateur.

Création Resources

Les ressources d'application sont stockées sous le dossier res dans la hiérarchie de votre projet. Chacun des types de ressources disponibles est stocké dans des sous-dossiers, regroupés par type de ressource.Si vous créez un nouveau projet à l'aide de l'Assistant Nouveau projet Android Studio, il crée un dossier res contenant des sous-dossiers pour les ressources value, mipmap et layout, qui contiennent les valeurs par défaut des ressources chaîne, dimensions, couleur et style, ainsi que une icône d’application et la présentation par défaut.

Remarque

Notez que le dossier de ressources mipmap contient cinq icônes d'application différentes pour différents affichages de densité. Vous en apprendrez plus sur la fourniture de différentes valeurs de ressources pour les variantes matérielles plus loin dans ce chapitre. Une fois votre application créée, ces ressources seront compressées le plus efficacement possible et intégrées à votre fichier APK.Le processus de génération génère également un fichier de classe R contenant des références à chacune des ressources incluses dans votre projet. Cela vous permet de référencer des ressources à partir de votre code, avec l'avantage de la vérification de la syntaxe au moment du design.Les sections suivantes décrivent de nombreux types de ressources spécifiques disponibles et expliquent comment les créer pour vos applications.Dans tous les cas, les noms de fichiers de ressources ne doivent contenir que des lettres minuscules, des chiffres et les symboles point (.) Et trait de soulignement (_).

Valeurs Simples

Les valeurs simples prises en charge comprennent les chaînes, les couleurs, les dimensions, les styles, les valeurs booléennes ou les valeurs entières, ainsi que les tableaux de chaînes ou de types. Toutes les valeurs simples sont stockées dans des fichiers XML dans le dossier res / values. Chaque fichier XML de valeurs vous permet de décrire plusieurs ressources. Vous indiquez le type de valeur stockée à l'aide de balises, comme indiqué dans l'exemple de fichier XML du Listing 4-1.

 

LISTING 4-1 : Valeurs simples XML

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

< resources >

  <string name="app_name">To Do List</string>

  <plurals name="androidPlural">

    <item quantity="one">One android</item>

    <item quantity="other">%d androids</item>

  </plurals>

  <color name="app_background">#FF0000FF</color>

  <dimen name="default_border">5px</dimen>

  <integer name="book_ignition_temp">451</integer>

  <bool name="is_a_trap">true</bool>

  <string-array name="string_array">

    <item>Item 1</item>

    <item>Item 2</item>

    <item>Item 3</item>

  </string-array>

  <integer-array name="integer_array">

    <item>3</item>

    <item>2</item>

    <item>1</item>

  </integer-array>

  <array name="color_typed_array">

    <item>#FF0000FF</item>

    <item>#00FFFF00</item>

    <item>#FF00FF00</item>

  </array>

  <style name="AppTheme" parent="Theme.AppCompat.Light.DarkActionBar">

    <item name="colorPrimary">@color/colorPrimary</item>

  </style>

< /resources >

 Cet exemple inclut de nombreux types de valeurs simples différents. Par convention, pour des raisons de clarté et de lisibilité, les ressources sont généralement stockées dans des fichiers séparés, un pour chaque type. par exemple, res / values ​​/ strings.xml ne contiendrait que des ressources de chaîne.Les sections suivantes détaillent les options permettant de définir des ressources simples communes.

Strings

L'externalisation de vos chaînes permet de maintenir la cohérence de votre application et facilite grandement leur internationalisation.Les ressources de chaîne sont spécifiées avec la balise string, comme indiqué dans l'extrait de code XML suivant:

< string name="stop_message">Stop.</string >

Les apostrophes ('), les guillemets (") et les barres obliques inverses (\) doivent être masquées à l'aide d'une barre oblique inverse, comme ceci:

< string name="quoting_myself" >

Escape \"Apostrophes (\') and double-quotes (\") with a backslash (\\)\"

< /string >

Android prend en charge le style de texte simple. Vous pouvez ainsi utiliser les balises HTML <b>, <i> et <u> pour appliquer des expressions en gras, en italique ou en soulignant, respectivement, à des parties de vos chaînes de texte, comme illustré dans l'exemple suivant:

< string name="stop_message"><b>Stop.</b></string >

Vous pouvez également utiliser des chaînes de ressources comme paramètres d'entrée pour la méthode String.format. Cependant, String.format ne prend pas en charge le style de texte décrit précédemment. Pour appliquer un style à une chaîne de format, vous devez échapper les balises HTML lors de la création de votre ressource, comme indiqué dans l'extrait de code suivant:

 < string name="stop_message">&lt;b>Stop&lt;/b>. %1$s</string >

Dans votre code, utilisez la méthode Html.fromHtml pour la reconvertir en une séquence de caractères stylée:

 String rString = getString(R.string.stop_message);

String fString = String.format(rString, "Collaborate and listen.");

CharSequence styledString = Html.fromHtml(fString, FROM_HTML_MODE_LEGACY);

 Remarque

Android 6.0 Nougat (API niveau 24) a introduit la méthode Html.fromHtml indiquée dans l'extrait de code ci-dessus, qui vous permet de spécifier un indicateur pour déterminer le mode de séparation des éléments de niveau bloc. Pour les applications prenant en charge des versions antérieures d'Android, vous pouvez continuer à utiliser la méthode obsolète Html.fromHtml qui se comporte de manière identique à la nouvelle méthode à l'aide de l'indicateur FROM_HTML_MODE_ LEGACY. Vous pouvez également définir des formes plurielles alternatives pour vos chaînes. Cela vous permet de définir différentes chaînes en fonction du nombre d'éléments auxquels vous faites référence. Par exemple, en anglais, vous vous référez à «un Android» mais à «sept androïdes».En créant une ressource de pluriels, vous pouvez spécifier une chaîne de remplacement pour l'une des quantités suivantes: zéro, une, plusieurs, plusieurs, plusieurs, etc. En anglais, le singulier est un cas particulier, alors que certaines langues exigent des détails plus fins et dans d’autres, le singulier n’est jamais utilisé:

 < plurals name="unicorn_count" >

  <item quantity="one">One unicorn</item>

  <item quantity="other">%d unicorns</item>

< /plurals >

 Pour accéder au pluriel correct dans le code, utilisez la méthode getQuantityString sur l'objet Resources de votre application, en transmettant l'ID de ressource de la ressource au pluriel et en spécifiant le nombre d'objets que vous souhaitez décrire:

 Resources resources = getResources();

String unicornStr = resources.getQuantityString(

  R.plurals.unicorn_count, unicornCount, unicornCount);

 Notez que dans cet exemple, le nombre d'objets est passé deux fois: une fois pour renvoyer la chaîne plurielle correcte, et une fois encore, en tant que paramètre d'entrée pour compléter la phrase.

 Couleurs 

Utilisez l’étiquette de couleur pour définir une nouvelle ressource de couleur. Spécifiez la valeur de couleur à l'aide d'un symbole # suivi du canal alpha (facultatif), puis des valeurs rouge, verte et bleue à l'aide d'un ou deux nombres hexadécimaux avec l'une des notations suivantes:

  • #RGB
  • #RRGGBB
  • #ARGB
  • #AARRGGBB 

L'exemple suivant montre comment spécifier le vert Android et un bleu partiellement transparent:

 < color name="android_green">#A4C639</color >

< color name="transparent_blue">#770000FF</color >

Dimensions 

Les dimensions sont le plus souvent référencées dans les ressources de style et de présentation. Ils sont utiles pour définir les valeurs de mise en page, telles que les bordures et les hauteurs de police.Pour spécifier une ressource de dimension, utilisez la balise dimen, en spécifiant la valeur de la dimension, suivie d'un identifiant décrivant l'échelle de votre dimension: Dp (pixels indépendants de la densité)

  • sp (pixels modulables)
  • px (pixels de l'écran)Po (pouces physiques)
  • pt (points physiques)
  • mm (millimètres physiques)  

Bien que vous puissiez utiliser n’importe laquelle de ces mesures pour définir une dimension, il est préférable d’utiliser des pixels indépendants de la densité ou évolutifs. Ces alternatives vous permettent de définir une dimension à l'aide d'échelles relatives tenant compte de différentes résolutions et densités d'écran afin de simplifier la mise à l'échelle sur différents matériels.Les pixels évolutifs sont particulièrement bien adaptés lors de la définition de la taille des polices car ils sont automatiquement mis à l'échelle si l'utilisateur modifie la taille de la police système.L'extrait de code XML suivant montre comment spécifier des valeurs de dimension pour une taille de police importante et une bordure standard:

< dimen name="large_font_size">16sp</dimen >

< dimen name="activity_horizontal_margin">16dp</dimen >

Styles et Thèmes

Les ressources de style permettent à vos applications de conserver une apparence cohérente en vous permettant de spécifier les valeurs d'attribut utilisées par Vues, ​​généralement les couleurs, les bordures et les tailles de police pour une application.Pour créer un style, utilisez une balise de style qui comprend un attribut de nom et contient une ou plusieurs balises d'élément. Chaque étiquette d'élément doit inclure un attribut de nom utilisé pour spécifier l'attribut défini (tel que la taille ou la couleur de la police). La balise elle-même devrait alors contenir la valeur, comme indiqué dans le code du squelette suivant:

< style name="base_text" >

  <item name="android:textSize">14sp</item>

  <item name="android:textColor">#111</item>

< /style >

 Les styles prennent en charge l'héritage en utilisant l'attribut parent sur la balise de style, ce qui facilite la création de variations simples:

 < style name="AppTheme" parent="Theme.AppCompat.Light.DarkActionBar" >

  <item name="colorPrimary">@color/colorPrimary</item>

  <item name="colorPrimaryDark">@color/colorPrimaryDark</item>

  <item name="colorAccent">@color/colorAccent</item>

< /style >

Drawables

 Les ressources pouvant être dessinées incluent les bitmaps, NinePatches (images PNG étirables) et les éléments vectoriels pouvant être dessinés. Ils incluent également des objets composables composites complexes, tels que LevelListDrawables et StateListDrawables, définis en XML. REMARQUE NinePatch Drawables, Vector Drawables et des ressources composites complexes sont traités plus en détail dans le chapitre suivant. Tous les tirables sont stockés sous forme de fichiers individuels dans le dossier res / drawable. Notez qu’il est judicieux de stocker les actifs d’image bitmap dans les dossiers drawable-ldpi, -mdpi, -hdpi et -xhdpi appropriés, comme décrit plus loin dans ce chapitre. L'identifiant de ressource pour une ressource Drawable est le nom de fichier en minuscule sans son extension. 

NOTE Le format préféré pour une ressource bitmap Drawable est PNG, bien que les fichiers JPG et GIF soient également pris en charge.

 MipMaps

 Il est considéré comme une bonne pratique de stocker l’icône de lanceur de votre application dans le groupe de dossiers MipMap, une pour chaque taille de résolution jusqu’à xxxhdpi (comme indiqué dans votre application Hello World).Différentes applications de lanceur d’écran d’accueil sur différents appareils affichent les icônes du lanceur d’applications à différentes résolutions. Certains appareils redimensionnent les icônes du lanceur jusqu’à 25%. Les techniques d’optimisation des ressources d’application permettent de supprimer les ressources disponibles pour les densités d’écrans inutilisées Cependant, toutes les ressources MipMap sont préservées, ce qui garantit que les applications de lanceur peuvent choisir des icônes avec la meilleure résolution d'affichage.Notez que le qualificatif mipmap-xxxhdpi est généralement fourni uniquement pour garantir qu'une icône de lanceur de haute résolution appropriée est disponible dans le cas d'une mise à l'échelle sur un périphérique xxhdpi. vous n’avez généralement pas besoin de fournir des ressources xxxhdpi pour le reste de vos ressources Drawable.

 Layouts

 Les ressources de présentation vous permettent de découpler votre couche de présentation de votre logique métier en concevant des dispositions d'interface utilisateur en XML plutôt qu'en les construisant en code.Vous pouvez utiliser des dispositions pour définir l'interface utilisateur de tout composant visuel, y compris les activités, les fragments et les widgets. Une fois défini en XML, la mise en page doit être «gonflée» dans l'interface utilisateur. Pour ce faire, vous utilisez setContentView (généralement dans la méthode onCreate), alors que les fragments sont gonflés à l’aide de la méthode inflate de l’objet Inflator transmis au gestionnaire onCreateView du fragment.Pour plus d'informations sur l'utilisation et la création de présentations dans Activités et Fragments, reportez-vous au Chapitre 5, «Création d'interfaces utilisateur».Utiliser des mises en page pour construire vos écrans en XML est la meilleure pratique sous Android. Le découplage de la présentation du code vous permet de créer des dispositions optimisées pour différentes configurations matérielles, telles que des tailles d'écran différentes, l'orientation ou la présence de claviers et d'écrans tactiles, comme décrit plus loin dans ce chapitre.Chaque définition de présentation est stockée dans son propre fichier XML, dans le dossier res / layout, le nom du fichier devenant l'identifiant de la ressource.Une explication détaillée des conteneurs de mise en page et des éléments View est incluse dans le chapitre suivant, mais le Listing 4-2 présente la mise en page créée par l'Assistant Nouveau projet. Il utilise un conteneur Disposition de contrainte pour une vue de texte qui affiche le message d'accueil «Hello World».

 LISTING 4-2 : Mise en page Hello World

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

< android.support.constraint.ConstraintLayout

  xmlns:android="http://schemas.android.com/apk/res/android"   xmlns:app="http://schemas.android.com/apk/res-auto"

  android:layout_width="match_parent"   android:layout_height="match_parent">

  <TextView

    android:layout_width="wrap_content"     android:layout_height="wrap_content"     android:text="Hello World!"

    app:layout_constraintBottom_toBottomOf="parent"     app:layout_constraintLeft_toLeftOf="parent"     app:layout_constraintRight_toRightOf="parent"     app:layout_constraintTop_toTopOf="parent"/> < /android.support.constraint.ConstraintLayout >

Animations

  •  Android prend en charge trois types d'animation pouvant être appliqués dans une vue ou une activité. Il est défini en XML:
  •  Animations de propriétés: animation interpolée pouvant être utilisée pour animer éventuellement une propriété de l'objet cible en appliquant des modifications incrémentielles entre deux valeurs. Cela peut être utilisé pour n'importe quoi, du changement de couleur ou d'opacité d'une Vue à un fondu progressif, au changement de la taille de la police ou à l'augmentation des points de vie d'un personnage.
  • Animations de vue - Animations interpolées pouvant être appliquées pour faire pivoter, déplacer, atténuer et étirer une vue.
  • Animations d'images - Des animations «cellule» image par image permettent d'afficher une séquence d'images Drawable.

Android comprend également le cadre de transition de scène, que vous pouvez utiliser pour animer une mise en page à une autre lors de l'exécution en interpolant et en modifiant chacune des valeurs de propriété des vues dans chaque hiérarchie de mise en page. REMARQUE Vous trouverez un aperçu complet de la création, de l'utilisation et de l'application d'animations et de transitions de scènes au chapitre 14, «Personnalisation avancée de votre interface utilisateur». La définition d'animations de propriété, de vue et d'image en tant que ressources externes vous permet de réutiliser la même séquence à plusieurs endroits et vous offre la possibilité de présenter différentes animations en fonction du matériel ou de l'orientation du périphérique. Définition d'animations de propriété Les animateurs de propriétés constituent un puissant cadre permettant de créer des chemins d'animation interpolés pour presque toutes les valeurs ou propriétés.Chaque animation de propriété est stockée dans un fichier XML distinct dans le dossier res / animator du projet. Comme pour les dispositions et les ressources Drawable, le nom de fichier de l’animation est utilisé comme identifiant de ressource.Vous pouvez utiliser un animateur de propriétés pour animer la plupart des propriétés numériques sur un objet cible. Vous pouvez définir des animateurs liés à une propriété spécifique ou un animateur de valeur générique pouvant être alloué à une propriété ou à un objet.Le fragment de code XML suivant montre un animateur de propriété qui modifie l'opacité de l'objet cible en appelant sa méthode setAlpha (ou en modifiant la propriété alpha) par incréments de 0 à 1 en l'espace d'une seconde:

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

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

   android:propertyName="alpha"    android:duration="1000"    android:valueFrom="0f"    android:valueTo="1f" />

 Vous pouvez créer des animations plus complexes qui modifient plusieurs valeurs de propriété à l'aide de la balise set imbriquable. Dans chaque ensemble d'animateurs de propriétés, vous pouvez choisir d'exécuter les animations groupées simultanément (option par défaut) ou de manière séquentielle à l'aide de la balise ordering, comme indiqué ci-dessous:

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

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

     android:ordering="sequentially">

  <set>

    <objectAnimator       android:propertyName="x"       android:duration="200"       android:valueTo="0"

      android:valueType="intType"/>

    <objectAnimator       android:propertyName="y"       android:duration="200"       android:valueTo="0"

      android:valueType="intType"/>

  </set>

  <objectAnimator

    android:propertyName="alpha"     android:duration="1000"     android:valueTo="1f"/> < /set >

 Notez que les animations de propriété changent en réalité les propriétés de l'objet cible et que ces modifications sont conservées. Définition des animations de vue Chaque animation de vue est stockée dans un fichier XML distinct dans le dossier res / anim du projet. Comme pour les dispositions et les ressources Drawable, le nom de fichier de l’animation est utilisé comme identifiant de ressource.Une animation peut être définie pour les modifications alpha (fondu), échelle (scaling), translation (mouvement) ou rotation (rotation).REMARQUE Même si elles sont parfois utiles, les animations View ont d'importantes restrictions par rapport au nouvel animateur de propriétés décrit précédemment. Par conséquent, il est généralement préférable d’utiliser des animateurs de propriétés chaque fois que cela est possible. Le tableau 4-1 montre les attributs valides et les valeurs d'attribut pris en charge par chaque type d'animation.TABLEAU 4-1: Attributs de type d'animation

 ANIMATION            ATTRIBUTES                 VALID VALUES TYPE

Alpha deAlpha / toAlpha Float de 0 à 1 Échelle deXScale / toXScale Float de 0 à 1 deYcale / toYScale Float de 0 à 1 pivotX / pivotY Chaîne du pourcentage de largeur / hauteur du graphique de 0% à 100%Traduire fromXDelta / toXDelta Un des nombres flottants représentant le nombre de pixels par rapport à la position normale, un pourcentage par rapport à la largeur de l'élément (avec le suffixe «%») ou un pourcentage par rapport à la largeur du parent (utilisant le suffixe «% p»). . fromYDelta / toYDelta Un des flottants représentant le nombre de pixels par rapport àtive à la position normale, un pourcentage par rapport à la largeur de l’élément (avec le suffixe «%») ou un pourcentage par rapport à la largeur du parent (avec le suffixe «% p»).Tourner de Degrés / Flottant de 0 à 360 en Degrés 

 Vous pouvez créer une combinaison d'animations à l'aide de la balise set. Un ensemble d'animation contient une ou plusieurs transformations d'animation et prend en charge divers tags et attributs supplémentaires pour personnaliser le moment et la manière dont chaque animation de l'ensemble est exécutée. La liste suivante répertorie certaines des balises définies disponibles: ➤ duration: durée de l'animation complète en millisecondes.

  • startOffset: un délai d'une milliseconde avant le début de l'animation.
  • remplirAvant - Applique la transformation d'animation avant qu'elle ne commence.
  • fillAfter: applique la transformation d'animation à la fin.
  • interpolateur - Définit comment la vitesse de cet effet varie dans le temps.

L'exemple suivant montre un ensemble d'animation qui tourne la cible à 360 degrés pendant qu'elle se réduit et disparaît progressivement: 

Remarque Si vous n'utilisez pas la balise startOffset, tous les effets d'animation d'un ensemble seront exécutés simultanément.

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

< set xmlns:android="http://schemas.android.com/apk/res/android"      android:interpolator="@android:anim/accelerate_interpolator">

  <rotate

    android:fromDegrees="0"     android:toDegrees="360"     android:pivotX="50%"     android:pivotY="50%"     android:startOffset="500"     android:duration="1000" />

  <scale

    android:fromXScale="1.0"     android:toXScale="0.0"     android:fromYScale="1.0"     android:toYScale="0.0"     android:pivotX="50%"     android:pivotY="50%"     android:startOffset="500"     android:duration="500" />

  <alpha

    android:fromAlpha="1.0"     android:toAlpha="0.0"     android:startOffset="500"     android:duration="500" /> < /set >

 Définition d'animations image par image 

Les animations image par image (cellule) représentent une séquence de tirables, chacune étant affichée pendant une durée spécifiée.Étant donné que les animations image par image représentent des dessins animés, elles sont stockées dans le dossier res / drawable et utilisent leurs noms de fichier (sans l'extension .xml) comme identificateurs de ressources.L'extrait de code XML suivant montre une animation simple qui parcourt une série de ressources bitmap, affichant chacune une demi-seconde. Pour utiliser cet extrait, vous devez également créer de nouvelles ressources d'image Android1 à l'aide d'Android3:

 < animation-list

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

  android:oneshot="false">

  <item android:drawable="@drawable/android1" android:duration="500" />

  <item android:drawable="@drawable/android2" android:duration="500" />

  <item android:drawable="@drawable/android3" android:duration="500" />

< /animation-list >

 Notez que dans de nombreux cas, vous devez inclure plusieurs résolutions de chacun des tirables utilisés dans la liste d'animation.Pour lire l'animation, commencez par attribuer la ressource à une vue hôte avant d'obtenir une référence à l'objet Drawable d'animation et de le démarrer:

 ImageView androidIV = findViewById(R.id.iv_android); androidIV.setBackgroundResource(R.drawable.android_anim);

AnimationDrawable androidAnimation =

  (AnimationDrawable)androidIV.getBackground(); androidAnimation.start();

 En règle générale, vous le faites en deux étapes. vous affectez la ressource à l'arrière-plan dans le gestionnaire onCreate.Au sein de ce gestionnaire, l’animation n’est pas complètement attachée à la fenêtre. Par conséquent, les animations ne peuvent pas être démarrées. à la place, ceci est généralement effectué en conséquence d'une action de l'utilisateur (telle qu'une pression sur un bouton) ou dans le gestionnaire onWindowFocusChanged.