PTC
Registrati Passa a Pro Il tuo account

Come localizzare la tua app Android con l'IA

Configura le cartelle values/, traduci strings.xml con l'IA, cambia lingua in Kotlin e poi carica gli screenshot affinché PTC (Private Translation Cloud) possa revisionare l'app Android in esecuzione. Al termine di questa guida avrai un'app Android multilingue pronta per la produzione, con ogni lingua di destinazione verificata tramite revisione visiva prima del rilascio.

Questa guida presuppone che tu abbia un progetto Android esistente in Android Studio. Se stai iniziando da zero, crea prima un nuovo progetto con il template Empty Activity.

Come Android risolve le risorse localizzate dalle cartelle values-{locale}/

Android organizza le risorse localizzate in cartelle res/values-{locale}/ all'interno di app/src/main/. La cartella predefinita è values/, che contiene le stringhe nella lingua di origine. Ogni lingua di destinazione riceve la propria cartella 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)

Includi sempre la cartella predefinita values/ senza codice lingua. Essa è la tua risorsa di fallback. Android sceglie la cartella corretta al runtime in base alla lingua del dispositivo dell'utente. Se la lingua dell'utente è lo spagnolo ma non hai la cartella values-es/, Android ripiega su values/. Il fallback avviene in modo silenzioso. Un'app parzialmente tradotta mostrerà l'inglese mescolato allo spagnolo, senza alcun errore.

I codici delle lingue seguono lo standard BCP 47. es per lo spagnolo, pt-rBR per il portoghese brasiliano (nota il prefisso r per la regione), zh-rCN per il cinese semplificato.

Sposta ogni stringa rivolta all'utente in strings.xml

Usa sempre le risorse stringa memorizzate in strings.xml. Non inserire mai testo direttamente nel codice Kotlin/Java o in un attributo di layout android:text=. Il testo inserito direttamente nel codice non può essere tradotto.

Sposta ogni stringa rivolta all'utente in 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>

Fai riferimento a ogni stringa in Kotlin tramite l'ID R.string.* generato:

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)

Convenzioni chiave rispettate da PTC:

  • Segnaposto posizionali. Usa %1$s, %2$d, %3$f invece di %s, %d. Alcune lingue richiedono di riordinare gli argomenti. I segnaposto posizionali lo rendono possibile. PTC li riconosce e li preserva automaticamente.
  • <plurals> per i sostantivi numerabili. Non scrivere if (count == 1) "1 note" else "$count notes" nel codice. Usa <plurals> con le quantità one / other / few / many. PTC genera le categorie plurali corrette per ogni lingua di destinazione (1 forma per il giapponese, 2 per l'inglese, 4 per il polacco, 6 per l'arabo).
  • <string-array> per liste statiche. PTC traduce ogni elemento preservando la struttura dell'array.
  • Usa l'escape per gli apostrofi (\') e le virgolette (\") per evitare errori di parsing XML.

Traduci strings.xml con PTC in 5 passaggi

  1. Avvia un progetto PTC nel tuo pannello di controllo. Carica il tuo file values/strings.xml, imposta i percorsi di output e scegli le lingue di destinazione. PTC ne supporta più di 40. Durante la prova gratuita, puoi selezionarne due a scelta. PTC usa la lingua di origine per scegliere il motore di traduzione automatica corretto e per saltare le stringhe in cui l'origine corrisponde alla destinazione.
  2. Revisiona la descrizione dell'app generata automaticamente. PTC crea una breve descrizione della tua app Android dal file caricato. Modificala per descrivere meglio la tua app e il tuo pubblico. PTC usa questo contesto per adottare il tono e la formalità corretti per ogni lingua.
  3. Opzionalmente, carica le traduzioni esistenti. Se hai già dei file values-*/strings.xml tradotti, caricali in modo che PTC possa adattarsi al tuo stile esistente. In caso contrario, traduci da zero.
  4. Traduci e revisiona. PTC rispetta ogni chiave name= (le tue chiavi non cambiano mai), ogni segnaposto posizionale e genera le categorie plurali corrette per ogni destinazione. Se una traduzione supera i tuoi limiti di lunghezza, PTC la evidenzia affinché nulla passi inosservato. Modifica qualsiasi stringa direttamente o chiedi a PTC di ri-tradurre tenendo conto del vincolo.
  5. Scarica i file strings.xml tradotti per lingua in un archivio ZIP. Ogni file è strutturalmente identico al tuo file di origine. Stesse chiavi, stessi array, stessi tag plurali. Valori tradotti.

Inserisci i file strings.xml tradotti in values-{locale}/

Inserisci ogni file tradotto nella cartella values-{locale}/ corrispondente:

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

Ricompila il progetto. Android rileverà automaticamente le nuove risorse. Per verificare, cambia la lingua dell'emulatore o del dispositivo e riavvia l'app. L'interfaccia utente dovrebbe apparire nella nuova lingua.

Aggiungi un selettore di lingua in-app con AppCompatDelegate.setApplicationLocales()

Molte app necessitano di un selettore di lingua interno affinché gli utenti possano ignorare la lingua del dispositivo. A partire da Android 13 (API 33), l'approccio canonico utilizza 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")
}

Per dichiarare quali lingue supporta la tua app (in modo che il selettore di lingua di sistema le mostri), aggiungi un file 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>

E fai riferimento ad esso in AndroidManifest.xml:

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

Per le app che puntano ad Android 12 o versioni precedenti, l'approccio meno recente consiste nel salvare la scelta dell'utente in SharedPreferences e applicarla a ogni avvio dell'app:

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()
    }
}

Quindi carica la lingua salvata a ogni avvio dell'app:

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

Questo persiste tra le sessioni e funziona correttamente dopo la pubblicazione su Google Play.

Usa start/end (non left/right) per le lingue con scrittura da destra a sinistra

Per l'arabo, l'ebraico, il persiano e l'urdu, usa start e end invece di left e right nei tuoi layout, così Android specchierà automaticamente il layout:

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

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

In Jetpack Compose, usa Arrangement.Start invece di Arrangement.Absolute.Left. Abilita “Forza direzione layout RTL” nelle Opzioni sviluppatore per testare il mirroring senza cambiare la lingua del dispositivo.

Automatizza la traduzione Android a ogni rilascio con Git o l'API di PTC

Per i progetti attivi, rieseguire manualmente la traduzione a ogni rilascio non è scalabile. PTC ti offre due modi per automatizzare.

Integrazione Git (consigliata). Vai su Settings > Merge Requests nel pannello di controllo di PTC e clicca su Add Git Integration per connettere il tuo repository GitHub, GitLab o Bitbucket. Fornisci un token di accesso con permessi di lettura e scrittura e scegli i rami che PTC deve monitorare. Da quel momento, PTC rileva le modifiche, traduce le stringhe nuove o aggiornate e apre una merge request per la tua revisione.

Integrazione API. Vai su Settings > Manage API Tokens e crea un token di accesso. Quindi usa l'API di PTC all'interno della tua CI esistente:

# .github/workflows/translate.yml
name: PTC translate
on:
  push:
    branches: [main]
    paths:
      - 'app/src/main/res/values/strings.xml'
jobs:
  translate:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Trigger PTC translation
        run: |
          curl -X POST https://api.ptc.wpml.org/v1/projects/${{ secrets.PTC_PROJECT_ID }}/sync \
            -H "Authorization: Bearer ${{ secrets.PTC_API_KEY }}"

Sia l'integrazione Git che quella API sono funzionalità Pro che diventano disponibili quando attivi il Pay-As-You-Go. Consulta il riferimento API di PTC per endpoint, webhook e il modello di integrazione completo.

Revisione visiva della traduzione della tua app Android: pubblica senza QA manuale per lingua

Dopo che PTC ha tradotto il tuo strings.xml, il lavoro non è finito. Un'etichetta tradotta potrebbe causare un overflow in un pulsante in tedesco. “Submit” potrebbe essere tradotto come sostantivo in francese quando l'interfaccia utente richiedeva un verbo. Una stringa inglese inserita direttamente nel codice che qualcuno ha dimenticato di racchiudere in getString(R.string.welcome) risulterà palesemente non tradotta nell'app Android in esecuzione. Individuare questi problemi tradizionalmente significa effettuare un passaggio di QA manuale in ogni lingua di destinazione. Questa è la fase più lenta e costosa della localizzazione mobile.

L'AI Visual QA di PTC sostituisce quel passaggio. Per le app Android native (che non girano in un browser, quindi il flusso dell'estensione non è applicabile), usa il caricamento screenshot. Cattura le schermate critiche dell'app in esecuzione in ogni lingua di destinazione (impostazioni, flusso principale, casi limite) e caricale su PTC. L'IA visiva di PTC ispeziona ogni schermata e segnala:

  • Problemi che PTC può risolvere in strings.xml. PTC ri-traduce il senso del verbo, sceglie un sinonimo più breve che si adatti alla larghezza del pulsante, rigenera un plurale consapevole del layout. PTC apre una PR con le correzioni. Non richiede alcun lavoro da parte tua.
  • Problemi che risiedono nel tuo codice Kotlin. Wrapper getString() mancanti, stringhe inserite direttamente nel codice, concatenazioni di frasi che dovrebbero usare String.format() con i segnaposto. PTC genera un prompt pronto da incollare per Cursor o Claude Code. Il tuo team di sviluppo sistema le stringhe in pochi secondi.

Il risultato: pubblichi un'app Android verificata e multilingue a ogni rilascio. Non ottieni solo un file strings.xml tradotto con una coda di QA manuale.

Traduci la tua scheda del Play Store, le note di rilascio e le notifiche push

La descrizione della tua scheda del Play Store, le note di rilascio con le novità e i testi delle notifiche push vivono al di fuori di strings.xml. Paste to Translate di PTC gestisce quei testi nello stesso progetto. Incolla il testo di origine nel pannello di controllo di PTC, scegli le lingue di destinazione e ottieni traduzioni che utilizzano lo stesso glossario e la stessa voce del brand delle tue stringhe in-app. Quindi, in Google Play Console, vai su Presenza nello store > Scheda dello Store principale > Traduzioni, aggiungi le descrizioni brevi e lunghe tradotte e salva.

Traduci i contenuti degli utenti in-app con l'API di PTC

Le chat in-app, i post sui social e le recensioni generate dagli utenti necessitano di traduzione man mano che i contenuti arrivano. L'API REST di PTC traduce questi contenuti su richiesta con autenticazione tramite Bearer token, utilizzando lo stesso glossario e la stessa voce del brand delle tue traduzioni di strings.xml.

Testa la tua app Android localizzata a ogni rilascio

Cambia la lingua del dispositivo in Impostazioni, oppure usa il selettore di lingua dell'emulatore di Android Studio. Per ogni lingua, controlla la presenza di testo troppo lungo per gli elementi dell'interfaccia utente, traduzioni mancanti (fallback silenzioso al valore predefinito), formattazione errata di date/numeri/valute e problemi di layout con testi più lunghi. Per le lingue RTL, abilita “Forza direzione layout RTL” nelle Opzioni sviluppatore.

Prezzi della traduzione Android dopo la prova gratuita

Pay-As-You-Go, nessun abbonamento. Paghi solo per ciò che traduci. Le prime 500 parole ogni mese sono gratuite e la tariffa diminuisce man mano che traduci di più. Usa il calcolatore dei prezzi per un preventivo.

Ora traduci la tua vera app Android

Inizia la tua prova gratuita di 30 giorni – 20.000 parole in 2 lingue, senza carta di credito. Carica il tuo strings.xml, traducilo in pochi minuti, quindi carica gli screenshot e lascia che PTC verifichi l'app in esecuzione.

Correlati: