# General Translation Knowledge Base: Comment localiser une application Android avec strings.xml ? URL: https://generaltranslation.com/fr/kb/localize-android-app.mdx Docs index: https://generaltranslation.com/llms.txt Description: Placez toutes les chaînes de caractères par défaut dans res/values/strings.xml, ajoutez un strings.xml pour chaque langue dans un dossier qualifié par paramètre régional, comme values-es ou values-b+zh+Hant+TW, et lisez le texte avec stringResource ou getString. Traduisez à la main, dans la Play Console ou avec la CLI de General Translation, qui génère chaque dossier values et reconstruit les formes plurielles pour chaque langue cible. Category: Internationalisation Last updated: 2026-10-28 Authors: General Translation Team Published: 2026-10-28 À l’exécution, Android sélectionne les ressources dans des dossiers nommés d’après le paramètre régional de l’appareil. Votre texte par défaut se trouve dans `res/values/strings.xml`, et chaque traduction est un autre fichier `strings.xml` reprenant les mêmes noms de ressources, placé dans un dossier tel que `res/values-es/`. Il vous reste donc deux choses à faire : regrouper dans `strings.xml` toutes les chaînes de caractères visibles par l’utilisateur, et placer des traductions de qualité dans chaque dossier de langue. ## Configurer les ressources de chaînes de caractères ### Placez toutes les chaînes de caractères dans res/values/strings.xml Le fichier par défaut doit contenir toutes les chaînes de caractères utilisées par l'application : s'il en manque une, l'application « ne s'exécute pas et affiche une erreur », selon le guide de localisation d'Android. Un fichier traduit peut n'en contenir qu'un sous-ensemble : toute chaîne de caractères absente est alors récupérée depuis le fichier par défaut ([Android: Localize your app](https://developer.android.com/guide/topics/resources/localization)). Voici un fichier par défaut contenant les motifs dont vous aurez besoin, chacun accompagné d'annotations : ```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 ``` Dans Compose, lisez-les avec `stringResource`, `pluralStringResource` et `stringArrayResource` ; avec les Views, utilisez `context.getString` et `resources.getQuantityString` ([Android : String resources](https://developer.android.com/guide/topics/resources/string-resource)). Pour les formes plurielles, passez d'abord le nombre, qui détermine la forme à utiliser, puis les valeurs des espaces réservés, y compris le nombre lui-même. ```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) ``` Les applications React Native possèdent elles aussi ce fichier : le `strings.xml` du modèle de projet, situé dans `android/app/src/main/res/values/`, contient `app_name`, le libellé qu'Android affiche sous l'icône, tandis que l'IU JavaScript est traduite séparément. (Voir [Comment traduire une application React Native ?](/kb/translate-react-native-app).) ### Nommer un dossier pour chaque langue Un dossier de langue se compose de `values-` suivi d’un qualificateur de ressource. La langue est indiquée par un code ISO 639-1, la région est précédée du préfixe `r` en minuscule, et tout code comportant un système d’écriture ou une région numérique utilise la forme BCP 47 : `b+` suivi des sous-balises séparées par `+`, prise en charge depuis Android 7.0 (API 24) ([Android: App resources overview](https://developer.android.com/guide/topics/resources/providing-resources)) : | Langue | Code de langue | Dossier | | ------------------------------ | -------------- | -------------------------- | | Espagnol | `es` | `res/values-es/` | | Portugais (Brésil) | `pt-BR` | `res/values-pt-rBR/` | | Espagnol (Amérique latine) | `es-419` | `res/values-b+es+419/` | | Chinois (traditionnel, Taïwan) | `zh-Hant-TW` | `res/values-b+zh+Hant+TW/` | N’ajoutez un dossier régional que pour les chaînes qui diffèrent. Dans l’exemple d’Android, tout l’anglais se trouve dans `values/` et seules les orthographes propres au Royaume-Uni figurent dans `values-en-rGB/` ; tout le reste se rabat sur les valeurs par défaut. (Voir [Que sont les codes de paramètres régionaux ?](/kb/locale-codes).) ### Écrire des chaînes de caractères que les traducteurs ne peuvent pas casser Ces règles, tirées du [guide des ressources de chaînes de caractères](https://developer.android.com/guide/topics/resources/string-resource) d'Android, évitent qu'une traduction ne casse la compilation ou la grammaire : * **Les formes plurielles suivent la grammaire de chaque langue.** Les quantités possibles sont `zero`, `one`, `two`, `few`, `many` et `other`, mais chaque langue n'utilise que celles dont sa grammaire a besoin : l'anglais ignore `zero`, même pour 0, tandis que le chinois et le coréen n'utilisent que `other`. N'utilisez pas `` comme une instruction `if` pour gérer le cas « aucun élément » ; créez plutôt une chaîne de caractères distincte. * **Utilisez des arguments positionnels.** `%1$s` et `%2$d` permettent au traducteur de placer le nom après le nombre si la langue cible impose cet ordre. * **Échappez les apostrophes et les guillemets.** Écrivez `\'` ou entourez toute la chaîne de caractères de guillemets doubles, et écrivez `\"` pour un guillemet littéral. Échappez un `@` ou un `?` en début de chaîne de caractères avec `\@` et `\?`, sinon Android interprète la valeur comme une référence de ressource. * **Protégez ce qui ne doit pas changer.** Encapsulez les espaces réservés et les URL dans `` avec un `id` et un `example`, comme dans la chaîne de caractères du compte à rebours ([Android : Localiser votre application](https://developer.android.com/guide/topics/resources/localization)). * **Marquez les ressources qui ne changent jamais.** Ajoutez `translatable="false"` aux valeurs comme le nom de l'application, ou déplacez-les dans un fichier `donottranslate.xml`. * **Laissez un commentaire.** Un commentaire placé au-dessus d'une ressource indique aux traducteurs où le texte s'affiche et de combien de place il dispose. Isolé, « Checkout » peut être un nom comme un verbe. ## Permettre aux utilisateurs de choisir la langue de l'application Depuis Android 13 (API 33), les utilisateurs peuvent définir une langue propre à chaque application dans les paramètres système, à condition que celle-ci déclare les langues qu'elle prend en charge. Si vous activez `generateLocaleConfig`, Android Gradle Plugin (AGP) 8.1 ou version ultérieure génère la liste des langues à partir de vos dossiers `values-*` lors du build ; cela nécessite `compileSdk` 33 ou supérieur, ainsi qu'un fichier `res/resources.properties` indiquant le paramètre régional du dossier par défaut, par exemple `unqualifiedResLocale=en-US`. Pour lister plutôt les langues manuellement, ajoutez `res/xml/locale_config.xml` et faites pointer `android:localeConfig` vers ce fichier dans le manifeste. La compilation échoue si vous combinez les deux méthodes ([Android : préférences de langue par application](https://developer.android.com/guide/topics/resources/app-languages)). ```kotlin title="app/build.gradle.kts" android { androidResources { generateLocaleConfig = true } } ``` Pour proposer un sélecteur de langue dans l'application, utilisez AppCompat 1.6.0 ou une version ultérieure et appelez `setApplicationLocales` sur le thread principal. Cet appel recrée l'activité ; avec Compose, celle-ci doit donc étendre `AppCompatActivity` : ```kotlin // À appeler sur le thread principal ; peut redémarrer l'Activity. AppCompatDelegate.setApplicationLocales(LocaleListCompat.forLanguageTags("es")) ``` Sur Android 12 et versions antérieures, AppCompat peut mémoriser ce choix à votre place si vous déclarez son `AppLocalesMetadataHolderService` dans le manifeste avec `autoStoreLocales` défini sur `true`. (Pour la conception du sélecteur, consultez [Bonnes pratiques pour le sélecteur de langue](/kb/language-switcher).) ## Détecter les chaînes de caractères manquantes et codées en dur Le **Translations Editor** d'Android Studio affiche toutes les clés dans une grille, avec une colonne par langue, et signale les problèmes en rouge. Faites un clic droit sur `strings.xml` et choisissez **Open Translations Editor**. L'icône en forme de globe ajoute une langue et crée le dossier `values-*` correspondant, tandis que la case **Untranslatable** ajoute automatiquement `translatable="false"` ([Android : Translations Editor](https://developer.android.com/studio/write/translations-editor)). Android Lint effectue les mêmes vérifications en CI : * [`MissingTranslation`](https://googlesamples.github.io/android-custom-lint-rules/checks/MissingTranslation.md.html) (erreur) signale une chaîne de caractères absente dans une langue. Désactivez-la ressource par ressource avec `tools:ignore="MissingTranslation"`, et définissez `tools:locale` sur l'élément `` du fichier par défaut pour indiquer sa langue à lint. * [`ExtraTranslation`](https://googlesamples.github.io/android-custom-lint-rules/checks/ExtraTranslation.md.html) (fatale) signale une chaîne de caractères traduite sans équivalent par défaut, ce qui peut faire planter l'application dans les paramètres régionaux où elle est absente. * [`HardcodedText`](https://googlesamples.github.io/android-custom-lint-rules/checks/HardcodedText.md.html) (avertissement) signale le texte littéral dans le XML de mise en page. Elle ne détecte pas les appels Compose `Text("...")`. (Voir [Comment trouver les chaînes de caractères codées en dur qui ne sont pas traduites ?](/kb/find-hardcoded-strings).) ## Tester chaque langue Android fournit deux pseudo-locales pour tester votre application avant même que les traductions existent. `en-XA` ajoute des accents, allonge le texte et encadre chaque message de crochets, ce qui met en évidence les problèmes de troncature et les phrases concaténées. `ar-XB` affiche le texte de droite à gauche. Définissez `isPseudoLocalesEnabled = true` sur le type de compilation de débogage, activez les Options pour les développeurs sur l’appareil, puis sélectionnez la pseudo-locale dans les paramètres de langue ([Android : Test with pseudolocales](https://developer.android.com/guide/topics/resources/pseudolocales)). (Voir [Qu’est-ce que la pseudo-localisation ?](/kb/pseudo-localization).) Pour l’arabe, l’hébreu et le persan, définissez `android:supportsRtl="true"` sur l’élément `` et utilisez les attributs `start` et `end` (`paddingStart`, `layout_marginEnd`) au lieu de `left` et `right`, afin que les mises en page s’affichent en miroir. Ajoutez `android:autoMirrored="true"` aux drawables directionnels, et encapsulez toute valeur insérée dans une phrase avec `BidiFormatter.unicodeWrap()` pour qu’une adresse postale ou un nombre conserve son sens d’écriture ([Android : Support different languages and cultures](https://developer.android.com/training/basics/supporting-devices/languages)). Dans Compose, `@Preview(locale = "ar")` permet de prévisualiser un écran de droite à gauche. (Voir [Comment prendre en charge les langues RTL (right-to-left) en CSS ?](/kb/right-to-left-css) pour la version web.) La fiche de votre application sur Google Play se traduit séparément. Dans la Play Console, ouvrez la fiche Play Store, cliquez sur **Gérer les traductions**, puis ajoutez pour chaque langue votre propre titre, votre description courte, votre description complète et vos éléments graphiques localisés ([Aide Play Console : Traduire et localiser votre application](https://support.google.com/googleplay/android-developer/answer/9844778)). ## Choisir comment traduire Ces approches remplissent vos dossiers `values-*` : | Approche | Qui traduit | Contexte dont dispose le traducteur | Reproductible à chaque livraison | Ce qu’il vous reste à faire | | ------------------------------------------------------------------------------------- | ----------------------------------------------- | --------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------- | | Saisie dans le Translations Editor | Vous ou un collègue bilingue | L’application entière | Non | Chaque chaîne de caractères dans chaque langue, à la main | | Traduction des chaînes de l’application dans la Play Console | Modèles Gemini dans la Play Console, sans frais | Votre `strings.xml` | Oui, pour chaque paquet applicatif téléversé dans une version brouillon | Les traductions sont stockées dans Play, et non dans votre dépôt, et remplacent les traductions existantes pour les langues sélectionnées | | Envoi de fichiers à des traducteurs ou à un système de gestion de la traduction (TMS) | Traducteurs professionnels | Les commentaires, ainsi que les captures d’écran que vous joignez | Via la synchronisation du TMS | Un aller-retour par livraison, et l’attente qui va avec | | Script de traduction automatique ou par LLM appliqué au XML | Un modèle ou une API de traduction | Ce que votre script envoie | Oui | Les catégories de pluriel de chaque langue, l’échappement, les éléments ``, les arguments de format et la relecture | | CLI de General Translation | Le service de traduction de GT | Les commentaires des ressources, ainsi que le glossaire et les instructions personnalisées partagés | Exécutez [`gt translate`](/docs/cli/reference/commands/translate) avant la compilation | Relecture dans le tableau de bord ou dans Android Studio, puis test de l’application | La Play Console peut aussi traduire l’application elle-même : une fois la traduction des chaînes de l’application activée, chaque paquet applicatif que vous téléversez dans une version brouillon reçoit des traductions générées à partir de son `strings.xml` le plus récent, que vous pouvez prévisualiser dans un émulateur et modifier avant la publication. La sélection d’une langue remplace toutes les traductions existantes pour celle-ci, et une case à cocher **Translate** permet d’exclure des chaînes individuellement ([Aide Play Console](https://support.google.com/googleplay/android-developer/answer/9844778)). Utilisez le Translations Editor pour une ou deux langues que vous maîtrisez. Optez pour la traduction de la Play Console si vous publiez via Google Play et n’avez pas besoin des traductions dans votre base de code. Choisissez General Translation si les fichiers `strings.xml` traduits doivent être commités à chaque livraison et partager la même terminologie que votre application iOS et votre site web. Faites appel à un [TMS](/kb/what-is-a-translation-management-system) lorsque le travail est confié à des traducteurs professionnels ou à un prestataire existant. ## Traduire strings.xml avec General Translation La CLI de General Translation, `gt`, traduit les ressources de chaînes Android à l'aide de la clé de fichier `androidStrings` (`gt` 2.19.0 ou version ultérieure). Comme le chemin du fichier par défaut ne contient aucun paramètre régional, faites pointer `include` vers ce fichier et utilisez `transform` pour placer chaque traduction dans le dossier de sa langue : ```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 convertit chaque paramètre régional en qualificateur attendu par Android : cette configuration écrit donc `values-es/`, `values-pt-rBR/` et `values-b+zh+Hant+TW/`. N'utilisez pas d'approche `values-[locale]` pour un projet standard : elle cherche un dossier `values-en/`, ne trouve aucune correspondance et ne traduit rien. La CLI nécessite Node.js 20 ou une version ultérieure. Installez-la comme indiqué dans le [Démarrage rapide de la CLI](/docs/cli/quickstart), connectez-vous avec [`npx gt login`](/docs/cli/reference/commands/login), définissez `GT_PROJECT_ID` ([informations d’authentification de la CLI](/docs/cli/guides/configuring#credentials)) et, si votre application possède déjà des traductions, importez-les avec [`npx gt upload`](/docs/cli/reference/commands/upload). Exécutez ensuite [`npx gt translate`](/docs/cli/reference/commands/translate). En CI, stockez dans `GT_API_KEY` une clé API de projet disposant des droits **Files > Write** et **Translation queue > Enabled**. Les fichiers traduits conservent les noms de ressources, les éléments ``, les arguments de format et le balisage intégré, et chaque chaîne de caractères traduite est vérifiée sur ces points, ainsi que sur l'échappement des apostrophes et des guillemets exigé par la compilation Android. Les `` sont reconstruits selon les catégories de la langue cible : le polonais reçoit `one`, `few`, `many` et `other`, l'arabe les six, et le chinois uniquement `other` ; les catégories que la langue n'utilise jamais, y compris un `zero` présent dans la source, sont supprimées. Un commentaire placé au-dessus d'une ressource est transmis comme contexte. La CLI ne traduit pas les ressources marquées `translatable="false"`, les valeurs qui font référence à une autre ressource, ni les types non textuels comme ``. (Consultez la [référence strings.xml](/docs/cli/reference/formats/android-strings-files).) Les ressources marquées `translatable="false"` dans un fichier inclus sont copiées telles quelles dans chaque fichier traduit, et la vérification [`Untranslatable`](https://googlesamples.github.io/android-custom-lint-rules/checks/Untranslatable.md.html) d'Android Lint signale chacune de ces copies. Placez ces valeurs dans `res/values/donottranslate.xml` et n'incluez que `strings.xml`. Relisez les traductions dans le [tableau de bord](/docs/platform/dashboard/guides/reviewing-translations) ou dans Android Studio ; si vous modifiez des fichiers localement, exécutez [`npx gt save-local`](/docs/cli/reference/commands/save-local) pour que les exécutions suivantes conservent vos modifications. Attribuez un même [groupe de contexte](/docs/platform/dashboard/guides/defining-context-for-translations) à vos projets Android, [iOS](/kb/localize-ios-app) et web : un terme du glossaire, comme le nom d'une offre, sera alors traduit de la même façon partout. Partiful utilise General Translation pour plus de 2 paramètres régionaux sur le web, iOS et Android ([déploiements en production](https://generaltranslation.com/enterprise)). ## Questions fréquentes ### Ai-je besoin d'un dossier values-en pour l'anglais ? Non. Le dossier `values/` sans qualificatif sert pour tous les paramètres régionaux que vous ne traduisez pas. Lorsque vous activez `generateLocaleConfig`, `resources.properties` indique au processus de compilation à quel paramètre régional correspond ce dossier. ### Pourquoi mon application traduite affiche-t-elle certaines chaînes en anglais ? Ces noms sont absents du fichier `strings.xml` traduit : Android se rabat donc sur `values/`. La vérification `MissingTranslation` de Lint les liste pour chaque langue. ### Google Play traduit-il automatiquement ma fiche Play Store ? Les utilisateurs qui consultent une fiche dans une langue que vous n'avez pas traduite peuvent choisir d'en afficher une traduction automatique. Les traductions que vous ajoutez vous-même dans **Gérer les traductions** la remplacent pour chaque langue concernée. ## Points clés * `res/values/strings.xml` doit contenir toutes les chaînes de caractères ; les dossiers traduits peuvent n’en contenir qu’un sous-ensemble et se rabattre sur ce fichier pour le reste. * Les noms de dossiers utilisent des qualificateurs : `values-pt-rBR` pour une région, `values-b+zh+Hant+TW` pour un système d’écriture. * Utilisez des arguments positionnels tels que `%1$s`, échappez les apostrophes et laissez chaque langue définir ses propres catégories ``. * Activez `generateLocaleConfig` (AGP 8.1+) pour prendre en charge le choix de la langue par application introduit dans Android 13, et testez avec les pseudo-locales `en-XA` et `ar-XB`. * La CLI de General Translation traduit `strings.xml` vers `values-{locale}` grâce à `androidStrings` et à un `transform` : elle applique le qualificateur attendu par Android et reconstruit les formes plurielles pour chaque langue. ## Related questions - [Comment localiser une app iOS avec les String Catalogs ?](https://generaltranslation.com/fr/kb/localize-ios-app.mdx): Ajoutez vos langues dans Xcode, rédigez le texte destiné aux utilisateurs avec des API localisables comme Text de SwiftUI et String(localized:), puis lancez une compilation pour que Xcode rassemble ces chaînes de caractères dans un String Catalog (.xcstrings). Traduisez dans Xcode, via XLIFF, ou avec la CLI de General Translation si vos catalogues doivent être mis à jour à chaque livraison et partager la même terminologie que votre site web et votre app Android. - [Comment traduire une application React Native ?](https://generaltranslation.com/fr/kb/translate-react-native-app.mdx): Marquez le texte dans vos composants, générez un fichier de traduction pour chaque langue, ajoutez des polyfills Intl et chargez le fichier correspondant à la langue de l’appareil. Avec gt-react-native, la bibliothèque expérimentale de General Translation, vous encapsulez le texte dans ``, un plugin Babel ajoute les polyfills et npx gt translate génère les fichiers. - [Qu’est-ce que la pseudo-localisation ?](https://generaltranslation.com/fr/kb/pseudo-localization.mdx): La pseudo-localisation est un test qui remplace votre texte source par une version modifiée, accentuée, allongée d’environ 40 % et encadrée de crochets, afin de faire apparaître les chaînes codées en dur, les troncatures, les polices défaillantes et les phrases concaténées avant même qu’une traduction n’existe. Android propose à cet effet les pseudo-paramètres régionaux en-XA et ar-XB. - [Comment trouver les chaînes codées en dur qui ne sont pas traduites ?](https://generaltranslation.com/fr/kb/find-hardcoded-strings.mdx): Exécutez dans votre CI un linter qui signale les littéraux de chaîne de caractères visibles par l’utilisateur, comme la règle no-literal-string d’eslint-plugin-i18next pour JSX, la vérification HardcodedText d’Android Lint ou le linter HardCodedString d’erb_lint pour Rails. Parcourez ensuite l’application avec un pseudo-paramètre régional pour repérer le texte que les vérifications statiques ne peuvent pas détecter. - [Comment prendre en charge les langues RTL (right-to-left) en CSS ?](https://generaltranslation.com/fr/kb/right-to-left-css.mdx): Placez dir="rtl" et lang sur l’élément html, car lang seul ne modifie pas le sens d’écriture, puis remplacez les propriétés CSS physiques comme margin-left par des propriétés logiques comme margin-inline-start. Les lignes flex, les colonnes de grille et l’alignement du texte par défaut s’inversent automatiquement ; ce n’est pas le cas de translateX(), left et right. ## Previous and next questions - Previous question: [Comment garantir une terminologie cohérente dans la traduction par IA ?](https://generaltranslation.com/fr/kb/ai-translation-glossary.mdx) - Next question: [Comment traduire des animations Lottie ?](https://generaltranslation.com/fr/kb/translate-lottie-animations.mdx) ## Sitemap See the [Knowledge Base sitemap](https://generaltranslation.com/fr/kb/sitemap.md) for every article.