Android 内置的换肤

Android 中可以动态切换主题,但是只能切换主题的颜色,并且主题的切换会对view进行重新加载并不连贯.
Android 中内置的换肤需要在apk中存在需要换肤的图片等资源,导致apk包的增大,并且不能进行更多皮肤的扩展,需要重新打包上线.

如何实现动态换肤

类似网易云音乐的动态换肤,是通过下载皮肤包,加载皮肤包来实现动态换肤的功能,那么皮肤包是啥呢? 其实就是apk包,读取apk中的资源文件进行替换就可以实现动态的换肤功能.

实现代码地址:https://github.com/JakePrim/PrimSkinCore

那么动态换肤的实现原理是什么? 我们知道在Activity和Fragment通过 setContentView 来加载布局文件,setContentView
中如何加载布局呢? 内部通过 LayoutInflater 布局加载器来加载布局. LayoutInflater
如何加载布局呢? 我们看如下系统的源代码:

  1. LayoutInflater.from(mContext).inflate(resId, contentParent);
  3. //inflate 做了什么呢? 点击看下inflate 方法做了什么
  5.  public View inflate(XmlPullParser parser, @Nullable ViewGroup root, boolean attachToRoot) {
  6.      .....
  7.      //这里是获取返回的view    
  8.      final View temp = createViewFromTag(root, name, inflaterContext, attrs);
  9.      ........
  10.  }
  11. //在createViewFromTag返回了一个view
  12. View createViewFromTag(View parent, String name, Context context, AttributeSet attrs,
  13.             boolean ignoreThemeAttr) {    
  14.     .....
  15.      View view;
  16.             if (mFactory2 != null) {//如果mFactory2 != null 则通过mFactory2加载
  17.                 view = mFactory2.onCreateView(parent, name, context, attrs);
  18.             } else if (mFactory != null) {//如果mFactory != null 则通过mFactory加载
  19.                 view = mFactory.onCreateView(name, context, attrs);
  20.             } else {
  21.                 view = null;
  22.             }
  24.             if (view == null && mPrivateFactory != null) {
  25.                 view = mPrivateFactory.onCreateView(parent, name, context, attrs);
  26.             }
  27.             //默认通过一下方式返回view          
  28.             if (view == null) {
  29.                 final Object lastContext = mConstructorArgs[0];
  30.                 mConstructorArgs[0] = context;
  31.                 try {
  32.                     if (-1 == name.indexOf('.')) {
  33.                         view = onCreateView(parent, name, attrs);
  34.                     } else {
  35.                         view = createView(name, null, attrs);
  36.                     }
  37.                 } finally {
  38.                     mConstructorArgs[0] = lastContext;
  39.                 }
  40.             }
  42.             return view;
  43.     ......
  44. }

上述代码中首先判断mFactory2是否为空,如果不为空就交给了mFactory2去处理返回view,很明显google给了我们支持自定义的方法.setFactory2方法还是public的公有的方法,我们只需要实现Factory2,对view进行响应的处理然后返回就可以实现动态换肤. 在上述代码中还有一个 mFactory 其实是和mFactory2 一样的道理,实现mFactory也是一样的只不过 mFactory2处于第一个,防止有其他的地方实现了mFactory2,所以我们就需要去实现mFactory2,确保mFactory2被正确运行.

  1.    /**
  2.      * Like {@link #setFactory}, but allows you to set a {@link Factory2}
  3.      * interface.
  4.      */
  5.     public void setFactory2(Factory2 factory) {
  6.         if (mFactorySet) {
  7.             throw new IllegalStateException("A factory has already been set on this LayoutInflater");
  8.         }
  9.         if (factory == null) {
  10.             throw new NullPointerException("Given factory can not be null");
  11.         }
  12.         mFactorySet = true;
  13.         if (mFactory == null) {
  14.             mFactory = mFactory2 = factory;
  15.         } else {
  16.             mFactory = mFactory2 = new FactoryMerger(factory, factory, mFactory, mFactory2);
  17.         }
  18.     }

我们看了上述的系统源代码,知道了系统是支持自定义mFactory2,来自己实现对view对加载,返回view.加载view只需要参考系统的代码即可,核心的代码就是筛选属性,然后修改属性的值,来实现颜色和图片的改变.

那么系统是如何加载view的呢? 我们从系统的源代码中来查找,在 createViewFromTag 方法中name.indexOf(‘.’)如果布局中的view带. 这说明是自定义view,否则是基本的view,我们先来看一下基本的view,来看一下 onCreateView 方法

  1.  if (view == null) {
  2.                 final Object lastContext = mConstructorArgs[0];
  3.                 mConstructorArgs[0] = context;
  4.                 try {
  5.                     if (-1 == name.indexOf('.')) {
  6.                         view = onCreateView(parent, name, attrs);
  7.                     } else {
  8.                         view = createView(name, null, attrs);
  9.                     }
  10.                 } finally {
  11.                     mConstructorArgs[0] = lastContext;
  12.                 }
  13.             }

onCreateView其实是有AsyncLayoutInlater调用的onCreateView

  1. private static class BasicInflater extends LayoutInflater {
  2.         private static final String[] sClassPrefixList = {
  3.             "android.widget.",
  4.             "android.webkit.",
  5.             "android.app."
  6.         };
  8.         BasicInflater(Context context) {
  9.             super(context);
  10.         }
  12.         @Override
  13.         public LayoutInflater cloneInContext(Context newContext) {
  14.             return new BasicInflater(newContext);
  15.         }
  17.         @Override
  18.         protected View onCreateView(String name, AttributeSet attrs) throws ClassNotFoundException {
  19.             for (String prefix : sClassPrefixList) {
  20.                 try {
  21.                     View view = createView(name, prefix, attrs);
  22.                     if (view != null) {
  23.                         return view;
  24.                     }
  25.                 } catch (ClassNotFoundException e) {
  26.                     // In this case we want to let the base class take a crack
  27.                     // at it.
  28.                 }
  29.             }
  31.             return super.onCreateView(name, attrs);
  32.         }
  33.     }

最核心的代码如下: 本质上是通过反射来实现返回View对象即可.是不是很简单,系统的源码就是这样加载布局的.

  1. if (constructor == null) {
  2.                 // Class not found in the cache, see if it's real, and try to add it
  3.                 clazz = mContext.getClassLoader().loadClass(
  4.                         prefix != null ? (prefix + name) : name).asSubclass(View.class);
  6.                 if (mFilter != null && clazz != null) {
  7.                     boolean allowed = mFilter.onLoadClass(clazz);
  8.                     if (!allowed) {
  9.                         failNotAllowed(name, prefix, attrs);
  10.                     }
  11.                 }
  12.                 constructor = clazz.getConstructor(mConstructorSignature);
  13.                 constructor.setAccessible(true);
  14.                 sConstructorMap.put(name, constructor);
  15.             }

我们在得到view对象之后,获取view的属性将view的属性资源修改为皮肤包的资源.需要采集需要换肤的需要替换的属性.
采集如下基本属性,替换为皮肤包中的资源ID

  1. static {
  2.         mAttributes.add("background");
  3.         mAttributes.add("src");
  5.         mAttributes.add("textColor");
  6.         mAttributes.add("drawableLeft");
  7.         mAttributes.add("drawableTop");
  8.         mAttributes.add("drawableRight");
  9.         mAttributes.add("drawableBottom");
  10.     }

动态换肤的实现

在上述中我们知道通过布局加载器LayoutInflater来加载布局,所以我们需要每进入一个Activity拿到 LayoutInflater 设置自定义布局加载工厂,如果建立一个BaseActivity对代码对入侵性很强,Application中提供监听App的所有Activity的生命周期回调.

代码如下

  1. public class SkinActivityLifecycle implements Application.ActivityLifecycleCallbacks {
  3.     private HashMap<Activity, SkinLayoutFactory> mLayoutFactoryMap = new HashMap<>();
  5.     @Override
  6.     public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
  7.         //拿到每个activity的布局加载器
  8.         LayoutInflater layoutInflater = LayoutInflater.from(activity);
  9.         //mFactorySet 如果为true 抛出异常，有可能会出现这种情况，通过反射将mFactorySet设置为false
  10.         try {
  11.             Field field = LayoutInflater.class.getDeclaredField("mFactorySet");
  12.             field.setAccessible(true);
  13.             field.setBoolean(layoutInflater, false);
  14.         } catch (Exception e) {
  15.             e.printStackTrace();
  16.         }
  17.         //自定义布局处理工厂
  18.         SkinLayoutFactory factory = new SkinLayoutFactory();
  19.         //设置工厂
  20.         LayoutInflaterCompat.setFactory2(layoutInflater, factory);
  21.     }
  23.     @Override
  24.     public void onActivityStarted(Activity activity) {
  26.     }
  28.     @Override
  29.     public void onActivityResumed(Activity activity) {
  31.     }
  33.     @Override
  34.     public void onActivityPaused(Activity activity) {
  36.     }
  38.     @Override
  39.     public void onActivityStopped(Activity activity) {
  41.     }
  43.     @Override
  44.     public void onActivitySaveInstanceState(Activity activity, Bundle outState) {
  46.     }
  48.     @Override
  49.     public void onActivityDestroyed(Activity activity) {
  51.     }
  52. }

接下来就是自定义 LayoutInflater.Factory2 ,Factory2的实现其实就是参考系统的实现,代码原理也非常简单,代码如下

  1. public class SkinLayoutFactory implements LayoutInflater.Factory2, Observer {
  3.     private static final String[] sClassPrefixList = {
  4.             "android.widget.",
  5.             "android.webkit.",
  6.             "android.app."
  7.     };
  9.     private static final HashMap<String, Constructor<? extends View>> sConstructorMap =
  10.             new HashMap<String, Constructor<? extends View>>();
  12.     private static final Class<?>[] mConstructorSignature = new Class[]{
  13.             Context.class, AttributeSet.class};
  15.     private SkinAttribute skinAttribute;
  17.     public SkinLayoutFactory() {
  18.         skinAttribute = new SkinAttribute();
  19.     }
  21.     @Override
  22.     public View onCreateView(View parent, String name, Context context, AttributeSet attrs) {
  23.         //参考系统的实现
  24.         View view = createViewFromTag(context, name, attrs);
  25.         if (view == null) {
  26.             view = createView(name, context, attrs);
  27.         }
  28.         //采集view的属性
  29.         skinAttribute.load(view,attrs);
  30.         return view;
  31.     }
  33.     @Override
  34.     public View onCreateView(String name, Context context, AttributeSet attrs) {
  35.         return null;
  36.     }
  38.     private View createViewFromTag(Context context, String name, AttributeSet attrs) {
  39.         if (name.contains(".")) {//如果布局xml中的view 名包含.表示为自定义view 此处先不做处理
  40.             return null;
  41.         }
  42.         View view = null;
  43.         for (String prefix : sClassPrefixList) {//遍历view属于哪个包中 然后反射创建view对象
  44.             try {
  45.                 view = createView(prefix + name, context, attrs);
  46.                 if (view != null) {
  47.                     break;
  48.                 }
  49.             } catch (Exception e) {
  50.                 // In this case we want to let the base class take a crack
  51.                 // at it.
  52.             }
  53.         }
  54.         return view;
  55.     }
  57.     private View createView(String name, Context context, AttributeSet attrs) {
  58.         Constructor<? extends View> constructor = sConstructorMap.get(name);
  59.         try {
  60.             if (constructor == null) {
  61.                 Class<? extends View> clazz = context.getClassLoader().loadClass(name).asSubclass(View.class);
  62.                 constructor = clazz.getConstructor(mConstructorSignature);
  63.                 constructor.setAccessible(true);
  64.                 sConstructorMap.put(name, constructor);
  65.             }
  66.         } catch (Exception e) {
  68.         }
  70.         if (null != constructor) {
  71.             try {
  72.                 return constructor.newInstance(context, attrs);
  73.             } catch (Exception e) {
  74.             }
  75.         }
  77.         return null;
  78.     }
  80.     @Override
  81.     public void update(Observable o, Object arg) {
  82.         skinAttribute.applySkin();
  83.     }
  84. }

真正实现换肤的就是,对Attribute的操作, 接下来看一下SkinAttribute的实现很非常简单,其实就是遍历所有view的属性拿到自己需要的属性,然后存储在集合中如下:

  1. //采集的属性集合
  2. static {
  3.         mAttributes.add("background");
  4.         mAttributes.add("src");
  6.         mAttributes.add("textColor");
  7.         mAttributes.add("drawableLeft");
  8.         mAttributes.add("drawableTop");
  9.         mAttributes.add("drawableRight");
  10.         mAttributes.add("drawableBottom");
  11.     }
  13. public void load(View view, AttributeSet attrs) {
  14.         List<SkinPair> skinPairs = new ArrayList<>();
  15.         //获取属性
  16.         for (int i = 0; i < attrs.getAttributeCount(); i++) {
  17.             //获取属性名
  18.             String attributeName = attrs.getAttributeName(i);
  19.             //匹配要修改的属性名
  20.             if (mAttributes.contains(attributeName)) {
  21.                 //获取属性值
  22.                 String attributeValue = attrs.getAttributeValue(i);
  23.                 if (attributeValue.startsWith("#")) {//写死的先不去管 #000000
  24.                     continue;
  25.                 }
  26.                 int resId;
  27.                 if (attributeValue.startsWith("?")) {
  28.                     //attrId
  29.                     int attrId = Integer.parseInt(attributeValue.substring(1));
  30.                     resId = utils.getResId(view.getContext(), new int[]{attrId})[0];
  31.                 } else {
  32.                     //@1232311
  33.                     resId = Integer.parseInt(attributeValue.substring(1));
  34.                 }
  35.                 if (resId != 0) {
  36.                     //将匹配的都存储下来
  37.                     SkinPair skinPair = new SkinPair(attributeName, resId);
  38.                     skinPairs.add(skinPair);
  39.                 }
  40.             }
  41.         }
  42.         //将布局中每个view与之对应的属性集合放入到对应的view集合中
  43.         if (!skinPairs.isEmpty()) {
  44.             SkinView skinView = new SkinView(view, skinPairs);
  45.             //每次新加载activity就要进行换肤
  46.             applySkin();
  47.             skinViews.add(skinView);
  48.         }
  49.     }

至于SkinView类存储了属性名和资源ID和当前的view

  1.    /**
  2.      * 保存每个view要修改的属性值列表
  3.      */
  4. static class SkinView {
  5.         View view;
  6.         List<SkinPair> skinPairs;
  8.         public SkinView(View view, List<SkinPair> skinPairs) {
  9.             this.view = view;
  10.             this.skinPairs = skinPairs;
  11.         }
  12. }
  14. static class SkinPair {
  15.         String attrName;
  16.         int resId;
  18.         public SkinPair(String attrName, int resId) {
  19.             this.attrName = attrName;
  20.             this.resId = resId;
  21.         }
  22.     }

上述代码就是核心的实现,最后我们需要实现初始化和资源的切换,代码如下 通过皮肤包的路径,Application获取到资源管理器AssetManager获取皮肤包的资源,然后通过SkinResources来实现资源的加载,然后使SkinLayoutFactory做为观察者,当更换皮肤包时更新SkinLayoutFactory. 然后通过SkinAttribute将属性的资源更改为皮肤包的资源

  1.    /**
  2.      * 加载皮肤包
  3.      *
  4.      * @param path
  5.      */
  6.     public void loadSkin(String path) {
  7.         if (path == null || path.isEmpty()) {
  8.             SkinPreference.getInstance().setSkin("");
  9.             SkinResources.getInstance().reset();
  10.         } else {
  11.             try {
  12.                 //获取资源管理器 加载皮肤包中的资源
  13.                 AssetManager assetManager = AssetManager.class.newInstance();
  14.                 Method addAssetPath = assetManager.getClass().getMethod("addAssetPath", String.class);
  15.                 addAssetPath.setAccessible(true);
  16.                 addAssetPath.invoke(assetManager, path);
  18.                 //加载皮肤包里的资源
  20.                 //获取当前应用的资源
  21.                 Resources resources = application.getResources();
  23.                 //皮肤包的资源
  24.                 Resources skinResources = new Resources(assetManager,
  25.                         resources.getDisplayMetrics(), resources.getConfiguration());
  27.                 //加载皮肤包资源
  28.                 //皮肤包的包名
  29.                 PackageManager packageManager = application.getPackageManager();
  30.                 //获取一个apk的包名
  31.                 PackageInfo info = packageManager.getPackageArchiveInfo(path, PackageManager.GET_ACTIVITIES);
  32.                 String packageName = info.packageName;
  33.                 Log.e(TAG, "loadSkin: " + packageName);
  34.                 //更换为皮肤包资源
  35.                 SkinResources.getInstance().applySkin(skinResources, packageName);
  36.                 //记录使用的皮肤包
  37.                 SkinPreference.getInstance().setSkin(path);
  38.             } catch (Exception e) {
  39.                 e.printStackTrace();
  40.             }
  42.         }
  44.         //通知观察者 //应用皮肤包
  45.         setChanged();
  46.         notifyObservers();
  47.     }

SkinResources的实现,其实就是根据app的资源的资源名和资源类型,通过皮肤包的资源返回皮肤包的资源ID,如果没有就返回当前app的资源ID.

  1. public class SkinResources {
  2.     //皮肤的资源
  3.     private Resources mSkinResources;
  4.     //当前应用的资源
  5.     private Resources mAppResources;
  6.     //皮肤包名
  7.     private String mSkinName;
  8.     //是否使用默认皮肤
  9.     private boolean isDefalueSkin = true;
  11.     public static SkinResources instance;
  13.     public static void init(Context context) {
  14.         if (null == instance) {
  15.             synchronized (SkinResources.class) {
  16.                 if (null == instance) {
  17.                     instance = new SkinResources(context);
  18.                 }
  19.             }
  20.         }
  21.     }
  23.     public static SkinResources getInstance() {
  24.         return instance;
  25.     }
  27.     public SkinResources(Context context) {
  28.         mAppResources = context.getResources();
  29.     }
  31.     public void reset() {
  32.         mSkinResources = null;
  33.         mSkinName = "";
  34.         isDefalueSkin = true;
  35.     }
  37.     public void applySkin(Resources resources, String name) {
  38.         mSkinResources = resources;
  39.         mSkinName = name;
  40.         isDefalueSkin = false;
  41.     }
  43.     /**
  44.      * 通过资源ID 获取皮肤包中对应的资源ID 然后进行设置
  45.      *
  46.      * @param resId
  47.      * @return
  48.      */
  49.     public int getIdentfier(int resId) {
  50.         if (isDefalueSkin) {
  51.             return resId;
  52.         }
  54.         //通过当前应用资源获取到 资源名 和 资源类型，然后通过资源名  资源类型 资源ID 获取到皮肤包中的资源ID
  55.         String resourceName = mAppResources.getResourceEntryName(resId);
  56.         String resourceTypeName = mAppResources.getResourceTypeName(resId);
  57.         //getIdentifier ?? 获取到皮肤包对应到资源ID
  58.         int skinId = mSkinResources.getIdentifier(resourceName, resourceTypeName, mSkinName);
  59.         return skinId;
  60.     }
  62.     private static final String TAG = "SkinResources";
  64.     public int getColor(int resId) {
  65.         if (isDefalueSkin) {
  66.             return mAppResources.getColor(resId);
  67.         }
  68.         int skinId = getIdentfier(resId);
  69.         Log.e(TAG, "getColor: " + skinId);
  70.         if (skinId == 0) {
  71.             return mAppResources.getColor(resId);
  72.         }
  73.         return mSkinResources.getColor(skinId);
  74.     }
  76.     public ColorStateList getColorStateList(int resId) {
  77.         if (isDefalueSkin) {
  78.             return mAppResources.getColorStateList(resId);
  79.         }
  80.         int skinId = getIdentfier(resId);
  81.         if (skinId == 0) {
  82.             return mAppResources.getColorStateList(resId);
  83.         }
  84.         return mSkinResources.getColorStateList(skinId);
  85.     }
  87.     public Drawable getDrawable(int resId) {
  88.         //如果有皮肤  isDefaultSkin false 没有就是true
  89.         if (isDefalueSkin) {
  90.             return mAppResources.getDrawable(resId);
  91.         }
  92.         int skinId = getIdentfier(resId);
  93.         if (skinId == 0) {
  94.             return mAppResources.getDrawable(resId);
  95.         }
  96.         return mSkinResources.getDrawable(skinId);
  97.     }
  100.     /**
  101.      * 可能是Color 也可能是drawable
  102.      *
  103.      * @return
  104.      */
  105.     public Object getBackground(int resId) {
  106.         String resourceTypeName = mAppResources.getResourceTypeName(resId);
  108.         if (resourceTypeName.equals("color")) {
  109.             return getColor(resId);
  110.         } else {
  111.             // drawable
  112.             return getDrawable(resId);
  113.         }
  114.     }
  116.     public String getString(int resId) {
  117.         try {
  118.             if (isDefalueSkin) {
  119.                 return mAppResources.getString(resId);
  120.             }
  121.             int skinId = getIdentfier(resId);
  122.             if (skinId == 0) {
  123.                 return mAppResources.getString(skinId);
  124.             }
  125.             return mSkinResources.getString(skinId);
  126.         } catch (Resources.NotFoundException e) {
  128.         }
  129.         return null;
  130.     }
  132.     public Typeface getTypeface(int resId) {
  133.         String skinTypefacePath = getString(resId);
  134.         if (TextUtils.isEmpty(skinTypefacePath)) {
  135.             return Typeface.DEFAULT;
  136.         }
  137.         try {
  138.             Typeface typeface;
  139.             if (isDefalueSkin) {
  140.                 typeface = Typeface.createFromAsset(mAppResources.getAssets(), skinTypefacePath);
  141.                 return typeface;
  143.             }
  144.             typeface = Typeface.createFromAsset(mSkinResources.getAssets(), skinTypefacePath);
  145.             return typeface;
  146.         } catch (RuntimeException e) {
  147.         }
  148.         return Typeface.DEFAULT;
  149.     }
  152. }

当切换资源通知观察者SkinLayoutFactory的SkinAttribute 来采集属性和更换资源ID.代码的实现都非常简单

  1. /**
  2.      * 更换皮肤
  3.      */
  4.     public void applySkin() {
  5.         //遍历保存的表然后换皮肤
  6.         for (SkinView skinView : skinViews) {
  7.             skinView.applySkin();
  8.         }
  9.     }
  11.  /**
  12.      * 保存每个view要修改的属性值列表
  13.      */
  14.     static class SkinView {
  15.         View view;
  16.         List<SkinPair> skinPairs;
  18.         public SkinView(View view, List<SkinPair> skinPairs) {
  19.             this.view = view;
  20.             this.skinPairs = skinPairs;
  21.         }
  23.         public void applySkin() {
  24.             for (SkinPair skinPair : skinPairs) {
  25.                 Drawable left = null, right = null, top = null, bottom = null;
  26.                 switch (skinPair.attrName) {
  27.                     case "background":
  28.                         Object background = SkinResources.getInstance().getBackground(skinPair.resId);
  29.                         //可能是一个图片或者颜色
  30.                         if (background instanceof Integer) {
  31.                             //color 选择器
  32.                             view.setBackgroundColor((Integer) background);
  33.                         } else {
  34.                             ViewCompat.setBackground(view, (Drawable) background);
  35.                         }
  36.                         break;
  37.                     case "src":
  38.                         if (view instanceof ImageView) {
  39.                             ImageView imageView = (ImageView) view;
  40.                             Object background1 = SkinResources.getInstance().getBackground(skinPair.resId);
  41.                             if (background1 instanceof Integer) {
  42.                                 imageView.setImageDrawable(new ColorDrawable((Integer) background1));
  43.                             } else {
  44.                                 imageView.setImageDrawable((Drawable) background1);
  45.                             }
  46.                         }
  47.                         break;
  48.                     case "textColor":
  49.                         int color = SkinResources.getInstance().getColor(skinPair.resId);
  50.                         if (view instanceof TextView) {
  51.                             TextView textView = (TextView) view;
  52.                             textView.setTextColor(color);
  53.                         }
  54.                         break;
  55.                     case "drawableLeft":
  56.                         left = SkinResources.getInstance().getDrawable(skinPair.resId);
  57.                         break;
  58.                     case "drawableTop":
  59.                         top = SkinResources.getInstance().getDrawable(skinPair.resId);
  60.                         break;
  61.                     case "drawableRight":
  62.                         right = SkinResources.getInstance().getDrawable(skinPair.resId);
  63.                         break;
  64.                     case "drawableBottom":
  65.                         bottom = SkinResources.getInstance().getDrawable(skinPair.resId);
  66.                         break;
  67.                 }
  68.                 if (null != left || null != right || null != top || null != bottom) {
  69.                     ((TextView) view).setCompoundDrawablesWithIntrinsicBounds(left, top, right,
  70.                             bottom);
  71.                 }
  72.             }
  73.         }
  74.     }

OK,现在我们实现了基本的动态换肤功能,目前我们实现的换肤功能还没有实现自定义view和状态栏的换肤功能.下一节来讲解如何实现自定义view的换肤和状态栏的换肤,其实代码写到这里大家都知道了实现的原理可以先试着自己实现.