一.问题背景描述
测试妹子:我发现我一打开X界面，Y界面的分隔线消失了！！！
我:这么神奇？？？
二.初找原因
经过一顿操作后发现，这两个界面用到同一个颜色值，而X界面对用了这个颜色值的当背景的view改变了透明度，所以再打开Y界面的时候，用同一个颜色的分割线就消失了。
三.临时解决
考虑到项目进度，我先用这个颜色写了一个shape来当背景，五分钟解决问题。
四.寻找真相
对于真相的好奇，打算看看究竟咋回事，之前对于资源加载这块也没好好了解过，趁这次正好看一下。
猜测
一定是哪里对这颜色做了缓存，如果这个猜测是对的，那么打印这两个drawable应该是同一个对象
I bbbb : ====background=android.graphics.drawable.ColorDrawable@f74fed8
I bbbb : ====getDrawable=android.graphics.drawable.ColorDrawable@d868231
凉凉,不是同一个对象，猜想错误
分析
那么接下来只能看源码了。通过setbackground不断的深入，最后来到ResourcesImpl.loadDrawable。
仔细看一下这个drawable的加载流程。
Drawable loadDrawable(@NonNull Resources wrapper, @NonNull TypedValue value, int id,
int density, @Nullable Resources.Theme theme)
throws NotFoundException {
...
}
1. 先判断是不是ColorDrawable,然后去取相应类型的缓存。
final boolean isColorDrawable;
final DrawableCache caches;
final long key;
if (value.type >= TypedValue.TYPE_FIRST_COLOR_INT
&& value.type <= TypedValue.TYPE_LAST_COLOR_INT) {
isColorDrawable = true;
caches = mColorDrawableCache;
key = value.data;
} else {
isColorDrawable = false;
caches = mDrawableCache;
key = (((long) value.assetCookie) << 32) | value.data;
}
ColorDrawable和其他drawable分别是两个缓存
private final DrawableCache mDrawableCache = new DrawableCache();
private final DrawableCache mColorDrawableCache = new DrawableCache();
至于其他drawable都有些啥，这就有点多了，如下图，
接下来其他Drawable都以BitmapDrawable为代表。
2. 缓存里是否能取到Drawable，如果有就直接返回。这里代码请先忽略!mPreloading && useCache这个条件
if (!mPreloading && useCache) {
//注意这里getInstance方法，等一下会分析到
final Drawable cachedDrawable = caches.getInstance(key, wrapper, theme);
if (cachedDrawable != null) {
return cachedDrawable;
}
}
3. 如果缓存里没有，就加载新的drawable。(中间略过了跟预加载相关的部分)
Drawable dr;
if (cs != null) {
//这里是对预加载来的判断，暂时先跳过
dr = cs.newDrawable(wrapper);
} else if (isColorDrawable) {
dr = new ColorDrawable(value.data);
} else {
dr = loadDrawableForCookie(wrapper, value, id, null);
}
4. 缓存这次生成的drawable，并返回，然后看一下缓存的代码
if (dr != null && useCache) {
dr.setChangingConfigurations(value.changingConfigurations);
cacheDrawable(value, isColorDrawable, caches, theme, canApplyTheme, key, dr);
}
return dr;
然后看一下缓存的代码,就是把当前的ConstantState缓存起来，ConstantState是从Drawable获取的，具体ConstantState是啥，接着往下。
private void cacheDrawable(TypedValue value, boolean isColorDrawable, DrawableCache caches,
Resources.Theme theme, boolean usesTheme, long key, Drawable dr) {
final Drawable.ConstantState cs = dr.getConstantState();
if (cs == null) {
return;
}
...
synchronized (mAccessLock) {
caches.put(key, theme, cs, usesTheme);
}
}
}
目前的结论，加载drawable这个过程，针对ColorDrawable和非ColorDrawable分别加了两个缓存mColorDrawableCache和mDrawableCache，这两个cache都是DrawableCache，都继承于ThemedResourceCache。里面都存放着Drawable.ConstantState。
class DrawableCache extends ThemedResourceCache<Drawable.ConstantState> {
...
public Drawable getInstance(long key, Resources resources, Resources.Theme theme) {
final Drawable.ConstantState entry = get(key, theme);
if (entry != null) {
return entry.newDrawable(resources, theme);
}
return null;
}
...
}
其中ThemedResourceCache有mThemedEntries，mUnthemedEntries，mNullThemedEntries存放着各种资源，主要是对不同主题的支持。这里的存储数据结构是ArrayMap和LongSparseArray。
abstract class ThemedResourceCache<T> {
private ArrayMap<ThemeKey, LongSparseArray<WeakReference<T>>> mThemedEntries;
private LongSparseArray<WeakReference<T>> mUnthemedEntries;
private LongSparseArray<WeakReference<T>> mNullThemedEntries;
...
}
mColorDrawableCache和ColorDrawable具体缓存的东西不一样，mColorDrawableCache是存放ColorDrawable.ColorState,mDrawableCache是存放BItmapDrawable.BItmapState。ColorDrawable.ColorState和BItmapDrawable.BItmapState都继承于Drawable.ConstantState。
5. 接着分析，从刚才的第2步里面看到，如果缓存里面取到Drawable.ConstantState，就会调用getInstance，然后返回Drawable。
那么这个getInstance是怎么得到相应的Drawable的呢？
在刚才的DrawableCache的代码看到是通过Drawable.ConstantState.newDrawable得到的。再贴一下这段代码
class DrawableCache extends ThemedResourceCache<Drawable.ConstantState> {
...
public Drawable getInstance(long key, Resources resources, Resources.Theme theme) {
final Drawable.ConstantState entry = get(key, theme);
if (entry != null) {
return entry.newDrawable(resources, theme);
}
return null;
}
...
}
那么接下来看看Drawable.ConstantState.newDrawable，这里我们选取ColorDrawable.ColorState作为代表，比较简单，易于理解。
public class ColorDrawable extends Drawable {
private ColorState mColorState;
private boolean mMutated;
public ColorDrawable() {
mColorState = new ColorState();
}
public ColorDrawable(@ColorInt int color) {
mColorState = new ColorState();
setColor(color);
}
@Override
public Drawable mutate() {
if (!mMutated && super.mutate() == this) {
mColorState = new ColorState(mColorState);
mMutated = true;
}
return this;
}
@ColorInt
public int getColor() {
return mColorState.mUseColor;
}
@Override
public ConstantState getConstantState() {
return mColorState;
}
final static class ColorState extends ConstantState {
int[] mThemeAttrs;
int mBaseColor; // base color, independent of setAlpha()
@ViewDebug.ExportedProperty
int mUseColor; // basecolor modulated by setAlpha()
@Config int mChangingConfigurations;
ColorStateList mTint = null;
Mode mTintMode = DEFAULT_TINT_MODE;
ColorState() {
// Empty constructor.
}
ColorState(ColorState state) {
mThemeAttrs = state.mThemeAttrs;
mBaseColor = state.mBaseColor;
mUseColor = state.mUseColor;
mChangingConfigurations = state.mChangingConfigurations;
mTint = state.mTint;
mTintMode = state.mTintMode;
}
@Override
public Drawable newDrawable() {
return new ColorDrawable(this, null);
}
@Override
public Drawable newDrawable(Resources res) {
return new ColorDrawable(this, res);
}
}
private ColorDrawable(ColorState state, Resources res) {
mColorState = state;
updateLocalState(res);
}
}
这里我删除了很多于这里无关的代码。从newDrawable的方法看出，即使刚才我们从缓存里面取到了缓存的ColorState，但还是会new ColorDrawable，所以就出现了，刚开始打脸的一幕，Drawable并不是同一个对象。但是，new drawable这个过程中，会把ColorState也传到新的Drawable中，所以ColorState中的属性都会传到新的Drawable。
那么现在可以大胆的猜想:
1. 刚开始的猜想，再进一步获取ConstantState,这两个的ConstantState肯定就是同一个对象了。验证如下
I bbbb : ====background cs=android.graphics.drawable.ColorDrawable$ColorState@dfe7bd1
I bbbb : ====getDrawable cs=android.graphics.drawable.ColorDrawable$ColorState@dfe7bd1
2. ConstantState里面一定存储着改变后的Drawable，要不然也不会获取到，透明度改变后的颜色了。
这个可以从ColorState里面的属性可以容易的发现mUseColor，这个就是改变后的颜色。
同理BitmapDrawable等一些其他的Drawable也是类似的，只是相应的ConstantState存储东西不一样而已。
至此我们，大概缕清楚了这个缓存的过程。
五.正经的解决办法
那么这个getDrawable互相影响的问题，到底怎么解决呢？难道只能想我刚开始用的方法一样，新建另外一个资源吗。那可能有点低估了Google爸爸了。
在刚才ColorDrawable里面的代码中有个mutate方法注意到没，这个方法里面有new ColorState(mColorState)，会把原来的ColorState传进去，再new一个ColorState。
这样我们只要在设置独有的属性前，调用mutate，就不会影响到其他的Drawable了。
六.总结
问题: drawable在不同的地方，修改属性会相互影响，
原因: android缓存了调用过的drawable的ConstantState，ConstantState里面保存了drawable的一些属性
解决方法: 设置独有的属性前，调用mutate，就不会影响到其他的Drawable了
