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, quindi carica le schermate in modo che PTC (Private Translation Cloud) revisioni l'app Android in esecuzione. Alla fine di questa guida avrai un'app Android multilingue pronta per essere rilasciata, 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 partendo da zero, genera prima la struttura di 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 ha 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 un codice lingua. Questo è il tuo fallback. Android sceglie la cartella giusta a runtime in base al locale del dispositivo dell'utente. Se la lingua dell'utente è lo spagnolo ma non hai values-es/, Android esegue il fallback a values/. Il fallback è silenzioso. Un'app parzialmente tradotta mostra l'inglese mescolato allo spagnolo, senza alcun errore.

I codici locale 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 visibile all'utente in strings.xml

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

Sposta ogni stringa visibile 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 ciascuna 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 delle chiavi che PTC rispetta:

  • Segnaposto posizionali. Usa %1$s, %2$d, %3$f invece di %s, %d. Alcune lingue hanno bisogno 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 di 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 le liste statiche. PTC traduce ogni elemento preservando la struttura dell'array.
  • Esegui l'escape degli apostrofi (\') e delle virgolette (\") per evitare errori di parsing XML.

Traduci strings.xml con PTC in 5 passaggi

  1. Inizia un progetto PTC nel tuo pannello di controllo. Carica il tuo values/strings.xml, imposta i percorsi di output e scegli le lingue di destinazione. PTC ne supporta più di 40. Durante la prova, puoi selezionarne due qualsiasi. PTC usa la lingua di origine per scegliere l'MT engine giusto e per saltare le stringhe in cui l'origine è uguale 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 abbinare il tono e il livello di formalità giusti per ogni lingua.
  3. Carica facoltativamente le traduzioni esistenti. Se hai già dei file values-*/strings.xml tradotti, caricali in modo che PTC possa adattarsi al tuo stile esistente. Altrimenti, 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 di plurali corrette per destinazione. Se una traduzione supera i tuoi limiti di lunghezza, PTC la evidenzia in modo che nulla sfugga. Modifica qualsiasi stringa sul posto o chiedi a PTC di ritradurla tenendo a mente il vincolo.
  5. Scarica il strings.xml tradotto per ogni lingua come file ZIP. Ogni file è strutturalmente identico alla tua origine. Stesse chiavi, stessi array, stessi tag per i plurali. Valori tradotti.

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

Inserisci ciascun 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 rileva automaticamente le nuove risorse. Per verificare, cambia la lingua del tuo emulatore o 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 in-app in modo che gli utenti possano sovrascrivere il locale del dispositivo. A partire da Android 13 (API 33), l'approccio canonico usa 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 locale del sistema le mostri), aggiungi 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>

E fai riferimento ad esso in AndroidManifest.xml:

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

Per le app che hanno come target Android 12 o versioni precedenti, l'approccio più vecchio 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)
}

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

Usa start/end (non left/right) per le lingue right-to-left

Per l'arabo, l'ebraico, il persiano e l'urdu, usa start e end invece di left e right nei tuoi layout in modo che Android specchi il layout automaticamente:

<!-- 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» in Opzioni sviluppatore per testare l'inversione senza cambiare la lingua del dispositivo.

Automatizza la traduzione per Android a ogni release con Git o con l'API PTC

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

Integrazione Git (consigliata). Vai su Impostazioni > Merge Requests nel pannello di controllo di PTC e fai clic su Add Git Integration per collegare il tuo repository GitHub, GitLab o Bitbucket. Fornisci un access token con permessi read and write e scegli i branch che PTC deve monitorare. Da lì, PTC rileva le modifiche, traduce le stringhe nuove o aggiornate e apre una merge request per la tua revisione.

API integration. Vai su Impostazioni > Gestisci token API e crea un access token. Quindi usa l'API PTC all'interno della tua CI esistente.

Fai il commit di un .ptc-config.yml che indichi il tuo file di origine e la destinazione delle traduzioni:

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

Quindi aggiungi la PTC Translate action al tuo workflow. Contiene al suo interno una versione bloccata della CLI di PTC, così la tua build non scarica nulla in fase di esecuzione:

# .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

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

Revisione visiva della traduzione della tua app Android tradotta: rilascia 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» (invia) potrebbe essere tradotto come sostantivo in francese quando l'interfaccia richiedeva un verbo. Una stringa hardcoded in inglese che qualcuno ha dimenticato di racchiudere in getString(R.string.welcome) risulterà palesemente non tradotta nell'app Android in esecuzione. Individuare questi errori significa tradizionalmente eseguire un ciclo 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 ciclo. Per le app Android native (che non vengono eseguite in un browser, quindi il flusso dell'estensione del browser non si applica), usa il caricamento delle schermate. 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 ti restituisce un resoconto:

  • Problemi che PTC può risolvere in strings.xml. PTC ritraduce l'accezione del verbo, sceglie un sinonimo più corto che si adatta alla larghezza del pulsante, rigenera un plurale che tiene conto del layout. PTC apre una merge request con le correzioni. Non richiede alcun lavoro da parte tua.
  • Problemi che risiedono nel tuo codice Kotlin. Wrapper getString() mancante, stringhe hardcoded, concatenazione di frasi che dovrebbe usare String.format() con segnaposto. PTC genera un prompt pronto da incollare per Cursor o Claude Code. Il tuo team di sviluppo racchiude le stringhe in pochi secondi.

Il risultato: rilasci un'app Android multilingue verificata per ogni release. Non ottieni un strings.xml tradotto con un lavoro residuo di QA manuale.

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

La descrizione della scheda dello store del Play Store, le note di rilascio sulle novità e i testi delle notifiche push si trovano fuori da strings.xml. Il Paste to Translate di PTC gestisce questi testi nello stesso progetto. Incolla il testo di origine nel pannello di controllo di PTC, scegli le lingue di destinazione e ottieni traduzioni che usano 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 principale dello Store > Traduzioni, aggiungi le descrizioni brevi e lunghe tradotte e salva.

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

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

Testa la tua app Android localizzata a ogni release

Cambia la lingua del tuo dispositivo in Impostazioni, oppure usa il selettore della lingua dell'emulatore di Android Studio. Per ogni lingua, controlla che non ci siano testi troppo lunghi per gli elementi dell'interfaccia, traduzioni mancanti (fallback silenzioso al predefinito), formattazione errata di date/numeri/valute e problemi di layout con testi più lunghi. Per le lingue RTL (da destra a sinistra), abilita «Forza direzione layout RTL» in Opzioni sviluppatore.

Prezzi della traduzione per Android dopo la prova

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 di 30 giorni: 20.000 parole in 2 lingue, nessuna carta di credito. Carica il tuo strings.xml, traducilo in pochi minuti, quindi carica le schermate e lascia che PTC verifichi l'app in esecuzione.

Correlati: