Android
risorse

Traduci una stringa

Le stringhe possono essere internazionalizzate definendo un diverso string.xml per ogni lingua supportata.

Si aggiunge una nuova lingua creando una nuova directory dei valori con il codice della lingua ISO come suffisso. Ad esempio, quando si aggiunge un set tedesco, la struttura potrebbe essere simile a quanto segue:

Quando il sistema cerca la stringa richiesta, prima controlla l'xml specifico della lingua, se non viene trovato, viene restituito il valore dal file strings.xml predefinito. La chiave rimane la stessa per ogni lingua e solo il valore cambia.

Contenuti di esempio:

/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>

Definisci stringhe

Le stringhe sono in genere memorizzate nel file di risorse strings.xml . Sono definiti utilizzando un elemento XML <string> .

Lo scopo di strings.xml è di consentire l'internazionalizzazione. È possibile definire un file strings.xml per ogni codice ISO. Pertanto, quando il sistema cerca la stringa "nome_app", verifica innanzitutto il file xml corrispondente alla lingua corrente e, se non viene trovato, cerca la voce nel file strings.xml predefinito. Ciò significa che puoi scegliere di localizzare solo alcune delle tue stringhe mentre non altre.

/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>

Una volta definita una stringa in un file di risorse XML, può essere utilizzata da altre parti dell'app.

I file di progetto XML di un'app possono utilizzare un elemento <string> facendo riferimento a @string/string_name . Ad esempio, il file manifest di app (/manifests/AndroidManifest.xml) include la seguente riga per impostazione predefinita in Android Studio:

android:label="@string/app_name"

Questo dice ad Android di cercare una risorsa <string> chiamata "nome_app" da usare come nome per l'app quando viene installata o visualizzata in un launcher.

Un'altra volta che usereste una risorsa <string> da un file XML in Android si troverà in un file di layout. Ad esempio, il seguente rappresenta un TextView che mostra la stringa hello_world definita in precedenza:

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

Puoi anche accedere alle <string> risorse dalla porzione java della tua app. Per richiamare la nostra stessa stringa hello_world dall'alto in una classe di attività, utilizzare:

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

Definisci array di stringhe

Per definire un array di stringhe scrivere in un file di risorse

res / valori / filename.xml

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

per esempio

res / valori / 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>

e usalo da java come

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

Produzione

I/TAG: [HelloWorld, Hello World!]

Definire le dimensioni

Le dimensioni sono in genere memorizzate in nomi di file di risorse dimens.xml . Sono definiti usando un elemento <dimen> .

res / valori / 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> 

Puoi usare diverse unità:

• sp: pixel indipendenti dalla scala. Per i caratteri.
• dp: pixel indipendenti dalla densità. Per tutto il resto.
• pt: punti
• px: Pixel
• mm: millimetri
• im: pollici

Le quote possono ora essere referenziate in XML con la sintassi @dimen/name_of_the_dimension .

Per esempio:

<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>

Definisci interi

Gli integer sono in genere memorizzati in un file di risorse denominato integers.xml , ma il nome del file può essere scelto arbitrariamente. Ogni intero è definito utilizzando un elemento <integer> , come mostrato nel seguente file:

res / valori / integers.xml

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

Gli integer possono ora essere referenziati in XML con la sintassi @integer/name_of_the_integer , come mostrato nell'esempio seguente:

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

Definire l'array intero

Per definire una scrittura di array intero in un file di risorse

res / valori / filename.xml

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

per esempio

res / valori / 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>

e usalo da java come

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

Produzione

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

Definire i colori

I colori vengono solitamente memorizzati in un file di risorse denominato colors.xml nella colors.xml /res/values/ .

Sono definiti da elementi <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>

I colori sono rappresentati da valori di colore esadecimali per ciascun canale di colore (0 - FF) in uno dei seguenti formati:

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

Leggenda

• A - canale alfa - il valore 0 è completamente trasparente, il valore FF è opaco
• R - canale rosso
• G - canale verde
• B - canale blu

I colori definiti possono essere utilizzati in XML con la seguente sintassi @color/name_of_the_color

Per esempio:

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

Uso dei colori nel codice

Questi esempi presuppongono che this tratti di un riferimento di attività. Un riferimento al contesto può essere utilizzato anche al suo posto.

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);

Nella dichiarazione sopra colorPrimary , colorPrimaryDark e colorAccent vengono utilizzati per definire i colori di progettazione del materiale che verranno utilizzati nella definizione del tema Android personalizzato in styles.xml . Vengono aggiunti automaticamente quando viene creato un nuovo progetto con Android Studio.

Ottenere risorse senza avvisi "deprecati"

Utilizzando l'API di Android 23 o superiore, molto spesso tale situazione può essere vista:

Questa situazione è causata dal cambiamento strutturale dell'API di Android per quanto riguarda il recupero delle risorse.
Ora la funzione:

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

dovrebbe essere usato. Ma la libreria android.support.v4 ha un'altra soluzione.

Aggiungi la seguente dipendenza al file build.gradle :

com.android.support:support-v4:24.0.0

Quindi sono disponibili tutti i metodi dalla libreria di supporto:

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));

Inoltre è possibile utilizzare più metodi dalla libreria di supporto:

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

Definire una risorsa di menu e utilizzarla all'interno di Attività / Frammento

Definire un menu in 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>

Per ulteriori opzioni di configurazione, fare riferimento a: Risorsa del menu

Activity interna:

@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);
}

Per invocare i metodi precedenti durante la visualizzazione della vista, chiamare getActivity().invalidateOptionsMenu();

All'interno di Fragment è necessaria una chiamata aggiuntiva:

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

Formattazione delle stringhe in strings.xml

La definizione di stringhe nel file strings.xml consente anche la formattazione delle stringhe. L'unica avvertenza è che la stringa dovrà essere trattata nel codice come sotto, invece di collegarlo semplicemente a un layout.

<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);

Nell'esempio sopra,
% 1 $ s
'%' si separa dai caratteri normali,
'1' indica il primo parametro,
'$' è usato come separatore tra numero di parametro e tipo,
's' indica il tipo di stringa ('d' è usato per intero)

Nota che getString() è un metodo di Context o Resources , cioè puoi usarlo direttamente all'interno di un'istanza di Activity , altrimenti puoi usare getActivity().getString() o getContext().getString() rispettivamente.

Definire un elenco di stati colore

Gli elenchi degli stati del colore possono essere utilizzati come colori, ma cambiano a seconda dello stato della vista per cui sono utilizzati.

Per definirne uno, creare un file di risorse in 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>

Gli articoli vengono valutati nell'ordine in cui sono definiti e viene utilizzato il primo elemento i cui stati specificati corrispondono allo stato corrente della vista. Pertanto, è buona norma specificare un catch-all alla fine, senza specificare alcun selettore di stato.

Ogni elemento può utilizzare un letterale di colore o fare riferimento a un colore definito da qualche altra parte.

Definire i plurali della stringa

Per distinguere tra stringhe plurali e singolari, puoi definire un plurale nel tuo file strings.xml ed elencare le diverse quantità, come mostrato nell'esempio seguente:

<?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>

È possibile accedere a questa definizione dal codice Java utilizzando il metodo getQuantityString() della classe Resources , come illustrato nell'esempio seguente:

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

Qui, il primo parametro R.plurals.hello_people è il nome della risorsa. Il secondo parametro ( 3 in questo esempio) viene utilizzato per selezionare la stringa di quantity corretta. Il terzo parametro (anche 3 in questo esempio) è l'argomento di formato che verrà utilizzato per sostituire lo specificatore di formato %d .

I valori di quantità possibili (elencati in ordine alfabetico) sono:

few
many
one
other
two
zero

