如何应对Android面试官-＞布局原理与xml解析，手写插件化换肤框架核心实现(下)

老A说

已于 2024-01-03 12:56:35 修改

阅读量870

点赞数 19

文章标签： android xml java

于 2024-01-03 12:55:41 首次发布

本文链接：https://blog.csdn.net/IT_Android/article/details/135348993

版权

前言

上一章我们讲解了布局原理与xml解析流程，以及资源加载流程、插件化换肤思路，可以查看上一章，本章咱们重点代码实现插件化换肤逻辑；

撸码实现

自定义 View 换肤控制

这里我们采用接口的方式，进行自定义 View 的换肤控制

public interface SkinCustomViewSupport {    
    void applySkin();
}

这里是一个预留接口，预留给哪些自定义的 View 且需要支持换肤的 View；

记录皮肤配置信息工具类

这里使用 MMVK、SP、DataStore、Room 等等都可以只要能用来记录当前配置的皮肤信息即可，并且在下次冷启动的时候能获取到即可，我这里使用了 SP；

public class SkinSharedPreference {    
    private static final String SKIN_SHARED = "skins";    
    private static final String KEY_SKIN_PATH = "skin-path";    
    private SharedPreferences mPref;    
    public void init(Context context) {        
        mPref = context.getSharedPreferences(SKIN_SHARED, Context.MODE_WORLD_WRITEABLE);    
    }    
    private SkinSharedPreference() {}        
    public static final class Holder {        
        private static final SkinSharedPreference instance = new SkinSharedPreference();    
    }    
    public static SkinSharedPreference getInstance() {        
        return Holder.instance;    
    }    
    /**     
      * 设置并记录当前生效的皮肤包信息     
      * @param skinPath 皮肤包路径     
      */    
    public void setSkin(String skinPath) {        
        mPref.edit().putString(KEY_SKIN_PATH, skinPath).apply();    
    }    
    /**     
      * 重置     
      */    
    public void reset() {        
        mPref.edit().remove(KEY_SKIN_PATH).apply();    
    }    
    /**     
      * 获取当前缓存的皮肤包信息     
      * @return str     
      */    
    public String getSkin() {        
        return mPref.getString(KEY_SKIN_PATH, null);    
    }
}

通过name获取皮肤中对应的资源值

换肤的本质就是将皮肤包中的同名资源值进行替换，也就是说：在setTextColor的时候，通过传入的 R.color.white 这个white 找到皮肤包中对应的white 的值，然后传递给 setTextColor；

通过上一章的讲解，Resources 中持有着 ResourcesImpl，ResourcesImpl 中持有着 AssetManager，我们只要拿到皮肤包的 Resources 就可以获取皮肤包中的资源值；所以我们需要一个 SkinResource 用来记录当前使用的是主 App 的 Resources 还是皮肤包中的 Resources，并通过getIdentifier getResourceEntryName getResourceTypeName来获取对应的资源值；

