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. לעולם אל תשלבו טקסט hardcoded ישירות בקוד Kotlin/Java או בתכונת פריסה של android:text=. לא ניתן לתרגם טקסט hardcoded.

העבירו כל מחרוזת המוצגת למשתמש לתוך 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 שלכם. ספקו טוקן גישה עם הרשאות Read and write ובחרו את הענפים שעל PTC לנטר. משם, PTC מזהה שינויים, מתרגמת מחרוזות חדשות או מעודכנות, ופותחת merge request לסקירה שלכם.

API integration. עברו אל הגדרות > ניהול אסימוני API וצרו טוקן גישה. לאחר מכן השתמשו ב־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: Translate with PTC
        run: |
          cat > .ptc-config.yml <<'EOF'
          source_locale: en
          files:
            - file: app/src/main/res/values/strings.xml
              output: app/src/main/res/values-{{lang}}/strings.xml
          EOF
          curl -fsSL https://raw.githubusercontent.com/OnTheGoSystems/ptc-cli/main/ptc-cli.sh -o ptc-cli.sh
          chmod +x ptc-cli.sh
          ./ptc-cli.sh --config-file .ptc-config.yml --api-token="${{ secrets.PTC_API_TOKEN }}"

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

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

לאחר ש־PTC מתרגמת את ה־strings.xml שלכם, העבודה לא הסתיימה. תווית מתורגמת עלולה לגלוש מחוץ לכפתור בגרמנית. המילה “Submit” עשויה להיות מתורגמת כשם עצם בצרפתית, בעוד שממשק המשתמש דרש פועל. מחרוזת אנגלית hardcoded שמישהו שכח לעטוף ב־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, את הערות הגרסה ואת התראות הפוש שלכם

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

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

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

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

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

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

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

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

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

קשור: