Localisez les applications Android avec l’IA

Préparation des applications Android pour une localisation continue (avec des exemples d’applications de démonstration)

Maintenant que vous avez vu comment PTC automatise le processus de traduction, assurons-nous que votre application Android est prête pour cela.

Cette section montre comment structurer votre projet afin que PTC puisse détecter les mises à jour de votre fichier strings.xml et maintenir automatiquement vos traductions à jour.

Nous commencerons par une application Jetpack Compose simple qui utilise du texte codé en dur et la transformerons en un projet localisable avec des ressources correctement organisées.

Voici ce que nous couvrirons :

• Déplacer le texte de Kotlin vers strings.xml
• Organiser les ressources localisées sous res/values-{{lang}}
• Ajouter des placeholders et des pluriels pour gérer le texte et les quantités dynamiques
• Voir comment PTC met automatiquement à jour les traductions pour les chaînes nouvelles ou modifiées

1. Extraire les chaînes codées en dur dans strings.xml

Commencez par déplacer le texte destiné à l’utilisateur de votre code Jetpack Compose vers un fichier de ressources de chaînes. C’est la base de la localisation Android et permet à PTC de détecter le contenu traduisible.

@Composable
fun Greeting(name: String, modifier: Modifier = Modifier) {
 Text(
 text = "Hello $name!", // Chaîne codée en dur
 modifier = modifier
 )
}

@Composable
fun Greeting(name: String, modifier: Modifier = Modifier) {
    Text(
        text = "Hello $name!", // Hardcoded string
        modifier = modifier
    )
}

<resources>
    <string name="hello_text">Hello %1$s!</string>
</resources>

<resources>
    <string name="hello_text">Hello %1$s!</string>
</resources>

import androidx.compose.ui.res.stringResource
import com.example.androidappdemo.R // ajustez si votre nom de package diffère

@Composable
fun Greeting(name: String, modifier: Modifier = Modifier) {
 val hello = stringResource(id = R.string.hello_text, name)
 Text(
 text = hello,
 modifier = modifier
 )
}

import androidx.compose.ui.res.stringResource
import com.example.androidappdemo.R   // adjust if your package name differs

@Composable
fun Greeting(name: String, modifier: Modifier = Modifier) {
    val hello = stringResource(id = R.string.hello_text, name)
    Text(
        text = hello,
        modifier = modifier
    )
}

2. Configurer la localisation continue dans PTC

Avec votre fichier strings.xml en place, vous êtes prêt à configurer PTC et à créer des traductions.

1. Inscrivez-vous ou connectez-vous à PTC.
2. Créez un nouveau projet. L’assistant de configuration vous guidera dans la description de votre projet afin que PTC puisse générer des traductions tenant compte du contexte.
3. Choisissez comment intégrer PTC à votre projet pour une localisation continue. Vous pouvez connecter votre référentiel GitHub, GitLab ou Bitbucket, ou utiliser l’API PTC pour intégrer la localisation dans votre pipeline CI/CD.
4. Configurez les modèles de fichiers :

• Fichier source : app/src/main/res/values/strings.xml
• Fichiers de traduction : app/src/main/res/values-{{lang}}/strings.xml
• Type de fichier : Android XML

Une fois la configuration terminée, PTC génère automatiquement de nouveaux dossiers avec des fichiers traduits (par exemple, res/values-fr/strings.xml) et ouvre une demande de fusion dans votre référentiel.

3. Utiliser des placeholders pour le contenu dynamique

Maintenant que vous avez vu comment PTC gère vos traductions initiales, rendons l’application plus réaliste en ajoutant des chaînes dynamiques. Ce sont des chaînes qui incluent des valeurs changeantes, comme le nom d’un utilisateur.

<resources>
    <string name="welcome_user">Bienvenue, %1$s!</string>
    <string name="points_summary">%1$s, vous avez %2$d points.</string>
</resources>

<resources>
    <string name="welcome_user">Welcome, %1$s!</string>
    <string name="points_summary">%1$s, you have %2$d points.</string>
</resources>

AndroidDemoTheme {
 Scaffold(modifier = Modifier.fillMaxSize()) { innerPadding ->
 Column(
 modifier = Modifier
 .padding(innerPadding)
 .padding(16.dp)
 ) {
 // garder Greeting
 Greeting(name = "Android")

  Spacer(modifier = Modifier.height(16.dp))

  // démo des placeholders
 Header(name = "PTC", points = 42)

  Spacer(modifier = Modifier.height(16.dp))
 }


@Composable
fun Header(name: String, points: Int) {
 val welcome = stringResource(R.string.welcome_user, name)
 val summary = stringResource(R.string.points_summary, name, points)

  Column(modifier = Modifier.padding(16.dp)) {
 Text(welcome)
 Text(summary)
 }
}

AndroidDemoTheme {
         Scaffold(modifier = Modifier.fillMaxSize()) { innerPadding ->
                    Column(
                        modifier = Modifier
                            .padding(innerPadding)
                            .padding(16.dp)
                    ) {
                        // keep Greeting
                        Greeting(name = "Android")

                        Spacer(modifier = Modifier.height(16.dp))

                        // placeholders demo
                        Header(name = "PTC", points = 42)

                        Spacer(modifier = Modifier.height(16.dp))
                    }


@Composable
fun Header(name: String, points: Int) {
    val welcome = stringResource(R.string.welcome_user, name)
    val summary = stringResource(R.string.points_summary, name, points)

    Column(modifier = Modifier.padding(16.dp)) {
        Text(welcome)
        Text(summary)
    }
}

Étant donné que votre projet utilise la localisation continue, PTC détectera automatiquement ces nouvelles chaînes lorsque vous validerez.

4. Ajouter des pluriels pour les chaînes basées sur la quantité

Ensuite, gérons les formes plurielles, comme « 1 message » contre « 5 messages ». Android prend en charge cela nativement, et PTC traduit automatiquement chaque forme plurielle.

<resources>
    <plurals name="inbox_count">
        <item quantity="one">%d nouveau message</item>
        <item quantity="other">%d nouveaux messages</item>
    </plurals>
</resources>

<resources>
    <plurals name="inbox_count">
        <item quantity="one">%d new message</item>
        <item quantity="other">%d new messages</item>
    </plurals>
</resources>

import androidx.compose.ui.res.pluralStringResource

AndroidDemoTheme {
 Scaffold(modifier = Modifier.fillMaxSize()) { innerPadding ->
 Column(
 modifier = Modifier
 .padding(innerPadding)
 .padding(16.dp)
 ) {
 // garder Greeting
 Greeting(name = "Android")

  Spacer(modifier = Modifier.height(16.dp))

  // démo des pluriels
 InboxCount(count = 1)
 InboxCount(count = 5)
 }


@Composable
fun InboxCount(count: Int) {
 val text = pluralStringResource(R.plurals.inbox_count, count, count)
 Text(text)
}

import androidx.compose.ui.res.pluralStringResource

AndroidDemoTheme {
        Scaffold(modifier = Modifier.fillMaxSize()) { innerPadding ->
                    Column(
                        modifier = Modifier
                            .padding(innerPadding)
                            .padding(16.dp)
                    ) {
                        // keep Greeting
                        Greeting(name = "Android")

                        Spacer(modifier = Modifier.height(16.dp))

                        // plurals demo
                        InboxCount(count = 1)
                        InboxCount(count = 5)
                    }


@Composable
fun InboxCount(count: Int) {
    val text = pluralStringResource(R.plurals.inbox_count, count, count)
    Text(text)
}

Lorsque vous poussez ces modifications, PTC détecte et traduit automatiquement les nouvelles chaînes plurielles.