本篇文章是针对Android端换肤框架Android-Skin-Loader的源码解析
整个框架的架构
从加载皮肤说起
SkinManager.getInstance( ).load一行代码便实现了换肤功能，那么进入该方法看看具体是怎样实现的
SkinManager.java
public void load(String skinPackagePath, final ILoaderListener callback) {
new AsyncTask<String, Void, Resources>() {
protected void onPreExecute() {
if (callback != null) {
callback.onStart(); //对外通知 开始加载皮肤
}
};
@Override
protected Resources doInBackground(String... params) {
try {
if (params.length == 1) {
String skinPkgPath = params[0];
File file = new File(skinPkgPath);
if(file == null || !file.exists()){
return null;
}
PackageManager mPm = context.getPackageManager();
PackageInfo mInfo = mPm.getPackageArchiveInfo(skinPkgPath, PackageManager.GET_ACTIVITIES); //获取apk包信息
skinPackageName = mInfo.packageName;
//反射构造AssetManager实例，将皮肤包加载进内存，然后通过新构造的Resources去加载皮肤资源
AssetManager assetManager = AssetManager.class.newInstance();
Method addAssetPath = assetManager.getClass().getMethod("addAssetPath", String.class);
addAssetPath.invoke(assetManager, skinPkgPath);
Resources superRes = context.getResources();
Resources skinResource = new Resources(assetManager,superRes.getDisplayMetrics(),superRes.getConfiguration());
SkinConfig.saveSkinPath(context, skinPkgPath); //保存皮肤包的绝对路径
skinPath = skinPkgPath;
isDefaultSkin = false;
return skinResource;
}
return null;
} catch (Exception e) {
e.printStackTrace();
return null;
}
};
protected void onPostExecute(Resources result) {
mResources = result; //得到异步处理结果，然后在SkinManager实例中维持Resources
if (mResources != null) {
if (callback != null) callback.onSuccess(); //对外通知 加载皮肤成功
notifySkinUpdate(); //通知观察者改变皮肤
}else{
isDefaultSkin = true;
if (callback != null) callback.onFailed(); //对外通知 加载皮肤失败
}
};
}.execute(skinPackagePath);
}第一个参数代表外部皮肤包的绝对路径(通过gradle打包)，第二个参数是加载皮肤成功与否的回调接口；
load方法主要构造了一个AsyncTask执行异步任务，通过PackageManager获取皮肤的包信息(皮肤本质上是个apk)，利用反射构造AssetManager实例，调用addAssetPath方法将皮肤包加载进内存
addAssetPath方法中的关键代码
public int addAssetPath(String path) {
return addAssetPathInternal(path, false /*overlay*/, false /*appAsLib*/);
}
private int addAssetPathInternal(String path, boolean overlay, boolean appAsLib) {
......
final ApkAssets assets;
try {
if (overlay) {
assets = ApkAssets.loadOverlayFromPath(idmapPath, false /*system*/);
} else {
assets = ApkAssets.loadFromPath(path, false /*system*/, appAsLib);
}
} catch (IOException e) {
return 0;
}
mApkAssets = Arrays.copyOf(mApkAssets, count + 1);
mApkAssets[count] = assets;
......
}
}android源码中对ApkAssets的解释：The loaded, immutable, in-memory representation of an APK.
也就是说，是Apk包在内存中的类实例
接着load方法分析，利用新构造的AssetManager去new Resources目的是通过Resources来动态加载资源文件，执行完异步任务后，就在onPostExecute方法中将新的Resources赋值给字段mResources，这样加载皮肤时使用mResources，恢复默认皮肤时使用context.getResources( )加载资源，最后notifySkinUpdate( )通知view改变皮肤
在进入notifySkinUpdate( )分析之前，我们先分析一下SkinManager类
SkinManager
为了便于分析逻辑，将部分代码省略
public class SkinManager implements ISkinLoader{
......
private List<ISkinUpdate> skinObservers;
private String skinPackageName;
private Resources mResources;
private String skinPath;
private boolean isDefaultSkin = false;
......
public void restoreDefaultTheme(){
......
}
public void load(){
......
}
public void load(ILoaderListener callback){
......
}
public void load(String skinPackagePath, final ILoaderListener callback) {
......
}
@Override
public void attach(ISkinUpdate observer) {
if(skinObservers == null){
skinObservers = new ArrayList<ISkinUpdate>();
}
if(!skinObservers.contains(observer)){
skinObservers.add(observer);
}
}
@Override
public void detach(ISkinUpdate observer) {
if(skinObservers == null) return;
if(skinObservers.contains(observer)){
skinObservers.remove(observer);
}
}
@Override
public void notifySkinUpdate() {
if(skinObservers == null) return;
for(ISkinUpdate observer : skinObservers){
observer.onThemeUpdate();
}
}
public int getColor(int resId){
......
}
public Drawable getDrawable(int resId){
......
}
}在Application中初始化SkinManager，类中skinObservers字段存储所有的观察者，这个观察者是你实现了ISkinUpdate接口的Activity或Fragment
public interface ISkinUpdate {
void onThemeUpdate();
}注意该类中的attach与detach方法，分别将 观察者(activity和Fragment) 建立订阅或解除订阅关系
接下来我们再来分析下notifySkinUpdate( )方法，遍历所有的观察者，并调用观察者的onThemeUpdate方法完成皮肤切换，那么我们看看观察者(Activity或Fragment)的onThemeUpdate需要如何实现
@Override
public void onThemeUpdate() {
if(!isResponseOnSkinChanging){
return;
}
mSkinInflaterFactory.applySkin();
}进入SkinInflaterFactory的applySkin( )看看
public void applySkin(){
if(ListUtils.isEmpty(mSkinItems)){
return;
}
for(SkinItem si : mSkinItems){
if(si.view == null){
continue;
}
si.apply();
}
}遍历list中的SkinItem，并调用apply( )方法，那么SkinItem又是什么东西呢？
public class SkinItem {
public View view;
public List<SkinAttr> attrs;
public SkinItem(){
attrs = new ArrayList<SkinAttr>();
}
public void apply(){
if(ListUtils.isEmpty(attrs)){
return;
}
for(SkinAttr at : attrs){
at.apply(view);
}
}
public void clean(){
if(ListUtils.isEmpty(attrs)){
return;
}
for(SkinAttr at : attrs){
at = null;
}
}
}SkinItem的代码十分简洁，我们看看它的成员变量，SkinItem中持有了需要换肤的View，以及更换资源的属性(封装在SkinAttr中)，apply( )方法实际上的任务是遍历并调用SkinAttr.apply(view)
public abstract class SkinAttr {
protected static final String RES_TYPE_NAME_COLOR = "color";
protected static final String RES_TYPE_NAME_DRAWABLE = "drawable";
/**
* name of the attr, ex: background or textSize or textColor
*/
public String attrName;
/**
* id of the attr value refered to, normally is [2130745655]
*/
public int attrValueRefId;
/**
* entry name of the value , such as [app_exit_btn_background]
*/
public String attrValueRefName;
/**
* type of the value , such as color or drawable
*/
public String attrValueTypeName;
/**
* Use to apply view with new TypedValue
* @param view
* @param tv
*/
public abstract void apply(View view);
}SkinAttr中每个字段的含义就不赘述了，注释还是比较详尽；
下面我们分析具体的SkinAttr实现类，以框架中的BackgroundAttr类为例
public class BackgroundAttr extends SkinAttr {
@Override
public void apply(View view) {
if(RES_TYPE_NAME_COLOR.equals(attrValueTypeName)){ //当属性type为color
view.setBackgroundColor(SkinManager.getInstance().getColor(attrValueRefId));
}else if(RES_TYPE_NAME_DRAWABLE.equals(attrValueTypeName)){ //当属性type为drawable
Drawable bg = SkinManager.getInstance().getDrawable(attrValueRefId);
view.setBackground(bg);
}
}
}为view的属性设置新的资源文件，我们进入kinManager.getInstance( ).getColor( )中看看具体实现
public int getColor(int resId){
int originColor = context.getResources().getColor(resId);
if(mResources == null || isDefaultSkin){
return originColor;
}
String resName = context.getResources().getResourceEntryName(resId);
int trueResId = mResources.getIdentifier(resName, "color", skinPackageName); //根据加载到内存中的皮肤包(apk)的packageName，得到皮肤包中的资源id
int trueColor = 0;
try{
trueColor = mResources.getColor(trueResId);
}catch(NotFoundException e){
e.printStackTrace();
trueColor = originColor;
}
return trueColor;
}如果是默认皮肤，则使用context.getResources().getColor(resId)加载，如果是使用其他皮肤，则使用mResources.getColor(trueResId)加载，完成view属性的改变，即 完成皮肤切换
但你是否还有疑问，究竟什么时候确定哪些view是需要换肤的？什么时候将需要换肤的view封装进了SkinItem中，并使SkinInflaterFactory持有SkinItem？
请看下面的解析?
SkinInflaterFactory
为了便于分析逻辑，将部分代码省略
public class SkinInflaterFactory implements Factory {
/**
* Store the view item that need skin changing in the activity
*/
private List<SkinItem> mSkinItems = new ArrayList<SkinItem>();
@Override
public View onCreateView(String name, Context context, AttributeSet attrs) {
......
}
private View createView(Context context, String name, AttributeSet attrs) {
......
}
private void parseSkinAttr(Context context, AttributeSet attrs, View view) {
......
}
public void applySkin(){
......
}
......
public void addSkinView(SkinItem item){
mSkinItems.add(item);
}
public void clean(){
......
}
}SkinInflaterFactory实现了LayoutInflater的Factory接口，为什么要实现这个接口？
因为不自定义Factory，那么LayoutInflater就会交给系统去完成由xml布局到View实例的创建，自定义Factory后，在观察者(Activity或Fragment)中设置自定义的Factory
//Activity
getLayoutInflater().setFactory(mSkinInflaterFactory);
//Fragment
Field field = LayoutInflater.class.getDeclaredField("mFactorySet");
field.setAccessible(true);
field.setBoolean(getLayoutInflater(), false);
mSkinInflaterFactory = new SkinInflaterFactory();
getLayoutInflater().setFactory(mSkinInflaterFactory);这样我们就代理了由xml布局创建View实例的过程，当由xml布局文件创建View实例时，会调用SkinInflaterFactory的onCreateView( )方法
@Override
public View onCreateView(String name, Context context, AttributeSet attrs) {
// 判断xml布局中，需要换肤的控件是否将SkinConfig.NAMESPACE 命名空间下的SkinConfig.ATTR_SKIN_ENABLE属性设置为true
boolean isSkinEnable = attrs.getAttributeBooleanValue(SkinConfig.NAMESPACE, SkinConfig.ATTR_SKIN_ENABLE, false);
if (!isSkinEnable){
return null;
}
View view = createView(context, name, attrs); //由xml创建View实例
if (view == null){
return null;
}
parseSkinAttr(context, attrs, view);
return view;
}
private View createView(Context context, String name, AttributeSet attrs) {
View view = null;
try {
if (-1 == name.indexOf('.')){
if ("View".equals(name)) {
view = LayoutInflater.from(context).createView(name, "android.view.", attrs);
}
if (view == null) {
view = LayoutInflater.from(context).createView(name, "android.widget.", attrs);
}
if (view == null) {
view = LayoutInflater.from(context).createView(name, "android.webkit.", attrs);
}
}else {
view = LayoutInflater.from(context).createView(name, null, attrs);
}
L.i("about to create " + name);
} catch (Exception e) {
......
}
return view;
}通过LayoutInflater的createView方法，根据xml标签中的控件名name和AttributeSet完成View实例的创建
LayoutInflater的createView关键源码如下
public final View createView(String name, String prefix, AttributeSet attrs) throws ClassNotFoundException, InflateException {
clazz = mContext.getClassLoader().loadClass(prefix != null ? (prefix + name) : name).asSubclass(View.class);
......
constructor = clazz.getConstructor(mConstructorSignature);
......
args[1] = attrs;
final View view = constructor.newInstance(args);
......
}通过类加载和反射创建了View实例，创建View实例后，将调用parseSkinAttr将需要换肤的view和属性封装在SkinItem中
private void parseSkinAttr(Context context, AttributeSet attrs, View view) {
List<SkinAttr> viewAttrs = new ArrayList<SkinAttr>();
for (int i = 0; i < attrs.getAttributeCount(); i++){
String attrName = attrs.getAttributeName(i);
String attrValue = attrs.getAttributeValue(i);
if(!AttrFactory.isSupportedAttr(attrName)){
continue;
}
if(attrValue.startsWith("@")){
try {
int id = Integer.parseInt(attrValue.substring(1));
String entryName = context.getResources().getResourceEntryName(id);
String typeName = context.getResources().getResourceTypeName(id);
SkinAttr mSkinAttr = AttrFactory.get(attrName, id, entryName, typeName); //封装需要切换资源的view属性
if (mSkinAttr != null) {
viewAttrs.add(mSkinAttr);
}
} catch (NumberFormatException e) {
e.printStackTrace();
} catch (NotFoundException e) {
e.printStackTrace();
}
}
}
if(!ListUtils.isEmpty(viewAttrs)){
SkinItem skinItem = new SkinItem();
skinItem.view = view;
skinItem.attrs = viewAttrs;
mSkinItems.add(skinItem); //在这里，将需要换肤的SkinItem(封装了View)添加到SkinInflaterFactory的list中
if(SkinManager.getInstance().isExternalSkin()){
skinItem.apply();
}
}
}属性是如何封装的呢？
public class AttrFactory {
public static final String BACKGROUND = "background";
public static final String TEXT_COLOR = "textColor";
public static final String LIST_SELECTOR = "listSelector";
public static final String DIVIDER = "divider";
public static SkinAttr get(String attrName, int attrValueRefId, String attrValueRefName, String typeName){
SkinAttr mSkinAttr = null;
if(BACKGROUND.equals(attrName)){
mSkinAttr = new BackgroundAttr();
}else if(TEXT_COLOR.equals(attrName)){
mSkinAttr = new TextColorAttr();
}else if(LIST_SELECTOR.equals(attrName)){
mSkinAttr = new ListSelectorAttr();
}else if(DIVIDER.equals(attrName)){
mSkinAttr = new DividerAttr();
}else{
return null;
}
mSkinAttr.attrName = attrName;
mSkinAttr.attrValueRefId = attrValueRefId;
mSkinAttr.attrValueRefName = attrValueRefName;
mSkinAttr.attrValueTypeName = typeName;
return mSkinAttr;
}
/**
* Check whether the attribute is supported
*/
public static boolean isSupportedAttr(String attrName){
......
}
}将资源的属性名，id，资源名，资源类型封装在SkinAttr中
最后在SkinInflaterFactory中持有一个list，list包含需要换肤SkinItem，SkinItem封装了View和属性
总结：SkinManager持有观察者(Activity或Fragment)，当切换皮肤时，利用Resources动态加载皮肤资源，加载成功后，对外通知切换皮肤，遍历观察者，每个观察者中持有SkinFactory，每个SkinFactory中持有需要换肤的View，也就是List，调用每个SkinAttr中的apply( )方法，完成view属性资源的切换
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
