Android
Ressources

Traduire une chaîne

Les chaînes peuvent être internationalisées en définissant un fichier strings.xml différent pour chaque langue prise en charge.

Vous ajoutez une nouvelle langue en créant un nouveau répertoire de valeurs avec le code de langue ISO comme suffixe. Par exemple, lors de l'ajout d'un ensemble allemand, votre structure peut ressembler à ceci:

Lorsque le système recherche la chaîne demandée, il vérifie d'abord le fichier XML spécifique à la langue. S'il n'est pas trouvé, la valeur du fichier strings.xml par défaut est renvoyée. La clé reste la même pour chaque langue et seule la valeur change.

Exemple de contenu:

/res/values/strings.xml

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="app_name">HelloWorld</string>
    <string name="hello_world">Hello World!</string>
</resources>

/res/values-fr/strings.xml

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="hello_world">Bonjour tout le monde !!!</string>
</resources>

Définir des chaînes

Les chaînes sont généralement stockées dans le fichier de ressources strings.xml . Ils sont définis à l'aide d'un élément XML <string> .

Strings.xml a pour but de permettre l'internationalisation. Vous pouvez définir un fichier strings.xml pour chaque code iso de la langue. Ainsi, lorsque le système recherche la chaîne 'nom_application', il vérifie d'abord le fichier xml correspondant à la langue actuelle et, s'il n'est pas trouvé, recherche l'entrée dans le fichier strings.xml par défaut. Cela signifie que vous pouvez choisir de ne localiser que certaines de vos chaînes alors que d'autres ne le sont pas.

/res/values/strings.xml

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="app_name">Hello World App</string>
    <string name="hello_world">Hello World!</string>
</resources>

Une fois qu'une chaîne est définie dans un fichier de ressources XML, elle peut être utilisée par d'autres parties de l'application.

Les fichiers de projet XML d'une application peuvent utiliser un élément <string> en faisant référence à @string/string_name . Par exemple, le fichier de manifeste d' une application (/manifests/AndroidManifest.xml) inclut la ligne suivante par défaut dans Android Studio:

android:label="@string/app_name"

Cela dit à Android de rechercher une ressource <string> appelée "app_name" à utiliser comme nom de l'application lorsqu'elle est installée ou affichée dans un lanceur.

Une autre fois, vous utiliseriez une ressource <string> partir d'un fichier XML dans android dans un fichier de mise en page. Par exemple, ce qui suit représente un TextView qui affiche la chaîne hello_world définie précédemment:

<TextView
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="@string/hello_world"/>

Vous pouvez également accéder aux ressources <string> partir de la partie Java de votre application. Pour rappeler notre même chaîne hello_world de dessus dans une classe Activity, utilisez:

String helloWorld = getString(R.string.hello_world);

Définir un tableau de chaînes

Pour définir un tableau de chaînes, écrivez dans un fichier de ressources

res / values ​​/ filename.xml

<string-array name="string_array_name">
    <item>text_string</item>
    <item>@string/string_id</item>
</string-array>

par exemple

res / values ​​/ arrays.xml

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string-array name="string_array_example">
        <item>@string/app_name</item>
        <item>@string/hello_world</item>
    </string-array>
</resources>

et l'utiliser de java comme

String[] strings = getResources().getStringArray(R.array.string_array_example;
Log.i("TAG",Arrays.toString(strings)));

Sortie

I/TAG: [HelloWorld, Hello World!]

Définir les dimensions

Les dimensions sont généralement stockées dans un fichier de ressources dimens.xml . Ils sont définis à l'aide d'un élément <dimen> .

res / values ​​/ dimens.xml

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <dimen name="small_padding">5dp</dimen>
    <dimen name="medium_padding">10dp</dimen>
    <dimen name="large_padding">20dp</dimen>

    <dimen name="small_font">14sp</dimen>
    <dimen name="medium_font">16sp</dimen>
    <dimen name="large_font">20sp</dimen>
</resources> 

Vous pouvez utiliser différentes unités:

• sp: Pixels indépendants de l'échelle. Pour les polices
• dp: Pixels indépendants de la densité. Pour tout le reste.
• pt: Points
• px: Pixels
• mm: millimètres
• im: pouces

Les dimensions peuvent maintenant être référencées en XML avec la syntaxe @dimen/name_of_the_dimension .

Par exemple:

<RelativeLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:padding="@dimen/large_padding">
</RelativeLayout>

Définir des entiers

Les entiers sont généralement stockés dans un fichier de ressources nommé integers.xml , mais le nom du fichier peut être choisi de manière arbitraire. Chaque entier est défini à l'aide d'un élément <integer> , comme indiqué dans le fichier suivant:

res / values ​​/ integers.xml

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <integer name="max">100</integer>
</resources> 

Les entiers peuvent maintenant être référencés en XML avec la syntaxe @integer/name_of_the_integer , comme illustré dans l'exemple suivant:

<ProgressBar
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:max="@integer/max"/>

Définir un tableau d'entiers

Pour définir un tableau entier, écrivez dans un fichier de ressources

res / values ​​/ filename.xml

<integer-array name="integer_array_name">
    <item>integer_value</item>
    <item>@integer/integer_id</item>
</integer-array>

par exemple

res / values ​​/ arrays.xml

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <integer-array name="fibo">
        <item>@integer/zero</item>
        <item>@integer/one</item>
        <item>@integer/one</item>
        <item>@integer/two</item>
        <item>@integer/three</item>
        <item>@integer/five</item>
    </integer-array>
</resources>

et l'utiliser de java comme

int[] values = getResources().getIntArray(R.array.fibo);
Log.i("TAG",Arrays.toString(values)));

Sortie

I/TAG: [0, 1, 1, 2, 3, 5]

Définir les couleurs

Les couleurs sont généralement stockées dans un fichier de ressources nommé colors.xml dans le dossier /res/values/ .

Ils sont définis par <color> éléments <color> :

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <color name="colorPrimary">#3F51B5</color>
    <color name="colorPrimaryDark">#303F9F</color>
    <color name="colorAccent">#FF4081</color>

    <color name="blackOverlay">#66000000</color>
</resources>

Les couleurs sont représentées par des valeurs de couleur hexadécimales pour chaque canal de couleur (0 - FF) dans l'un des formats:

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

Légende

• A - canal alpha - la valeur 0 est totalement transparente, la valeur FF est opaque
• R - canal rouge
• G - canal vert
• B - canal bleu

Les couleurs définies peuvent être utilisées en XML avec la syntaxe suivante @color/name_of_the_color

Par exemple:

<RelativeLayout
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:background="@color/blackOverlay">

Utiliser des couleurs dans le code

Ces exemples supposent this s'agit d'une référence d'activité. Une référence de contexte peut également être utilisée à sa place.

int color = ContextCompat.getColor(this, R.color.black_overlay);
view.setBackgroundColor(color);

int color = this.getResources().getColor(this, R.color.black_overlay);
view.setBackgroundColor(color);

Dans la déclaration ci-dessus, colorPrimary , colorPrimaryDark et colorAccent sont utilisés pour définir les couleurs de conception de matériaux qui seront utilisées pour définir un thème Android personnalisé dans styles.xml . Ils sont automatiquement ajoutés lorsqu'un nouveau projet est créé avec Android Studio.

Obtenir des ressources sans avertissements "obsolètes"

En utilisant l'API Android 23 ou supérieure, très souvent, une telle situation peut être observée:

Cette situation est due au changement structurel de l'API Android concernant l'obtention des ressources.
Maintenant la fonction:

public int getColor(@ColorRes int id, @Nullable Theme theme) throws NotFoundException    

Devrait être utilisé. Mais la bibliothèque android.support.v4 a une autre solution.

Ajoutez la dépendance suivante au fichier build.gradle :

com.android.support:support-v4:24.0.0

Ensuite, toutes les méthodes de la bibliothèque de support sont disponibles:

ContextCompat.getColor(context, R.color.colorPrimaryDark);
ContextCompat.getDrawable(context, R.drawable.btn_check);
ContextCompat.getColorStateList(context, R.color.colorPrimary);
DrawableCompat.setTint(drawable);
ContextCompat.getColor(context,R.color.colorPrimaryDark));

De plus, d'autres méthodes de la bibliothèque de support peuvent être utilisées:

ViewCompat.setElevation(textView, 1F);
ViewCompat.animate(textView);
TextViewCompat.setTextAppearance(textView, R.style.AppThemeTextStyle);
...

Définir une ressource de menu et l'utiliser à l'intérieur d'Activité / Fragment

Définir un menu dans res / menu

<?xml version="1.0" encoding="utf-8"?>
<menu
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto">

    <item
        android:id="@+id/first_item_id"
        android:orderInCategory="100"
        android:title="@string/first_item_string"
        android:icon="@drawable/first_item_icon"
        app:showAsAction="ifRoom"/>

    <item
        android:id="@+id/second_item_id"
        android:orderInCategory="110"
        android:title="@string/second_item_string"
        android:icon="@drawable/second_item_icon"
        app:showAsAction="ifRoom"/>

</menu>

Pour plus d'options de configuration, reportez-vous à: Ressource de menu

Activity intérieure:

@Override
public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
    ///Override defining menu resource
    inflater.inflate(R.menu.menu_resource_id, menu);
    super.onCreateOptionsMenu(menu, inflater);
}

@Override
public void onPrepareOptionsMenu(Menu menu) {
    //Override for preparing items (setting visibility, change text, change icon...)
    super.onPrepareOptionsMenu(menu);
}

@Override
public boolean onOptionsItemSelected(MenuItem item) {
    //Override it for handling items
    int menuItemId = item.getItemId();
    switch (menuItemId) {
        case: R.id.first_item_id
             return true; //return true, if is handled
    }
    return super.onOptionsItemSelected(item);
}

Pour appeler les méthodes ci-dessus pendant l'affichage de la vue, appelez getActivity().invalidateOptionsMenu();

Inside Fragment un appel supplémentaire est nécessaire:

@Nullable
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
    setHasOptionsMenu(true);
    super.onCreateView(inflater, container, savedInstanceState);
}

Formatage de chaîne dans strings.xml

La définition de chaînes dans le fichier strings.xml permet également le formatage des chaînes. Le seul inconvénient est que la chaîne devra être traitée dans le code ci-dessous, par opposition à la simple fixation à une mise en page.

<string name="welcome_trainer">Hello Pokémon Trainer, %1$s! You have caught %2$d Pokémon.</string>

String welcomePokemonTrainerText = getString(R.string.welcome_trainer, tranerName, pokemonCount);

Dans l'exemple ci-dessus,
% 1 $ s
'%' se sépare des caractères normaux,
«1» indique le premier paramètre,
'$' est utilisé comme séparateur entre le numéro de paramètre et le type,
's' dénote le type de chaîne ('d' est utilisé pour l'entier)

Notez que getString() est une méthode de Context ou Resources , c’est-à-dire que vous pouvez l’utiliser directement dans une instance Activity , ou bien utiliser getActivity().getString() ou getContext().getString() respectivement.

Définir une liste d'états de couleurs

Les listes d'états de couleurs peuvent être utilisées comme couleurs, mais changeront en fonction de l'état de la vue pour laquelle elles sont utilisées.

Pour en définir un, créez un fichier de ressources dans res/color/foo.xml

<?xml version="1.0" encoding="utf-8"?>
<selector xmlns:android="http://schemas.android.com/apk/res/android">
    <item android:color="#888888" android:state_enabled="false"/>
    <item android:color="@color/lightGray" android:state_selected="false"/>
    <item android:color="@android:color/white" />
</selector>

Les éléments sont évalués dans l'ordre où ils sont définis et le premier élément dont les états spécifiés correspondent à l'état actuel de la vue est utilisé. Il est donc recommandé de spécifier un catch-all à la fin, sans aucun sélecteur d'état spécifié.

Chaque élément peut utiliser un littéral de couleur ou faire référence à une couleur définie ailleurs.

Définir des cordes à cordes

Pour différencier les chaînes plurielles et singulières, vous pouvez définir un pluriel dans votre fichier strings.xml et répertorier les différentes quantités, comme illustré dans l'exemple ci-dessous:

<?xml version="1.0" encoding="utf-8"?>
<resources>  
    <plurals name="hello_people">
        <item quantity="one">Hello to %d person</item>
        <item quantity="other">Hello to %d people</item>
    </plurals>
</resources>

Cette définition est accessible à partir du code Java à l'aide de la méthode getQuantityString() de la classe Resources , comme illustré dans l'exemple suivant:

getResources().getQuantityString(R.plurals.hello_people, 3, 3);

Ici, le premier paramètre R.plurals.hello_people est le nom de la ressource. Le deuxième paramètre ( 3 dans cet exemple) est utilisé pour sélectionner la chaîne de quantity correcte. Le troisième paramètre (également 3 dans cet exemple) est l'argument de format qui sera utilisé pour remplacer le spécificateur de format %d .

Les valeurs de quantité possibles (répertoriées par ordre alphabétique) sont les suivantes:

few
many
one
other
two
zero

Il est important de noter que tous les paramètres régionaux ne prennent pas en charge chaque dénomination de quantity . Par exemple, la langue chinoise n'a pas de concept d' one élément. L'anglais n'a pas d'élément zero , car il est grammaticalement identique aux other . Les instances de quantity non prises en charge seront signalées par l'EDI en tant qu'avertissements Lint, mais ne provoqueront pas d'erreurs de complication si elles sont utilisées.

Importer un tableau d'objets définis dans les ressources

Il existe des cas où des objets personnalisés doivent être créés et définis dans les ressources de l'application. De tels objets peuvent être composés de types Java simples, par exemple Integer , Float , String .

Voici l'exemple de l'importation d'un objet défini dans les ressources de l'application. L'objet Category contient 3 propriétés de la catégorie:

• ID
• Couleur
• prénom

Ce POJO a son équivalent dans le fichier categories.xml , où chaque tableau a les mêmes propriétés définies pour chaque catégorie.

1. Créez un modèle pour votre objet:

public class Category {
    private Type id;
    private @ColorRes int color;
    private @StringRes String name;

    public Category getId() {
        return id;
    }

    public void setId(Category id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getColor() {
        return color;
    }

    public void setColor(int color) {
        this.color = color;
    }

    public enum Type{
        REGISTRATION,
        TO_ACCEPT,
        TO_COMPLETE,
        TO_VERIFY,
        CLOSED
    }
}

2. Créez le fichier dans le dossier res/values :

categories.xml

3. Composez chaque modèle composé de ressources:

<array name="no_action">
    <item>0</item>
    <item>@android:color/transparent</item>
    <item>@string/statusRegistration</item>
</array>
<array name="to_accept">
    <item>1</item>
    <item>@color/light_gray</item>
    <item>@string/acceptance</item>
</array>
<array name="opened">
    <item>2</item>
    <item>@color/material_green_500</item>
    <item>@string/open</item>
</array>
<array name="to_verify">
    <item>3</item>
    <item>@color/material_gray_800</item>
    <item>@string/verification</item>
</array>
<array name="to_close">
    <item>4</item>
    <item>@android:color/black</item>
    <item>@string/closed</item>
</array>

4. Définissez un tableau dans le fichier de ressources:

   <array name="categories">
       <item>@array/no_action</item>
       <item>@array/to_accept</item>
       <item>@array/opened</item>
       <item>@array/to_verify</item>
       <item>@array/to_close</item>
   </array>
   

5. Créez une fonction pour les importer:

   @NonNull
   public List<Category> getCategories(@NonNull Context context) {
   final int DEFAULT_VALUE = 0;
   final int ID_INDEX = 0;
   final int COLOR_INDEX = 1;
   final int LABEL_INDEX = 2;
   
   if (context == null) {
       return Collections.emptyList();
   }
   // Get the array of objects from the `tasks_categories` array
   TypedArray statuses = context.getResources().obtainTypedArray(R.array.categories);
   if (statuses == null) {
       return Collections.emptyList();
   }
   List<Category> categoryList = new ArrayList<>();
   for (int i = 0; i < statuses.length(); i++) {
       int statusId = statuses.getResourceId(i, DEFAULT_VALUE);
       // Get the properties of one object
       TypedArray rawStatus = context.getResources().obtainTypedArray(statusId);
   
       Category category = new Category();
   
       int id = rawStatus.getInteger(ID_INDEX, DEFAULT_VALUE);
       Category.Type categoryId;
       //The ID's should maintain the order with `Category.Type`
       switch (id) { 
           case 0:
               categoryId = Category.Type.REGISTRATION;
               break;
           case 1:
               categoryId = Category.Type.TO_ACCEPT;
               break;
           case 2:
               categoryId = Category.Type.TO_COMPLETE;
               break;
           case 3:
               categoryId = Category.Type.TO_VERIFY;
               break;
           case 4:
               categoryId  = Category.Type.CLOSED;
               break;
           default:
               categoryId = Category.Type.REGISTRATION;
               break;
       }
       category.setId(categoryId);
   
       category.setColor(rawStatus.getResourceId(COLOR_INDEX, DEFAULT_VALUE));
   
       int labelId = rawStatus.getResourceId(LABEL_INDEX, DEFAULT_VALUE);
       category.setName(getString(context.getResources(), labelId));
   
       categoryList.add(taskCategory);
   }
   return taskCategoryList;
   }
   

9 patchs

9 Les patchs sont des images extensibles dans lesquelles les zones pouvant être étirées sont définies par des marqueurs noirs sur une bordure transparente.

Il y a un excellent tutoriel ici .
En dépit d'être si vieux, c'est toujours si précieux et cela a aidé beaucoup d'entre nous à comprendre profondément les 9 équipements de patch.

Malheureusement, cette page a été récemment mise de côté (elle est actuellement à nouveau disponible).

Par conséquent, la nécessité d'avoir une copie physique de cette page pour les développeurs Android sur notre serveur fiable / s.

C'est ici.

UN GUIDE SIMPLE À L'APPLICATION 9-PATCH POUR ANDROID UI 18 mai 2011

Alors que je travaillais sur ma première application Android, j'ai trouvé 9-patch (aka 9.png) confus et mal documenté. Après un petit moment, j'ai finalement compris comment cela fonctionnait et j'ai décidé de rassembler quelque chose pour aider les autres à le comprendre.

Fondamentalement, 9-patch utilise la transparence png pour faire une forme avancée de 9-tranche ou échelle9. Les guides sont des lignes droites de 1 pixel dessinées sur le bord de votre image qui définissent la mise à l'échelle et le remplissage de votre image. En nommant votre nom de fichier image.9.png, Android reconnaîtra le format 9.png et utilisera les guides noirs pour mettre à l'échelle et remplir vos images bitmap.

Voici un guide de base:

Comme vous pouvez le voir, vous avez des guides de chaque côté de votre image. Les guides TOP et LEFT permettent de mettre à l'échelle votre image (c.-à-d. 9 tranches), tandis que les guides RIGHT et BOTTOM définissent la zone de remplissage.

Les lignes de guidage noires sont coupées / supprimées de votre image - elles n'apparaîtront pas dans l'application. Les guides ne doivent pas avoir plus d’un pixel de largeur, donc si vous voulez un bouton 48 × 48, votre png sera en réalité de 50 × 50. Tout ce qui est plus épais qu'un pixel restera dans votre image. (Mes exemples ont des guides de 4 pixels de large pour une meilleure visibilité. Ils ne doivent vraiment être que de 1 pixel).

Vos guides doivent être en noir (# 000000). Même une légère différence de couleur (# 000001) ou alpha entraînera une défaillance et un étirement normal. Cet échec ne sera pas évident non plus *, il échoue silencieusement! Oui. Vraiment. Maintenant tu sais.

Vous devez également garder à l'esprit que la zone restante du contour d'un pixel doit être complètement transparente. Cela inclut les quatre coins de l'image - ceux-ci devraient toujours être clairs. Cela peut être un problème plus grave que celui que vous réalisez. Par exemple, si vous redimensionnez une image dans Photoshop, elle ajoutera des pixels anti-aliasés pouvant inclure des pixels presque invisibles, ce qui entraînera également son échec *. Si vous devez évoluer dans Photoshop, utilisez le paramètre Voisin le plus proche dans le menu déroulant Rééchantillonnage d'image (en bas du menu contextuel Taille de l'image) pour conserver des bords nets sur vos repères.

* (mis à jour 1/2012) Il s’agit en fait d’un «correctif» dans le dernier kit de développement. Auparavant, il se manifestait sous la forme d'une rupture soudaine de toutes vos autres images et ressources, et non de l'image de 9 patchs réellement cassée.

Les guides TOP et LEFT sont utilisés pour définir la partie évolutive de votre image - GAUCHE pour la hauteur de mise à l'échelle, TOP pour la largeur de mise à l'échelle. En utilisant une image de bouton comme exemple, cela signifie que le bouton peut s'étendre horizontalement et verticalement dans la partie noire et que tout le reste, comme les coins, restera de la même taille. Cela vous permet d'avoir des boutons qui peuvent s'adapter à n'importe quelle taille et conserver un aspect uniforme.

Il est important de noter que les images à 9 patchs ne sont pas réduites - elles ne font qu’augmenter. Il est donc préférable de commencer le plus petit possible.

En outre, vous pouvez omettre des parties au milieu de la ligne d'échelle. Ainsi, par exemple, si vous avez un bouton avec un bord brillant au centre, vous pouvez laisser quelques pixels au milieu du guide LEFT. L'axe horizontal central de votre image ne sera pas mis à l'échelle, mais uniquement les parties situées au-dessus et au-dessous de celui-ci, de sorte que votre brillance ne deviendra pas anti-aliasée ou floue.

Les guides de zone de remplissage sont facultatifs et permettent de définir la zone pour des éléments tels que votre étiquette de texte. Fill détermine la quantité d'espace disponible dans votre image pour placer du texte, une icône ou d'autres choses. 9-patch ne concerne pas uniquement les boutons, il fonctionne également pour les images de fond.

L'exemple ci-dessus de bouton et d'étiquette est exagéré simplement pour expliquer l'idée de remplissage - l'étiquette n'est pas complètement exacte. Pour être honnête, je n'ai pas vu comment Android fait des étiquettes à plusieurs lignes, car une étiquette de bouton est généralement une seule ligne de texte.

Enfin, voici une bonne démonstration de la manière dont les guides d’échelle et de remplissage peuvent varier, tels que LinearLayout avec une image d’arrière-plan et des côtés entièrement arrondis:

Avec cet exemple, le guide LEFT n'est pas utilisé mais nous avons toujours besoin d'un guide. L'image d'arrière-plan n'est pas mise à l'échelle verticalement. il ne fait qu'échelonner horizontalement (basé sur le guide TOP). En regardant les guides de remplissage, les guides DROIT et BAS s'étendent au-delà de l'endroit où ils rencontrent les bords incurvés de l'image. Cela me permet de placer mes boutons ronds près des bords du fond pour un look ajusté et ajusté.

Alors c'est tout. 9-patch est super facile, une fois que vous l'obtenez. Ce n'est pas un moyen idéal de procéder à la mise à l'échelle, mais les repères d'échelle des zones de remplissage et des lignes multiples offrent une plus grande flexibilité que les modèles traditionnels à 9 et 9 tranches9. Essayez-le et vous le découvrirez rapidement.

Niveau de transparence des couleurs (alpha)

Valeurs de l'opacité hexadécimale

    ------------------------------
   |   Alpha(%)  |   Hex Value    |
    ------------------------------
   |    100%     |      FF        |
   |     95%     |      F2        |
   |     90%     |      E6        |
   |     85%     |      D9        |
   |     80%     |      CC        |
   |     75%     |      BF        |
   |     70%     |      B3        |
   |     65%     |      A6        |
   |     60%     |      99        |
   |     55%     |      8C        |
   |     50%     |      80        |
   |     45%     |      73        |
   |     40%     |      66        |
   |     35%     |      59        |
   |     30%     |      4D        |
   |     25%     |      40        |
   |     20%     |      33        |
   |     15%     |      26        |
   |     10%     |      1A        |
   |      5%     |      0D        |
   |      0%     |      00        |
    ------------------------------   

Si vous souhaitez définir la couleur rouge sur 45%.

<color name="red_with_alpha_45">#73FF0000</color> 

Valeur hexadécimale pour le rouge - # FF0000

Vous pouvez ajouter 73 pour une opacité de 45% dans le préfixe - # 73FF0000

Travailler avec le fichier strings.xml

Une ressource de chaîne fournit des chaînes de texte pour votre application avec un style de texte et une mise en forme facultatifs. Il existe trois types de ressources pouvant fournir des chaînes à votre application:

Chaîne

XML resource that provides a single string.

Syntaxe:

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="string_name">text_string</string>
</resources>

Et pour utiliser cette chaîne dans la mise en page:

<TextView
    android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    android:text="@string/string_name" />

Tableau de chaînes

XML resource that provides an array of strings.

Syntaxe:

    <resources>
<string-array name="planets_array">
    <item>Mercury</item>
    <item>Venus</item>
    <item>Earth</item>
    <item>Mars</item>
</string-array>

Usage

Resources res = getResources();
String[] planets = res.getStringArray(R.array.planets_array);

Quantité Strings (Plurals)

XML resource that carries different strings for pluralization. 

Syntaxe:

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <plurals
        name="plural_name">
        <item
            quantity=["zero" | "one" | "two" | "few" | "many" | "other"]
            >text_string</item>
    </plurals>
</resources>

Usage:

int count = getNumberOfsongsAvailable();
Resources res = getResources();
String songsFound = res.getQuantityString(R.plurals.plural_name, count, count);