public class SkinResources {    
    // 原始 app 使用的 resources    
    private Resources mAppResources;    
    // 插件 apk 中的 resources    
    private Resources mSkinResources;
    // 皮肤包的包名    
    private String mSkinPkgName;
    // 当前加载的是不是默认皮肤，true是    
    private boolean isDefaultSkin = true;    
    private volatile static SkinResources instance;    
    public void init(Context context) {        
         mAppResources = context.getResources();   
    }    
    private SkinResources(Context context) {}    
    public static SkinResources getInstance() {        
        return instance;    
    }
    // 重置信息    
    public void reset() {        
        mSkinResources = null;        
        mSkinPkgName = "";        
        isDefaultSkin = true;    
    }
    // 应用传递进来的皮肤    
    public void applySkin(Resources resources, String pkgName) {        
        mSkinResources = resources;        
        mSkinPkgName = pkgName;        
        isDefaultSkin = TextUtils.isEmpty(pkgName) || resources == null;    
    }    
    /**     
      * 1. 通过主 app 中的 resId(R.color/drawable.XX) 获取到自己的名字     
      * 2. 根据名字和类型获取皮肤包中的 ID     
      *     
      * @param resId resId     
      */    
    private int getIdentifier(int resId) {        
        if (isDefaultSkin) {            
            return resId;        
        }        
        //        
        String resName = mAppResources.getResourceEntryName(resId);        
        String resType = mAppResources.getResourceTypeName(resId);        
        return mSkinResources.getIdentifier(resName, resType, mSkinPkgName);    
    }    
    /**     
      * 获取颜色值     
      *     
      * @param resId resId     
      */    
    public int getColor(int resId) {        
        if (isDefaultSkin) {            
            return mAppResources.getColor(resId);        
        }        
        int skinId = getIdentifier(resId);        
        if (skinId == 0) {            
            return mAppResources.getColor(resId);        
        }        
        return mSkinResources.getColor(resId);    
    }    
    public ColorStateList getColorStateList(int resId) {        
        if (isDefaultSkin) {            
            return mAppResources.getColorStateList(resId);        
        }        
        int skinId = getIdentifier(resId);        
        if (skinId == 0) {            
            return mAppResources.getColorStateList(resId);        
        }        
        return mSkinResources.getColorStateList(resId);    
    }    
    /**     
      * 获取 drawable     
      *     
      * @param resId resId     
      */    
    public Drawable getDrawable(int resId) {        
        if (isDefaultSkin) {            
            return mAppResources.getDrawable(resId);        
        }        
        int skinId = getIdentifier(resId);        
        if (skinId == 0) {            
            return mAppResources.getDrawable(resId);        
        }        
        return mSkinResources.getDrawable(resId);    
    }    
    /**     
      * 可能是颜色值，可能是 drawable     
      *     
      * @param resId resId     
      */    
    public Object getBackground(int resId) {       
        String resourceTypeName = mAppResources.getResourceTypeName(resId);        
        if ("color".equals(resourceTypeName)) {            
            return getColor(resId);        
        } else {            
            return getDrawable(resId);        
        }    
    }
}

状态栏的换肤支持

当我们页面进行换肤的时候，我们的状态栏也是应该要跟着整体颜色进行改变的，也就是说我们需要动态的修改对应页面状态栏的颜色，这里写一个工具类，用来切换状态栏

public class SkinThemeUtils {    
    private static final int[] APPCOMPAT_COLOR_PRIMARY_DARK_ATTRS = {android.R.attr.colorPrimaryDark};    
    private static final int[] STATUS_BAR_COLOR_ATTRS = {android.R.attr.statusBarColor, android.R.attr.navigationBarColor};    
    /**     
      * 获得 Theme 中属性中定义的资源 id     
      *     
      * @param context context     
      * @param attrs attrs     
      * @return int[]     
      * */    
    public static int[] getResId(Context context, int[] attrs) {        
        int[] resIds = new int[attrs.length];        
        TypedArray a = context.obtainStyledAttributes(attrs);        
        for (int i = 0; i < attrs.length; i++) {            
            resIds[i] = a.getResourceId(i, 0);        
        }        
        a.recycle();        
        return resIds;    
    }    
    /**     
     *  更新导航栏，状态栏的颜色值     
     *     
     * @param activity  activity 当前页面     
     *     
     * */    
    public static void updateStatusBarColor(Activity activity) {        
        // 不处理 5.0 以下的        
        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) {            
            return;        
        }        
        // 获得 statusBarColor 与 navigationBarColor        
        // 当与 colorPrimaryDark 不同时 以 statusBarColor 为准        
        int[] resIds = getResId(activity, STATUS_BAR_COLOR_ATTRS);        
        int statusBarColorResId = resIds[0];        
        int navigationBarColor = resIds[1];        
        // 如果直接在 style 中写入固定颜色值(而不是 @color/XXX ) 获得0，不处理，这里需要和业务侧订好规范        
        if (statusBarColorResId != 0) {            
            int color = SkinResources.getInstance().getColor(statusBarColorResId);            
            activity.getWindow().setStatusBarColor(color);        
        } else {            
            int colorPrimaryDarkResId = getResId(activity, APPCOMPAT_COLOR_PRIMARY_DARK_ATTRS)[0];            
            if (colorPrimaryDarkResId != 0) {                
                int color = SkinResources.getInstance().getColor(colorPrimaryDarkResId);                
                activity.getWindow().setStatusBarColor(color);            
            }        
        }        
        if (navigationBarColor != 0) {            
            int color = SkinResources.getInstance().getColor(navigationBarColor);            
            activity.getWindow().setNavigationBarColor(color);        
        }    
    }
}

记录所有需要换肤的View的所有属性

在创建 View 的时候，我们需要记录下这个 view 的所有可以换肤的属性，例如：

<TextView    
    android:id="@+id/storage"    
    android:layout_width="match_parent"    
    android:layout_height="50dp"    
    app:layout_constraintStart_toStartOf="parent"    
    app:layout_constraintEnd_toEndOf="parent"    
    app:layout_constraintTop_toTopOf="parent"    
    android:text="@string/scope_storage"    
    android:textColor="@color/material_on_background_disabled"    
    android:gravity="center"/>

我们要拿到 TextView 的 textColor 属性，并记录下来，以及拿到对应的 id 值记录下来

static class SkinNameValuePair {    
    // 属性名    
    String attributeName;    
    // 对应资源 id    
    int resId;    
    SkinNameValuePair(String attributeName, int resId) {        
        this.attributeName = attributeName;        
        this.resId = resId;    
    }
}

有时候，一个View 可能会设置多个支持换肤的属性，那么就需要一个集合来封装，这里声明了一个内部类，View 和对应的 List 集合；

public static class SkinView {    
    public View view;    
    // 这个 View 换肤的属性与它对应的 id 的集合    
    List<SkinNameValuePair> skinNameValuePairs;    
    SkinView(View view, List<SkinNameValuePair> skinPairs) {        
        this.view = view;        
        this.skinPairs = skinNameValuePairs;    
    }    
    void applySkin() {        
        applySkinSupport();        
        for (SkinNameValuePair skinPair : skinPairs) {            
            Drawable left = null, top = null, right = null, bottom = null;            
            switch (skinPair.attributeName) {                
                case "background":                    
                    Object background = SkinResources.getInstance().getBackground(skinPair.resId);                    
                    if (background instanceof Integer) {                        
                        view.setBackgroundColor((Integer) background);                    
                    } else {                        
                        ViewCompat.setBackground(view, (Drawable) background);                    
                    }                    
                    break;                
                case "src":                  
                    background = SkinResources.getInstance().getBackground(skinPair.resId);                    
                    if (background instanceof Integer) {                        
                        ((ImageView) view).setImageDrawable(new ColorDrawable((Integer) background));                    
                    } else {                        
                        ((ImageView) view).setImageDrawable((Drawable) background);                    
                    }                    
                    break;                
                case "textColor":                    
                    ((TextView) view).setTextColor(SkinResources.getInstance().getColorStateList(skinPair.resId));                    
                    break;                
                case "drawableLeft":                    
                    left = SkinResources.getInstance().getDrawable(skinPair.resId);                    
                    break;                
                case "drawableTop":                    
                    top = SkinResources.getInstance().getDrawable(skinPair.resId);                    
                    break;                
                case "drawableRight":                    
                    right = SkinResources.getInstance().getDrawable(skinPair.resId);                    
                    break;                
                case "drawableBottom":                    
                    bottom = SkinResources.getInstance().getDrawable(skinPair.resId);                    
                    break;            
            }            
            if (left != null || null != top || right != null || null != bottom) {                
                ((TextView) view).setCompoundDrawablesWithIntrinsicBounds(left, top, right, bottom);            
            }        
        }    
    }    
    private void applySkinSupport() {        
        if (view instanceof SkinCustomViewSupport) {            
            ((SkinCustomViewSupport) view).applySkin();        
        }    
    }
}

接下来，就需要收集当前 View 支持换肤的属性，并将这些支持换肤的 View 的属性封装到一个集合中，整体就是下面这样的一个层级

接下来就是遍历这个 View 的所有要换肤的属性并记录下来；

