前言
APP更换皮肤的方式有很多，如系统自带的黑夜模式、插件换肤、通过下发配置文件加载不同主题等等，我们这里就浅谈下插件换肤方式。想实现插件换肤功能，我们就需要先弄清楚 :APP是如何完成资源加载的。
资源加载流程
这里我们以ImageView加载图片来进行分析，我们先看下ImageView获取drawable的源码：
public ImageView(Context context, @Nullable AttributeSet attrs, int defStyleAttr,
int defStyleRes) {
super(context, attrs, defStyleAttr, defStyleRes);
initImageView();
...
final Drawable d = a.getDrawable(R.styleable.ImageView_src);
if (d != null) {
setImageDrawable(d);
}
...
}
重点在a.getDrawable(R.styleable.ImageView_src)这段代码，我们继续跟进：
TypedArray.getDrawable()
public Drawable getDrawable(@StyleableRes int index) {
return getDrawableForDensity(index, 0);
}
TypedArray.getDrawableForDensity()
public Drawable getDrawableForDensity(@StyleableRes int index, int density) {
...
return mResources.loadDrawable(value, value.resourceId, density, mTheme);
}
return null;
}
Resources.loadDrawable()
Drawable loadDrawable(@NonNull TypedValue value, int id, int density, @Nullable Theme theme) throws NotFoundException {
return mResourcesImpl.loadDrawable(this, value, id, density, theme);
}
ResourcesImpl.loadDrawable（）
Drawable loadDrawable(@NonNull Resources wrapper, @NonNull TypedValue value, int id,
int density, @Nullable Resources.Theme theme)
throws NotFoundException {
...
//如果使用缓存，先从缓存中取cachedDrawable
if (!mPreloading && useCache) {
final Drawable cachedDrawable = caches.getInstance(key, wrapper, theme);
if (cachedDrawable != null) {
cachedDrawable.setChangingConfigurations(value.changingConfigurations);
return cachedDrawable;
}
}
...
// 重点就是loadDrawableForCookie方法
dr = loadDrawableForCookie(wrapper, value, id, density);
...
}
}
从上面我们可以看到，资源加载通过Resources这个类，而它又将任务交给它的实现类ResourcesImpl,我们重点分析下ResourcesImpl.loadDrawableForCookie方法：
private Drawable loadDrawableForCookie(@NonNull Resources wrapper, @NonNull TypedValue value,
int id, int density) {
...
final String file = value.string.toString();
...
try {
//加载xml资源，如drawable下定义的shape.xml文件
if (file.endsWith(".xml")) {
final String typeName = getResourceTypeName(id);
if (typeName != null && typeName.equals("color")) {
dr = loadColorOrXmlDrawable(wrapper, value, id, density, file);
} else {
dr = loadXmlDrawable(wrapper, value, id, density, file);
}
} else {
//通过mAssets（AssetManager类型）打开资源文件流实现加载
final InputStream is = mAssets.openNonAsset(
value.assetCookie, file, AssetManager.ACCESS_STREAMING);
final AssetInputStream ais = (AssetInputStream) is;
dr = decodeImageDrawable(ais, wrapper, value);
}
} finally {
stack.pop();
}
} catch (Exception | StackOverflowError e) {
Trace.traceEnd(Trace.TRACE_TAG_RESOURCES);
final NotFoundException rnf = new NotFoundException(
"File " + file + " from drawable resource ID #0x" + Integer.toHexString(id));
rnf.initCause(e);
throw rnf;
...
}
}
return dr;
}
这里我们可以看到最终是交给AssetManager来进行资源文件访问，读取数据流完成资源加载。
通过上面源码分析，我们知道可以通过Resources来实现资源加载，那系统中Resources又是如何创建的呢？
Resources创建流程分析
我们在代码中经常这样使用：context.getResources().getDrawable(),那我们就从context的实现类ContextImpl抓起：
### ContextImpl
public Context createApplicationContext(ApplicationInfo application, int flags)
throws NameNotFoundException {
// 找到createResources方法
c.setResources(createResources(mToken, pi, null, displayId, null,
getDisplayAdjustments(displayId).getCompatibilityInfo(), null));
if (c.mResources != null) {
return c;
}
}
}
createResources方法跟进
private static Resources createResources(IBinder activityToken, LoadedApk pi, String splitName,
int displayId, Configuration overrideConfig, CompatibilityInfo compatInfo,
List<ResourcesLoader> resourcesLoader) {
final String[] splitResDirs;
final ClassLoader classLoader;
try {
splitResDirs = pi.getSplitPaths(splitName);
classLoader = pi.getSplitClassLoader(splitName);
} catch (NameNotFoundException e) {
throw new RuntimeException(e);
}
return ResourcesManager.getInstance().getResources(activityToken,
pi.getResDir(),
splitResDirs,
pi.getOverlayDirs(),
pi.getApplicationInfo().sharedLibraryFiles,
displayId,
overrideConfig,
compatInfo,
classLoader,
resourcesLoader);
}
ResourcesManager的getResources方法：
public @Nullable Resources getResources(
@Nullable IBinder activityToken,
@Nullable String resDir,
@Nullable String[] splitResDirs,
@Nullable String[] overlayDirs,
@Nullable String[] libDirs,
int displayId,
@Nullable Configuration overrideConfig,
@NonNull CompatibilityInfo compatInfo,
@Nullable ClassLoader classLoader,
@Nullable List<ResourcesLoader> loaders) {
try {
...
return createResources(activityToken, key, classLoader);
} finally {
Trace.traceEnd(Trace.TRACE_TAG_RESOURCES);
}
}
createResources方法如下：
private @Nullable Resources createResources(@Nullable IBinder activityToken,
@NonNull ResourcesKey key, @NonNull ClassLoader classLoader) {
synchronized (this) {
...
// Resources的创建需要resourcesImpl
ResourcesImpl resourcesImpl = findOrCreateResourcesImplForKeyLocked(key);
if (resourcesImpl == null) {
return null;
}
if (activityToken != null) {
return createResourcesForActivityLocked(activityToken, classLoader,
resourcesImpl, key.mCompatInfo);
} else {
return createResourcesLocked(classLoader, resourcesImpl, key.mCompatInfo);
}
}
}
createResourcesLocked方法如下：
private @NonNull Resources createResourcesLocked(@NonNull ClassLoader classLoader,
@NonNull ResourcesImpl impl, @NonNull CompatibilityInfo compatInfo) {
cleanupReferences(mResourceReferences, mResourcesReferencesQueue);
//系统源码中其实就是通过classLoader直接new了一个Resources，并初始化了resourcesImpl方便后续资源加载
Resources resources = compatInfo.needsCompatResources() ? new CompatResources(classLoader)
: new Resources(classLoader);
resources.setImpl(impl);
resources.setCallbacks(mUpdateCallbacks);
mResourceReferences.add(new WeakReference<>(resources, mResourcesReferencesQueue));
if (DEBUG) {
Slog.d(TAG, "- creating new ref=" + resources);
Slog.d(TAG, "- setting ref=" + resources + " with impl=" + impl);
}
return resources;
}
通过上面源码分析，我们可以得出结论：在ApplicationContext创建的时候，就完成了Resources的创建，创建是通过ResourcesManager来完成的。
那我们是不是就可以通过创建新的Resources来实现插件中资源的访问呢！！
插件换肤案例
我们先看下Resources的构造方法：
@Deprecated
public Resources(AssetManager assets, DisplayMetrics metrics, Configuration config) {
this(null);
mResourcesImpl = new ResourcesImpl(assets, metrics, config, new DisplayAdjustments());
}
/**
* @hide
*/
@UnsupportedAppUsage
public Resources(@Nullable ClassLoader classLoader) {
mClassLoader = classLoader == null ? ClassLoader.getSystemClassLoader() : classLoader;
}
/**
* Only for creating the System resources.
*/
@UnsupportedAppUsage
private Resources() {
this(null);
final DisplayMetrics metrics = new DisplayMetrics();
metrics.setToDefaults();
final Configuration config = new Configuration();
config.setToDefaults();
mResourcesImpl = new ResourcesImpl(AssetManager.getSystem(), metrics, config,
new DisplayAdjustments());
}
这里有三个构造方法，由于我们需要加载插件中的资源文件，通过上面的分析，我们知道资源访问是需要通过AssetManager来完成的，因此我们使用Resources(AssetManager assets, DisplayMetrics metrics, Configuration config)这个方式来完成插件资源加载：
private lateinit var iv: ImageView
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
iv = findViewById<ImageView>(R.id.iv)
iv.setImageDrawable(getDrawable(R.drawable.b))
findViewById<Button>(R.id.btn).setOnClickListener {
//更新皮肤
updateSkin()
}
}
private fun updateSkin() {
//反射调用AssetManager的addAssetPath方法
val assetMangerClazz = AssetManager::class.java
val assetManger = assetMangerClazz.newInstance()
//皮肤存放在当前包路径下
val skinPath = filesDir.path + File.separator + "skin.skin"
val method = assetMangerClazz.getDeclaredMethod("addAssetPath", String::class.java)
method.isAccessible = true
method.invoke(assetManger, skinPath)
//创建皮肤的Resources对象
val skinResources = Resources(assetManger, resources.displayMetrics, resources.configuration)
//通过资源名称，类型，包获取Id
val skinId = skinResources.getIdentifier("a", "drawable", "com.crystal.skin")
val skinDrawable = skinResources.getDrawable(skinId, null)
iv.setImageDrawable(skinDrawable)
}
测试效果：
总结
通过源码分析，了解了资源加载的基本流程，对插件换肤的实现有了进一步的认知。
参考文档
结语
如果以上文章对您有一点点帮助，希望您不要吝啬的点个赞加个关注，您每一次小小的举动都是我坚持写作的不懈动力！ღ( ´･ᴗ･` )
1285
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