È importante notare che non tutti i locali supportano ogni denominazione di quantity . Ad esempio, la lingua cinese non ha il concetto di one oggetto. L'inglese non ha un oggetto zero , poiché è grammaticalmente uguale other . Le istanze di quantity non supportate verranno contrassegnate dall'IDE come avvertenze sui rifiuti, ma non causeranno errori di complicazione se vengono utilizzate.

Importa array di oggetti definiti in risorse

Ci sono casi in cui gli oggetti personalizzati devono essere creati e definiti nelle risorse dell'applicazione. Tali oggetti possono essere composti da tipi semplici di Java , ad esempio Integer , Float , String .

Ecco l'esempio di come importare un oggetto definito nelle risorse dell'applicazione. L'oggetto Category comprende 3 proprietà della categoria:

• ID
• Colore
• Nome

Questo POJO ha il suo equivalente nel file categories.xml , in cui ogni array ha le stesse proprietà definite per ogni categoria.

1. Crea un modello per il tuo oggetto:

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. Crea il file nella cartella res/values :

categories.xml

3. Componi ogni modello composto da risorse:

<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. Definire un array nel file delle risorse:

   <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. Creare una funzione per importarli:

   @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 patch

9 Le patch sono immagini estensibili in cui le aree che possono essere allungate sono definite da pennarelli neri su un bordo trasparente.

C'è un ottimo tutorial qui .
Nonostante sia così vecchio, è ancora così prezioso e ha aiutato molti di noi a comprendere a fondo le 9 patch.

Sfortunatamente, recentemente quella pagina è stata messa giù per un po '(è attualmente di nuovo attiva).

Quindi, la necessità di avere una copia fisica di quella pagina per gli sviluppatori Android sul nostro server affidabile / s.

Ecco qui.

UNA GUIDA SEMPLICE A 9-PATCH PER ANDROID UI 18 maggio 2011

Mentre stavo lavorando alla mia prima app per Android, ho trovato 9 patch (aka 9.png) per essere confuso e scarsamente documentato. Dopo un po ', alla fine ho capito come funziona e ho deciso di mettere insieme qualcosa per aiutare gli altri a capirlo.

Fondamentalmente, 9-patch usa la trasparenza png per fare una forma avanzata di 9-slice o scale9. Le guide sono dritte, linee nere da 1 pixel disegnate sul bordo dell'immagine che definiscono il ridimensionamento e il riempimento dell'immagine. Denominando il file immagine nome.9.png, Android riconoscerà il formato 9.png e utilizzerà le guide nere per ridimensionare e riempire i bitmap.

Ecco una mappa guida di base:

Come puoi vedere, hai delle guide su ciascun lato dell'immagine. Le guide TOP e LEFT servono per ridimensionare l'immagine (ad esempio 9 sezioni), mentre le guide RIGHT e BOTTOM definiscono l'area di riempimento.

Le linee guida nere sono troncate / rimosse dalla tua immagine - non verranno mostrate nell'app. Le guide devono avere un solo pixel, quindi se vuoi un pulsante 48 × 48, il tuo png sarà effettivamente 50 × 50. Qualsiasi cosa più spessa di un pixel rimarrà parte dell'immagine. (I miei esempi hanno guide larghe 4 pixel per una migliore visibilità e dovrebbero essere solo 1 pixel).

