PTC
S'inscrire Passer à la version Pro Votre compte

Comment localiser votre application Android avec l'IA

Configurez les dossiers values/, traduisez strings.xml avec l'IA, changez de langue dans Kotlin, puis téléversez des captures d'écran pour que PTC (Private Translation Cloud) révise l'application Android en cours d'exécution. À la fin de ce guide, vous disposerez d'une application Android multilingue prête à être publiée, avec chaque langue cible vérifiée par une révision visuelle avant sa sortie.

Ce guide part du principe que vous possédez un projet Android existant dans Android Studio. Si vous partez de zéro, générez d'abord la structure d'un nouveau projet avec le modèle Empty Activity.

Comment Android résout les ressources localisées à partir des dossiers values-{locale}/

Android organise les ressources localisées dans des dossiers res/values-{locale}/ à l'intérieur de app/src/main/. Le dossier par défaut est values/, qui contient les chaînes de la langue source. Chaque langue cible obtient son propre dossier values-{locale}/.

app/src/main/res/
  values/strings.xml        # source language (typically English) - REQUIRED
  values-es/strings.xml     # Spanish
  values-fr/strings.xml     # French
  values-de/strings.xml     # German
  values-ja/strings.xml     # Japanese
  values-zh-rCN/strings.xml # Simplified Chinese (region-specific)

Incluez toujours le dossier values/ par défaut sans code de langue. C'est votre repli. Android choisit le bon dossier à l'exécution en fonction de la locale de l'appareil de l'utilisateur. Si la langue de l'utilisateur est l'espagnol mais que vous n'avez pas de values-es/, Android se replie sur values/. Le repli est silencieux. Une application partiellement traduite affiche de l'anglais mélangé à de l'espagnol, sans aucune erreur.

Les codes de locale suivent la norme BCP 47. es pour l'espagnol, pt-rBR pour le portugais brésilien (notez le préfixe r pour la région), zh-rCN pour le chinois simplifié.

Déplacez chaque chaîne destinée à l'utilisateur dans strings.xml

Utilisez toujours des ressources de chaîne stockées dans strings.xml. Ne mettez jamais de texte en dur directement dans le code Kotlin/Java ou dans un attribut de mise en page android:text=. Le texte en dur ne peut pas être traduit.

Déplacez chaque chaîne destinée à l'utilisateur dans res/values/strings.xml :

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="app_name">My Notes</string>
    <string name="welcome_message">Welcome, %1$s!</string>
    <string name="notes_count_zero">No notes yet</string>

    <plurals name="notes_count">
        <item quantity="one">%d note</item>
        <item quantity="other">%d notes</item>
    </plurals>

    <string-array name="categories">
        <item>Personal</item>
        <item>Work</item>
        <item>Travel</item>
    </string-array>
</resources>

Référencez chaque chaîne dans Kotlin via l'ID R.string.* généré :

val appName = stringResource(R.string.app_name)
val welcome = stringResource(R.string.welcome_message, userName)
val counts = pluralStringResource(R.plurals.notes_count, notes.size, notes.size)

Conventions de clés que PTC respecte :

  • Espaces réservés positionnels. Utilisez %1$s, %2$d, %3$f au lieu de %s, %d. Certaines langues nécessitent de réorganiser les arguments. Les espaces réservés positionnels rendent cela possible. PTC les reconnaît et les préserve automatiquement.
  • <plurals> pour les noms dénombrables. N'écrivez pas if (count == 1) "1 note" else "$count notes" dans le code. Utilisez <plurals> avec les quantités one / other / few / many. PTC génère les catégories de pluriel appropriées par langue cible (1 forme pour le japonais, 2 pour l'anglais, 4 pour le polonais, 6 pour l'arabe).
  • <string-array> pour les listes statiques. PTC traduit chaque élément tout en préservant la structure du tableau.
  • Échappez les apostrophes (\') et les guillemets (\") pour éviter les erreurs d'analyse XML.

Traduisez strings.xml avec PTC en 5 étapes

  1. Démarrez un projet PTC dans votre tableau de bord. Téléversez votre values/strings.xml, définissez vos chemins de sortie et choisissez vos langues cibles. PTC en prend en charge plus de 40. Pendant l'essai, vous pouvez en sélectionner deux au choix. PTC utilise la langue source pour choisir le bon moteur de traduction et pour ignorer les chaînes où la source est identique à la cible.
  2. Révisez la description de l'application générée automatiquement. PTC crée une courte description de votre application Android à partir du fichier téléversé. Modifiez-la pour mieux décrire votre application et votre public cible. PTC utilise ce contexte pour adapter le ton et le niveau de formalité appropriés pour chaque langue.
  3. Téléversez éventuellement des traductions existantes. Si vous avez déjà des fichiers values-*/strings.xml traduits, téléversez-les pour que PTC puisse correspondre à votre style existant. Sinon, traduisez à partir de zéro.
  4. Traduisez et révisez. PTC respecte chaque clé name= (vos clés ne changent jamais), chaque espace réservé positionnel, et génère les catégories de pluriel correctes par cible. Si une traduction dépasse vos limites de longueur, PTC la met en évidence pour que rien ne passe inaperçu. Modifiez n'importe quelle chaîne sur place ou demandez à PTC de la retraduire en tenant compte de la contrainte.
  5. Téléchargez le strings.xml traduit par langue sous forme de fichier ZIP. Chaque fichier est structurellement identique à votre source. Mêmes clés, mêmes tableaux, mêmes étiquettes de pluriel. Valeurs traduites.

Déposez les fichiers strings.xml traduits dans values-{locale}/

Déposez chaque fichier traduit dans le dossier values-{locale}/ correspondant :

app/src/main/res/values-es/strings.xml  # from PTC
app/src/main/res/values-fr/strings.xml  # from PTC
app/src/main/res/values-de/strings.xml  # from PTC

Recompilez le projet. Android détecte les nouvelles ressources automatiquement. Pour vérifier, changez la langue de votre émulateur ou de votre appareil et relancez l'application. L'interface utilisateur devrait apparaître dans la nouvelle langue.

Ajoutez un sélecteur de langue dans l'application avec AppCompatDelegate.setApplicationLocales()

De nombreuses applications ont besoin d'un sélecteur de langue dans l'application afin que les utilisateurs puissent outrepasser la locale de l'appareil. Depuis Android 13 (API 33), l'approche officielle utilise AppCompatDelegate.setApplicationLocales() :

import androidx.appcompat.app.AppCompatDelegate
import androidx.core.os.LocaleListCompat

fun setAppLanguage(languageTag: String) {
    val locales = LocaleListCompat.forLanguageTags(languageTag)
    AppCompatDelegate.setApplicationLocales(locales)
}

// Usage in a settings screen
binding.spanishButton.setOnClickListener {
    setAppLanguage("es")
}
binding.frenchButton.setOnClickListener {
    setAppLanguage("fr")
}

Pour déclarer les langues prises en charge par votre application (afin que le sélecteur de locale du système les affiche), ajoutez un locales_config.xml :

<!-- res/xml/locales_config.xml -->
<?xml version="1.0" encoding="utf-8"?>
<locale-config xmlns:android="http://schemas.android.com/apk/res/android">
    <locale android:name="en"/>
    <locale android:name="es"/>
    <locale android:name="fr"/>
    <locale android:name="de"/>
    <locale android:name="ja"/>
</locale-config>

Et référencez-le dans AndroidManifest.xml :

<application
    android:localeConfig="@xml/locales_config"
    ... >

Pour les applications ciblant Android 12 ou une version antérieure, l'ancienne approche consiste à enregistrer le choix de l'utilisateur dans SharedPreferences et à l'appliquer à chaque démarrage de l'application :

fun setLocale(context: Context, languageCode: String) {
    // Save the user's choice
    val prefs = context.getSharedPreferences("Settings", Context.MODE_PRIVATE)
    prefs.edit().putString("app_language", languageCode).apply()

    // Apply the new locale
    val locale = Locale(languageCode)
    Locale.setDefault(locale)
    val config = Configuration()
    config.setLocale(locale)
    context.resources.updateConfiguration(config, context.resources.displayMetrics)

    // Restart the activity so changes take effect
    if (context is Activity) {
        context.recreate()
    }
}

Ensuite, chargez la langue enregistrée à chaque lancement de l'application :

override fun onCreate() {
    super.onCreate()
    val prefs = getSharedPreferences("Settings", Context.MODE_PRIVATE)
    val languageCode = prefs.getString("app_language", "en") ?: "en"
    val locale = Locale(languageCode)
    Locale.setDefault(locale)
    val config = Configuration()
    config.setLocale(locale)
    resources.updateConfiguration(config, resources.displayMetrics)
}

Cela persiste entre les sessions et fonctionne correctement après la publication sur Google Play.

Utilisez start/end (et non left/right) pour les langues écrites de droite à gauche

Pour l'arabe, l'hébreu, le persan et l'ourdou, utilisez start et end au lieu de left et right dans vos mises en page afin qu'Android inverse automatiquement la mise en page :

<!-- Instead of this -->
<TextView android:layout_marginLeft="16dp" />

<!-- Use this -->
<TextView android:layout_marginStart="16dp" />

Dans Jetpack Compose, utilisez Arrangement.Start au lieu de Arrangement.Absolute.Left. Activez « Forcer le sens de mise en page RTL » dans les Options pour les développeurs pour tester l'inversion sans changer la langue de l'appareil.

Automatisez la traduction Android à chaque version avec Git ou l'API PTC

Pour les projets actifs, relancer manuellement la traduction à chaque version n'est pas viable à grande échelle. PTC vous offre deux moyens d'automatiser le processus.

Intégration Git (recommandée). Allez dans Paramètres > Merge Requests dans le tableau de bord PTC et cliquez sur Add Git Integration pour connecter votre dépôt GitHub, GitLab ou Bitbucket. Fournissez un jeton d'accès avec des autorisations de lecture et d'écriture et choisissez les branches que PTC doit surveiller. À partir de là, PTC détecte les modifications, traduit les chaînes nouvelles ou mises à jour, et ouvre une merge request pour votre relecture.

Intégration API. Allez dans Paramètres > Gérer les jetons API et créez un jeton d'accès. Utilisez ensuite l'API PTC dans votre CI existante.

Commitez un .ptc-config.yml qui indique votre fichier source et l'emplacement des traductions :

# .ptc-config.yml
source_locale: en
files:
  - file: app/src/main/res/values/strings.xml
    output: app/src/main/res/values-{{lang}}/strings.xml

Ajoutez ensuite l'action PTC Translate à votre flux de travail. Elle intègre une version épinglée de la PTC CLI, de sorte que votre build ne télécharge rien au moment de l'exécution :

# .github/workflows/translate.yml
name: Translate
on:
  push:
    branches: [main]
    paths:
      - 'app/src/main/res/values/strings.xml'
  workflow_dispatch: {}

jobs:
  translate:
    runs-on: ubuntu-latest
    permissions:
      contents: write
      pull-requests: write
    steps:
      - uses: actions/checkout@v4
      - uses: OnTheGoSystems/ptc-action@v1
        with:
          api-token: ${{ secrets.PTC_API_TOKEN }}
          create-pr: true

L'intégration Git et l'intégration API sont toutes deux des fonctionnalités Pro qui deviennent disponibles lorsque vous activez le Pay-As-You-Go. Consultez la référence de l'API PTC pour connaître les points de terminaison d'API, les webhooks et le modèle d'intégration complet.

Révision visuelle de la traduction de votre application Android : publiez sans contrôle qualité manuel par langue

Après que PTC a traduit votre strings.xml, le travail n'est pas terminé. Un libellé traduit peut déborder d'un bouton en allemand. « Submit » (Envoyer) peut être traduit en tant que nom en français alors que l'interface utilisateur nécessitait un verbe. Une chaîne en dur en anglais que quelqu'un a oublié d'encapsuler dans getString(R.string.welcome) restera manifestement non traduite dans l'application Android en cours d'exécution. Détecter ces erreurs implique traditionnellement une passe de contrôle qualité manuel dans chaque langue cible. C'est létape la plus lente et la plus coûteuse de la localisation mobile.

L'AI Visual QA de PTC remplace cette passe. Pour les applications Android natives (qui ne s'exécutent pas dans un navigateur, le processus de relecture via l'extension ne s'applique donc pas), utilisez le téléversement de captures d'écran. Capturez les écrans critiques de l'application en cours d'exécution dans chaque langue cible (paramètres, parcours principal, cas limites) et téléversez-les sur PTC. L'IA de vision de PTC inspecte chaque écran et vous fait un rapport :

  • Les problèmes que PTC peut corriger dans strings.xml. PTC retraduit le sens du verbe, choisit un synonyme plus court qui s'adapte à la largeur du bouton, et régénère un pluriel tenant compte de la mise en page. PTC ouvre une merge request avec les correctifs. Cela ne nécessite aucun travail de votre part.
  • Les problèmes qui résident dans votre code Kotlin. Un wrapper getString() manquant, des chaînes en dur, une concaténation de chaînes qui devrait utiliser String.format() avec des espaces réservés. PTC génère un prompt prêt à coller pour Cursor ou Claude Code. Votre équipe de développement encapsule les chaînes en quelques secondes.

Le résultat : vous publiez une application Android vérifiée et multilingue à chaque version. Vous ne vous retrouvez pas avec un strings.xml traduit accompagné d'un reliquat de contrôle qualité manuel.

Traduisez votre fiche Google Play, vos notes de version et vos notifications push

La description de votre fiche Google Play, vos notes de version des nouveautés et le texte de vos notifications push se trouvent en dehors de strings.xml. La fonctionnalité Paste to Translate de PTC gère ce texte dans le même projet. Collez le texte source dans le tableau de bord PTC, choisissez les langues cibles, et obtenez des traductions qui utilisent le même glossaire et la même voix de marque que vos chaînes dans l'application. Ensuite, dans la Google Play Console, allez dans Présence sur le Store > Fiche Play Store par défaut > Traductions, ajoutez les descriptions courtes et longues traduites, et enregistrez.

Traduisez le contenu utilisateur dans l'application avec l'API PTC

Les discussions dans l'application, les publications sociales et les avis générés par les utilisateurs nécessitent d'être traduits à mesure que le contenu arrive. L'API REST PTC traduit ce contenu à la demande avec l'authentification par jeton Bearer, en utilisant le même glossaire et la même voix de marque que vos traductions strings.xml.

Testez votre application Android localisée à chaque version

Modifiez la langue de votre appareil dans les Paramètres, ou utilisez le sélecteur de langue de l'émulateur d'Android Studio. Pour chaque langue, vérifiez s'il y a du texte trop long pour les éléments de l'interface utilisateur, des traductions manquantes (repli silencieux vers la langue par défaut), un formatage incorrect des dates/nombres/devises, et des problèmes de mise en page avec les textes plus longs. Pour les langues RTL, activez « Forcer le sens de mise en page RTL » dans les Options pour les développeurs.

Tarification de la traduction Android après l'essai

Pay-As-You-Go, sans abonnement. Vous ne payez que pour ce que vous traduisez. Les 500 premiers mots de chaque mois sont gratuits, et le tarif diminue à mesure que vous traduisez. Utilisez le calculateur de prix pour obtenir une estimation.

Traduisez maintenant votre véritable application Android

Commencez votre essai de 30 jours - 20 000 mots dans 2 langues, sans carte bancaire. Téléversez votre strings.xml, traduisez-le en quelques minutes, puis téléversez des captures d'écran et laissez PTC vérifier l'application en cours d'exécution.

Articles connexes :