class SkinAttributeAttrs {    
    private final List<SkinView> mSkinViews = new ArrayList<>();    
    private static final List<String> mAttributes = new ArrayList<>();    
    static {        
        mAttributes.add("background");        
        mAttributes.add("src");       
        mAttributes.add("textColor");        
        mAttributes.add("drawableLeft");        
        mAttributes.add("drawableTop");        
        mAttributes.add("drawableRight");        
        mAttributes.add("drawableBottom");    
    }    
    /**     
      * 寻找所有可以换肤的 view     
      * 以 ？开头的 和 以 @ 开头的属性值     
      */    
    void searchView(View view, AttributeSet attrs) {        
        List<SkinNameValuePair> skinPairs = new ArrayList<>();        
        for (int i = 0; i < attrs.getAttributeCount(); i++) {            
            // 获取属性名            
            String attributeName = attrs.getAttributeName(i);            
            if (mAttributes.contains(attributeName)) {                
                // 获取属性值                
                String attributeValue = attrs.getAttributeValue(i);                
                // 比如 color，以 # 号写死的颜色
                // 不支持换肤 android:textColor="#FFFFFFFF" 这种不知道插件皮肤对应的值               
                if (attributeValue.startsWith("#")) {                    
                    continue;                
                }                
                int resId;                
                if (attributeValue.startsWith("?")) {                    
                    // 以 ? 开头的属性值                    
                    int attrId = Integer.parseInt(attributeValue.substring(1));                    
                    resId = SkinThemeUtils.getResId(view.getContext(), new int[]{attrId})[0];                
                } else {                    
                    // 正常以 @ 开头的属性值                    
                    resId = Integer.parseInt(attributeValue.substring(1));                
                }                
                SkinNameValuePair skinPair = new SkinNameValuePair(attributeName, resId);                
                skinPairs.add(skinPair);            
            }        
        }        
        if (!skinPairs.isEmpty() || view instanceof SkinCustomViewSupport) {            
            SkinView skinView = new SkinView(view, skinPairs);            
            mSkinViews.add(skinView);        
        }    
    }    
    /**     
      * 对所有的 View 中的所有属性进行皮肤修改     
      */    
    void applySkin() {        
        for (SkinView mSkinView : mSkinViews) {            
            mSkinView.applySkin();        
        }    
    }
}

接下来就是要接管 View 的创建过程了；

接管 View 的创建流程

上一章讲解过，接管 View 的创建过程，只需要替换 Factory2 接口即可，这里我们也实现 Factory2 接口

public class SkinLayoutInflaterFactory2 implements LayoutInflater.Factory2, Observer {    
    private static final String[] mClassPrefixList = {            
        "android.widget.",            
        "android.webkit.",            
        "android.app.",            
        "android.view.",    
    };    
    // 记录对应 view 的构造函数    
    private static final Class<?>[] mConstructorSignature = new Class[] {            
        Context.class, AttributeSet.class    
    };    
    private static final HashMap<String, Constructor<? extends View>> sConstructorMap = new HashMap<>();    // 当选择新皮肤后需要替换 View 与之对应的属性    
    // 页面属性管理器    
    private final SkinAttributeAttrs mSkinAttribute;    
    // 用于获取窗口的状态框的信息    
    private final Activity mActivity;    
    SkinLayoutInflaterFactory2(Activity activity) {        
        this.mActivity = activity;        
        this.mSkinAttribute = new SkinAttributeAttrs();    
    }    
    @Override    
    public View onCreateView(View parent, String name, Context context, AttributeSet attrs) {        
        // 换肤就是在需要的时候替换 View 的属性(src background 等)        
        // 所以这里创建 view 从而修改 View 属性        
        View view = createSystemView(name, context, attrs);        
        if (view == null) {            
            view = createView(name, context, attrs);        
        }        
        if (null != view) {            
            // 加载属性            
            mSkinAttribute.searchView(view, attrs);        
        }        
        return view;    
    }    
    @Override    
    public View onCreateView(String name, Context context, AttributeSet attrs) {        
        View view = createSystemView(name, context, attrs);        
        if (view == null) {            
            view = createView(name, context, attrs);        
        }        
        if (null != view) { 
            // 处理换肤的逻辑           
            mSkinAttribute.searchView(view, attrs);        
        }        
        return view;
    }    
    /**     
      * @param name View的类名     
      * @param context 上下文     
      * @param attrs 属性     
      * @return View对象     
      */    
    private View createSystemView(String name, Context context, AttributeSet attrs) {        
        // 如果包含 . 则不是 SDK 中的 View 可能是自定义 View 包括 support 库中的 View        
        if (-1 != name.indexOf('.')) {            
            return null;        
        }        
        for (String s : mClassPrefixList) {
            // 找到了对应的 View 之后返回            
            View view = createView(s + name, context, attrs);            
            if (view != null) {                
                return view;            
            }        
        }        
        return null;    
    }    
    /**     
      * 反射创建全类名View对象     
      *     
      * @param name 全类名View     
      * @param context 上下文     
      * @param attrs 属性     
      * @return View对象     
      */    
    private View createView(String name, Context context, AttributeSet attrs) {        
        Constructor<? extends View> constructor = findConstructor(context, name);        
        try {            
            return constructor.newInstance(context, attrs);        
        } catch (Exception e) {            
            e.printStackTrace();        
        }        
        return null;    
    }    
    /**     
      * 根据全类名找到其对应的构造方法对象     
      *     
      * @param context 上下文     
      * @param name 全类名View     
      * @return 构造方法对象     
      */    
    private Constructor<? extends View> findConstructor(Context context, String name) {        
        Constructor<? extends View> constructor = sConstructorMap.get(name);        
        if (constructor == null) {            
            try {                
                Class<? extends View> clazz = context.getClassLoader().loadClass(name).asSubclass(View.class);                
                constructor = clazz.getConstructor(mConstructorSignature);                
                constructor.setAccessible(true);                
                sConstructorMap.put(name, constructor);            
            } catch (Exception e) {                
                e.printStackTrace();            
            }        
        }        
        return constructor;    
    }    
    /**     
      *  Activity(Observable)发出通知，这里就会执行     
      *     
      *  执行换肤操作     
      * */    
    @Override    
    public void update(Observable o, Object arg) {        
        SkinThemeUtils.updateStatusBarColor(mActivity);        
        mSkinAttribute.applySkin();    
    }
}

接管了 View 的创建流程，这里大部分都是直接抄的源码的创建逻辑，在 View 创建的时候，就可以替换成插件包中皮肤；

接下来就需要监听 Activity 的创建和销毁，在创建之后的回调了重置 mFactorySet 这里 API 也提供了相关接口；

public class SkinActivityLifeCycle extends AbsActivityLifeCycle {    
    private final Observable mObservable;    
    private final ArrayMap<Activity, SkinLayoutInflaterFactory2> mLayoutInflaterFactory = new ArrayMap<>();    
    SkinActivityLifeCycle(Observable observable) {        
        this.mObservable = observable;    
    }    
    @Override    
    public void onActivityCreated(Activity activity, Bundle savedInstanceState) {        
        /*         
         *  onCreate方法执行之后 回调到这里，此时Activity的onCreate已经执行完毕，也就是setContentView方法已经执行结束，         
         *  mFactorySet已经被设置为true，所以要反射修改为false，否则会抛出 IllegalStateException("A factory has already been set on this LayoutInflater")         
         * */        
        /*         
         * 更新状态栏         
         * */        
        SkinThemeUtils.updateStatusBarColor(activity);        
        /*         
         * 更新布局视图         
         * */        
        LayoutInflater layoutInflater = activity.getLayoutInflater();        
        try {            
            // Android布局加载器 使用 mFactorySet 标记是否设置过 Factory            
            // 如设置过，再次设置会抛出异常            
            // 设置 mFactorySet 为 false            
            Field field = LayoutInflater.class.getDeclaredField("mFactorySet");            
            field.setAccessible(true);            
            field.setBoolean(layoutInflater, false);        
        } catch (Exception e) {            
            e.printStackTrace();        
        }        
        SkinLayoutInflaterFactory2 skinLayoutInflaterFactory = new SkinLayoutInflaterFactory2(activity);        
        LayoutInflaterCompat.setFactory2(layoutInflater, skinLayoutInflaterFactory);        
        mLayoutInflaterFactory.put(activity, skinLayoutInflaterFactory);        
        // 观察者模式       
        mObservable.addObserver(skinLayoutInflaterFactory);    
    }    
    @Override    
    public void onActivityDestroyed(Activity activity) {        
        SkinLayoutInflaterFactory2 skinLayoutInflaterFactory = mLayoutInflaterFactory.remove(activity);        
        SkinManager.getInstance().deleteObserver(skinLayoutInflaterFactory);    
    }
}

加载皮肤资源，初始化配置信息，