Le tue guide devono essere nere (# 000000). Anche una leggera differenza di colore (# 000001) o alpha causerà un errore e si allungherà normalmente. Anche questo fallimento non sarà ovvio *, fallisce silenziosamente! Sì. Veramente. Ora sai.

Inoltre, tieni presente che l'area rimanente del contorno di un pixel deve essere completamente trasparente. Questo include i quattro angoli dell'immagine - quelli dovrebbero essere sempre chiari. Questo può essere un problema più grande di quello che ti rendi conto. Ad esempio, se ridimensioni un'immagine in Photoshop, aggiungerai pixel anti-alias che potrebbero includere pixel quasi invisibili che causeranno anche il fallimento *. Se è necessario ridimensionare in Photoshop, utilizzare l'impostazione Vicini più vicini nel menu a discesa Ridimensionamento immagine (nella parte inferiore del menu a comparsa Dimensioni immagine) per mantenere i bordi nitidi sulle guide.

* (aggiornato 1/2012) Questa è in realtà una "correzione" nell'ultimo kit di sviluppo. In precedenza si manifestava quando tutte le altre immagini e risorse si rompevano all'improvviso, non l'immagine a 9 patch effettivamente rotta.

Le guide TOP e LEFT sono utilizzate per definire la porzione scalabile dell'immagine: SINISTRA per l'altezza di ridimensionamento, TOP per la larghezza di ridimensionamento. Usando l'immagine di un pulsante come esempio, questo significa che il pulsante può estendersi orizzontalmente e verticalmente all'interno della porzione nera e tutto il resto, come gli angoli, rimarrà della stessa dimensione. Ti consente di avere pulsanti che possono ridimensionare a qualsiasi dimensione e mantenere un aspetto uniforme.

È importante notare che le immagini a 9 patch non si ridimensionano, ma si scalano. Quindi è meglio iniziare il più piccolo possibile.

Inoltre, è possibile tralasciare porzioni nel mezzo della linea di scala. Ad esempio, se hai un pulsante con un bordo lucido e affilato nel mezzo, puoi lasciare alcuni pixel nel mezzo della guida LEFT. L'asse orizzontale centrale della tua immagine non si ridimensiona, solo le parti sopra e sotto di essa, così il tuo gloss non risulterà anti-alias o sfocato.

Le guide dell'area di riempimento sono facoltative e forniscono un modo per definire l'area per elementi come l'etichetta di testo. Riempi determina la quantità di spazio all'interno dell'immagine per posizionare il testo, un'icona o altre cose. 9-patch non è solo per i pulsanti, funziona anche per le immagini di sfondo.

Il precedente esempio di pulsante ed etichetta è esagerato semplicemente per spiegare l'idea del riempimento: l'etichetta non è completamente accurata. Per essere onesti, non ho esperienza di come Android fa le etichette su più righe poiché un'etichetta di pulsante è in genere una singola riga di testo.

Infine, ecco una buona dimostrazione di come le guide di scala e riempimento possono variare, come ad esempio LinearLayout con un'immagine di sfondo e lati completamente arrotondati:

Con questo esempio, la guida LEFT non viene utilizzata, ma dobbiamo ancora avere una guida. L'immagine di sfondo non si scala verticalmente; scala solo orizzontalmente (in base alla guida TOP). Osservando le guide di riempimento, le guide DESTRA e BASSA si estendono oltre il punto in cui incontrano i bordi curvi dell'immagine. Questo mi consente di posizionare i miei pulsanti rotondi vicino ai bordi dello sfondo per un look aderente e aderente.

Quindi è così. 9 patch è semplicissimo, una volta ottenuto. Non è un modo perfetto per eseguire il ridimensionamento, ma le guide della scala di riempimento e multilinea offrono una maggiore flessibilità rispetto al tradizionale 9-slice e scale9. Fare un tentativo e lo capirai rapidamente.

Livello di trasparenza del colore (alfa)

Hex Opacity Values

    ------------------------------
   |   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        |
    ------------------------------   

Se si desidera impostare il 45% sul rosso.

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

valore esadecimale per rosso - # FF0000

Puoi aggiungere 73 per il 45% di opacità nel prefisso - # 73FF0000

Lavorare con il file strings.xml

Una risorsa stringa fornisce stringhe di testo per l'applicazione con stile e formattazione del testo opzionali. Esistono tre tipi di risorse che possono fornire all'applicazione stringhe:

Stringa

XML resource that provides a single string.

Sintassi:

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

E per usare questa stringa nel layout:

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

Array di stringhe

XML resource that provides an array of strings.

Sintassi:

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

uso

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

Quantità di corde (plurali)

XML resource that carries different strings for pluralization. 

Sintassi:

<?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>

Uso:

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