換膚思路： 1.什麼時候換膚？ xml載入前換膚，如果xml載入後換膚，用戶將會看見換膚之前的色彩，用戶體驗不好。 2.皮膚是什麼？皮膚就是apk，是一個資源包，包含了顏色、圖片等。 3.什麼樣的控制項應該進行換膚？包含背景圖片的控制項，例如textView文字顏色。 4.皮膚與已安裝的資源如何匹配 ...

換膚思路：

1.什麼時候換膚？

xml載入前換膚，如果xml載入後換膚，用戶將會看見換膚之前的色彩，用戶體驗不好。

2.皮膚是什麼？

皮膚就是apk，是一個資源包，包含了顏色、圖片等。

3.什麼樣的控制項應該進行換膚？

包含背景圖片的控制項，例如textView文字顏色。

4.皮膚與已安裝的資源如何匹配？

資源名字匹配

效果展示：

步驟：

1.xml載入前換膚，意味著需要將所需要換膚的控制項收集起來。因此要監聽xml載入的過程。

 1 public class BaseActivity extends Activity {
 2 
 3     SkinFactory skinFactory;
 4 
 5     @Override
 6     protected void onCreate(@Nullable Bundle savedInstanceState){
 7         super.onCreate(savedInstanceState);
 8 
 9         //監聽xml生成的過程
10         skinFactory = new SkinFactory();
11         LayoutInflaterCompat.setFactory(getLayoutInflater(),skinFactory);
12     }
13 }

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)

 1 class SkinItem{
 2         // attrName   background
 3         String attrName;
 4 
 5         int refId;
 6         // 資源名字  @color/colorPrimaryDark
 7         String attrValue;
 8         //  drawable color
 9         String attrType;
10 
11         public SkinItem(String attrName, int refId, String attrValue, String attrType) {
12             this.attrName = attrName;
13             this.refId = refId;
14             this.attrValue = attrValue;
15             this.attrType = attrType;
16         }
17 
18         public String getAttrName() {
19             return attrName;
20         }
21 
22         public int getRefId() {
23             return refId;
24         }
25 
26         public String getAttrValue() {
27             return attrValue;
28         }
29 
30         public String getAttrType() {
31             return attrType;
32         }
33     }

SkinView：

1 class SkinView{
2         private View view;
3         private List<SkinItem> list;  //收集需要換膚的集合
4 
5         public SkinView(View view, List<SkinItem> list) {
6             this.view = view;
7             this.list = list;
8         }
9     }

收集控制項：

SkinFactory：

  1 package com.example.apk_demo2;
  2 
  3 import android.content.Context;
  4 import android.util.AttributeSet;
  5 import android.util.Log;
  6 import android.view.View;
  7 import android.widget.TextView;
  8 
  9 import androidx.core.view.LayoutInflaterFactory;
 10 
 11 import java.lang.reflect.Constructor;
 12 import java.lang.reflect.InvocationTargetException;
 13 import java.util.ArrayList;
 14 import java.util.List;
 15 
 16 // LayoutInflaterFactory介面
 17 public class SkinFactory implements LayoutInflaterFactory {
 18 
 19     private List<SkinView> cacheList = new ArrayList<>();
 20     private static final String TAG = "david" ;
 21     //補充系統控制項的包名
 22     private static final String[] prefixList={"android.widget.","android.view.","android.webkit."};   // 包名，android.webkit為瀏覽器包，v4、v7包都可以認為是自定義控制項
 23 
 24 
 25     /**
 26      * xml生成的時候會回調這個方法，返回值為view
 27      * @param parent
 28      * @param name   控制項名
 29      * @param context
 30      * @param attrs
 31      * @return
 32      */
 33     @Override
 34     public View onCreateView(View parent, String name, Context context, AttributeSet attrs) {
 35         Log.i(TAG,"onCreateView:"+name);
 36         // 需要換膚的控制項收集到一個容器中
 37 
 38         View view = null;  //初始化view
 39         // 判斷自定義與非自定義控制項(自定義控制項列印時是全報名)
 40         if(name.contains(".")){
 41             // 自定義控制項
 42             view = createView(context,attrs,name);  // 獲得自定義控制項的實例化對象
 43         }else{
 44             // 系統控制項
 45             for(String pre : prefixList){
 46                 view = createView(context,attrs,pre + name);
 47 //                Log.i(TAG,"創建view："+view);
 48                 if(view != null){
 49                     // 找對包名，實例化成功
 50                     // 解析view
 51                     //如果不為空則說明實例化成功，找對了包名
 52                     break;
 53                     //找對了可以退出迴圈
 54                 }
 55             }
 56         }
 57 
 58         if(view != null){
 59             //view不為空則說明已經拿到了這個view，這時候開始解析這個view，判斷哪些控制項需要換膚
 60             parseSkinView(context,attrs,view);
 61             //這個方法用於收集需要換膚的view
 62         }
 63         return view;
 64     }
 65 
 66 
 67     /**
 68      * 收集需要換膚的控制項
 69      * @param context
 70      * @param attrs
 71      * @param view
 72      */
 73     private void parseSkinView(Context context, AttributeSet attrs, View view) {
 74         List<SkinItem> list = new ArrayList<>();  //將需要換膚的控制項添加到這個集合裡面
 75         for(int i = 0; i < attrs.getAttributeCount(); i++){
 76             //做一個java bean來封裝這些值：
 77             // attrName-屬性名（background）、attrValue-屬性值id 十六進位（@color/colorPrimaryDark）、attrType--類型（color）、Id(R文件的id)
 78             // attrName == background等 時 (屬性名)
 79             String attrName = attrs.getAttributeName(i);
 80             // 獲得控制項的id值，eg：@color/colorPrimaryDark  (屬性值)
 81             String attrValue = attrs.getAttributeValue(i);
 82 
 83             if(attrName.equals("background") || attrName.equals("textColor")){
 84                 // 需要換膚的控制項——具備換膚的潛力，並不是一定需要換膚
 85 //                Log.i(TAG,"parseSkinView:"+attrName);
 86                 int id = Integer.parseInt(attrValue.substring(1)); //引用類型
 87 
 88                 String entry_name = context.getResources().getResourceEntryName(id);
 89 
 90                 String typeNme = context.getResources().getResourceTypeName(id);
 91 
 92                 SkinItem skinItem = new SkinItem(attrName,id,entry_name,typeNme);
 93                 list.add(skinItem);
 94             }
 95         }
 96 
 97         if(!list.isEmpty()){
 98             SkinView skinView = new SkinView(view,list);
 99             cacheList.add(skinView);
100             //應用換膚  xml載入過程中換膚
101             skinView.apply();
102 
103         }
104     }
105 
106     //點擊應用
107     public void apply() {
108         for(SkinView skinView : cacheList){
109             skinView.apply();
110         }
111     }
112 
113     public void remove() {
114         for (SkinView skinView : cacheList){
115             //清空集合
116 //            cacheList.removeAll();
117         }
118     }
119 
120     /**
121      * 一個activity有多個控制項
122      * 一個控制項對應多個換膚屬性
123      */
124     class SkinView{
125         private View view;
126         private List<SkinItem> list;  //收集需要換膚的集合
127 
128         public SkinView(View view, List<SkinItem> list) {
129             Log.i(TAG,"view123:"+view);
130             this.view = view;
131             this.list = list;
132         }
133 
134         //應用換膚
135         public void apply(){
136             //迴圈需要換膚的SkinItem,應用所有的換膚
137             for(SkinItem skinItem : list){
138                 Log.i(TAG,"skinItem:"+skinItem.getAttrName());
139                 if("textColor".equals(skinItem.getAttrName())){
140                     Log.i(TAG,"view_1:"+view);
141                     //if (!SkinManager.getInstance().getSkinPackage().equals("")){
142                     //最開始的時候系統沒有資源文件，所以當有沒有都運行這行代碼是，系統沒有獲得顏色id，因此為灰色。
143                     //所以得加一個判斷，在沒有換膚之前採用系統預設顏色
144                     if (!SkinManager.getInstance().getSkinPackage().equals("")) {
145                         ((TextView) view).setTextColor(SkinManager.getInstance().getColor(skinItem.getRefId()));
146                     }
147                 }
148                 if("background".equals(skinItem.getAttrName())){
149                     if("color".equals(skinItem.getAttrType())){
150                         //直接這樣設置，沒有任何換膚功能，這樣載入就是本身預設顏色
151 //                        view.setBackgroundColor(skinItem.getRefId());
152 
153                         if (!SkinManager.getInstance().getSkinPackage().equals("")){
154                             view.setBackgroundColor(SkinManager.getInstance().getColor(skinItem.getRefId()));
155                         }
156                     }else if("drawable".equals(skinItem.getAttrType())){
157                         if(!SkinManager.getInstance().getSkinPackage().equals("")){
158                             view.setBackgroundDrawable(SkinManager.getInstance().getDrawable(skinItem.getRefId()));
159                         }
160                     }
161 
162                 }
163             }
164         }
165     }
166 
167     /**
168      * 封裝值
169      */
170     class SkinItem{
171         // attrName   background
172         String attrName;
173         //R裡面的id
174         int refId;
175         // 資源名字  @color/colorPrimaryDark
176         String attrValue;
177         //  drawable color
178         String attrType;
179 
180         public SkinItem(String attrName, int refId, String attrValue, String attrType) {
181             this.attrName = attrName;
182             this.refId = refId;
183             this.attrValue = attrValue;
184             this.attrType = attrType;
185         }
186 
187         public String getAttrName() {
188             return attrName;
189         }
190 
191         public int getRefId() {
192             return refId;
193         }
194 
195         public String getAttrValue() {
196             return attrValue;
197         }
198 
199         public String getAttrType() {
200             return attrType;
201         }
202     }
203 
204     /**
205      * 載入自定義控制項
206      * @param context
207      * @param attrs
208      * @param name
209      * @return
210      */
211     private View createView(Context context, AttributeSet attrs, String name) {
212         try{
213             //運用反射拿到自定義控制項的構造方法,沒有性能損耗
214             Class viewClazz = context.getClassLoader().loadClass(name);
215             Constructor<? extends View> constructor = viewClazz.getConstructor(new Class[]{Context.class,AttributeSet.class});  //通過反射獲得自定義控制項的構造方法
216             return constructor.newInstance(context,attrs);  //通過反射而來的構造函數來實例化對象
217         } catch (InstantiationException e) {
218             e.printStackTrace();
219         } catch (InvocationTargetException e) {
220             e.printStackTrace();
221         } catch (NoSuchMethodException e) {
222             e.printStackTrace();
223         } catch (IllegalAccessException e) {
224             e.printStackTrace();
225         } catch (ClassNotFoundException e) {
226             e.printStackTrace();
227         }
228 
229         return null;
230     }
231 }

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：

  1 package com.example.apk_demo2;
  2 
  3 import android.content.Context;
  4 import android.content.pm.PackageManager;
  5 import android.content.res.AssetManager;
  6 import android.content.res.Resources;
  7 import android.graphics.drawable.Drawable;
  8 import android.util.Log;
  9 
 10 import androidx.core.content.ContextCompat;
 11 
 12 import java.lang.reflect.InvocationTargetException;
 13 import java.lang.reflect.Method;
 14 
 15 public class SkinManager {
 16     private static final String TAG = "yu" ;
 17     //代表外置卡皮膚app的resource
 18     private Resources skinResource;
 19 
 20     private Context context;
 21     //皮膚apk包名
 22     private String skinPackage;
 23     // 初始化context
 24     public void init(Context context){
 25         // 一定用getApplicationContext（）方法獲得context，其是一定存在的；（從記憶體角度上引用全局上下文）
 26         // 如果是靠參數context，有可能是不存在的（如果activity被銷毀了）
 27         this.context = context.getApplicationContext();
 28     }
 29     private static final SkinManager ourInstance = new SkinManager();
 30 
 31     public static SkinManager getInstance(){ return ourInstance; }
 32 
 33     /**
 34      *載入皮膚包
 35      * @param path 路徑
 36      */
 37     public void loadSkin(String path){
 38 
 39         // Resources(AssetManager assets, DisplayMetrics metrics, Configuration config)
 40         // 實例化AssetManager (@hide)AssetManager()是一個系統保護函數，需要通過反射來調用
 41         try{
 42             AssetManager assetManager = AssetManager.class.newInstance();
 43             //通過assetManager.addAssetPath(""); 方法獲得皮膚apk  需反射
 44             Method addAssetPath = assetManager.getClass().getMethod("addAssetPath",String.class);
 45             addAssetPath.invoke(assetManager,path);
 46 
 47             skinResource = new Resources(assetManager,context.getResources().getDisplayMetrics(),
 48                     context.getResources().getConfiguration());// 實例化skonResource
 49             // skinResource.getColor(R.color.colorAccent);通過這樣就可以獲得資源文件的皮膚設置
 50             PackageManager packageManager = context.getPackageManager();  //包管理器
 51             //獲得皮膚包名
 52             Log.i(TAG,"路徑"+path);
 53 //            Log.i(TAG,"上下文"+context);
 54             Log.i(TAG,"上下文"+context);
 55             skinPackage = packageManager.getPackageArchiveInfo(path,PackageManager.GET_ACTIVITIES).packageName;
 56             Log.i(TAG,"包名"+skinPackage);
 57         } catch (IllegalAccessException e) {
 58             e.printStackTrace();
 59         } catch (InstantiationException e) {
 60             e.printStackTrace();
 61         } catch (NoSuchMethodException e) {
 62             e.printStackTrace();
 63         } catch (InvocationTargetException e) {
 64             e.printStackTrace();
 65        } catch (Exception e){
 66             Log.i(TAG,"上下文"+context);
 67             Log.i(TAG,"包名"+skinPackage);
 68         }
 69 
 70     }
 71 
 72     private SkinManager(){ }
 73 
 74     /**
 75      *
 76      * @param resId
 77      * @return
 78      */
 79     public int getColor(int resId){
 80         //判斷有沒有皮膚包
 81         if(skinResource == null){
 82             return resId;
 83         }
 84 
 85         //能否通過這個方法獲得 int skinId = skinResource.getColor(resId);
 86         //不能，因為R文件的id與皮膚apk的id不一樣
 87         //eg：獲得colorAccent
 88         String resName = context.getResources().getResourceEntryName(resId);
 89         // public int getIdentifier(String name, String defType, String defPackage)
 90         int skinId = skinResource.getIdentifier(resName,"color",skinPackage);
 91         if(skinId == 0){
 92             //如果不合法，返回預設xml
 93             return resId;
 94         }
 95 //        Log.i(TAG,"resId:"+resId);
 96 //        Log.i(TAG,"skinResource:"+skinResource.getColor(skinId));
 97         return skinResource.getColor(skinId);
 98     }
 99 
100 
101     /**
102      * 判斷有無資源可以載入，如沒有就用初始化皮膚
103      * @return
104      */
105     public Object getSkinPackage() {
106         if(skinPackage == null){return "";}
107         return "ok";
108     }
109 
110     public Drawable getDrawable(int refId) {
111         if(skinResource == null){
112             return ContextCompat.getDrawable(context,refId);
113         }
114         String resName = context.getResources().getResourceEntryName(refId);
115         int skinId = skinResource.getIdentifier(resName,"drawable",skinPackage);
116         if(skinId == 0){
117             //如果不合法，返回預設xml
118             return ContextCompat.getDrawable(context,refId);
119         }
120         return skinResource.getDrawable(refId);
121     }
122 }

總結：

從學習Android到現在已經過去了一個月，學習最初感覺還好，誰知遇到了換膚這一大難題。

網上資料非常多，卻很難找到一個適合我們的。非常幸運的是，雖然這其中不乏走了很多彎路，但對虧朋友們之間的互相幫助，互相共用學習資料，最後終於做了出來。在自己的項目中也遇到過許許多多的bug需要調試，保持頭腦清晰是必須的啦~

想要跟深入學習的同學，可以去學習github上的開源框架Android-Skin-Loader。這個框架的換膚機制使用動態載入機制前去載入皮膚內容，無需重啟即可實時更換。這個框架也可以直接拿來使用，不過個人認為身為一個人程式員還是需要瞭解好的項目的基本原理的。

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

Android實現apk插件方式換膚

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