Android之实现apk插件方式换肤

换肤思路：

1.什么时候换肤？

xml加载前换肤，如果xml加载后换肤，用户将会看见换肤之前的色彩，用户体验不好。

2.皮肤是什么？

皮肤就是apk，是一个资源包，包含了颜色、图片等。

3.什么样的控件应该进行换肤？

包含背景图片的控件，例如textView文字颜色。

4.皮肤与已安装的资源如何匹配？

资源名字匹配

效果展示：

步骤：

1.xml加载前换肤，意味着需要将所需要换肤的控件收集起来。因此要监听xml加载的过程。

public class BaseActivity extends Activity {

    SkinFactory skinFactory;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState){
        super.onCreate(savedInstanceState);

        //监听xml生成的过程
        skinFactory = new SkinFactory();
        LayoutInflaterCompat.setFactory(getLayoutInflater(),skinFactory);
    }
}

 

2.需要换肤的控件收集到一个容器中并且不更改自己的逻辑直接换肤（例如：不用在每个需要换肤的空间里面加上： “ app:...... ”  自定义控件属性）

思考：

（1）安装的apk的id与皮肤id是否一样？

（2）图片的资源、颜色资源都对应R自动生成的id

（3）皮肤包的资源id、R文件的资源id以及app里R文件的资源的id是否是一样的？——是不一样的

 

3.一个activity有多个控件（SkinView） 一个控件对应多个换肤属性（SkinItem）

SkinItem来封装这些值：

• attrName-属性名（background）
• attrValue-属性值id 十六进制（@color/colorPrimaryDark）
• attrType--类型（color）
• Id(R文件的id)

class SkinItem{
        // attrName   background
        String attrName;

        int refId;
        // 资源名字  @color/colorPrimaryDark
        String attrValue;
        //  drawable color
        String attrType;

        public SkinItem(String attrName, int refId, String attrValue, String attrType) {
            this.attrName = attrName;
            this.refId = refId;
            this.attrValue = attrValue;
            this.attrType = attrType;
        }

        public String getAttrName() {
            return attrName;
        }

        public int getRefId() {
            return refId;
        }

        public String getAttrValue() {
            return attrValue;
        }

        public String getAttrType() {
            return attrType;
        }
    }

SkinView：

class SkinView{
        private View view;
        private List<SkinItem> list;  //收集需要换肤的集合

        public SkinView(View view, List<SkinItem> list) {
            this.view = view;
            this.list = list;
        }
    }

收集控件：

SkinFactory：

package com.example.apk_demo2;

import android.content.Context;
import android.util.AttributeSet;
import android.util.Log;
import android.view.View;
import android.widget.TextView;

import androidx.core.view.LayoutInflaterFactory;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.List;

// LayoutInflaterFactory接口
public class SkinFactory implements LayoutInflaterFactory {

    private List<SkinView> cacheList = new ArrayList<>();
    private static final String TAG = "david" ;
    //补充系统控件的包名
    private static final String[] prefixList={"android.widget.","android.view.","android.webkit."};   // 包名，android.webkit为浏览器包，v4、v7包都可以认为是自定义控件


    /**
     * xml生成的时候会回调这个方法，返回值为view
     * @param parent
     * @param name   控件名
     * @param context
     * @param attrs
     * @return
     */
    @Override
    public View onCreateView(View parent, String name, Context context, AttributeSet attrs) {
        Log.i(TAG,"onCreateView:"+name);
        // 需要换肤的控件收集到一个容器中

        View view = null;  //初始化view
        // 判断自定义与非自定义控件(自定义控件打印时是全报名)
        if(name.contains(".")){
            // 自定义控件
            view = createView(context,attrs,name);  // 获得自定义控件的实例化对象
        }else{
            // 系统控件
            for(String pre : prefixList){
                view = createView(context,attrs,pre + name);
//                Log.i(TAG,"创建view："+view);
                if(view != null){
                    // 找对包名，实例化成功
                    // 解析view
                    //如果不为空则说明实例化成功，找对了包名
                    break;
                    //找对了可以退出循环
                }
            }
        }

        if(view != null){
            //view不为空则说明已经拿到了这个view，这时候开始解析这个view，判断哪些控件需要换肤
            parseSkinView(context,attrs,view);
            //这个方法用于收集需要换肤的view
        }
        return view;
    }


    /**
     * 收集需要换肤的控件
     * @param context
     * @param attrs
     * @param view
     */
    private void parseSkinView(Context context, AttributeSet attrs, View view) {
        List<SkinItem> list = new ArrayList<>();  //将需要换肤的控件添加到这个集合里面
        for(int i = 0; i < attrs.getAttributeCount(); i++){
            //做一个java bean来封装这些值：
            // attrName-属性名（background）、attrValue-属性值id 十六进制（@color/colorPrimaryDark）、attrType--类型（color）、Id(R文件的id)
            // attrName == background等 时 (属性名)
            String attrName = attrs.getAttributeName(i);
            // 获得控件的id值，eg：@color/colorPrimaryDark  (属性值)
            String attrValue = attrs.getAttributeValue(i);

            if(attrName.equals("background") || attrName.equals("textColor")){
                // 需要换肤的控件——具备换肤的潜力，并不是一定需要换肤
//                Log.i(TAG,"parseSkinView:"+attrName);
                int id = Integer.parseInt(attrValue.substring(1)); //引用类型

                String entry_name = context.getResources().getResourceEntryName(id);

                String typeNme = context.getResources().getResourceTypeName(id);

                SkinItem skinItem = new SkinItem(attrName,id,entry_name,typeNme);
                list.add(skinItem);
            }
        }

        if(!list.isEmpty()){
            SkinView skinView = new SkinView(view,list);
            cacheList.add(skinView);
            //应用换肤  xml加载过程中换肤
            skinView.apply();

        }
    }

    //点击应用
    public void apply() {
        for(SkinView skinView : cacheList){
            skinView.apply();
        }
    }

    public void remove() {
        for (SkinView skinView : cacheList){
            //清空集合
//            cacheList.removeAll();
        }
    }

    /**
     * 一个activity有多个控件
     * 一个控件对应多个换肤属性
     */
    class SkinView{
        private View view;
        private List<SkinItem> list;  //收集需要换肤的集合

        public SkinView(View view, List<SkinItem> list) {
            Log.i(TAG,"view123:"+view);
            this.view = view;
            this.list = list;
        }

        //应用换肤
        public void apply(){
            //循环需要换肤的SkinItem,应用所有的换肤
            for(SkinItem skinItem : list){
                Log.i(TAG,"skinItem:"+skinItem.getAttrName());
                if("textColor".equals(skinItem.getAttrName())){
                    Log.i(TAG,"view_1:"+view);
                    //if (!SkinManager.getInstance().getSkinPackage().equals("")){
                    //最开始的时候系统没有资源文件，所以当有没有都运行这行代码是，系统没有获得颜色id，因此为灰色。
                    //所以得加一个判断，在没有换肤之前采用系统默认颜色
                    if (!SkinManager.getInstance().getSkinPackage().equals("")) {
                        ((TextView) view).setTextColor(SkinManager.getInstance().getColor(skinItem.getRefId()));
                    }
                }
                if("background".equals(skinItem.getAttrName())){
                    if("color".equals(skinItem.getAttrType())){
                        //直接这样设置，没有任何换肤功能，这样加载就是本身默认颜色
//                        view.setBackgroundColor(skinItem.getRefId());

                        if (!SkinManager.getInstance().getSkinPackage().equals("")){
                            view.setBackgroundColor(SkinManager.getInstance().getColor(skinItem.getRefId()));
                        }
                    }else if("drawable".equals(skinItem.getAttrType())){
                        if(!SkinManager.getInstance().getSkinPackage().equals("")){
                            view.setBackgroundDrawable(SkinManager.getInstance().getDrawable(skinItem.getRefId()));
                        }
                    }

                }
            }
        }
    }

    /**
     * 封装值
     */
    class SkinItem{
        // attrName   background
        String attrName;
        //R里面的id
        int refId;
        // 资源名字  @color/colorPrimaryDark
        String attrValue;
        //  drawable color
        String attrType;

        public SkinItem(String attrName, int refId, String attrValue, String attrType) {
            this.attrName = attrName;
            this.refId = refId;
            this.attrValue = attrValue;
            this.attrType = attrType;
        }

        public String getAttrName() {
            return attrName;
        }

        public int getRefId() {
            return refId;
        }

        public String getAttrValue() {
            return attrValue;
        }

        public String getAttrType() {
            return attrType;
        }
    }