public class SkinManager extends Observable {    
    private Application mContext;
    private Resources skinResources;    
    private SkinManager() {}    
    /**     
      * 初始化必须放在 application 中     
      * */    
    public void init(Application application) {        
        mContext = application;        
        SkinSharedPreference.getInstance().init(application);        
        SkinResources.init(application);        
        // 注册 Activity 生命周期，并设置被观察者        
        SkinActivityLifeCycle skinApplicationActivityLifeCycle = new SkinActivityLifeCycle(this);        
        application.registerActivityLifecycleCallbacks(skinApplicationActivityLifeCycle);        
        // 加载上次使用保存的皮肤        
        loadSkin(SkinSharedPreference.getInstance().getSkin());    
    } 
    public Resources getSkinResources() {
        return skinResources;
    }   
    public static SkinManager getInstance() {        
        return Holder.instance;    
    }    
    private static final class Holder {        
        private static final SkinManager instance = new SkinManager();    
    }    
    /**     
      *  加载皮肤并应用     
      *  @param skin skin 皮肤路径     
      *     
      *  对外暴露这个方法，可以添加设置页面，增加换肤按钮，点击事件中 调用此方法，传递皮肤包路径     
      *     
      * */    
    public void loadSkin(String skin) {        
        if (TextUtils.isEmpty(skin)) {            
            // 还原默认皮肤            
            SkinSharedPreference.getInstance().reset();            
            SkinResources.getInstance().reset();        
        } else {            
            // 宿主 app 的 resources            
            Resources resources = mContext.getResources();            
            // 反射创建 AssetManager 与 Resources            
            try {                
                AssetManager assetManager = AssetManager.class.newInstance();                
                // 资源路径设置目录或者压缩包                
                // TODO 同一个 key 的颜色值 就会被替换掉，所以未打开的Activity页面，在初次打开的时候，使用的是接管 View 创建的过程，同时替换成新的皮肤资源                
                // TODO Resources进行getColor(R.color.xxx) 因为是同名的，这里已经替换成皮肤插件包中的Resources了，所以未打开过的Activity，执行onCreate方法中的setContentView                
                // TODO 中的inflate的时候 读取到的颜色值 就是插件包中的                
                Method addAssetPath = assetManager.getClass().getMethod("addAssetPath", String.class);                
                addAssetPath.setAccessible(true);                
                addAssetPath.invoke(assetManager, skin);                
                // 根据当前的设备显示器信息与配置(横竖屏，语言等) 创建 Resources，                
                skinResources = new Resources(assetManager, resources.getDisplayMetrics(), resources.getConfiguration());                
                // 获取外部 apk(皮肤包) 包名                
                PackageManager mPm = mContext.getPackageManager();                
                PackageInfo info = mPm.getPackageArchiveInfo(skin, PackageManager.GET_ACTIVITIES);                
                if(info == null) {
                    return;
                }
                String packageName = info.packageName;                
                // 这里就会进行一个赋值，如果皮肤插件包有值，就会给SkinResources进行赋值                
                SkinResources.getInstance().applySkin(skinResources, packageName);                
                // 记录                
                SkinSharedPreference.getInstance().setSkin(skin);            
            } catch (Exception e) {                
                //            
            }        
        }        
        // 通知采集的 view 更新皮肤        
        // 被观察者改变，通知所有的观察者        
        setChanged();        
        notifyObservers(null);    
    }
}

Application 中初始化插件化换肤框架

public class MyApplication extends Application {    
    public static Application sApplication;    
    @Override    
    public void onCreate() {        
        super.onCreate();        
        sApplication = this;        
        SkinManager.getInstance().init(this);    
    }    
    public static Application getApplication() {        
        return sApplication;    
    }    
    @Override    
    public Resources getResources() {        
        Resources skinResources = SkinManager.getInstance().getSkinResources();        
        if (skinResources != null) {            
            if (skinResources.getConfiguration() != getSuperResources().getConfiguration()                     
                || skinResources.getDisplayMetrics() != getSuperResources().getDisplayMetrics()) {                
                skinResources.updateConfiguration(getSuperResources().getConfiguration(), 
                    getSuperResources().getDisplayMetrics());            
            }            
            return skinResources;        
        }        
        return getSuperResources();    
    }    
    @Override    
    public void onConfigurationChanged(@NonNull Configuration newConfig) {        
        super.onConfigurationChanged(newConfig);        
        // 适配 Android 12 屏幕切换 resources 不更新的问题        
        if (Build.VERSION.SDK_INT > Build.VERSION_CODES.R) {            
            getSuperResources().updateConfiguration(newConfig, Resources.getSystem().getDisplayMetrics());        
        }    
    }    
    public Resources getSuperResources() {        
        return super.getResources();    
    }
}

换肤按钮切换通知

// 这里也可以是网络下载的地址

SkinManager.getInstance().loadSkin("/data/data/com.example.llc/skin/skin-debug.apk");

最终效果

PS：TODO 版本适配，以及编译版本和目标版本

mFactorySet 做了版本限制，当 targetSdkVersion > 27 的时候会抛出异常，因为涉及到了插件化Hook，demo中做了 compileSdkVersion 和 targetSdkVersion 都是 27 的限制，主要是为了讲解 xml 解析和布局原理，后面我会补上适配的内容；

根据注释提示，可以参考 AsyncLayoutInflater 的实现自己的 LayoutInflater 接管 View 的创建；