【Android】换肤技术讲解

主题，是许多APP必备的一个功能，用户可以根据自己的喜好，来切换具有个性的主题，同时能让我们的APP更具把玩性。这篇博文就来聊聊皮肤切换的原理，效果图如下：

这里为了便于理解，在换肤的时候，只是简单切换背景图片，文件颜色和组件背景色
这篇博文将用到一下知识点：

• classLoader：实例化控件
• PackageManager：拿到插件的包信息
• 反射：拿到插件的resource
• LayoutInflaterFactory：解析xml

一、思路

首先通过LayoutInflaterCompat的setFactory方法设置自定义的LayoutInflaterFactory，并实现onCreateView，我们可以在该方法中解析xml的每一个节点(即view )，先通过组件名创建对应的view ，再遍历每一个view的 attrs属性和值，并以map保存，以便后续调用（即皮肤资源的切换）。
我们知道，在Android中是通过resource来获取资源的，若能获取插件的resource对象，那么就可以获取其图片等资源，到达换肤的目的，说得简单点，换肤就是换resource和packName。
在拿到插件的resource之后，就可以通过resource Id 来给每一个view设置其属性（如background）
当然，道理想必大家都懂，show me your code ~

二、偷梁换柱，换掉应用的LayoutInflaterFactory

我们需要持切换皮肤的组件，因此创建SkinFactory类实现LayoutInflaterFactory接口，并实现该接口中的方法onCreateView

 /**
     * Hook you can supply that is called when inflating from a LayoutInflater.
     * You can use this to customize the tag names available in your XML
     * layout files.
     *
     * @param parent The parent that the created view will be placed
     * in; <em>note that this may be null</em>.
     * @param name Tag name to be inflated.
     * @param context The context the view is being created in.
     * @param attrs Inflation attributes as specified in XML file.
     *
     * @return View Newly created view. Return null for the default
     *         behavior.
     */
    View onCreateView(View parent, String name, Context context, AttributeSet attrs);

显然这是一个hook， 执行LayoutInflater.inflate()的时候调用，如上所述，我们可以通过该方法获取每一个节点的属性和值（即资源id），资源类型（drawable 、color 等）。先简单介绍这四个参数：

• parent：即当前节点的父类节点，可能为null
• name :节点名，列如 TextView
• context ：该执行过程的上下文
• attrs：该节点的属性集合，例如 background属性

那么，我们怎么通过节点来创建对应的组件对象呢？我们都知道在android.widget包下的Button在布局文件中的节点名只有Button，并不是完整的包路径，例如

    <Button
        android:layout_width="match_parent"
        android:layout_height="wrap_content"/>

以及android.view包下的SurfaceView等等。

<SurfaceView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content" />

想必读者明白列举以上的用意了，对，我们需要先对获取到的节点名字进行处理，判断获取到的节点名是系统组件，还是自定义组件，从而构建完整的class name 。如下代码

    private static final String[] preFixList = {
            "android.widget.",
            "android.view.",
            "android.webkit."
    };  //这些都是系统组件
    @Override
    public View onCreateView(View parent, String name, Context context, AttributeSet attrs) {
        View view = null;
        if (name.indexOf(".") == -1) {
            //系统控件
            for (String prix : preFixList) {
                view = createView(context, attrs, prix + name);
                if (null != view) {
                    break;
                }
            }
        } else {
            //自定义控件
            view = createView(context, attrs, name);
        }
        if (null != view) {
            parseSkinView(view, context, attrs);
        }
        return view;
    }

这里需要我们返回一个view，即该组件对应的view，既然能拿到组件对应的class name，那就好办，直接通过classloader去load一个class即可

    //创建一个view
    private View createView(Context context, AttributeSet attrs, String name) {
        try {
            //实例化一个控件
            Class clarr = context.getClassLoader().loadClass(name);
            Constructor<? extends View> constructor =
                    clarr.getConstructor(new Class[]{Context.class, AttributeSet.class});
            constructor.setAccessible(true);
            return constructor.newInstance(context, attrs);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
        return null;
    }

在拿到该控件后，需要遍历其需要替换值的属性，例如background，存放在list集合中。

    //找到需要换肤的控件
    private void parseSkinView(View view, Context context, AttributeSet attrs) {
        List<SkinInterface> attrList = new ArrayList<>();
        for (int i = 0; i < attrs.getAttributeCount(); i++) {
            //拿到属性名
            String attrName = attrs.getAttributeName(i);
            String attrValue = attrs.getAttributeValue(i);
            int id =-1;
            String entryName ="";

            String typeName ="";

            SkinInterface skinInterface = null ;

            switch (attrName) {
                case "background"://需要进行换肤
                    id = Integer.parseInt(attrValue.substring(1));
                    entryName = context.getResources().getResourceEntryName(id);
                    typeName = context.getResources().getResourceTypeName(id);
                    skinInterface = new BackgroundSkin(attrName,id,entryName,typeName);
                    break;
                case "textColor":
                    id = Integer.parseInt(attrValue.substring(1));
                    entryName = context.getResources().getResourceEntryName(id);
                    typeName = context.getResources().getResourceTypeName(id);
                    skinInterface = new TextSkin(attrName,id,entryName,typeName);
                    break;
                default:
                    break;
            }
            if(null != skinInterface){
                attrList.add(skinInterface);
            }

        }
        SkinItem skinItem = new SkinItem(attrList,view);
        map.put(view,skinItem);
        //在这里进行应用，判断是皮肤资源还是本地资源
        skinItem.apply();
    }

为了方便属性的替换，这里用SkinItem对象来持有view和view对应的属性集合list。

  class SkinItem {
        public SkinItem(List<SkinInterface> attrList, View view) {
            this.attrList = attrList;
            this.view = view;
        }

        public List<SkinInterface> attrList;
        public View view;
        //更新组件资源，调用skinInterface 的实现类
        public void apply() {
            for (SkinInterface skinInterface : attrList) {
                skinInterface.apply(view);
            }
        }
    }

在进行皮肤切换的时候，有设置background的，有设置textColor的，但他们都需要以下参数

• 组件的属性名称，例如 background
• 组件引用资源的id (integer 类型)
• 组件引用资源的名称，例如 app_icon
• 组件引用资源的类型，例如 drawable

所以我们这里可以抽象出一个类SkinInterface，所有需要换肤的实现类都继承该类

public abstract class SkinInterface {
    String attrName;
    int refId = 0;
    String attrValueName;
    String attrType;
    public SkinInterface(String attrName, int refId, String attrValueName, String attrType) {
        this.attrName = attrName;
        this.refId = refId;
        this.attrType = attrType;
        this.attrValueName = attrValueName;
    }
   /**
     * 执行具体切换工作 
     * @param view 作用对象
     */
    public abstract void apply(View view);
}

列如SkinInterface的继承类 TextSkin

public class TextSkin extends SkinInterface {
    public TextSkin(String attrName, int refId, String attrValueName, String attrType) {
        super(attrName, refId, attrValueName, attrType);
    }

    @Override
    public void apply(View view) {
        if(view instanceof TextView){
            TextView textView = (TextView)view ;
            textView.setTextColor(SkinManager.getInstance().getColor(refId));
        }
    }
}

还有BackgroundSkin类的实现

public class BackgroundSkin extends SkinInterface{
    private static final String TAG = "BackgroundSkin";

    public BackgroundSkin(String attrName, int refId, String attrValueName, String attrType) {
        super(attrName, refId, attrValueName, attrType);
    }

    @Override
    public void apply(View view) {
        if("color".equals(attrType)){
            view.setBackgroundColor(SkinManager.getInstance().getColor(refId));
        }else if("drawable".equals(attrType)){
            view.setBackgroundDrawable(SkinManager.getInstance().getDrawable(refId));
        }
    }
}

最后在SkinFactory中提供一个更新的方法，来实现资源的替换工作

   public void upDate() {
        for(View view : map.keySet()){
            if(null == view){
                continue;
            }
            map.get(view).apply();
        }
    }

总之一句话，SkinFactory 负责创建view并获取其属性名和值，以及后续的切换资源工作

三、resource的中心枢纽——SkinManager

上一节在讲到皮肤切换具体实现类的时候，涉及到SkinManager对象，他就是resource的主要负责人，负责返回组件所需要的资源。
回想一下，我们是如何在activity中获取资源的？是不是通过getResources().get……方法？显然我们需要获取插件的resource对象，才能拿到插件里的资源，先来看看resource的构造函数

  @Deprecated
    public Resources(AssetManager assets, DisplayMetrics metrics, Configuration config) {
        this(null);
        mResourcesImpl = new ResourcesImpl(assets, metrics, config, new DisplayAdjustments());
    }

这里需要三个参数？有什么办法，那就给他咯~
首先看AssetManager ，他有两个构造函数，一个是hide的，一个是private的，均不能直接new 出来，这个好办~~

AssetManager  assetManager = AssetManager.class.newInstance();

AssetManager 有一个addAssetPath方法可以通过文件路径来加载资源，但也是hide状态，怎么办？easy ！反射啦~~

 Method method = AssetManager.class.getMethod("addAssetPath", String.class);
 method.invoke(assetManager, path);

这样我们就顺利滴拿到了插件的AssetManager对象，剩下的两个参数就直接使用宿主项目上下文的resource的默认值即可

Resources resources = context.getResources();
Resources  skinResource = new Resources(assetManager, resources.getDisplayMetrics(),
                    resources.getConfiguration());

于是乎，就这样顺利的拿到了插件的resource对象，但是我们还需要获取插件的包名

PackageManager packageManager = context.getPackageManager();
PackageInfo packageInfo = packageManager.getPackageArchiveInfo(path, PackageManager.GET_ACTIVITIES);
String skinPackage = packageInfo.packageName;

获取资源不是通过resource吗，为什么还需要插件的packageName 呢？接着往下看

在获取resource对象后，就可以提供接口给其他类获取资源了，例如获取color

 public int getColor(int refId) {
        if (null == skinResource) {
            return refId;
        }
        String resName = context.getResources().getResourceEntryName(refId);
        int realId = skinResource.getIdentifier(resName, "color", skinPackage);
        int color;
        if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.M) {
            color = skinResource.getColor(realId, null);
        } else {
            color = skinResource.getColor(realId);
        }
        return color;
    }

看到这里，想必大家知道packageName的用处了吧？就是获取插件同资源名对应的id，然后再通过插件的id 获取对应的资源，获取drawable同理

   public Drawable getDrawable(@DrawableRes int refId) {
        Drawable drawable = ContextCompat.getDrawable(context, refId);
        if (null == skinResource) {
            return drawable;
        }
        String resName = context.getResources().getResourceEntryName(refId);
        int resId = skinResource.getIdentifier(resName, "drawable", skinPackage);
        return skinResource.getDrawable(resId);
    }

这样SkinManager 就创建完成了

四、创建基类

大家说得好，万物基于…..基类~~，这里我们需要创建一个抽象的SkinBaseActivity，凡是需要进行换肤的activity都要继承该类

public abstract class SkinBaseActivity extends Activity {
    private SkinFactory skinFactory ;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        skinFactory = new SkinFactory();
        //设置当前activity解析xml的工厂类
        LayoutInflaterCompat.setFactory(getLayoutInflater(),skinFactory );//LayoutInflaterFactory
    }
    //手动更换皮肤
    public void upDate(){
        skinFactory.upDate();
    }

}

然后在MainActivity中继承该类，并将SkinManager初始化

public class MainActivity extends SkinBaseActivity {

    private static final String TAG = "MainActivity ";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        SkinManager.getInstance().init(this);
        setContentView(R.layout.activity_main);
    }
}

在进行皮肤切换的时候执行（要确保file的路径正确，否则会出错）

   public void change(View view) {
        String path = new File(Environment.getExternalStorageDirectory(), "skin.apk").getAbsolutePath();
        SkinManager.getInstance().loadSkin(path);
        upDate();
    }

这里要注意加上权限，并到权限管理中心给该应用读写权限

    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />

那么，如何恢复默认皮肤呢？很简单，将SKinmanager中的resource，packageName替换为当前应用的即可

   public void back(View view) {
        SkinManager.getInstance().setSkinResource(getResources());
        upDate();
    }

五、run it！

创建一个module，按照宿主apk的资源名重新建立新的资源即可，选择module，打包成apk，再将apk copy到手机的根目录下，在as中切换到宿主apk，将宿主项目打包到手机，即可
至此，换肤技术就讲解完毕
源码下载