העדפות שפה לכל אפליקציה

שפות לכל אפליקציה בהגדרות המערכת

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

  • הגדרות מערכת: מקום מרכזי שבו המשתמשים יכולים לבחור את השפה המועדפת לכל אפליקציה.

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

  • ממשקי API נוספים: ממשקי ה-API הציבוריים האלה, כמו השיטות setApplicationLocales ו-getApplicationLocales ב-LocaleManager, מאפשרים לאפליקציות להגדיר שפה שונה משפת המערכת בזמן הריצה.

    ממשקי ה-API האלה מסתנכרנים אוטומטית עם הגדרות המערכת. לכן, אפליקציות שמשתמשות בממשקי ה-API האלה כדי ליצור כלי לבחירת שפה מותאם אישית בתוך האפליקציה, מבטיחות שהמשתמשים ייהנו מחוויית משתמש עקבית, לא משנה איפה הם בוחרים את העדפות השפה שלהם. ממשקי ה-API הציבוריים גם עוזרים לצמצם את כמות קוד ה-boilerplate, הם תומכים בפיצול קובצי APK ותומכים בגיבוי אוטומטי לאפליקציות כדי לאחסן את הגדרות שפת המשתמש ברמת האפליקציה.

    כדי לשמור על תאימות לדור קודם עם גרסאות קודמות של Android, יש גם ממשקי API מקבילים ב-AndroidX. עם זאת, ממשקי ה-API עם תאימות לאחור פועלים עם ההקשר של AppCompatActivity, ולא עם הקשר האפליקציה, ב-Android מגרסה 12 (רמת API‏ 32) ומטה. אפשר לגשת לממשקי API שתואמים לדורות קודמים באמצעות Appcompat 1.6.0 או גרסה מתקדמת יותר.

סקירה כללית של הטמעת התכונה הזו

בטבלה הבאה מוצגות המלצות להטמעה בהתאם לתרחישי שימוש שונים.

תרחיש שימוש הטמעה מומלצת
באפליקציה שלך אין כלי לבחירת שפה מתוך האפליקציה
  1. מפעילים תמיכה אוטומטית בשפה לכל אפליקציה כדי ליצור קובץ LocaleConfig ולהוסיף את השפות של האפליקציה להגדרות המערכת.
  2. אם רוצים להוסיף כלי לבחירת שפה באפליקציה: מטמיעים כלי כזה ב-Compose או משתמשים בספריית AndroidX ומצטרפים להטמעת ה-API שלנו כדי לתמוך בתאימות לאחור דרך autoStoreLocales.
באפליקציה שלך כבר יש כלי לבחירת שפה מתוך האפליקציה
  1. מפעילים תמיכה אוטומטית בשפה לכל אפליקציה כדי ליצור קובץ LocaleConfig ולהוסיף את השפות של האפליקציה להגדרות המערכת.
  2. כדי להבטיח שהמשתמשים ייהנו מחוויה עקבית, צריך להעביר את הלוגיקה המותאמת אישית של האפליקציה לשימוש ב-Compose או ב-public APIs.
  3. טיפול במקרים הבאים:
    1. מפעילים את AppCompatDelegate.setApplicationLocales בפעם הראשונה שהאפליקציה מורצת במכשיר עם Android 13.
    2. מתקשרים אל AppCompatDelegate.setApplicationLocales כדי לספק למערכת לוקאלים קיימים שהמשתמשים ביקשו במקרים הבאים:

הגדרות מערכת למשתמשים

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

הפעלת תמיכה אוטומטית בשפה לכל אפליקציה

זו הדרך המומלצת להוסיף תמיכה בשפה לכל אפליקציה, כי היא לא דורשת שינויים ב-XML.

החל מ-Android Studio Giraffe ומ-AGP 8.1, אפשר להגדיר את האפליקציה כך שתתמוך אוטומטית בהעדפות שפה לכל אפליקציה. בהתבסס על משאבי הפרויקט, AGP יוצר את הקובץ LocaleConfig ומוסיף אליו הפניה בקובץ המניפסט הסופי, כך שלא צריך יותר לעשות זאת באופן ידני. ‫AGP משתמש במשאבים בתיקיות res של מודולי האפליקציה וביחסי תלות של מודולי ספריות כדי לקבוע את הלוקאלים שייכללו בקובץ LocaleConfig. המשמעות היא שאם מוסיפים לאפליקציה משאבים לשפה חדשה, לא צריך לעדכן את הקובץ LocaleConfig.

שימו לב שתכונת השפה האוטומטית לכל אפליקציה תומכת באפליקציות שפועלות ב-Android 13 (רמת API‏ 33) ומעלה. כדי להשתמש בתכונה, צריך להגדיר את הערך של compileSdkVersion ל-33 ומעלה. כדי להגדיר העדפות שפה לכל אפליקציה בגרסאות קודמות של Android, עדיין צריך להשתמש בממשקי ה-API ובבוררי השפה בתוך האפליקציה.

כדי להפעיל תמיכה אוטומטית בשפה לכל אפליקציה:

  1. כדי להפעיל את התכונה, משתמשים בהגדרה generateLocaleConfig בקטע androidResources {} של הקובץ build.gradle.kts ברמת המודול (קובץ build.gradle אם משתמשים ב-Groovy). התכונה מושבתת כברירת מחדל.

Kotlin

    android {
      androidResources {
        generateLocaleConfig = true
      }
    }

מגניב

  android {
    androidResources {
      generateLocaleConfig true
    }
  }
  1. מציינים את הלוקאל שמוגדר כברירת מחדל:
    1. בתיקייה res של מודול האפליקציה, יוצרים קובץ חדש בשם resources.properties.
    2. בקובץ resources.properties, מגדירים את הלוקאל של ברירת המחדל באמצעות התווית unqualifiedResLocale. הוראות לפורמט של שמות הלוקאל מפורטות במאמר איך יוצרים שמות לוקאל.

הכלי AGP מוסיף את הלוקאל שמוגדר כברירת מחדל ולוקאלים חלופיים שציינתם, באמצעות ספריות values-* בתיקייה res, לקובץ LocaleConfig שנוצר אוטומטית.

איך יוצרים שמות של לוקאלים

כדי ליצור שמות של לוקאלים, משלבים את קוד השפה עם קודי הסקריפט והאזור האופציונליים, ומפרידים ביניהם באמצעות מקף:

  • שפה: צריך להשתמש בקוד ISO 639-2 בן שתי אותיות או שלוש אותיות.
  • סקריפט (אופציונלי): צריך להשתמש בקוד ISO 15924.
  • אזור (אופציונלי): משתמשים בקוד בן שתי אותיות ISO 3166-1-alpha-2 או בקוד בן שלוש ספרות UN_M.49.

לדוגמה, אם ברירת המחדל של הלוקאל היא אנגלית אמריקאית:

unqualifiedResLocale=en-US

שימוש ב-android:localeConfig כדי להוסיף שפות נתמכות להגדרות המערכת

אתם יכולים להגדיר את האפליקציה באופן ידני כדי לוודא שהשפות שלה ניתנות להגדרה בהגדרות המערכת במכשירים עם Android מגרסה 13 ואילך. כדי לעשות זאת, יוצרים קובץ locale_config XML ומוסיפים אותו למניפסט של האפליקציה באמצעות המאפיין android:localeConfig. השמטה של הרשומה android:localeConfig manifest מציינת שמשתמשים לא יכולים להגדיר את השפה של האפליקציה בלי קשר לשפת המערכת שלהם בהגדרות המערכת.

כדי להוסיף באופן ידני את השפות הנתמכות באפליקציה להגדרות המערכת של המשתמש:

  1. יוצרים קובץ בשם res/xml/locale_config.xml ומציינים את השפות של האפליקציה, כולל לוקאל ברירת המחדל של האפליקציה, שהוא הלוקאל שצוין ב-res/values/strings.xml.

    במאמר איך יוצרים שמות של לוקאלים מפורטות הדרישות בנוגע לפורמט. אפשר גם לעיין בקובץ locale_config.xml לדוגמה כדי לראות רשימה של הלוקאלים הנפוצים ביותר.

    לדוגמה, אם האפליקציה תומכת בשפות הבאות, קובץ locale_config.xml צריך להיות בפורמט הזה:

    • אנגלית (ארצות הברית) כלוקאל הגיבוי החלופי הסופי
    • אנגלית (בריטניה)
    • צרפתית
    • יפנית
    • סינית (פשוטה, מקאו)
    • סינית (מסורתית, מקאו)
    <?xml version="1.0" encoding="utf-8"?>
<locale-config xmlns:android="http://schemas.android.com/apk/res/android">
   <locale android:name="en-US"/>
   <locale android:name="en-GB"/>
   <locale android:name="fr"/>
   <locale android:name="ja"/>
   <locale android:name="zh-Hans-MO"/>
   <locale android:name="zh-Hant-MO"/>
</locale-config>

  2. בקובץ המניפסט, מוסיפים שורה שמפנה לקובץ החדש:

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

אתם יכולים לעדכן באופן דינמי את localeConfig של האפליקציה באמצעות LocaleManager.setOverrideLocaleConfig כדי להתאים אישית את קבוצת השפות שמוצגת ברשימת השפות של כל אפליקציה בהגדרות Android. התכונה הזו מאפשרת לכם להתאים אישית את רשימת השפות לפי אזור, להריץ ניסויי A/B ולספק לוקאלים מעודכנים אם האפליקציה שלכם משתמשת בהעברות של לוקליזציה בצד השרת, כמו בדוגמה הבאה:

//For setOverrideLocaleConfig
val localeManager = applicationContext
    .getSystemService(LocaleManager::class.java)
localeManager.overrideLocaleConfig = LocaleConfig(
LocaleList.forLanguageTags("en-US,ja-JP,zh-Hans-SG")
)

//For getOverrideLocaleConfig
// The app calls the API to get the override LocaleConfig
val overrideLocaleConfig = localeManager.overrideLocaleConfig
// If the returned overrideLocaleConfig isn't equal to NULL, then the app calls the API to get the supported Locales
val supportedLocales = overrideLocaleConfig.supportedLocales()

בנוסף, עכשיו אפשר להשתמש ב-LocaleManager.getApplicationLocales ב-IME כדי לדעת את שפת ממשק המשתמש של האפליקציה הנוכחית ולעדכן את שפת המקלדת כמו שמוצג:

val currentAppLocales: LocaleList = applicationContext.getSystemService(LocaleManager::class.java).getApplicationLocales(appPackageName)

ציון שפות נתמכות ב-Gradle

אם המאפיין לא קיים, מציינים את אותן שפות באמצעות המאפיין resourceConfigurations בקובץ build.gradle ברמת המודול של האפליקציה:

android {
  ...
  defaultConfig {
    resourceConfigurations += ["en", "en-rGB", "fr", "ja", "b+zh+Hans+MO", "b+zh+Hant+MO"]
  }
}

אם הנכס resourceConfigurations קיים, מערכת ה-Build כוללת ב-APK רק משאבי שפה עבור השפות שצוינו, וכך מונעת הכללה של מחרוזות מתורגמות מספרייה אחרת שעשויה לתמוך בשפות שהאפליקציה לא תומכת בהן. מידע נוסף זמין במאמר בנושא ציון השפות שהאפליקציה תומכת בהן.

איך משתמשים בוחרים שפה לאפליקציה בהגדרות המערכת

המשתמשים יכולים לבחור את השפה המועדפת שלהם לכל אפליקציה דרך הגדרות המערכת. יש שתי דרכים לגשת להגדרות האלה:

  • גישה דרך ההגדרות של המערכת

    הגדרות > מערכת > שפות וקלט > שפות של אפליקציות > (בחירת אפליקציה)

  • גישה דרך ההגדרות של אפליקציות

    הגדרות > אפליקציות > (בחירת אפליקציה) > שפה

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

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

הטמעה באמצעות Jetpack פיתוח נייטיב

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

כדי להבטיח תאימות לדור קודם עם Android 12 (רמת API‏ 32) וגרסאות קודמות, מומלץ מאוד להשתמש בספריית התמיכה של AndroidX ‏ (AppCompatDelegate) כשמטמיעים כלי לבחירת שפה באפליקציה. אם משתמשים בגישה הזו, הפעילות שמארחת את ממשק המשתמש של Compose חייבת להרחיב את AppCompatActivity. עם זאת, אפשר גם להטמיע את ממשקי ה-API של המסגרת ישירות אם יש צורך בכך.

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

import androidx.appcompat.app.AppCompatDelegate
import androidx.compose.material3.Button
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.core.os.LocaleListCompat

