Android应用TextView分语言设置字体及备选字体方案咨询

Hey there! Let's tackle this font adaptation problem step by step—since you already have multi-language support set up with values-ar and other resource directories, you're halfway there.

First, let's break down your two core needs:

• Switch fonts automatically based on the system language (English vs. Arabic)
• Add fallback fonts for each language, just like CSS's font-family stack

Option 1: Use Android's Built-in Font Family Resources (Simpler for Most Cases) #

Starting from Android 8.0 (API 26), you can define font families in XML that handle fallback automatically. This is the cleanest approach if your min SDK supports it.

1. Add your font files
   Place all your font files (e.g., english_main.ttf, english_fallback.ttf, arabic_main.ttf, arabic_fallback.ttf) in the res/font directory (create it if it doesn't exist).

2. Define font families for each language

   • Create res/font/english_font.xml:

     <font-family xmlns:android="http://schemas.android.com/apk/res/android">
         <!-- Primary font for English -->
         <font
             android:font="@font/english_main"
             android:fontStyle="normal"
             android:fontWeight="400"/>
         <!-- Fallback if primary fails to load -->
         <font
             android:font="@font/english_fallback"
             android:fontStyle="normal"
             android:fontWeight="400"/>
     </font-family>
     

   • Create res/font/arabic_font.xml similarly for Arabic fonts.

3. Link fonts to language-specific styles

   • In values/styles.xml (for English/other languages):

     <style name="LocalizedTextViewStyle">
         <item name="android:fontFamily">@font/english_font</item>
     </style>
     

   • In values-ar/styles.xml (for Arabic):

     <style name="LocalizedTextViewStyle">
         <item name="android:fontFamily">@font/arabic_font</item>
     </style>
     

4. Apply the style to your TextView
   In your layout XML:

   <TextView
       android:id="@+id/localized_text"
       android:layout_width="wrap_content"
       android:layout_height="wrap_content"
       style="@style/LocalizedTextViewStyle"
       android:text="@string/your_localized_text"/>
   

   That's it! Android will automatically load the correct font family based on the system language, and handle fallback if the primary font fails.

Option 2: Dynamic Loading with a Utility Class (For Older SDKs or Custom Logic) #

If you need to support SDK versions below 26, or want more control over the fallback logic, a utility class works great.

1. Create a Font Utility Class
   This class will handle trying to load fonts in order until it finds one that works:

   import android.content.Context
   import android.graphics.Typeface
   import android.util.Log
   
   object FontUtils {
       private const val TAG = "FontUtils"
   
       fun getFontWithFallback(context: Context, vararg fontPaths: String): Typeface {
           // Start with system default as final fallback
           var fallbackFont = Typeface.DEFAULT
   
           for (path in fontPaths) {
               try {
                   val typeface = Typeface.createFromAsset(context.assets, path)
                   return typeface
               } catch (e: Exception) {
                   Log.w(TAG, "Failed to load font: $path, trying next fallback")
               }
           }
   
           return fallbackFont
       }
   }
   

2. Define Language-Specific Font Paths in Resources

   • In values/arrays.xml:

     <string-array name="english_font_paths">
         <item>fonts/english_main.ttf</item>
         <item>fonts/english_fallback.ttf</item>
     </string-array>
     

   • In values-ar/arrays.xml:

     <string-array name="arabic_font_paths">
         <item>fonts/arabic_main.ttf</item>
         <item>fonts/arabic_fallback.ttf</item>
     </string-array>
     

3. Load and Apply Font in Your Activity/Fragment

   import android.os.Bundle
   import android.widget.TextView
   import androidx.appcompat.app.AppCompatActivity
   
   class MainActivity : AppCompatActivity() {
       override fun onCreate(savedInstanceState: Bundle?) {
           super.onCreate(savedInstanceState)
           setContentView(R.layout.activity_main)
   
           val localizedTextView = findViewById<TextView>(R.id.localized_text)
           val fontPaths = when (resources.configuration.locale.language) {
               "ar" -> resources.getStringArray(R.array.arabic_font_paths)
               else -> resources.getStringArray(R.array.english_font_paths)
           }
   
           val typeface = FontUtils.getFontWithFallback(this, *fontPaths)
           localizedTextView.typeface = typeface
       }
   
       // Handle configuration changes (like language switch)
       override fun onConfigurationChanged(newConfig: android.content.res.Configuration) {
           super.onConfigurationChanged(newConfig)
           // Refresh the font when language changes
           val localizedTextView = findViewById<TextView>(R.id.localized_text)
           val fontPaths = when (newConfig.locale.language) {
               "ar" -> resources.getStringArray(R.array.arabic_font_paths)
               else -> resources.getStringArray(R.array.english_font_paths)
           }
           localizedTextView.typeface = FontUtils.getFontWithFallback(this, *fontPaths)
       }
   }
   

Key Notes #

• Make sure your font files are correctly placed in assets/fonts (for the utility class approach) or res/font (for the XML font family approach).
• For the XML method, if you need to support pre-API 26, you can use the Support Library's font-family implementation (add implementation 'com.android.support:support-core-utils:28.0.0' to your gradle file and use app:fontFamily instead of android:fontFamily).

内容的提问来源于stack exchange，提问作者ASghostKI