    /**
     * 加载自定义控件
     * @param context
     * @param attrs
     * @param name
     * @return
     */
    private View createView(Context context, AttributeSet attrs, String name) {
        try{
            //运用反射拿到自定义控件的构造方法,没有性能损耗
            Class viewClazz = context.getClassLoader().loadClass(name);
            Constructor<? extends View> constructor = viewClazz.getConstructor(new Class[]{Context.class,AttributeSet.class});  //通过反射获得自定义控件的构造方法
            return constructor.newInstance(context,attrs);  //通过反射而来的构造函数来实例化对象
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

        return null;
    }
}

4.收集完毕后，应用换肤 （xml加载过程中换肤）

 

创建SkinManager去获得皮肤apk，app通过SkinManager获取皮肤apk

（1）加载皮肤包（loadSkin）：通过反射获得AsserManager的addAssetpath()方法，再通过这个方法获得皮肤apk，从而实例化skinResource；再通过PackageManager.getPackageArchiveInfo(path,PackageManager.GET_ACTIVITIES).packageName;获得皮肤包名

（2）获取颜色（getColor）：判断skinResource是否为空；拿到res的名字，eg：通过“colorAccent”去寻找id

 

SkinManager：

package com.example.apk_demo2;

import android.content.Context;
import android.content.pm.PackageManager;
import android.content.res.AssetManager;
import android.content.res.Resources;
import android.graphics.drawable.Drawable;
import android.util.Log;

import androidx.core.content.ContextCompat;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class SkinManager {
    private static final String TAG = "yu" ;
    //代表外置卡皮肤app的resource
    private Resources skinResource;

    private Context context;
    //皮肤apk包名
    private String skinPackage;
    // 初始化context
    public void init(Context context){
        // 一定用getApplicationContext（）方法获得context，其是一定存在的；（从内存角度上引用全局上下文）
        // 如果是靠参数context，有可能是不存在的（如果activity被销毁了）
        this.context = context.getApplicationContext();
    }
    private static final SkinManager ourInstance = new SkinManager();

    public static SkinManager getInstance(){ return ourInstance; }

    /**
     *加载皮肤包
     * @param path 路径
     */
    public void loadSkin(String path){

        // Resources(AssetManager assets, DisplayMetrics metrics, Configuration config)
        // 实例化AssetManager (@hide)AssetManager()是一个系统保护函数，需要通过反射来调用
        try{
            AssetManager assetManager = AssetManager.class.newInstance();
            //通过assetManager.addAssetPath(""); 方法获得皮肤apk  需反射
            Method addAssetPath = assetManager.getClass().getMethod("addAssetPath",String.class);
            addAssetPath.invoke(assetManager,path);

            skinResource = new Resources(assetManager,context.getResources().getDisplayMetrics(),
                    context.getResources().getConfiguration());// 实例化skonResource
            // skinResource.getColor(R.color.colorAccent);通过这样就可以获得资源文件的皮肤设置
            PackageManager packageManager = context.getPackageManager();  //包管理器
            //获得皮肤包名
            Log.i(TAG,"路径"+path);
//            Log.i(TAG,"上下文"+context);
            Log.i(TAG,"上下文"+context);
            skinPackage = packageManager.getPackageArchiveInfo(path,PackageManager.GET_ACTIVITIES).packageName;
            Log.i(TAG,"包名"+skinPackage);
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
       } catch (Exception e){
            Log.i(TAG,"上下文"+context);
            Log.i(TAG,"包名"+skinPackage);
        }

    }

    private SkinManager(){ }

    /**
     *
     * @param resId
     * @return
     */
    public int getColor(int resId){
        //判断有没有皮肤包
        if(skinResource == null){
            return resId;
        }

        //能否通过这个方法获得 int skinId = skinResource.getColor(resId);
        //不能，因为R文件的id与皮肤apk的id不一样
        //eg：获得colorAccent
        String resName = context.getResources().getResourceEntryName(resId);
        // public int getIdentifier(String name, String defType, String defPackage)
        int skinId = skinResource.getIdentifier(resName,"color",skinPackage);
        if(skinId == 0){
            //如果不合法，返回默认xml
            return resId;
        }
//        Log.i(TAG,"resId:"+resId);
//        Log.i(TAG,"skinResource:"+skinResource.getColor(skinId));
        return skinResource.getColor(skinId);
    }


    /**
     * 判断有无资源可以加载，如没有就用初始化皮肤
     * @return
     */
    public Object getSkinPackage() {
        if(skinPackage == null){return "";}
        return "ok";
    }

    public Drawable getDrawable(int refId) {
        if(skinResource == null){
            return ContextCompat.getDrawable(context,refId);
        }
        String resName = context.getResources().getResourceEntryName(refId);
        int skinId = skinResource.getIdentifier(resName,"drawable",skinPackage);
        if(skinId == 0){
            //如果不合法，返回默认xml
            return ContextCompat.getDrawable(context,refId);
        }
        return skinResource.getDrawable(refId);
    }
}

 总结：

   从学习Android到现在已经过去了一个月，学习最初感觉还好，谁知遇到了换肤这一大难题。

   网上资料非常多，却很难找到一个适合我们的。非常幸运的是，虽然这其中不乏走了很多弯路，但对亏朋友们之间的互相帮助，互相共享学习资料，最后终于做了出来。在自己的项目中也遇到过许许多多的bug需要调试，保持头脑清晰是必须的啦~

   想要跟深入学习的同学，可以去学习github上的开源框架Android-Skin-Loader。这个框架的换肤机制使用动态加载机制前去加载皮肤内容，无需重启即可实时更换。这个框架也可以直接拿来使用，不过个人认为身为一个人程序员还是需要了解好的项目的基本原理的。

  

本章涉及知识，想要了解的朋友可以去我的其他博客：Android资源管理利器Resources和AssetManager