@Composable
fun LanguageSelector() {
    // Retrieve the currently configured app locale.
    // If no app-specific locale is set, LocaleListCompat.get(0) returns null,
    // so we safely fall back to a default (e.g., "en").
    val appLocales = AppCompatDelegate.getApplicationLocales()
    val currentLocaleTag = appLocales.get(0)?.toLanguageTag() ?: "en"

    // Example UI: A button to toggle between English and Spanish
    Button(
        onClick = {
            val newLanguageTag = if (currentLocaleTag == "en") "es" else "en"
            val localeList = LocaleListCompat.forLanguageTags(newLanguageTag)

            // Setting the locale re-creates the Activity by default,
            // which automatically applies the new configuration to Compose.
            AppCompatDelegate.setApplicationLocales(localeList)
        }
    ) {
        Text(
            text = if (currentLocaleTag == "en") "Switch to Spanish" else "Switch to English"
        )
    }
}

כדי להגדיר את השפה המועדפת של משתמש, צריך לבקש מהמשתמש לבחור לוקאל בכלי לבחירת שפה, ואז להגדיר את הערך הזה במערכת:

val appLocale: LocaleListCompat = LocaleListCompat.forLanguageTags("xx-YY")
// Call this on the main thread as it may require Activity.restart()
AppCompatDelegate.setApplicationLocales(appLocale)

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

משתמשים ב-AppCompatDelegate.getApplicationLocales כדי לאחזר את הלוקאל המועדף של המשתמש. יכול להיות שהמשתמש בחר את הלוקאל של האפליקציה מתוך הגדרות המערכת או מתוך בורר השפות באפליקציה.

תמיכה ב-Android מגרסה 12 ומטה

כדי לתמוך במכשירים עם Android מגרסה 12 (רמת API‏ 32) ומטה, צריך להגדיר את הערך autoStoreLocales ל-true ואת הערך android:enabled ל-false ברשומה של שירות AppLocalesMetadataHolderService האפליקציה במניפסט, כמו בדוגמת הקוד הבאה:

<application
  ...
  <service
    android:name="androidx.appcompat.app.AppLocalesMetadataHolderService"
    android:enabled="false"
    android:exported="false">
    <meta-data
      android:name="autoStoreLocales"
      android:value="true" />
  </service>
  ...
</application>

הערה: הגדרת ערך של autoStoreLocales ל-true גורמת לקריאה חוסמת בשרשור הראשי, ועשויה לגרום להפרה של StrictMode diskRead ושל diskWrite אם אתם מתעדים הפרות של שרשורים. מידע נוסף זמין במאמר AppCompatDelegate.setApplicationLocales.

טיפול מותאם אישית באחסון

אם לא מציינים את רכיב המניפסט או מגדירים את autoStoreLocales ל-false signals מציינים שאתם מטפלים באחסון בעצמכם. במקרה כזה, צריך לספק את הלוקאלים המאוחסנים לפני onCreate במחזור החיים של הפעילות, ולשלוח קריאות ל-AppCompatDelegate.setApplicationLocales ב-Android 12 (רמת API‏ 32) או בגרסאות קודמות.

אם באפליקציה שלכם יש מיקום אחסון מותאם אישית לאזור, מומלץ להשתמש בהעברה חד-פעמית בין פתרון האחסון המותאם אישית לאזור לבין autoStoreLocales כדי שהמשתמשים יוכלו להמשיך ליהנות מהאפליקציה בשפה המועדפת עליהם. זה רלוונטי במיוחד במקרים שבהם האפליקציה מופעלת בפעם הראשונה אחרי שמכשיר שודרג ל-Android 13. במקרה כזה, אפשר לספק לוקאלים קיימים שהמשתמש ביקש על ידי אחזור הלוקאלים מהאחסון המותאם אישית והעברתם אל AppCompatDelegate.setApplicationLocales.

הטמעה באמצעות ממשקי ה-API של Android Framework

מומלץ מאוד להשתמש בספריית התמיכה של AndroidX כדי להטמיע את בוררי השפה באפליקציה, אבל אפשר גם להשתמש בשיטות setApplicationLocales ו-getApplicationLocales ב-Android Framework במכשירים עם Android 13.

בקטע הקוד הבא אפשר לראות איך מגדירים את השפה המועדפת של המשתמש ומקבלים אותה באמצעות שירות המערכת LocaleManager:

import android.app.LocaleManager
import android.content.Context
import android.os.Build
import android.os.LocaleList
import androidx.annotation.RequiresApi
import java.util.Locale

@RequiresApi(Build.VERSION_CODES.TIRAMISU)
fun setAppLanguage(context: Context, languageTag: String) {
    // 1. Retrieve the system service
    val localeManager = context.getSystemService(LocaleManager::class.java)

    // 2. Create a LocaleList from the language tag (e.g., "es-ES" or "ja")
    val localeList = LocaleList(Locale.forLanguageTag(languageTag))

    // 3. Set the locale. The system automatically updates the locale and
    // restarts the app, including any necessary configuration updates.
    localeManager.applicationLocales = localeList
}

@RequiresApi(Build.VERSION_CODES.TIRAMISU)
fun getAppLanguage(context: Context): String {
    val localeManager = context.getSystemService(LocaleManager::class.java)
    val currentLocales = localeManager.applicationLocales

    // Return the primary app locale, or fall back to the system default
    return if (!currentLocales.isEmpty) {
        currentLocales.get(0).toLanguageTag()
    } else {
        Locale.getDefault().toLanguageTag()
    }
}

שיטות מומלצות נוספות

כדאי ליישם את השיטות המומלצות הבאות.

התחשבות בשפה כשמפעילים כוונה באפליקציה אחרת

יכול להיות שכוונות שמתמקדות בשפה יאפשרו לכם לציין את השפה שבה אתם רוצים שהאפליקציה תופעל. דוגמה אחת היא התכונה EXTRA_LANGUAGE מ-Speech Recognizer API.

התייחסות לכותרת Accept-Language בכרטיסייה מותאמת אישית ב-Chrome

כדאי להוסיף את הכותרת Accept-Language דרך Browser.EXTRA_HEADERS כדי לפתוח דף אינטרנט בשפה של האפליקציה כשמפעילים כרטיסייה מותאמת ב-Chrome.

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

אם מסירים את העדפות השפה של האפליקציה מהגדרות המערכת (על ידי הסרת android:localeConfig מAndroidManifest.xml של האפליקציה), המשתמשים לא יכולים לאפס בקלות את שפת האפליקציה בחזרה לברירת המחדל של המערכת.

לכן, אם מסירים את android:localeConfig, כדאי לאפס את הלוקאל של האפליקציה ללוקאל של המערכת באמצעות LocaleListCompat.getEmptyLocaleList או LocaleList.getEmptyLocaleList, כמו בדוגמת קטע הקוד הבאה:

// Use the AndroidX APIs to reset to the system locale for backward and forward compatibility
AppCompatDelegate.setApplicationLocales(
  LocaleListCompat.getEmptyLocaleList()
)

// Or use the Framework APIs for Android 13 and above to reset to the system locale
val context = LocalContext.current
context.getSystemService(LocaleManager::class.java)
  .applicationLocales = LocaleList.getEmptyLocaleList()

קובץ לדוגמה של locale_config.xml

כברירת מחדל, מערכת Android כוללת תרגומים ברמת המערכת בפרויקט הקוד הפתוח של Android‏ (AOSP) עבור קבוצה סטנדרטית של הלוקאלים הנפוצים ביותר. קובץ locale_config.xml הדוגמה שמופיע בקטע הזה מציג את הפורמט המומלץ לכל אחד מהלוקאלים האלה. אפשר להיעזר בקובץ לדוגמה הזה כדי ליצור קובץ locale_config.xml משלכם עבור השפות שהאפליקציה תומכת בהן.

<?xml version="1.0" encoding="utf-8"?>
<locale-config xmlns:android="http://schemas.android.com/apk/res/android">
   <locale android:name="af"/> <!-- Afrikaans -->
   <locale android:name="am"/> <!-- Amharic -->
   <locale android:name="ar"/> <!-- Arabic -->
   <locale android:name="as"/> <!-- Assamese -->
   <locale android:name="az"/> <!-- Azerbaijani -->
   <locale android:name="be"/> <!-- Belarusian -->
   <locale android:name="bg"/> <!-- Bulgarian -->
   <locale android:name="bn"/> <!-- Bengali -->
   <locale android:name="bs"/> <!-- Bosnian -->
   <locale android:name="ca"/> <!-- Catalan -->
   <locale android:name="cs"/> <!-- Czech -->
   <locale android:name="da"/> <!-- Danish -->
   <locale android:name="de"/> <!-- German -->
   <locale android:name="el"/> <!-- Greek -->
   <locale android:name="en-AU"/> <!-- English (Australia) -->
   <locale android:name="en-CA"/> <!-- English (Canada) -->
   <locale android:name="en-GB"/> <!-- English (United Kingdom) -->
   <locale android:name="en-IN"/> <!-- English (India) -->
   <locale android:name="en-US"/> <!-- English (United States) -->
   <locale android:name="es"/> <!-- Spanish (Spain) -->
   <locale android:name="es-US"/> <!-- Spanish (United States) -->
   <locale android:name="et"/> <!-- Estonian -->
   <locale android:name="eu"/> <!-- Basque -->
   <locale android:name="fa"/> <!-- Farsi -->
   <locale android:name="fi"/> <!-- Finnish -->
   <locale android:name="fil"/> <!-- Filipino -->
   <locale android:name="fr"/> <!-- French (France) -->
   <locale android:name="fr-CA"/> <!-- French (Canada) -->
   <locale android:name="gl"/> <!-- Galician -->
   <locale android:name="gu"/> <!-- Gujarati -->
   <locale android:name="hi"/> <!-- Hindi -->
   <locale android:name="hr"/> <!-- Croatian -->
   <locale android:name="hu"/> <!-- Hungarian -->
   <locale android:name="hy"/> <!-- Armenian -->
   <locale android:name="in"/> <!-- Indonesian -->
   <locale android:name="is"/> <!-- Icelandic -->
   <locale android:name="it"/> <!-- Italian -->
   <locale android:name="iw"/> <!-- Hebrew -->
   <locale android:name="ja"/> <!-- Japanese -->
   <locale android:name="ka"/> <!-- Georgian -->
   <locale android:name="kk"/> <!-- Kazakh -->
   <locale android:name="km"/> <!-- Khmer -->
   <locale android:name="kn"/> <!-- Kannada -->
   <locale android:name="ko"/> <!-- Korean -->
   <locale android:name="ky"/> <!-- Kyrgyz -->
   <locale android:name="lo"/> <!-- Lao -->
   <locale android:name="lt"/> <!-- Lithuanian -->
   <locale android:name="lv"/> <!-- Latvian -->
   <locale android:name="mk"/> <!-- Macedonian -->
   <locale android:name="ml"/> <!-- Malayalam -->
   <locale android:name="mn"/> <!-- Mongolian -->
   <locale android:name="mr"/> <!-- Marathi -->
   <locale android:name="ms"/> <!-- Malay -->
   <locale android:name="my"/> <!-- Burmese -->
   <locale android:name="nb"/> <!-- Norwegian -->
   <locale android:name="ne"/> <!-- Nepali -->
   <locale android:name="nl"/> <!-- Dutch -->
   <locale android:name="or"/> <!-- Odia -->
   <locale android:name="pa"/> <!-- Punjabi -->
   <locale android:name="pl"/> <!-- Polish -->
   <locale android:name="pt-BR"/> <!-- Portuguese (Brazil) -->
   <locale android:name="pt-PT"/> <!-- Portuguese (Portugal) -->
   <locale android:name="ro"/> <!-- Romanian -->
   <locale android:name="ru"/> <!-- Russian -->
   <locale android:name="si"/> <!-- Sinhala -->
   <locale android:name="sk"/> <!-- Slovak -->
   <locale android:name="sl"/> <!-- Slovenian -->
   <locale android:name="sq"/> <!-- Albanian -->
   <locale android:name="sr"/> <!-- Serbian (Cyrillic) -->
   <locale android:name="sr-Latn"/> <!-- Serbian (Latin) -->
   <locale android:name="sv"/> <!-- Swedish -->
   <locale android:name="sw"/> <!-- Swahili -->
   <locale android:name="ta"/> <!-- Tamil -->
   <locale android:name="te"/> <!-- Telugu -->
   <locale android:name="th"/> <!-- Thai -->
   <locale android:name="tr"/> <!-- Turkish -->
   <locale android:name="uk"/> <!-- Ukrainian -->
   <locale android:name="ur"/> <!-- Urdu -->
   <locale android:name="uz"/> <!-- Uzbek -->
   <locale android:name="vi"/> <!-- Vietnamese -->
   <locale android:name="zh-Hans"/> <!-- Chinese (Simplified) -->
   <locale android:name="zh-Hant"/> <!-- Chinese (Traditional) -->
   <locale android:name="zu"/> <!-- Zulu -->
</locale-config>

מקורות מידע נוספים

מידע נוסף זמין בדוגמאות הקוד, במאמרים בבלוג ובסרטונים שלנו.

הקודם
Language and locale resolution