首先所有皮肤的view——skinView:如ImageView
public class SkinView {
private View mSkView;//ImageView
private List<SkinAttr> mSkinAttrs;//src,backgroud
public SkinView(View mSkView, List<SkinAttr> mSkinAttrs) {
this.mSkView = mSkView;
this.mSkinAttrs = mSkinAttrs;
}
public void skin(){
for (SkinAttr skinAttr : mSkinAttrs) {
skinAttr.skin(mSkView);
}
}
}
所有view的属性——SkinAttr
public class SkinAttr {
private String mResName;//如资源的名字,meinv.jpg
private SkinType mSkinType;//textColor,background
public SkinAttr(String mResName, SkinType mSkinType) {
this.mResName = mResName;
this.mSkinType = mSkinType;
}
public void skin(View view) {
mSkinType.skin(view,mResName);
}
}
每个类型进行判断并设置
public enum SkinType {
TEXT_COLO("textColor") {
@Override
public void skin(View view, String resName) {
SkinResource resource = getSkinResource();
ColorStateList color = resource.getColorByName(resName);
if (color != null) {
TextView tv = (TextView) view;
tv.setTextColor(color);
}
}
}, BACKGROUND("background") {
@Override
public void skin(View view, String resName) {
SkinResource resource = getSkinResource();
Drawable drawable = resource.getDrawableByName(resName);
ImageView imageView = (ImageView) view;
if (drawable != null) {
imageView.setBackgroundDrawable(drawable);
return;
}
//有可能是颜色
ColorStateList color = resource.getColorByName(resName);
if (color != null) {
view.setBackgroundColor(color.getDefaultColor());
}
}
}, SRC("src") {
@Override
public void skin(View view, String resName) {
SkinResource resource = getSkinResource();
Drawable drawable = resource.getDrawableByName(resName);
if (drawable != null) {
ImageView imageView = (ImageView) view;
imageView.setImageDrawable(drawable);
return;
}
}
};
private String mResName;
SkinType(String resName) {
this.mResName = resName;
}
public abstract void skin(View view, String resName);
/**
* 获得资源的名字(meinv.jpg)
*/
public String getResName() {
return mResName;
}
/**
* 获得皮肤
*/
public SkinResource getSkinResource() {
return SkinManager.getInstance().getSkinResource();
}
}
皮肤属性解析辅助类SkinAttrSupport
public class SkinAttrSupport {
private static final String TAG = SkinAttrSupport.class.getSimpleName();
public static List<SkinAttr> skin(Context context, AttributeSet attrs) {
List<SkinAttr> skinAttrs = new ArrayList<>();
int count = attrs.getAttributeCount();
for (int index = 0; index < count; index++) {//layout_marginTop,----->10.0dip
//Log.e(TAG, attrs.getAttributeName(index)+",----->"+attrs.getAttributeValue(index));
//获得属性的名字和值
String attrName = attrs.getAttributeName(index);
String attrValue = attrs.getAttributeValue(index);
SkinType skinType = getSkinType(attrName);
if (skinType != null) {
String resName = getResName(context, attrValue);
//Log.e(TAG,resName);//image_src
if(TextUtils.isEmpty(resName)){
continue;
}
SkinAttr skinAttr = new SkinAttr(resName, skinType);
skinAttrs.add(skinAttr);
}
}
return skinAttrs;
}
/**
* 获得资源的名字
*/
private static String getResName(Context context, String attrs) {//textSize=15
if (attrs.startsWith("@")) {
attrs = attrs.substring(1);//从1开始截取
int resId = Integer.parseInt(attrs);
return context.getResources().getResourceEntryName(resId);//设置的图片的资源的名字
}
return null;
}
/**
* 获得属性的名字
*/
private static SkinType getSkinType(String attrName) {
SkinType[] skinTypes = SkinType.values();
for (SkinType skinType : skinTypes) {
if (skinType.getResName().equals(attrName)) {
return skinType;
}
}
return null;
}
}
获取资源——skinResource
public class SkinResource {
private Resources mSkinResource;
private String mPackName;
private String TAG=SkinResource.class.getSimpleName();
public SkinResource(Context context, String skinPath) {
Resources superResource = context.getResources();
try {
AssetManager assets = AssetManager.class.newInstance();//{@hide}
Method method = AssetManager.class.getDeclaredMethod("addAssetPath", String.class);
method.invoke(assets, skinPath);
mSkinResource = new Resources
(assets, superResource.getDisplayMetrics(), superResource.getConfiguration());
//获取包名
mPackName = context.getPackageManager()
.getPackageArchiveInfo(skinPath, PackageManager.GET_ACTIVITIES).packageName;
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 获取资源
*/
public Drawable getDrawableByName(String resName) {
try {
int resourceId = mSkinResource.getIdentifier(resName, "drawable", mPackName);
//Log.e(TAG,resName+"——>mPackName"+mPackName);
Drawable drawable = mSkinResource.getDrawable(resourceId);
return drawable;
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* 获取颜色
*/
public ColorStateList getColorByName(String resName) {
try {
int resourceId = mSkinResource.getIdentifier(resName, "drawable", mPackName);
ColorStateList color = mSkinResource.getColorStateList(resourceId);
return color;
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
}
皮肤管理
public class SkinManager {
private static final SkinManager mInstance;
private Context mContext;
private Map<Activity, List<SkinView>> mSkinView = new HashMap<>();
private SkinResource mSkinResource;
public void init(Context context) {
mContext = context.getApplicationContext();
String skinPath = SkinPreUtils.getInstance(context).getSkinPath();
File file = new File(skinPath);
if (!file.exists()) {
SkinPreUtils.getInstance(context).clearSkinInfo();
return;
}
//包名不存在
String packageName = context.getPackageManager().getPackageArchiveInfo
(skinPath, PackageManager.GET_ACTIVITIES).packageName;
if (TextUtils.isEmpty(packageName)) {
SkinPreUtils.getInstance(mContext).clearSkinInfo();
return;
}
mSkinResource = new SkinResource(mContext, skinPath);
}
static {
mInstance = new SkinManager();
}
public static SkinManager getInstance() {
return mInstance;
}
//换肤
public int loadSkin(String skinPath) {
File file = new File(skinPath);
if (!file.exists()) {
return SkinConfig.SKIN_FILE_NOEXSIST;//文件不存在
}
//包名不存在
String packageName = mContext.getPackageManager().getPackageArchiveInfo
(skinPath, PackageManager.GET_ACTIVITIES).packageName;
if (TextUtils.isEmpty(packageName)) {
return SkinConfig.SKIN_FILE_ERROR;//不是一个apk
}
//如果当前是一样的就不换肤
String currentPath = SkinPreUtils.getInstance(mContext).getSkinPath();
if (currentPath.equals(skinPath)) {
return SkinConfig.SKIN_CHANGE_NOTHING;
}
mSkinResource = new SkinResource(mContext, skinPath);
changeSkin();
//4.保存皮肤
SkinPreUtils.getInstance(mContext).saveSkinPath(skinPath);
return 0;
}
/**
* 切换皮肤
*/
private void changeSkin() {
Set<Activity> keys = mSkinView.keySet();
for (Activity key : keys) {
List<SkinView> skinViews = mSkinView.get(key);
for (SkinView skinView : skinViews) {
skinView.skin();
}
}
}
//恢复默认
public int restoreDefault() {
String currentSkinPath = SkinPreUtils.getInstance(mContext).getSkinPath();
if (TextUtils.isEmpty(currentSkinPath)) {
return SkinConfig.SKIN_CHANGE_NOTHING;
}
//当前手机运行的路径
String skinPath = mContext.getPackageResourcePath();
mSkinResource = new SkinResource(mContext, skinPath);
//改变皮肤
changeSkin();
//清空皮肤信息
SkinPreUtils.getInstance(mContext).clearSkinInfo();
return SkinConfig.SKIN_CHANGE_SUCCESS;
}
public List<SkinView> getSkinView(Activity activity) {
return mSkinView.get(activity);
}
public SkinResource getSkinResource() {
return mSkinResource;
}
public void register(Activity activity, List<SkinView> skinViews) {
mSkinView.put(activity, skinViews);
}
/**
* 检查是否需要切换
*
* @param skinView
*/
public void checkChangeSkin(SkinView skinView) {
String skinPath = SkinPreUtils.getInstance(mContext).getSkinPath();
if (!TextUtils.isEmpty(skinPath)) {
skinView.skin();
}
}
public void unRegister(Activity activity) {
mSkinView.remove(activity);
}
}
拦截view
public abstract class BaseSkinActivity extends BaseActivity implements LayoutInflaterFactory {
private SkinAppCompatViewInflater mAppCompatViewInflater;
private String TAG = "BaseSkinActivity";
private static final boolean IS_PRE_LOLLIPOP = Build.VERSION.SDK_INT < 21;
//只能放一些通用的方法，基本每个activity都需要使用的方法
// 如果是两个或两个以上的地方要使用，最好写一个工具类
@Override
public void onCreate(@Nullable Bundle savedInstanceState) {
//拦截到View的创建 获取View之后去解析
LayoutInflater layoutInflater = LayoutInflater.from(this);
LayoutInflaterCompat.setFactory(layoutInflater, this);//会调用onCreateView方法
super.onCreate(savedInstanceState);
}
public View onCreateView(View parent, final String name, @NonNull Context context,
@NonNull AttributeSet attrs) {
// //1.创建View
final View view = createView(parent, name, context, attrs);
// Log.e(TAG, view + "");
if (view != null) {
// 2. 解析属性 src textColor background 自定义属性
// 2.1 一个activity的布局肯定对应多个这样的 SkinView
List<SkinAttr> skinAttrs = SkinAttrSupport.skin(context, attrs);
SkinView skinView = new SkinView(view, skinAttrs);
// 3.统一交给SkinManager管理
managerSkinView(skinView);
//4.判断是否需要换肤
SkinManager.getInstance().checkChangeSkin(skinView);
return view;
}
return view;
}
protected void managerSkinView(SkinView skinView) {
List<SkinView> skinViews = SkinManager.getInstance().getSkinView(this);
if (skinViews == null) {
skinViews = new ArrayList<>();
SkinManager.getInstance().register(this, skinViews);
}
skinViews.add(skinView);
}
public View createView(View parent, final String name, @NonNull Context context,
@NonNull AttributeSet attrs) {
if (mAppCompatViewInflater == null) {
mAppCompatViewInflater = new SkinAppCompatViewInflater();
}
boolean inheritContext = false;
if (IS_PRE_LOLLIPOP) {
inheritContext = (attrs instanceof XmlPullParser)
// If we have a XmlPullParser, we can detect where we are in the layout
? ((XmlPullParser) attrs).getDepth() > 1
// Otherwise we have to use the old heuristic
: shouldInheritContext((ViewParent) parent);
}
return mAppCompatViewInflater.createView(parent, name, context, attrs, inheritContext,
IS_PRE_LOLLIPOP, /* Only read android:theme pre-L (L+ handles this anyway) */
true, /* Read read app:theme as a fallback at all times for legacy reasons */
VectorEnabledTintResources.shouldBeUsed() /* Only tint wrap the context if enabled */
);
}
private boolean shouldInheritContext(ViewParent parent) {
if (parent == null) {
// The initial parent is null so just return false
return false;
}
final View windowDecor = getWindow().getDecorView();
while (true) {
if (parent == null) {
// Bingo. We've hit a view which has a null parent before being terminated from
// the loop. This is (most probably) because it's the root view in an inflation
// call, therefore we should inherit. This works as the inflated layout is only
// added to the hierarchy at the end of the inflate() call.
return true;
} else if (parent == windowDecor || !(parent instanceof View)
|| ViewCompat.isAttachedToWindow((View) parent)) {
// We have either hit the window's decor view, a parent which isn't a View
// (i.e. ViewRootImpl), or an attached view, so we know that the original parent
// is currently added to the view hierarchy. This means that it has not be
// inflated in the current inflate() call and we should not inherit the context.
return false;
}
parent = parent.getParent();
}
}
@Override
protected void onDestroy() {
super.onDestroy();
SkinManager.getInstance().unRegister(this);
}
}
工具类封装
资源文件配置SkinConfig
public class SkinConfig {
// SP的文件名称
public static final String SKIN_INFO_NAME = "skinInfo";
// 保存皮肤文件的路径的名称
public static final String SKIN_PATH_NAME = "skinPath";
// 不需要改变任何东西
public static final int SKIN_CHANGE_NOTHING = -1;
// 换肤成功
public static final int SKIN_CHANGE_SUCCESS = 1;
// 皮肤文件不存在
public static final int SKIN_FILE_NOEXSIST = -2;
// 皮肤文件有错误可能不是一个apk文件
public static final int SKIN_FILE_ERROR = -3;
}
sp保存
public class SkinPreUtils {
private static SkinPreUtils mInstance;
private static Context mContext;
private SkinPreUtils(Context context) {
this.mContext = context.getApplicationContext();
}
public static SkinPreUtils getInstance(Context context) {
if (mInstance == null) {
synchronized (SkinPreUtils.class) {
if (mInstance == null) {
mInstance = new SkinPreUtils(context);
}
}
}
return mInstance;
}
/**
* 保存当前皮肤路径
*
* @param skinPath
*/
public void saveSkinPath(String skinPath) {
mContext.getSharedPreferences(SkinConfig.SKIN_INFO_NAME, Context.MODE_PRIVATE)
.edit().putString(SkinConfig.SKIN_PATH_NAME, skinPath).commit();
}
/**
* 获取皮肤的路径
*
* @return 当前皮肤路径
*/
public String getSkinPath() {
return mContext.getSharedPreferences(SkinConfig.SKIN_INFO_NAME, Context.MODE_PRIVATE)
.getString(SkinConfig.SKIN_PATH_NAME, "");
}
/**
* 清空皮肤路径
*/
public void clearSkinInfo() {
saveSkinPath("");
}
}
SkinAppCompatViewInflate：是Google官方提供的源码，因为源码不是public所以不能直接使用
public class SkinAppCompatViewInflater {
private static final Class<?>[] sConstructorSignature = new Class[]{
Context.class, AttributeSet.class};
private static final int[] sOnClickAttrs = new int[]{android.R.attr.onClick};
private static final String[] sClassPrefixList = {
"android.widget.",
"android.view.",
"android.webkit."
};
private static final String LOG_TAG = "AppCompatViewInflater";
private static final Map<String, Constructor<? extends View>> sConstructorMap
= new ArrayMap<>();
private final Object[] mConstructorArgs = new Object[2];
public final View createView(View parent, final String name, @NonNull Context context,
@NonNull AttributeSet attrs, boolean inheritContext,
boolean readAndroidTheme, boolean readAppTheme, boolean wrapContext) {
final Context originalContext = context;
// We can emulate Lollipop's android:theme attribute propagating down the view hierarchy
// by using the parent's context
if (inheritContext && parent != null) {
context = parent.getContext();
}
if (readAndroidTheme || readAppTheme) {
// We then apply the theme on the context, if specified
context = themifyContext(context, attrs, readAndroidTheme, readAppTheme);
}
if (wrapContext) {
context = TintContextWrapper.wrap(context);
}
View view = null;
// We need to 'inject' our tint aware Views in place of the standard framework versions
switch (name) {
case "TextView":
view = new AppCompatTextView(context, attrs);
break;
case "ImageView":
view = new AppCompatImageView(context, attrs);
break;
case "Button":
view = new AppCompatButton(context, attrs);
break;
case "EditText":
view = new AppCompatEditText(context, attrs);
break;
case "Spinner":
view = new AppCompatSpinner(context, attrs);
break;
case "ImageButton":
view = new AppCompatImageButton(context, attrs);
break;
case "CheckBox":
view = new AppCompatCheckBox(context, attrs);
break;
case "RadioButton":
view = new AppCompatRadioButton(context, attrs);
break;
case "CheckedTextView":
view = new AppCompatCheckedTextView(context, attrs);
break;
case "AutoCompleteTextView":
view = new AppCompatAutoCompleteTextView(context, attrs);
break;
case "MultiAutoCompleteTextView":
view = new AppCompatMultiAutoCompleteTextView(context, attrs);
break;
case "RatingBar":
view = new AppCompatRatingBar(context, attrs);
break;
case "SeekBar":
view = new AppCompatSeekBar(context, attrs);
break;
}
if (view == null && originalContext != context) {
// If the original context does not equal our themed context, then we need to manually
// inflate it using the name so that android:theme takes effect.
view = createViewFromTag(context, name, attrs);
}
if (view != null) {
// If we have created a view, check it's android:onClick
checkOnClickListener(view, attrs);
}
return view;
}
private View createViewFromTag(Context context, String name, AttributeSet attrs) {
if (name.equals("view")) {
name = attrs.getAttributeValue(null, "class");
}
try {
mConstructorArgs[0] = context;
mConstructorArgs[1] = attrs;
if (-1 == name.indexOf('.')) {
for (int i = 0; i < sClassPrefixList.length; i++) {
final View view = createView(context, name, sClassPrefixList[i]);
if (view != null) {
return view;
}
}
return null;
} else {
return createView(context, name, null);
}
} catch (Exception e) {
// We do not want to catch these, lets return null and let the actual LayoutInflater
// try
return null;
} finally {
// Don't retain references on context.
mConstructorArgs[0] = null;
mConstructorArgs[1] = null;
}
}
/**
* android:onClick doesn't handle views with a ContextWrapper context. This method
* backports new framework functionality to traverse the Context wrappers to find a
* suitable target.
*/
private void checkOnClickListener(View view, AttributeSet attrs) {
final Context context = view.getContext();
if (!(context instanceof ContextWrapper) ||
(Build.VERSION.SDK_INT >= 15 && !ViewCompat.hasOnClickListeners(view))) {
// Skip our compat functionality if: the Context isn't a ContextWrapper, or
// the view doesn't have an OnClickListener (we can only rely on this on API 15+ so
// always use our compat code on older devices)
return;
}
final TypedArray a = context.obtainStyledAttributes(attrs, sOnClickAttrs);
final String handlerName = a.getString(0);
if (handlerName != null) {
view.setOnClickListener(new DeclaredOnClickListener(view, handlerName));
}
a.recycle();
}
private View createView(Context context, String name, String prefix)
throws ClassNotFoundException, InflateException {
Constructor<? extends View> constructor = sConstructorMap.get(name);
try {
if (constructor == null) {
// Class not found in the cache, see if it's real, and try to add it
Class<? extends View> clazz = context.getClassLoader().loadClass(
prefix != null ? (prefix + name) : name).asSubclass(View.class);
constructor = clazz.getConstructor(sConstructorSignature);
sConstructorMap.put(name, constructor);
}
constructor.setAccessible(true);
return constructor.newInstance(mConstructorArgs);
} catch (Exception e) {
// We do not want to catch these, lets return null and let the actual LayoutInflater
// try
return null;
}
}
/**
* Allows us to emulate the {@code android:theme} attribute for devices before L.
*/
private static Context themifyContext(Context context, AttributeSet attrs,
boolean useAndroidTheme, boolean useAppTheme) {
final TypedArray a = context.obtainStyledAttributes(attrs, android.support.v7.appcompat.R.styleable.View, 0, 0);
int themeId = 0;
if (useAndroidTheme) {
// First try reading android:theme if enabled
themeId = a.getResourceId(android.support.v7.appcompat.R.styleable.View_android_theme, 0);
}
if (useAppTheme && themeId == 0) {
// ...if that didn't work, try reading app:theme (for legacy reasons) if enabled
themeId = a.getResourceId(android.support.v7.appcompat.R.styleable.View_theme, 0);
if (themeId != 0) {
Log.i(LOG_TAG, "app:theme is now deprecated. "
+ "Please move to using android:theme instead.");
}
}
a.recycle();
if (themeId != 0 && (!(context instanceof ContextThemeWrapper)
|| ((ContextThemeWrapper) context).getThemeResId() != themeId)) {
// If the context isn't a ContextThemeWrapper, or it is but does not have
// the same theme as we need, wrap it in a new wrapper
context = new ContextThemeWrapper(context, themeId);
}
return context;
}
/**
* An implementation of OnClickListener that attempts to lazily load a
* named click handling method from a parent or ancestor context.
*/
private static class DeclaredOnClickListener implements View.OnClickListener {
private final View mHostView;
private final String mMethodName;
private Method mResolvedMethod;
private Context mResolvedContext;
public DeclaredOnClickListener(@NonNull View hostView, @NonNull String methodName) {
mHostView = hostView;
mMethodName = methodName;
}
@Override
public void onClick(@NonNull View v) {
if (mResolvedMethod == null) {
resolveMethod(mHostView.getContext(), mMethodName);
}
try {
mResolvedMethod.invoke(mResolvedContext, v);
} catch (IllegalAccessException e) {
throw new IllegalStateException(
"Could not execute non-public method for android:onClick", e);
} catch (InvocationTargetException e) {
throw new IllegalStateException(
"Could not execute method for android:onClick", e);
}
}
@NonNull
private void resolveMethod(@Nullable Context context, @NonNull String name) {
while (context != null) {
try {
if (!context.isRestricted()) {
final Method method = context.getClass().getMethod(mMethodName, View.class);
if (method != null) {
mResolvedMethod = method;
mResolvedContext = context;
return;
}
}
} catch (NoSuchMethodException e) {
// Failed to find method, keep searching up the hierarchy.
}
if (context instanceof ContextWrapper) {
context = ((ContextWrapper) context).getBaseContext();
} else {
// Can't search up the hierarchy, null out and fail.
context = null;
}
}
final int id = mHostView.getId();
final String idText = id == View.NO_ID ? "" : " with id '"
+ mHostView.getContext().getResources().getResourceEntryName(id) + "'";
throw new IllegalStateException("Could not find method " + mMethodName
+ "(View) in a parent or ancestor Context for android:onClick "
+ "attribute defined on view " + mHostView.getClass() + idText);
}
}
}
使用
public void skin(View view) {
//换肤
String skinPath= Environment.getExternalStorageDirectory().getAbsolutePath()+File.separator
+ "Download"+File.separator+"meinv.skin";
int loadSkin = SkinManager.getInstance().loadSkin(skinPath);
}
public void skin1(View view) {
//默认
SkinManager.getInstance().restoreDefault();
}
public void skin2(View view) {
//跳转
Intent intent = new Intent(this, MainActivity.class);
startActivity(intent);
}
