כיצד לבצע לוקליזציה לאפליקציית 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/ כברירת מחדל ללא קוד שפה. זהו הגיבוי (fallback) שלכם. Android בוחרת את התיקייה הנכונה בזמן ריצה בהתאם להגדרות המיקום (locale) במכשיר המשתמש. אם שפת המשתמש היא ספרדית אך אין לכם תיקיית values-es/,‏ Android תיסוג לתיקיית values/. החזרה לברירת המחדל היא שקטה. אפליקציה המתורגמת בחלקה תציג אנגלית מעורבת בספרדית, ללא שגיאה.

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

העבירו כל מחרוזת הפונה למשתמש לקובץ strings.xml

השתמשו תמיד במשאבי מחרוזות המאוחסנים ב־strings.xml. לעולם אל תכתבו טקסט קבוע (hardcoded) ישירות בקוד 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 welcomeText = stringResource(R.string.welcome_text)
val welcome = stringResource(R.string.welcome_user, userName)
val summary = stringResource(R.string.points_summary, userName, points)

מוסכמות מפתח ש־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 לאנגלית, 3 לפולנית, 6 לערבית).
• <string-array> עבור רשימות סטטיות. PTC מתרגמת כל פריט תוך שמירה על מבנה המערך.
• השתמשו בתווי מילוט עבור גרש (\') ומרכאות (\") כדי למנוע שגיאות פענוח XML.

תרגום strings.xml עם PTC ב־5 שלבים

1. התחילו פרויקט PTC בלוח הבקרה שלכם. העלו את קובץ ה־values/strings.xml שלכם, הגדירו את נתיבי הפלט ובחרו שפות יעד. PTC תומכת ב-40+ שפות. במהלך תקופת הניסיון בחינם, תוכלו לבחור שתיים. PTC משתמשת בשפת המקור כדי לבחור את מנוע תרגום המכונה המתאים וכדי לדלג על מחרוזות שבהן המקור זהה ליעד.
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()

אפליקציות רבות זקוקות לבורר שפות פנימי כדי שהמשתמשים יוכלו לעקוף את הגדרות המיקום של המכשיר. החל מ־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")
}

כדי להצהיר באילו שפות האפליקציה שלכם תומכת (כך שבורר השפות של המערכת יציג אותן), הוסיפו קובץ 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. הפעילו את האפשרות "Force RTL layout direction" ב־Developer Options כדי לבדוק את השיקוף מבלי לשנות את שפת המכשיר.

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

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

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

אינטגרציית API. עברו אל Settings > Manage API Tokens וצרו טוקן גישה. לאחר מכן השתמשו ב־API של PTC בתוך ה־CI הקיים שלכם:

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

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

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

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

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

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

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

תרגמו את דף האפליקציה ב־Play Store, את הערות הגרסה ואת הודעות ה־Push

תיאור דף האפליקציה ב־Play Store, הערות ה"מה חדש" והטקסט של הודעות ה־Push נמצאים מחוץ ל־strings.xml. תכונת הדבקה לתרגום של PTC מטפלת בטקסטים אלו באותו פרויקט. הדביקו את טקסט המקור בלוח הבקרה של PTC, בחרו שפות יעד, וקבלו תרגומים המשתמשים באותו מילון מונחים ובאותו טון מותג כמו המחרוזות שבתוך האפליקציה. לאחר מכן, ב־Google Play Console, עברו אל Store Presence > Main Store Listing > Translations, הוסיפו את התיאורים הקצרים והארוכים המתורגמים, ושמרו.

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

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

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

שנו את שפת המכשיר בהגדרות, או השתמשו בבורר השפות של האמולטור ב־Android Studio. עבור כל שפה, בדקו אם יש טקסט ארוך מדי עבור אלמנטים בממשק המשתמש, תרגומים חסרים (נסיגה שקטה לברירת המחדל), פורמט תאריך/מספר/מטבע שגוי ובעיות פריסה עם טקסט ארוך. עבור שפות RTL, הפעילו את האפשרות "Force RTL layout direction" ב־Developer Options.

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

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

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

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

נושאים קשורים:

• תרגום אפליקציות iOS ו־Android בעזרת בינה מלאכותית - סקירת שירות לצוותים העובדים על מספר פלטפורמות.
• כיצד לבצע לוקליזציה לאפליקציית iOS - המדריך המקביל עבור Xcode ו־SwiftUI.
• תיעוד ה־API של PTC - נקודות קצה REST לאינטגרציית CI.