devbox
盐析白兔
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Android动态换肤原理解析_android 动态下发皮肤包

作者：盐析白兔 | 2024-02-15 20:58:05

赞

踩

android 动态下发皮肤包

概述

换肤是指在APP运行期间改变界面的字体、颜色、图片等。换肤的出现是为了满足日常产品和运营需求，满足用户个性化界面定制，提高用户体验等。

换肤方案

1.静态换肤：将图片、颜色、字体等皮肤资源打包进apk，以实现不同的主题样式等换肤需求。

2.动态换肤：由服务器下发皮肤包资源，APP在运行时读取服务器下发的皮肤包完成换肤需求。

动态换肤优势

1.apk大小：动态换肤不需要将皮肤资源打包进apk内，可以有效减少apk的大小

2.灵活性：动态换肤的皮肤包由服务器下发，不需要发版本就可以实现皮肤包的更新，用户也可以有更多的皮肤进行选择

3.维护性：动态换肤的皮肤包模块独立，便于维护

动态换肤的优势明显，所以本文主要是讲解动态换肤的原理。

换肤流程

整个换肤的流程可以概括为三部分：加载皮肤资源、获取需要换肤的控件（View）、替换皮肤。下面分别对每个部分进行解析。

加载皮肤资源

当我们将从服务器下载的皮肤包保存到本地之后，我们需要将皮肤包内的资源加载进app内，然后我们才能使用皮肤包中的资源。Android中资源的加载都是通过AssetManager来完成的，所有我们加载皮肤包也需要用到AssetManager。

  1. public void loadSkin(String path) {
  2.         try {
  3.                 //反射创建AssetManager
  4.                 AssetManager manager = AssetManager.class.newInstance();
  5.                 // 资料路径设置 目录或者压缩包
  6.                 Method addAssetPath = manager.getClass().getMethod("addAssetPath", String.class);
  7.                 addAssetPath.invoke(manager, path);//1
  8.                 //app Resources对象
  9.                 Resources appResources = this.application.getResources();
  10.                 //皮肤包 Resources对象
  11.                 Resources skinResources = new Resources(manager, 
  12.                         appResources.getDisplayMetrics(), appResources.getConfiguration());//2
  13.  
  14.                 //记录
  15.                 SkinPreference.getInstance().setSkin(path);
  16.                 //获取外部Apk（皮肤包） 包名
  17.                 PackageManager packageManager = this.application.getPackageManager();
  18.                 PackageInfo packageArchiveInfo = packageManager.getPackageArchiveInfo(path, PackageManager.GET_ACTIVITIES);
  19.                 String packageName = packageArchiveInfo.packageName;
  20.                 
  21.                 SkinResources.getInstance().applySkin(skinResources,packageName);//3
  22.             } catch (Exception e) {
  23.                 e.printStackTrace();
  24.             }
  25.         
  26.     }

通过反射创建出AssetManager对象之后，反射调用AssetManager的addAssetPath方法将皮肤包的资源加载进apk。

注释2处根据刚刚创建的AssetManager对创建出皮肤包对应的Resources对象。在注释3处将皮肤包的Resources对象和皮肤包的包名保存到SkinResources中。至此我们已经将皮肤包资源加载进app中，后续可以通过皮肤包的Resources对象获取资源信息。

获取需要换肤的控件（View）

在换肤之前首先要确定哪些控件（View）是需要换肤的，那么我们如何采集这些需要换肤的控件？

看过源码的应该都清楚，Activity是依靠LayoutInflate来解析xml布局的，我们先来看一下LayoutInflate解析xml布局的核心方法实现：

  1. View createViewFromTag(View parent, String name, Context context, AttributeSet attrs,
  2.             boolean ignoreThemeAttr) {
  3.  
  4.         。。。
  5.  
  6.         
  7.             View view;
  8.             if (mFactory2 != null) {//1
  9.                 view = mFactory2.onCreateView(parent, name, context, attrs);
  10.             } else if (mFactory != null) {
  11.                 view = mFactory.onCreateView(name, context, attrs);
  12.             } else {
  13.                 view = null;
  14.             }
  15.            
  16.             if (view == null && mPrivateFactory != null) {
  17.                 view = mPrivateFactory.onCreateView(parent, name, context, attrs);
  18.             }
  19.  
  20.  
  21.  
  22.             if (view == null) {//2 mFactory2为null的情况下view也为null
  23.  
  24.                 final Object lastContext = mConstructorArgs[0];
  25.                 mConstructorArgs[0] = context;
  26.                 try {
  27.                     if (-1 == name.indexOf('.')) {
  28.                         view = onCreateView(parent, name, attrs);
  29.                     } else {
  30.                         view = createView(name, null, attrs);
  31.                     }
  32.                 } finally {
  33.                     mConstructorArgs[0] = lastContext;
  34.                 }
  35.             }
  36.  
  37.             return view;
  38.         
  39.     }

 

createViewFromTag方法负责将xml布局中的控件创建成view对象。正常情况下mFactory2为null，代码会走到注释2处创建view，view创建出来之后就可以填充到activity上显示给用户。

mFactory2是一个Factory2类型的接口，自定义一个类通过实现这个接口重写onCreateView方法我们就可以接管xml布局中View的创建，这样我们就能采集到需要换肤的控件。

  1. public View onCreateView(View parent, String name, Context context, AttributeSet attrs) {
  2.         
  3.         View view = createViewFromTag(name, context, attrs);
  4.         
  5.         if(null ==  view){
  6.             view = createView(name, context, attrs);
  7.         }
  8.  
  9.         //1.筛选符合属性View
  10.         skinAttribute.load(view, attrs);
  11.  
  12.         return view;
  13.     }

完成xml布局View的创建之后，通过调用SkinAttribute.load方法来采集单个view当中可以用于换肤的属性，比如background、textColor等。SkinAttribute是自定义用于采集控件属性和换肤操作的属性处理类。看一下SkinAttribute.load方法的实现：

  1. public void load(View view, AttributeSet attrs) {
  2.         List<SkinPain> skinPains = new ArrayList<>();
  3.         for (int i = 0; i < attrs.getAttributeCount(); i++) {
  4.             //获取属性名字
  5.             String attributeName = attrs.getAttributeName(i);
  6.  
  7.             //1.mAttribute是用来存储属性的集合
  8.             if (mAttributes.contains(attributeName)) {
  9.                 //获取属性对应的值
  10.                 String attributeValue = attrs.getAttributeValue(i);
  11.                 if (attributeValue.startsWith("#")) {
  12.                     continue;
  13.                 }
  14.  
  15.                 int resId;
  16.                 //判断前缀字符串 是否是"?"
  17.                 //attributeValue  = "?2130903043"
  18.                 if (attributeValue.startsWith("?")) {  //系统属性值
  19.                     //字符串的子字符串  从下标 1 位置开始
  20.                     int attrId = Integer.parseInt(attributeValue.substring(1));
  21.                     resId = SkinThemeUtils.getResId(view.getContext(), new int[]{attrId})[0];
  22.                 } else {
  23.                     //@1234564
  24.                     resId = Integer.parseInt(attributeValue.substring(1));
  25.                 }
  26.                 if (resId != 0) {                
  27.                     SkinPain skinPain = new SkinPain(attributeName, resId);//2
  28.                     skinPains.add(skinPain);
  29.                 }
  30.             }
  31.         }
  32.         if (!skinPains.isEmpty() || view instanceof TextView || view instanceof SkinViewSupport) {
  33.  
  34.             
  35.             SkinView skinView = new SkinView(view, skinPains);//3
  36.            
  37.             skinView.applySkin(mTypeface);
  38.             
  39.             skinViews.add(skinView);//4
  40.         }
  41.     }

load方法主要做的事是解析出控件（View）所对应属性的属性名和属性值在R文件中对应的id，并将控件与其对应的所有属性绑定在一起，然后将控件（View）保存在一个集合中。

注释1处的mAttribute是用来存储所有符合换肤条件的属性的集合。在xml中定义的每个控件（View）都会有 很多属性，但不是每个属性都需要换肤，比如控件的width和height。为了减少不必要的性能开销我们只对符合条件的属性（background、textColor等）进行操作。

所有的属性经过编译之后都会以int类型的值保存在R文件中，比如textColor对应的颜色值可能会被编译成123456。通过attrs.getAttributeValue()获取到的值会加一个前缀，所有获取到的值可能是@123456、#123456和?123456这几种类型。所以需要根据不同的前缀做出不同处理。

在获取到属性值在R文件中对应的id之后会在注释2处将属性名与id保存在SkinPain类中，并将SkinPain对象保存在skinPains集合当中。注释3是将控件与skinPains（保存所有符合条件的属性和属性值的集合）绑定在SkinView中，然后在注释4处将SkinView保存在集合当中。

替换皮肤

完成前两个步骤之后，我们就可以进行替换皮肤的操作。前面我们已经将所有可以用于换肤的控件（View）和其对应的属性保存了起来，在替换皮肤的时候只需要遍历处所有的控件然后对其符合条件的属性以此替换成皮肤包中的值就可以了。

  1. /**
  2.      * 换皮肤
  3.      */
  4.     public void applySkin() {
  5.         for (SkinView mSkinView : skinViews) {
  6.             mSkinView.applySkin(mTypeface);
  7.         }
  8.     }

前面已经说过，SkinView中保存了控件和其对应的所有符合条件的属性。遍历出SkinView对象后再调用其的applySkin方法。来看一下这个方法的具体实现：

  1.  public void applySkin(Typeface typeface) {
  2.             
  3.             for (SkinPain skinPair : skinPains) {
  4.                 Drawable left = null, top = null, right = null, bottom = null;
  5.                 switch (skinPair.attributeName) {
  6.                     case "background":
  7.                         Object background = SkinResources.getInstance().getBackground(
  8.                                 skinPair.resId);//1
  9.                         //Color
  10.                         if (background instanceof Integer) {
  11.                             view.setBackgroundColor((Integer) background);
  12.                         } else {
  13.                             ViewCompat.setBackground(view, (Drawable) background);
  14.                         }
  15.                     
  16.                         break;
  17.                     case "src":
  18.                         background = SkinResources.getInstance().getBackground(skinPair
  19.                                 .resId);
  20.                         if (background instanceof Integer) {
  21.                             ((ImageView) view).setImageDrawable(new ColorDrawable((Integer)
  22.                                     background));
  23.                         } else {
  24.                             ((ImageView) view).setImageDrawable((Drawable) background);
  25.                         }
  26.                         break;
  27.                     case "textColor":
  28.                         ((TextView) view).setTextColor(SkinResources.getInstance().getColorStateList
  29.                                 (skinPair.resId));
  30.                         break;
  31.                     case "drawableLeft":
  32.                         left = SkinResources.getInstance().getDrawable(skinPair.resId);
  33.                         break;
  34.                     case "drawableTop":
  35.                         top = SkinResources.getInstance().getDrawable(skinPair.resId);
  36.                         break;
  37.                     case "drawableRight":
  38.                         right = SkinResources.getInstance().getDrawable(skinPair.resId);
  39.                         break;
  40.                     case "drawableBottom":
  41.                         bottom = SkinResources.getInstance().getDrawable(skinPair.resId);
  42.                         break;
  43.                     case "skinTypeface" :
  44.                         applyTypeface(SkinResources.getInstance().getTypeface(skinPair.resId));
  45.                         break;
  46.                     default:
  47.                         break;
  48.                 }
  49.                 if (null != left || null != right || null != top || null != bottom) {
  50.                     ((TextView) view).setCompoundDrawablesWithIntrinsicBounds(left, top, right,
  51.                             bottom);
  52.                 }
  53.             }
  54.         }

可以看到，这个方法主要做的事情是遍历出控件的属性，然后根据xml中定义的属性值id取出皮肤包中对应的属性值id，最后再设置到控件（View）上，至此就完成了皮肤的替换。

以注释1处的代码为例子来看一下是如何做到根据xml中定义的属性值id（编译后从R文件中取出的id值）取出皮肤包中对应的属性值id。先看一下SkinResources的getBackground方法做了什么事：

  1. /**
  2.      * 可能是Color 也可能是drawable
  3.      *
  4.      * @return
  5.      */
  6.     public Object getBackground(int resId) {
  7.         String resourceTypeName = mAppResources.getResourceTypeName(resId);
  8.  
  9.         if (resourceTypeName.equals("color")) {//1
  10.             return getColor(resId);
  11.         } else {
  12.             // drawable
  13.             return getDrawable(resId);
  14.         }
  15.     }

background属性对应的值可能是color也可能是drawable，所有在注释1处需要做出区分。先看一下getColor方法的实现：

  1. public int getColor(int resId) {
  2.         
  3.         int skinId = getIdentifier(resId);//1
  4.         //skinId为0说明在皮肤包中没有对应的资源
  5.         if (skinId == 0) {
  6.             //返回app中定义的属性值
  7.             return mAppResources.getColor(resId);
  8.         }
  9.            //返回皮肤包中的属性值
  10.         return mSkinResources.getColor(skinId);
  11.     }

核心逻辑是注释1处的getIdentifier方法：

  1. public int getIdentifier(int resId) {
  2.         
  3.         //例子：R.drawable.ic_launcher 获取到的resName: ic_launcher resType: drawable
  4.         String resName = mAppResources.getResourceEntryName(resId);//1   
  5.         String resType = mAppResources.getResourceTypeName(resId);//2
  6.         int skinId = mSkinResources.getIdentifier(resName, resType, mSkinPkgName);//3
  7.         return skinId;
  8.     }

注释1处逻辑是根据xml中定义的属性值id（编译后从R文件中取出的id值）来获取xml中定义的属性值的名字（编译之前在xml中定义的名字，比如R.drawable.ic_launcher），注释2处是获取属性值对应的类型，比如R.drawable.ic_launcher对应的类型是drawable。取出resName和resType后，就可以在注释3处从皮肤包的Resources对象中拿到下载的皮肤包中同一个属性资源的id值。由此可以看出，皮肤包中属性资源名称一定要与app中属性资源名称一致。比如需要替换一张图片，在app中图片名称为ic_launcher.png，那么在皮肤包对应文件夹下的图片也要命名为ic_launcher.png才能完成替换。

拿到皮肤包中的属性值id之后，再将id设置到控件上就能完成替换。

皮肤包

皮肤包本质上也是一个apk文件。但是这个apk不包含任何代码，只包含需要替换的资源。需要注意的是，只有在皮肤包中与宿主app中名字完全一样的资源才能用于替换，否则无效。

总结

本文针对动态换肤的基本原理做出了解析，核心思想就是文中讲解的三个步骤，只要记住这三个步骤就能很容易实现皮肤主题的动态更换

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/盐析白兔/article/detail/86921
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号