# General Translation Knowledge Base: Come si localizza un'app Android con strings.xml? URL: https://generaltranslation.com/it/kb/localize-android-app.mdx Docs index: https://generaltranslation.com/llms.txt Description: Tieni tutte le stringhe predefinite in res/values/strings.xml, aggiungi un file strings.xml per ciascuna lingua in una cartella qualificata per impostazione regionale, come values-es o values-b+zh+Hant+TW, e leggi il testo con stringResource o getString. Puoi tradurre a mano, in Play Console o con la CLI di General Translation, che genera ogni cartella values e ricostruisce i plurali per ciascuna lingua di destinazione. Category: Internazionalizzazione Last updated: 2026-10-28 Authors: General Translation Team Published: 2026-10-28 Android sceglie le risorse a runtime da cartelle il cui nome corrisponde all'impostazione regionale del dispositivo. Il testo predefinito si trova in `res/values/strings.xml`, e ogni traduzione è un altro file `strings.xml` con gli stessi nomi di risorsa in una cartella come `res/values-es/`. A te restano quindi due compiti: spostare in `strings.xml` tutte le stringhe visibili all'utente e inserire traduzioni di qualità in ciascuna cartella di lingua. ## Configurare le risorse stringa ### Inserisci tutte le stringhe in res/values/strings.xml Il file predefinito deve contenere tutte le stringhe utilizzate dall'app: se ne manca anche solo una, secondo la guida alla localizzazione di Android l'app "non viene eseguita e mostra un errore". Un file tradotto può contenerne solo un sottoinsieme: per ogni stringa assente viene usata quella del file predefinito ([Android: Localize your app](https://developer.android.com/guide/topics/resources/localization)). Ecco un file predefinito con i modelli che ti serviranno, ciascuno con il proprio commento: ```xml title="res/values/strings.xml" Checkout Hi %1$s, you have %2$d new message. Hi %1$s, you have %2$d new messages. Your cart\'s empty %1$s until your trial ends %d item %d items Newest Price: low to high ``` In Compose, leggile con `stringResource`, `pluralStringResource` e `stringArrayResource`; con le View, usa `context.getString` e `resources.getQuantityString` ([Android: String resources](https://developer.android.com/guide/topics/resources/string-resource)). Per i plurali, passa prima il conteggio, che determina la forma da usare, e poi i valori dei segnaposto, compreso il conteggio stesso. ```kotlin val greeting = pluralStringResource(R.plurals.welcome, count, name, count) val cart = pluralStringResource(R.plurals.items_in_cart, count, count) val sortOptions = stringArrayResource(R.array.sort_options) ``` Anche le app React Native hanno questo file: lo `strings.xml` del template, in `android/app/src/main/res/values/`, contiene `app_name`, ovvero l'etichetta che Android mostra sotto l'icona, mentre la UI JavaScript viene tradotta a parte. (Consulta [Come si traduce un'app React Native?](/kb/translate-react-native-app).) ### Assegna un nome alla cartella di ogni lingua Il nome di una cartella di lingua è formato da `values-` seguito da un qualificatore di risorsa. La lingua è indicata da un codice ISO 639-1, la regione è preceduta da una `r` minuscola e qualsiasi combinazione che includa un sistema di scrittura o una regione numerica usa il formato BCP 47, ovvero `b+` seguito dai subtag uniti da `+`, supportato a partire da Android 7.0 (API 24) ([Android: App resources overview](https://developer.android.com/guide/topics/resources/providing-resources)): | Lingua | Codice locale | Cartella | | ----------------------------- | ------------- | -------------------------- | | Spagnolo | `es` | `res/values-es/` | | Portoghese (Brasile) | `pt-BR` | `res/values-pt-rBR/` | | Spagnolo (America Latina) | `es-419` | `res/values-b+es+419/` | | Cinese (tradizionale, Taiwan) | `zh-Hant-TW` | `res/values-b+zh+Hant+TW/` | Aggiungi una cartella regionale solo per le stringhe che cambiano. Nell'esempio di Android, tutti i testi in inglese si trovano in `values/` e in `values-en-rGB/` ci sono solo le varianti ortografiche del Regno Unito: per tutto il resto si ricorre al fallback. (Vedi [Cosa sono i codici locale?](/kb/locale-codes).) ### Scrivere stringhe a prova di traduttore Queste regole, tratte dalla [guida alle risorse stringa](https://developer.android.com/guide/topics/resources/string-resource) di Android, evitano che una traduzione comprometta la build o la grammatica: * **I plurali seguono la grammatica di ciascuna lingua.** Le quantità sono `zero`, `one`, `two`, `few`, `many` e `other`, ma ogni lingua usa solo quelle richieste dalla propria grammatica: l'inglese ignora `zero` anche per 0, mentre cinese e coreano usano sempre e solo `other`. Non usare `` come un'istruzione `if` per "nessun elemento": scrivi una stringa separata. * **Usa argomenti posizionali.** `%1$s` e `%2$d` permettono al traduttore di spostare il nome dopo il numero quando la lingua di destinazione richiede quell'ordine. * **Esegui l'escape di apostrofi e virgolette.** Scrivi `\'` oppure racchiudi l'intera stringa tra virgolette doppie, e usa `\"` per una virgoletta letterale. Esegui l'escape di una `@` o di un `?` iniziali con `\@` e `\?`, altrimenti Android interpreta il valore come un riferimento a una risorsa. * **Proteggi ciò che non deve cambiare.** Racchiudi segnaposto e URL in `` con un `id` e un `example`, come nella stringa del conto alla rovescia ([Android: Localize your app](https://developer.android.com/guide/topics/resources/localization)). * **Contrassegna le risorse che non cambiano mai.** Aggiungi `translatable="false"` a valori come il nome dell'app, oppure spostali in un file `donottranslate.xml`. * **Lascia un commento.** Un commento sopra una risorsa indica ai traduttori dove compare il testo e quanto spazio ha a disposizione. "Checkout", da solo, potrebbe essere un sostantivo o un verbo. ## Consentire agli utenti di scegliere la lingua dell'app A partire da Android 13 (API 33), gli utenti possono impostare una lingua specifica per ogni app nelle impostazioni di sistema, a condizione che l'app dichiari le lingue supportate. Se attivi `generateLocaleConfig`, Android Gradle Plugin (AGP) 8.1 o versioni successive genera l'elenco delle lingue a partire dalle cartelle `values-*` in fase di compilazione; servono `compileSdk` 33 o superiore e un file `res/resources.properties` che indichi l'impostazione regionale della cartella predefinita, ad esempio `unqualifiedResLocale=en-US`. Se invece preferisci elencare le lingue manualmente, aggiungi `res/xml/locale_config.xml` e fai puntare `android:localeConfig` a questo file nel manifest. Se usi entrambi i metodi, la build non va a buon fine ([Android: Per-app language preferences](https://developer.android.com/guide/topics/resources/app-languages)). ```kotlin title="app/build.gradle.kts" android { androidResources { generateLocaleConfig = true } } ``` Per un selettore della lingua all'interno dell'app, usa AppCompat 1.6.0 o versioni successive e chiama `setApplicationLocales` sul thread principale. Questa chiamata ricrea l'activity e, se usi Compose, l'activity deve estendere `AppCompatActivity`: ```kotlin // Da chiamare sul thread principale: potrebbe riavviare l'Activity. AppCompatDelegate.setApplicationLocales(LocaleListCompat.forLanguageTags("es")) ``` Su Android 12 e versioni precedenti, AppCompat può memorizzare la scelta al posto tuo se aggiungi il suo `AppLocalesMetadataHolderService` nel manifest, con `autoStoreLocales` impostato su `true`. (Per la progettazione del selettore, consulta [Best practice per il selettore della lingua](/kb/language-switcher).) ## Individuare stringhe mancanti e codificate direttamente nel codice Il **Translations Editor** di Android Studio mostra tutte le chiavi in una griglia, con una colonna per ogni lingua, ed evidenzia i problemi in rosso. Fai clic con il pulsante destro su `strings.xml` e scegli **Open Translations Editor**. L'icona del globo aggiunge una lingua e ne crea la cartella `values-*`, mentre la casella di controllo **Untranslatable** inserisce automaticamente `translatable="false"` ([Android: Translations Editor](https://developer.android.com/studio/write/translations-editor)). Android Lint esegue gli stessi controlli in CI: * [`MissingTranslation`](https://googlesamples.github.io/android-custom-lint-rules/checks/MissingTranslation.md.html) (errore) segnala una stringa mancante in una lingua. Puoi disattivarlo per singola risorsa con `tools:ignore="MissingTranslation"`; imposta inoltre `tools:locale` sull'elemento `` del file predefinito, in modo che lint ne conosca la lingua. * [`ExtraTranslation`](https://googlesamples.github.io/android-custom-lint-rules/checks/ExtraTranslation.md.html) (fatale) segnala una stringa tradotta priva di valore predefinito, che può causare l'arresto anomalo dell'app nelle impostazioni regionali in cui manca. * [`HardcodedText`](https://googlesamples.github.io/android-custom-lint-rules/checks/HardcodedText.md.html) (avviso) segnala il testo letterale nei file XML di layout. Non rileva invece le chiamate `Text("...")` di Compose. (Vedi [Come trovo le stringhe codificate direttamente nel codice che non sono tradotte?](/kb/find-hardcoded-strings).) ## Testa ogni lingua Android include due pseudo-impostazioni regionali per eseguire i test prima ancora di avere le traduzioni. `en-XA` aggiunge accenti, allunga il testo e racchiude ogni messaggio tra parentesi quadre, così da far emergere troncamenti e frasi concatenate. `ar-XB` dispone il testo da destra a sinistra. Imposta `isPseudoLocalesEnabled = true` sul tipo di build di debug, abilita le Opzioni sviluppatore sul dispositivo e seleziona la pseudo-impostazione regionale nelle impostazioni della lingua ([Android: Test with pseudolocales](https://developer.android.com/guide/topics/resources/pseudolocales)). (Vedi [Che cos'è la pseudo-localizzazione?](/kb/pseudo-localization).) Per arabo, ebraico e persiano, imposta `android:supportsRtl="true"` sull'elemento `` e usa gli attributi `start` ed `end` (`paddingStart`, `layout_marginEnd`) al posto di `left` e `right`, in modo che i layout vengano specchiati. Aggiungi `android:autoMirrored="true"` ai drawable direzionali e racchiudi qualsiasi valore inserito in una frase con `BidiFormatter.unicodeWrap()`, così che un indirizzo o un numero mantenga la propria direzione ([Android: Support different languages and cultures](https://developer.android.com/training/basics/supporting-devices/languages)). In Compose, `@Preview(locale = "ar")` mostra l'anteprima di una schermata da destra a sinistra. (Per la versione web, vedi [Come si supportano le lingue RTL (right-to-left) in CSS?](/kb/right-to-left-css).) La scheda dell'app sul Google Play Store va tradotta a parte. In Play Console, apri la scheda dello store, fai clic su **Manage translations** e aggiungi per ogni lingua titolo, descrizione breve, descrizione completa e immagini localizzate ([Play Console Help: Translate and localize your app](https://support.google.com/googleplay/android-developer/answer/9844778)). ## Scegli come tradurre Questi approcci popolano le tue cartelle `values-*`: | Approccio | Chi traduce | Contesto a disposizione del traduttore | Ripetibile a ogni rilascio | Cosa resta a tuo carico | | ----------------------------------------------------------------------------- | ------------------------------------------- | ----------------------------------------------------------------------- | --------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------- | | Digitare nel Translations Editor | Tu o un collega bilingue | L'intera app | No | Ogni stringa in ogni lingua, a mano | | Traduzione delle stringhe dell'app in Play Console | Modelli Gemini in Play Console, senza costi | Il tuo `strings.xml` | Sì, per ogni bundle caricato in una bozza di rilascio | Le traduzioni restano in Play, non nel tuo repository, e sovrascrivono quelle esistenti per le lingue selezionate | | Inviare i file a traduttori o a un sistema di gestione delle traduzioni (TMS) | Traduttori professionisti | Commenti, più eventuali screenshot allegati | Tramite la sincronizzazione del TMS | Un ciclo di andata e ritorno per ogni rilascio, con i relativi tempi di attesa | | Traduzione automatica o LLM applicati all'XML tramite script | Un modello o un'API di traduzione | Ciò che invia il tuo script | Sì | Categorie di plurale per lingua, escape, elementi ``, argomenti di formattazione e revisione | | CLI di General Translation | Il servizio di traduzione di GT | Commenti delle risorse, più Glossario e prompt personalizzati condivisi | Esegui [`gt translate`](/docs/cli/reference/commands/translate) prima della build | Revisione nella Dashboard o in Android Studio, poi test dell'app | Play Console può anche tradurre l'app stessa: una volta attivata la traduzione delle stringhe dell'app, ogni bundle dell'app caricato in una bozza di rilascio riceve traduzioni generate dal suo `strings.xml` più recente, che puoi visualizzare in anteprima in un emulatore e modificare prima della pubblicazione. Selezionando una lingua, tutte le traduzioni già esistenti per quella lingua vengono sostituite, mentre la casella di controllo **Translate** consente di escludere singole stringhe ([Guida di Play Console](https://support.google.com/googleplay/android-developer/answer/9844778)). Usa il Translations Editor per una o due lingue che conosci. Usa la traduzione di Play Console se pubblichi tramite Google Play e non ti servono le traduzioni nella tua base di codice. Scegli General Translation se vuoi committare i file `strings.xml` tradotti a ogni rilascio e condividere la terminologia con la tua app iOS e il tuo sito web. Usa un [TMS](/kb/what-is-a-translation-management-system) se il lavoro è affidato a traduttori professionisti o a un fornitore con cui collabori già. ## Tradurre strings.xml con General Translation La CLI di General Translation, `gt`, traduce le risorse stringa di Android tramite la chiave di file `androidStrings` (`gt` 2.19.0 o versioni successive). Il percorso del file predefinito non contiene alcuna impostazione regionale, quindi fai puntare `include` a questo file e usa `transform` per indirizzare ogni traduzione nella cartella della rispettiva lingua: ```json title="gt.config.json" { "defaultLocale": "en", "locales": ["es", "pt-BR", "zh-Hant-TW"], "files": { "androidStrings": { "include": ["app/src/main/res/values/strings.xml"], "transform": { "match": "res/values/(.*)", "replace": "res/values-{locale}/$1" } } } } ``` La CLI converte ogni impostazione regionale nel qualificatore previsto da Android, quindi questa config genera `values-es/`, `values-pt-rBR/` e `values-b+zh+Hant+TW/`. Non usare un pattern `values-[locale]` per un progetto standard: cercherebbe una cartella `values-en/`, non troverebbe corrispondenze e non tradurrebbe nulla. La CLI richiede Node.js 20 o versioni successive; installala come indicato nell'[Avvio rapido della CLI](/docs/cli/quickstart), accedi con [`npx gt login`](/docs/cli/reference/commands/login), imposta `GT_PROJECT_ID` ([credenziali della CLI](/docs/cli/guides/configuring#credentials)) e, se l'app ha già delle traduzioni, importale con [`npx gt upload`](/docs/cli/reference/commands/upload). Poi esegui [`npx gt translate`](/docs/cli/reference/commands/translate). In CI, salva come `GT_API_KEY` una chiave API di progetto con **Files > Write** e **Translation queue > Enabled**. I file tradotti mantengono i nomi delle risorse, gli elementi ``, gli argomenti di formattazione e il markup inline; su ogni stringa tradotta viene verificata la presenza di questi elementi e l'escape di apostrofi e virgolette richiesto dalla build Android. I `` vengono ricostruiti in base alle categorie della lingua di destinazione: il polacco riceve `one`, `few`, `many` e `other`, l'arabo tutte e sei, il cinese solo `other`, mentre le categorie che la lingua non usa mai, compreso un eventuale `zero` nella sorgente, vengono eliminate. Un commento posto sopra una risorsa viene inviato come contesto. La CLI non traduce le risorse contrassegnate con `translatable="false"`, i valori che fanno riferimento a un'altra risorsa né i tipi non testuali come ``. (Consulta il [riferimento di strings.xml](/docs/cli/reference/formats/android-strings-files).) Le risorse contrassegnate con `translatable="false"` all'interno di un file incluso vengono copiate invariate in ogni file tradotto, e il controllo [`Untranslatable`](https://googlesamples.github.io/android-custom-lint-rules/checks/Untranslatable.md.html) di Android Lint genera un avviso per ciascuna copia. Sposta quei valori in `res/values/donottranslate.xml` e includi solo `strings.xml`. Rivedi le traduzioni nella [dashboard](/docs/platform/dashboard/guides/reviewing-translations) o in Android Studio; se modifichi i file in locale, esegui [`npx gt save-local`](/docs/cli/reference/commands/save-local) affinché le esecuzioni successive conservino le tue modifiche. Assegna un unico [gruppo di contesto](/docs/platform/dashboard/guides/defining-context-for-translations) ai tuoi progetti Android, [iOS](/kb/localize-ios-app) e web: così un termine del Glossario, come il nome di un piano, verrà tradotto allo stesso modo ovunque. Partiful usa General Translation per oltre 2 impostazioni regionali su web, iOS e Android ([distribuzioni in produzione](https://generaltranslation.com/enterprise)). ## Domande frequenti ### Serve una cartella values-en per l'inglese? No. La cartella `values/` senza qualificatori viene usata per tutte le impostazioni regionali che non traduci. Quando attivi `generateLocaleConfig`, `resources.properties` indica alla build a quale impostazione regionale corrisponde quella cartella. ### Perché la mia app tradotta mostra alcune stringhe in inglese? Nel file `strings.xml` tradotto mancano quei nomi, quindi Android ricorre a quelli in `values/`. Il controllo `MissingTranslation` di Lint li elenca per ciascuna lingua. ### Google Play traduce automaticamente la mia scheda dello store? Chi visualizza una scheda in una lingua per cui non hai fornito una traduzione può scegliere di vederne una versione tradotta automaticamente. Le traduzioni che aggiungi in **Manage translations** la sostituiscono per ciascuna lingua aggiunta. ## Punti chiave * `res/values/strings.xml` deve contenere tutte le stringhe; le cartelle tradotte possono contenerne solo un sottoinsieme e usare il file predefinito come fallback. * I nomi delle cartelle usano qualificatori: `values-pt-rBR` per una regione, `values-b+zh+Hant+TW` per un sistema di scrittura. * Usa argomenti posizionali come `%1$s`, esegui l'escape degli apostrofi e lascia che ogni lingua definisca le proprie categorie ``. * Attiva `generateLocaleConfig` (AGP 8.1+) per supportare l'impostazione della lingua per singola app introdotta in Android 13 ed esegui i test con le pseudo-impostazioni regionali `en-XA` e `ar-XB`. * La CLI di General Translation traduce `strings.xml` tramite `androidStrings` e un `transform` verso `values-{locale}`, generando il qualificatore previsto da Android e ricostruendo i plurali per ciascuna lingua. ## Related questions - [Come si localizza un'app iOS con gli String Catalog?](https://generaltranslation.com/it/kb/localize-ios-app.mdx): Aggiungi le lingue in Xcode, scrivi il testo visibile all'utente con API localizzabili come Text di SwiftUI e String(localized:), quindi esegui la build affinché Xcode raccolga queste stringhe in uno String Catalog (.xcstrings). Traduci in Xcode, tramite XLIFF o con la CLI di General Translation se vuoi che i cataloghi si aggiornino a ogni rilascio e condividano la terminologia con il tuo sito web e la tua app Android. - [Come si traduce un'app React Native?](https://generaltranslation.com/it/kb/translate-react-native-app.mdx): Contrassegna il testo nei tuoi componenti, genera un file di traduzione per ogni lingua, aggiungi i Polyfill Intl e carica il file corrispondente alla lingua del dispositivo. Con gt-react-native, la libreria sperimentale di General Translation, racchiudi il testo in ``, un plugin Babel aggiunge i polyfill e npx gt translate genera i file. - [Che cos'è la pseudo-localizzazione?](https://generaltranslation.com/it/kb/pseudo-localization.mdx): La pseudo-localizzazione è un test che sostituisce il testo di origine con una versione alterata, con caratteri accentati, allungata di circa il 40% e racchiusa tra parentesi quadre, così che stringhe hardcoded, troncamenti, font che non vengono visualizzati correttamente e frasi concatenate emergano prima ancora che esista una traduzione. Android include a questo scopo le pseudo-impostazioni regionali en-XA e ar-XB. - [Come si trovano le stringhe hardcoded non tradotte?](https://generaltranslation.com/it/kb/find-hardcoded-strings.mdx): Esegui in CI un linter che segnali i letterali stringa visibili all'utente, come la regola no-literal-string di eslint-plugin-i18next per JSX, il controllo HardcodedText di Android Lint o il linter HardCodedString di erb_lint per Rails. Poi naviga nell'app con una pseudo-impostazione regionale per individuare il testo che i controlli statici non riescono a tracciare. - [Come si supportano le lingue RTL (right-to-left) in CSS?](https://generaltranslation.com/it/kb/right-to-left-css.mdx): Imposta dir="rtl" e lang sull'elemento html, perché lang da solo non cambia la direzione, poi sostituisci le proprietà CSS fisiche come margin-left con proprietà logiche come margin-inline-start. Le righe flex, le colonne della griglia e l'allineamento predefinito del testo si invertono da sole; translateX(), left e right no. ## Previous and next questions - Previous question: [Come si crea una mappa del sito per un sito web multilingue?](https://generaltranslation.com/it/kb/multilingual-sitemap.mdx) - Next question: [Come si traduce un'app Flask o FastAPI?](https://generaltranslation.com/it/kb/translate-python-app.mdx) ## Sitemap See the [Knowledge Base sitemap](https://generaltranslation.com/it/kb/sitemap.md) for every article.