PTC
הירשם שדרג ל־Pro החשבון שלך

כיצד לבצע לוקליזציה לאפליקציית ה־Android שלכם בעזרת בינה מלאכותית

הגדירו תיקיות values/, תרגמו את strings.xml בעזרת בינה מלאכותית, החליפו שפות ב־Kotlin, ולאחר מכן העלו צילומי מסך כדי ש־PTC (Private Translation Cloud) תסקור את אפליקציית ה־Android הפועלת. בסוף מדריך זה תהיה לכם אפליקציית Android רב־לשונית מוכנה לשחרור, כאשר כל שפת יעד מאומתת באמצעות סקירה חזותית לפני השחרור.

מדריך זה מניח שיש לכם פרויקט Android קיים ב־Android Studio. אם אתם מתחילים מאפס, צרו תחילה שלד לפרויקט חדש עם התבנית Empty Activity.

כיצד Android מאתרת משאבים שעברו לוקליזציה מתיקיות values-{locale}/

Android מארגנת קובצי משאבים שעברו לוקליזציה בתיקיות res/values-{locale}/ בתוך app/src/main/. תיקיית ברירת המחדל היא values/, והיא מכילה את מחרוזות שפת המקור. כל שפת יעד מקבלת תיקיית 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)

כללו תמיד את תיקיית ברירת המחדל values/ ללא קוד שפה. זוהי החלופה שלכם. Android בוחרת את התיקייה הנכונה בזמן ריצה על סמך ה־locale של מכשיר המשתמש. אם שפת המשתמש היא ספרדית אך אין לכם values-es/, Android משתמשת כחלופה ב־values/. המעבר לחלופה מתבצע בשקט. אפליקציה שתורגמה באופן חלקי תציג אנגלית מעורבת עם ספרדית, ללא שגיאה.

קודי ה־locale פועלים לפי תקן BCP 47. es עבור ספרדית, pt-rBR עבור פורטוגזית ברזילאית (שימו לב לקידומת r המציינת את האזור), zh-rCN עבור סינית מפושטת.

העבירו כל מחרוזת שמוצגת למשתמש אל strings.xml

השתמשו תמיד במשאבי מחרוזות המאוחסנים ב־strings.xml. לעולם אל תשתמשו במחרוזות מוטמעות בקוד ישירות בתוך קוד Kotlin/Java או בתכונת פריסה ב־android:text=. לא ניתן לתרגם טקסט שמוטמע בקוד.

העבירו כל מחרוזת שמוצגת למשתמש אל 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>

הפנו לכל מחרוזת ב־Kotlin באמצעות מזהה ה־R.string.* שנוצר:

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)

מוסכמות מרכזיות ש־PTC מכבדת:

  • מצייני מיקום. השתמשו ב־%1$s, %2$d, %3$f במקום ב־%s, %d. שפות מסוימות דורשות שינוי של סדר הארגומנטים. מצייני מיקום מוספרים מאפשרים זאת. PTC מזהה ומשמרת אותם אוטומטית.
  • <plurals> עבור שמות עצם ספירים. אל תכתבו if (count == 1) "1 note" else "$count notes" בקוד. השתמשו ב־<plurals> עם הכמויות one / other / few / many. PTC יוצרת את קטגוריות הרבים הנכונות עבור כל שפת יעד (צורה אחת ליפנית, 2 לאנגלית, 4 לפולנית, 6 לערבית).
  • <string-array> עבור רשימות סטטיות. PTC מתרגמת כל פריט תוך שמירה על מבנה המערך.
  • השתמשו ב־escape עבור גרשיים (\') ומרכאות (\") כדי למנוע שגיאות פענוח ב־XML.

תרגמו את strings.xml בעזרת PTC ב־5 צעדים

  1. התחילו פרויקט PTC בלוח הבקרה שלכם. העלו את קובץ ה־values/strings.xml שלכם, הגדירו את נתיבי הפלט, ובחרו שפות יעד. PTC תומכת ב־40+ שפות. במהלך תקופת הניסיון, תוכלו לבחור שתיים מתוכן. PTC משתמשת בשפת המקור כדי לבחור את מנוע תרגום המכונה (MT) הנכון ולדלג על מחרוזות שבהן המקור זהה ליעד.
  2. סקרו את תיאור האפליקציה שנוצר אוטומטית. PTC יוצרת תיאור קצר של אפליקציית ה־Android שלכם מתוך הקובץ שהועלה. ערכו אותו כדי לתאר טוב יותר את האפליקציה ואת קהל היעד שלכם. PTC משתמשת בהקשר זה כדי להתאים את הטון ורמת הפורמליות הנכונים לכל שפה.
  3. העלו תרגומים קיימים (אופציונלי). אם כבר יש לכם קובצי values-*/strings.xml מתורגמים, העלו אותם כדי ש־PTC תוכל להתאים את התרגום לסגנון הקיים שלכם. אחרת, בצעו תרגום מאפס.
  4. תרגמו וסקרו. PTC מכבדת כל מפתח name= (המפתחות שלכם לעולם אינם משתנים), כל מציין מיקום מוספר, ויוצרת את קטגוריות הרבים הנכונות לכל שפת יעד. אם תרגום חורג ממגבלות האורך שלכם, PTC מדגישה אותו כדי ששום דבר לא יחמוק. ערכו כל מחרוזת במקום או בקשו מ־PTC לתרגם מחדש תוך התחשבות במגבלה.
  5. הורידו את קובצי ה־strings.xml המתורגמים לכל שפה כקובץ ZIP. כל קובץ זהה מבחינה מבנית למקור שלכם. אותם מפתחות, אותם מערכים, אותן תגיות רבים. ערכים מתורגמים.

העבירו את קובצי ה־strings.xml המתורגמים אל תיקיות values-{locale}/

העבירו כל קובץ מתורגם אל תיקיית ה־values-{locale}/ התואמת:

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

בצעו בנייה מחדש של הפרויקט. Android מזהה את המשאבים החדשים אוטומטית. כדי לוודא זאת, שנו את שפת האימולטור או המכשיר שלכם והפעילו מחדש את האפליקציה. ממשק המשתמש אמור להופיע בשפה החדשה.

הוסיפו בורר שפה בתוך האפליקציה באמצעות AppCompatDelegate.setApplicationLocales()

אפליקציות רבות זקוקות לבורר שפה בתוך האפליקציה כדי שמשתמשים יוכלו לעקוף את ה־locale של המכשיר. החל מ־Android 13 (API 33), הגישה המקובלת משתמשת ב־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")
}

כדי להצהיר באילו שפות האפליקציה שלכם תומכת (כדי שבורר ה־locale של המערכת יציג אותן), הוסיפו 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>

והפנו אליו ב־AndroidManifest.xml:

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

עבור אפליקציות המיועדות ל־Android 12 ומטה, הגישה הישנה יותר היא לשמור את בחירת המשתמש ב־SharedPreferences ולהחיל אותה בכל הפעלה של האפליקציה:

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

לאחר מכן, טענו את השפה השמורה בכל הפעלה של האפליקציה:

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

הגדרה זו נשמרת בין הפעלות ופועלת כראוי לאחר שתפרסמו את האפליקציה ב־Google Play.

השתמשו ב־start/end (ולא ב־left/right) עבור שפות מימין לשמאל

עבור ערבית, עברית, פרסית ואורדו, השתמשו ב־start וב־end במקום ב־left וב־right בפריסות שלכם, כדי ש־Android תשקף את הפריסה אוטומטית:

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

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

ב־Jetpack Compose, השתמשו ב־Arrangement.Start במקום ב־Arrangement.Absolute.Left. הפעילו את האפשרות ”אילוץ כיוון פריסה RTL“ תחת ”אפשרויות למפתחים“ כדי לבדוק את השיקוף מבלי לשנות את שפת המכשיר.

אוטומציה של תרגום ל־Android בכל שחרור גרסה באמצעות Git או ה־API של PTC

בפרויקטים פעילים, הרצה מחדש של התרגום באופן ידני בכל שחרור גרסה אינה ישימה בקנה מידה גדול. PTC מספקת לכם שתי דרכים לאוטומציה.

אינטגרציית Git (מומלץ). עברו אל הגדרות > Merge Requests בלוח הבקרה של PTC ולחצו על Add Git Integration (חיבור) כדי לחבר את מאגר ה־GitHub, ה־GitLab או ה־Bitbucket שלכם. ספקו טוקן גישה עם הרשאות קריאה וכתיבה ובחרו את הענפים שעל PTC לנטר. משלב זה, PTC מזהה שינויים, מתרגמת מחרוזות חדשות או מעודכנות, ופותחת merge request לסקירה שלכם.

API integration. עברו אל הגדרות > ניהול אסימוני API וצרו טוקן גישה. לאחר מכן, השתמשו ב־API של PTC בתוך ה־CI הקיים שלכם.

בצעו commit ל־.ptc-config.yml המציין את קובץ המקור שלכם ואת המיקום שאליו שייכים התרגומים:

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

לאחר מכן, הוסיפו את ה־PTC Translate action ל־workflow שלכם. הוא מכיל בתוכו גרסה מקובעת של ה־CLI של PTC, כך שה־build שלכם לא מוריד דבר בזמן הריצה:

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

גם אינטגרציית Git וגם API integration הן תכונות Pro שהופכות לזמינות כאשר אתם מפעילים את Pay-As-You-Go. עיינו ב־PTC API reference למידע על endpoints, webhooks ומודל האינטגרציה המלא.

סקירה חזותית של התרגום של אפליקציית ה־Android המתורגמת שלכם - לשחרר ללא QA ידני לכל שפה

לאחר ש־PTC מתרגמת את strings.xml שלכם, העבודה לא הסתיימה. תווית מתורגמת עשויה לחרוג מכפתור בגרמנית. המילה "Submit" עשויה להיות מתורגמת כשם עצם בצרפתית, בזמן שהממשק דרש פועל. מחרוזת באנגלית המוטמעת בקוד שמישהו שכח לעטוף ב־getString(R.string.welcome) תישאר בולטת ללא תרגום באפליקציית ה־Android הפועלת. איתור בעיות אלו משמעו באופן מסורתי סבב QA ידני בכל שפת יעד. זהו השלב האיטי והיקר ביותר בלוקליזציה למובייל.

ה־AI Visual QA של PTC מחליף את הסבב הזה. עבור אפליקציות Android נייטיב (אשר אינן פועלות בדפדפן, ולכן תהליך ה־extension אינו רלוונטי), השתמשו בהעלאת צילומי מסך. צלמו את המסכים הקריטיים של האפליקציה הפועלת בכל שפת יעד (הגדרות, תהליך ראשי, מקרי קצה) והעלו אותם ל־PTC. הבינה המלאכותית החזותית של PTC בוחנת כל מסך ומדווחת בחזרה:

  • בעיות ש־PTC יכולה לתקן ב־strings.xml. PTC מתרגמת מחדש את משמעות הפועל, בוחרת מילה נרדפת קצרה יותר שמתאימה לרוחב הכפתור, ומייצרת מחדש צורת רבים שמתחשבת בפריסה. PTC פותחת merge request עם התיקונים. זה לא דורש מכם שום עבודה.
  • בעיות שנמצאות בקוד ה־Kotlin שלכם. עטיפת getString() חסרה, מחרוזות מוטמעות בקוד, שרשור משפטים שאמור להשתמש ב־String.format() עם מצייני מיקום. PTC מייצרת פרומפט מוכן להדבקה עבור Cursor או Claude Code. צוות הפיתוח שלכם עוטף את המחרוזות בתוך שניות.

התוצאה: אתם משחררים אפליקציית Android רב־לשונית ומאומתת בכל שחרור גרסה. אינכם מקבלים strings.xml מתורגם עם שאריות QA ידני.

תרגמו את דף האפליקציה בחנות Play, את הערות הגרסה ואת הודעות ה־Push שלכם

תיאור דף האפליקציה בחנות Play, הערות הגרסה של "מה חדש" וטקסט הודעות ה־Push שלכם נמצאים מחוץ ל־strings.xml. ה־Paste to Translate (תרגום טקסט) של PTC מטפל בטקסט הזה באותו פרויקט. הדביקו את טקסט המקור בלוח הבקרה של PTC, בחרו שפות יעד, וקבלו בחזרה תרגומים שמשתמשים באותו מילון מונחים ובאותו טון המותג כמו המחרוזות בתוך האפליקציה שלכם. לאחר מכן, ב־Google Play Console, עברו אל נוכחות בחנות > דף האפליקציה הראשי בחנות > תרגומים, הוסיפו את התיאורים הקצרים והארוכים המתורגמים, ושמרו.

תרגמו תוכן משתמשים בתוך האפליקציה באמצעות ה־API של PTC

צ'אט בתוך האפליקציה, פוסטים חברתיים וביקורות שנוצרו על ידי משתמשים דורשים תרגום עם הגעת התוכן. ה־PTC REST API מתרגם את התוכן הזה לפי דרישה עם אימות טוקן Bearer, תוך שימוש באותו מילון מונחים ובאותו טון המותג כמו תרגומי ה־strings.xml שלכם.

בדקו את אפליקציית ה־Android שלכם שעברה לוקליזציה בכל שחרור גרסה

שנו את שפת המכשיר שלכם ב'הגדרות' או השתמשו בבוחר השפה של האמולטור ב־Android Studio. עבור כל שפה, חפשו טקסט ארוך מדי עבור רכיבי ממשק, תרגומים חסרים (חלופה שקטה לברירת המחדל), עיצוב שגוי של תאריכים/מספרים/מטבעות, ובעיות פריסה עם טקסט ארוך יותר. עבור שפות RTL, הפעילו את "אילוץ כיוון פריסה RTL" תחת 'אפשרויות למפתחים'.

תמחור תרגום ל־Android לאחר תקופת הניסיון

מודל Pay-As-You-Go, ללא מינוי. אתם משלמים רק על מה שאתם מתרגמים. 500 המילים הראשונות בכל חודש הן בחינם, והתעריף יורד ככל שאתם מתרגמים יותר. השתמשו במחשבון התמחור לקבלת הערכה.

עכשיו תרגמו את אפליקציית ה־Android האמיתית שלכם

התחילו תקופת ניסיון של 30 יום - 20,000 מילים ל־2 שפות, ללא כרטיס אשראי. העלו את strings.xml שלכם, תרגמו אותו בתוך דקות, ולאחר מכן העלו צילומי מסך ותנו ל־PTC לאמת את האפליקציה הפועלת.

קשור: