Android替换APP字体 — Typeface

Android替换APP字体 — Typeface

　　APP字体的思路一般都会想到自定义控件（TextView、EditView），但是项目中会有很多种控件，就算用也会承担一些风险和资源的消耗，主要是这种思路太死板了，就考虑Android底层应该在字体设置上有放开的方法，然后可以通过Application对控件进行过滤与替换，通过一番搜索果然有所发现，下面贴出代码：

　　1、请在Application中添加以下代码替换全局字体

// 字体放在 assets 文件夹下
FontUtils.getInstance().replaceSystemDefaultFontFromAsset(this, "fonts/xxx.ttf"); // .otf 字体文件也可

　　2、请在设置主题代码中添加以下代码

　　主题代码为 application 中的theme属性的 style 里面。

<item name="android:typeface">monospace</item>

　　3、新建文件FontUtils.java

 package com.test.bean;
 import java.lang.ref.SoftReference;
 import java.lang.reflect.Field;
 import java.util.HashMap;
 import java.util.Map;

 import android.app.Application;
 import android.content.Context;
 import android.graphics.Typeface;
 import android.view.View;
 import android.view.ViewGroup;
 import android.widget.TextView;

 public class FontUtils {

     private Map<String, SoftReference<Typeface>> mCache = new HashMap<String, SoftReference<Typeface>>();
     private static FontUtils sSingleton = null;

     public static Typeface DEFAULT = Typeface.DEFAULT;

     // disable instantiate
     private FontUtils() {}

     public static FontUtils getInstance() {
         // double check
         if (sSingleton == null) {
             synchronized(FontUtils.class) {
                 if (sSingleton == null) {
                     sSingleton = new FontUtils();
                 }
             }
         }
         return sSingleton;
     }

     /**
      * <p>Replace the font of specified view and it's children</p>
      * @param root The root view.
      * @param fontPath font file path relative to 'assets' directory.
      */
     public void replaceFontFromAsset(View root, String fontPath) {
         replaceFont(root, createTypefaceFromAsset(root.getContext(), fontPath));
     }

     /**
      * <p>Replace the font of specified view and it's children</p>
      * @param root The root view.
      * @param fontPath font file path relative to 'assets' directory.
      * @param style One of {@link Typeface#NORMAL}, {@link Typeface#BOLD}, {@link Typeface#ITALIC}, {@link Typeface#BOLD_ITALIC}
      */
     public void replaceFontFromAsset(View root, String fontPath, int style) {
         replaceFont(root, createTypefaceFromAsset(root.getContext(), fontPath), style);
     }

     /**
      * <p>Replace the font of specified view and it's children</p>
      * @param root The root view.
      * @param fontPath The full path to the font data.
      */
     public void replaceFontFromFile(View root, String fontPath) {
         replaceFont(root, createTypefaceFromFile(fontPath));
     }

     /**
      * <p>Replace the font of specified view and it's children</p>
      * @param root The root view.
      * @param fontPath The full path to the font data.
      * @param style One of {@link Typeface#NORMAL}, {@link Typeface#BOLD}, {@link Typeface#ITALIC}, {@link Typeface#BOLD_ITALIC}
      */
     public void replaceFontFromFile(View root, String fontPath, int style) {
         replaceFont(root, createTypefaceFromFile(fontPath), style);
     }

     /**
      * <p>Replace the font of specified view and it's children with specified typeface</p>
      */
     private void replaceFont(View root, Typeface typeface) {
         if (root == null || typeface == null) {
             return;
         }

         if (root instanceof TextView) { // If view is TextView or it's subclass, replace it's font
             TextView textView = (TextView)root;
             // Extract previous style of TextView
             int style = Typeface.NORMAL;
             if (textView.getTypeface() != null) {
                 style = textView.getTypeface().getStyle();
             }
             textView.setTypeface(typeface, style);
         } else if (root instanceof ViewGroup) { // If view is ViewGroup, apply this method on it's child views
             ViewGroup viewGroup = (ViewGroup) root;
             for (int i = ; i < viewGroup.getChildCount(); ++i) {
                 replaceFont(viewGroup.getChildAt(i), typeface);
             }
         } // else return
     }

     /**
      * <p>Replace the font of specified view and it's children with specified typeface and text style</p>
      * @param style One of {@link Typeface#NORMAL}, {@link Typeface#BOLD}, {@link Typeface#ITALIC}, {@link Typeface#BOLD_ITALIC}
      */
     private void replaceFont(View root, Typeface typeface, int style) {
         if (root == null || typeface == null) {
             return;
         }
         if (style <  || style > ) {
             style = Typeface.NORMAL;
         }

         if (root instanceof TextView) { // If view is TextView or it's subclass, replace it's font
             TextView textView = (TextView)root;
             textView.setTypeface(typeface, style);
         } else if (root instanceof ViewGroup) { // If view is ViewGroup, apply this method on it's child views
             ViewGroup viewGroup = (ViewGroup) root;
             for (int i = ; i < viewGroup.getChildCount(); ++i) {
                 replaceFont(viewGroup.getChildAt(i), typeface, style);
             }
         } // else return
     }

     /**
      * <p>Create a Typeface instance with specified font file</p>
      * @param fontPath font file path relative to 'assets' directory.
      * @return Return created typeface instance.
      */
     private Typeface createTypefaceFromAsset(Context context, String fontPath) {
         SoftReference<Typeface> typefaceRef = mCache.get(fontPath);
         Typeface typeface = null;
         if (typefaceRef == null || (typeface = typefaceRef.get()) == null) {
             typeface = Typeface.createFromAsset(context.getAssets(), fontPath);
             typefaceRef = new SoftReference<Typeface>(typeface);
             mCache.put(fontPath, typefaceRef);
         }
         return typeface;
     }

     private Typeface createTypefaceFromFile(String fontPath) {
         SoftReference<Typeface> typefaceRef = mCache.get(fontPath);
         Typeface typeface = null;
         if (typefaceRef == null || (typeface = typefaceRef.get()) == null) {
             typeface = Typeface.createFromFile(fontPath);
             typefaceRef = new SoftReference<Typeface>(typeface);
             mCache.put(fontPath, typefaceRef);
         }
         return typeface;
     }

     /**
      * <p>Replace system default font. <b>Note:</b>you should also add code below to your app theme in styles.xml. </p>
      * {@code <item name="android:typeface">monospace</item>}
      * <p>The best place to call this method is {@link Application#onCreate()}, it will affect
      * whole app font.If you call this method after view is visible, you need to invalid the view to make it effective.</p>
      * @param context {@link Context Context}
      * @param fontPath font file path relative to 'assets' directory.
      */
     public void replaceSystemDefaultFontFromAsset(Context context, String fontPath) {
         replaceSystemDefaultFont(createTypefaceFromAsset(context, fontPath));
     }

     /**
      * <p>Replace system default font. <b>Note:</b>you should also add code below to your app theme in styles.xml. </p>
      * {@code <item name="android:typeface">monospace</item>}
      * <p>The best place to call this method is {@link Application#onCreate()}, it will affect
      * whole app font.If you call this method after view is visible, you need to invalid the view to make it effective.</p>
      * @param context {@link Context Context}
      * @param fontPath The full path to the font data.
      */
     public void replaceSystemDefaultFontFromFile(Context context, String fontPath) {
         replaceSystemDefaultFont(createTypefaceFromFile(fontPath));
     }

     /**
      * <p>Replace system default font. <b>Note:</b>you should also add code below to your app theme in styles.xml. </p>
      * {@code <item name="android:typeface">monospace</item>}
      * <p>The best place to call this method is {@link Application#onCreate()}, it will affect
      * whole app font.If you call this method after view is visible, you need to invalid the view to make it effective.</p>
      */
     private void replaceSystemDefaultFont(Typeface typeface) {
         modifyObjectField(null, "MONOSPACE", typeface);
     }

     private void modifyObjectField(Object obj, String fieldName, Object value) {
         try {
             Field defaultField = Typeface.class.getDeclaredField(fieldName);
             defaultField.setAccessible(true);
             defaultField.set(obj, value);

         } catch (NoSuchFieldException e) {
             e.printStackTrace();
         } catch (IllegalAccessException e) {
             e.printStackTrace();
         }
     }
 }

　　核心代码在：replaceFont方法，替换TextView的字体，那大家就会疑问了，这个工具类只替换了Textview的字体，那如果用了EditView、RadioButton等呢。大家可以看下那些控件的父类，它们都是继承TextView，这样就豁然开朗，细节果然决定成败啊。整个工具类在字体替换的效率上都有所体现，采用软引用和HashMap缓存策略大大降低替换时的资源消耗，考虑的确很全面，并采用反射机制对Typeface进行设置达到换字体的目的。

　　这个工具类的确有许多值得学习的地方，比如在单例设置是采用了synchronized 摒弃了懒汉的模式，在资源使用上用到了SoftReference  软引用，在缓存上用了HashMap，最后采用反射赋值，这几点都是可圈可点。如果将缓存的HashMap换成ConcurrentHashMap或许在多线程环境下性能表现会更好些。