Android Drawable完全解析（一）：Drawable源码分析（上）
Android Drawable完全解析（一）：Drawable源码分析（中）
Android Drawable完全解析（一）：Drawable源码分析（下）
呃…我不是故意要凑篇幅写个什么上下篇，实在是因为Drawable源码有点长，一篇写不下啦O(∩_∩)O~
鉴于源码一般较长，以后所有源码分析的部分，英文注释非必要情况都不再保留！
2:Drawable源码分析/翻译
继续上Drawable源码:
package android.graphics.drawable;
public abstract class Drawable {
****
略
****
/** 这个方法很重要，故保留英文注释！ 调用mutate()，使当前Drawable实例mutable，这个操作不可逆。 一个mutable的Drawable实例不会和其他Drawable实例共享它的状态。 当你需要修改一个从资源文件加载的Drawable实例时，mutate()方法尤其有用。 默认情况下，所有加载同一资源文件生成的Drawable实例都共享一个通用的状态， 如果你修改了其中一个Drawable实例，所有的相关Drawable实例都会发生同样的变化。 这个方法在[其实你不懂：Drawable着色(tint)的兼容方案 源码解析] 这篇文章里有过介绍，就是为了限定Drawable实例的编辑生效范围仅限于自身。 * Make this drawable mutable. This operation cannot be reversed. A mutable * drawable is guaranteed to not share its state with any other drawable. * This is especially useful when you need to modify properties of drawables * loaded from resources. By default, all drawables instances loaded from * the same resource share a common state; if you modify the state of one * instance, all the other instances will receive the same modification. * * Calling this method on a mutable Drawable will have no effect. * * @return This drawable. * @see ConstantState * @see #getConstantState() */
public @NonNull Drawable mutate() {
return this;
}
/** 被隐匿 * @hide */
public void clearMutated() {
// Default implementation is no-op.
}
//下面几个方法介绍了通过不同的方式创建Drawable实例：
//流、XML、文件地址
public static Drawable createFromStream(InputStream is, String srcName) {
Trace.traceBegin(Trace.TRACE_TAG_RESOURCES, srcName != null ? srcName : "Unknown drawable");
try {
return createFromResourceStream(null, null, is, srcName);
} finally {
Trace.traceEnd(Trace.TRACE_TAG_RESOURCES);
}
}
public static Drawable createFromResourceStream(Resources res, TypedValue value, InputStream is, String srcName) {
Trace.traceBegin(Trace.TRACE_TAG_RESOURCES, srcName != null ? srcName : "Unknown drawable");
try {
return createFromResourceStream(res, value, is, srcName, null);
} finally {
Trace.traceEnd(Trace.TRACE_TAG_RESOURCES);
}
}
public static Drawable createFromResourceStream(Resources res, TypedValue value, InputStream is, String srcName, BitmapFactory.Options opts) {
if (is == null) {
return null;
}
Rect pad = new Rect();
if (opts == null) opts = new BitmapFactory.Options();
opts.inScreenDensity = Drawable.resolveDensity(res, 0);
Bitmap bm = BitmapFactory.decodeResourceStream(res, value, is, pad, opts);
if (bm != null) {
byte[] np = bm.getNinePatchChunk();
if (np == null || !NinePatch.isNinePatchChunk(np)) {
np = null;
pad = null;
}
final Rect opticalInsets = new Rect();
bm.getOpticalInsets(opticalInsets);
return drawableFromBitmap(res, bm, np, pad, opticalInsets, srcName);
}
return null;
}
public static Drawable createFromXml(Resources r, XmlPullParser parser) throws XmlPullParserException, IOException {
return createFromXml(r, parser, null);
}
public static Drawable createFromXml(Resources r, XmlPullParser parser, Theme theme) throws XmlPullParserException, IOException {
AttributeSet attrs = Xml.asAttributeSet(parser);
int type;
//noinspection StatementWithEmptyBody
while ((type=parser.next()) != XmlPullParser.START_TAG
&& type != XmlPullParser.END_DOCUMENT) {
// Empty loop.
}
if (type != XmlPullParser.START_TAG) {
throw new XmlPullParserException("No start tag found");
}
Drawable drawable = createFromXmlInner(r, parser, attrs, theme);
if (drawable == null) {
throw new RuntimeException("Unknown initial tag: " + parser.getName());
}
return drawable;
}
public static Drawable createFromXmlInner(Resources r, XmlPullParser parser, AttributeSet attrs) throws XmlPullParserException, IOException {
return createFromXmlInner(r, parser, attrs, null);
}
public static Drawable createFromXmlInner(Resources r, XmlPullParser parser, AttributeSet attrs, Theme theme) throws XmlPullParserException, IOException {
return r.getDrawableInflater().inflateFromXml(parser.getName(), parser, attrs, theme);
}
public static Drawable createFromPath(String pathName) {
if (pathName == null) {
return null;
}
Trace.traceBegin(Trace.TRACE_TAG_RESOURCES, pathName);
try {
Bitmap bm = BitmapFactory.decodeFile(pathName);
if (bm != null) {
return drawableFromBitmap(null, bm, null, null, null, pathName);
}
} finally {
Trace.traceEnd(Trace.TRACE_TAG_RESOURCES);
}
return null;
}
public void inflate(@NonNull Resources r, @NonNull XmlPullParser parser, @NonNull AttributeSet attrs) throws XmlPullParserException, IOException {
inflate(r, parser, attrs, null);
}
/** 从XML文件中加载Drawable实例，Drawable实例接受主题设置的风格 */
public void inflate(@NonNull Resources r, @NonNull XmlPullParser parser, @NonNull AttributeSet attrs, @Nullable Theme theme) throws XmlPullParserException, IOException {
final TypedArray a = obtainAttributes(r, theme, attrs, R.styleable.Drawable);
mVisible = a.getBoolean(R.styleable.Drawable_visible, mVisible);
a.recycle();
}
/** 从XML文件中加载Drawable实例 */
void inflateWithAttributes(@NonNull @SuppressWarnings("unused") Resources r,
@NonNull @SuppressWarnings("unused") XmlPullParser parser, @NonNull TypedArray attrs,
@AttrRes int visibleAttr) throws XmlPullParserException, IOException {
mVisible = attrs.getBoolean(visibleAttr, mVisible);
}
/** 这段注释很重要，故保留英文注释！ ConstantState这个抽象类被用于存储 多个Drawable实例间 共享的 常量状态值及数据。 如从同一个图片资源创建的多个BitmapDrawable实例，它们将共享 同一个存储在它们的ConstantState中的Bitmap。 * This abstract class is used by {@link Drawable}s to store shared constant state and data * between Drawables. {@link BitmapDrawable}s created from the same resource will for instance * share a unique bitmap stored in their ConstantState. * newDrawable可以运用ConstantState创建一个新的Drawable实例 * <p> * {@link #newDrawable(Resources)} can be used as a factory to create new Drawable instances * from this ConstantState. * </p> * Drawable#getConstantState可以获取一个Drawable关联的ConstantState。 调用Drawable#mutate()，则将为新创建的Drawable实例单独关联一个ConstantState。 * Use {@link Drawable#getConstantState()} to retrieve the ConstantState of a Drawable. Calling * {@link Drawable#mutate()} on a Drawable should typically create a new ConstantState for that * Drawable. */
public static abstract class ConstantState {
/** 运用ConstantState创建一个新的Drawable实例 */
public abstract @NonNull Drawable newDrawable();
/** 运用ConstantState创建一个新的Drawable实例 */
public @NonNull Drawable newDrawable(@Nullable Resources res) {
return newDrawable();
}
/** 运用ConstantState创建一个新的Drawable实例 */
public @NonNull Drawable newDrawable(@Nullable Resources res,
@Nullable @SuppressWarnings("unused") Theme theme) {
return newDrawable(res);
}
/** 返回会影响Drawable实例的一个bit掩码变化设置 */
public abstract @Config int getChangingConfigurations();
/** 返回所有的像素数 public int addAtlasableBitmaps(@NonNull Collection<Bitmap> atlasList) { return 0; } /** @hide */
protected final boolean isAtlasable(@Nullable Bitmap bitmap) {
return bitmap != null && bitmap.getConfig() == Bitmap.Config.ARGB_8888;
}
/** 返回当前共享状态是否可以设置主题 */
public boolean canApplyTheme() {
return false;
}
}
/** 返回当前Drawable的用于存储共享状态值的ConstantState实例 */
public @Nullable ConstantState getConstantState() {
return null;
}
//通过Bitmap实例创建Drawable实例
private static Drawable drawableFromBitmap(Resources res, Bitmap bm, byte[] np, Rect pad, Rect layoutBounds, String srcName) {
if (np != null) {
return new NinePatchDrawable(res, bm, np, pad, layoutBounds, srcName);
}
return new BitmapDrawable(res, bm);
}
/** 确保色彩过滤器和当前色彩与色彩模式一致 */
@Nullable PorterDuffColorFilter updateTintFilter(@Nullable PorterDuffColorFilter tintFilter, @Nullable ColorStateList tint, @Nullable PorterDuff.Mode tintMode) {
if (tint == null || tintMode == null) {
return null;
}
final int color = tint.getColorForState(getState(), Color.TRANSPARENT);
if (tintFilter == null) {
return new PorterDuffColorFilter(color, tintMode);
}
tintFilter.setColor(color);
tintFilter.setMode(tintMode);
return tintFilter;
}
/** 如果主题有效，则从中获取样式属性， 如果主题无效，则返回没有样式的资源。 */
static @NonNull TypedArray obtainAttributes(@NonNull Resources res, @Nullable Theme theme, @NonNull AttributeSet set, @NonNull int[] attrs) {
if (theme == null) {
return res.obtainAttributes(set, attrs);
}
return theme.obtainStyledAttributes(set, attrs, 0, 0);
}
/** 根据 原始像素值，资源单位密度和目标设备单位密度 获得一个float像素值 */
static float scaleFromDensity(float pixels, int sourceDensity, int targetDensity) {
return pixels * targetDensity / sourceDensity;
}
static int scaleFromDensity( int pixels, int sourceDensity, int targetDensity, boolean isSize) {
if (pixels == 0 || sourceDensity == targetDensity) {
return pixels;
}
final float result = pixels * targetDensity / (float) sourceDensity;
if (!isSize) {
return (int) result;
}
final int rounded = Math.round(result);
if (rounded != 0) {
return rounded;
} else if (pixels > 0) {
return 1;
} else {
return -1;
}
}
//获取单位密度
static int resolveDensity(@Nullable Resources r, int parentDensity) {
final int densityDpi = r == null ? parentDensity : r.getDisplayMetrics().densityDpi;
return densityDpi == 0 ? DisplayMetrics.DENSITY_DEFAULT : densityDpi;
}
static void rethrowAsRuntimeException(@NonNull Exception cause) throws RuntimeException {
final RuntimeException e = new RuntimeException(cause);
e.setStackTrace(new StackTraceElement[0]);
throw e;
}
/** 通过解析tintMode属性枚举值获得一个PorterDuff.Mode 被隐匿 * @hide */
public static PorterDuff.Mode parseTintMode(int value, Mode defaultMode) {
switch (value) {
case 3: return Mode.SRC_OVER;
case 5: return Mode.SRC_IN;
case 9: return Mode.SRC_ATOP;
case 14: return Mode.MULTIPLY;
case 15: return Mode.SCREEN;
case 16: return Mode.ADD;
default: return defaultMode;
}
}
}Drawable类本身源码先写到这儿，接着往下看。
3:Drawable绘制流程
看过Drawable源码，其实我们还是不清楚:
Drawable实例到底是如何被绘制到屏幕上面？
Drawable源码中的那些方法又是什么时候被谁调用的？
我们回想一下，使用Drawable最通常的步骤：
通过Resource获取Drawable实例
将获取的Drawable实例当做背景设置给View或者作为ImageView的src进行显示:
下面就逐步分析理解Drawable的绘制流程。
3.1:通过Resource获取Drawable实例
最常用写法：getResources().getDrawable(int id)，看下关键代码：
public class Resources {
****
public Drawable getDrawable(@DrawableRes int id) throws NotFoundException {
final Drawable d = getDrawable(id, null);
*****
return d;
}
public Drawable getDrawable(@DrawableRes int id, @Nullable Theme theme) throws NotFoundException {
final TypedValue value = obtainTempTypedValue();
try {
final ResourcesImpl impl = mResourcesImpl;
//
impl.getValue(id, value, true);
//将获取到的Drawable实例返回
return impl.loadDrawable(this, value, id, theme, true);
} ****
}
}
一路追踪下去：
public class ResourcesImpl {
//Resource实例，TypedValue，资源ID，Theme实例，true
@Nullable Drawable loadDrawable(Resources wrapper, TypedValue value, int id, Resources.Theme theme, boolean useCache) throws NotFoundException {
try {
********
//是否属于ColorDrawable
final boolean isColorDrawable;
//Drawable缓存
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;
}
if (!mPreloading && useCache) {
final Drawable cachedDrawable = caches.getInstance(key, wrapper, theme);
if (cachedDrawable != null) {
return cachedDrawable;
}
}
//如果在Drawable缓存里面未找到资源ID对应的Drawable实例，继续
final Drawable.ConstantState cs;
if (isColorDrawable) {
cs = sPreloadedColorDrawables.get(key);
} else {
//如果不属于颜色资源，则从sPreloadedDrawables中查询
//sPreloadedDrawables只有在执行cacheDrawable方法时
//才会进行数据添加：而第一次加载图片时候还未执行cacheDrawable
//所以此时cs = null.
cs = sPreloadedDrawables[mConfiguration.getLayoutDirection()].get(key);
}
Drawable dr;
if (cs != null) {
dr = cs.newDrawable(wrapper);
} else if (isColorDrawable) {
dr = new ColorDrawable(value.data);
} else {
//当第一次加载图片资源时候，cs=null且不属于颜色资源，
//实际是通过loadDrawableForCookie来获取Drawable实例
dr = loadDrawableForCookie(wrapper, value, id, null);
}
*********
}
private Drawable loadDrawableForCookie(Resources wrapper, TypedValue value, int id, Resources.Theme theme) {
****
final String file = value.string.toString();
****
final Drawable dr;
Trace.traceBegin(Trace.TRACE_TAG_RESOURCES, file);
try {
if (file.endsWith(".xml")) {
//如果是从xml文件加载Drawable
final XmlResourceParser rp = loadXmlResourceParser(
file, id, value.assetCookie, "drawable");
dr = Drawable.createFromXml(wrapper, rp, theme);
rp.close();
} else {
//从图片资源加载Drawable，执行Drawable.createFromResourceStream
//获取Drawable实例
final InputStream is = mAssets.openNonAsset(
value.assetCookie, file, AssetManager.ACCESS_STREAMING);
dr = Drawable.createFromResourceStream(wrapper, value, is, file, null);
is.close();
}
} catch (Exception e) {
****
}
****
return dr;
}
}
一路追踪下去：
public abstract class Drawable {
public static Drawable createFromResourceStream(Resources res, TypedValue value, InputStream is, String srcName, BitmapFactory.Options opts) {
****
return drawableFromBitmap(res, bm, np, pad, opticalInsets, srcName);
****
}
private static Drawable drawableFromBitmap(Resources res, Bitmap bm, byte[] np, Rect pad, Rect layoutBounds, String srcName) {
if (np != null) {
//如果加载的图片资源是.9 PNG，返回NinePatchDrawable实例
return new NinePatchDrawable(res, bm, np, pad, layoutBounds, srcName);
}
//对于普通图片资源，返回BitmapDrawable
return new BitmapDrawable(res, bm);
}
}由此可见，通过Resource实例加载一张资源图片：
.9图返回1个NinePatchDrawable实例；
普通图片返回1个BitmapDrawable实例。
3.2:将获取的Drawable实例当做背景设置给View
最常用写法：targetView.setBackgroundDrawable(Drawable bg),
同样看一下关键代码
public class View implements Drawable.Callback, KeyEvent.Callback,
AccessibilityEventSource {
****
public void setBackgroundDrawable(Drawable background) {
****
if (background == mBackground) {
//如果当前背景和background相同，直接return
return;
}
boolean requestLayout = false;
mBackgroundResource = 0;
if (mBackground != null) {
if (isAttachedToWindow()) {
//如果当前View实例已经被绘制到屏幕上，则首先取消
//该View实例原始背景Drawable的动画
mBackground.setVisible(false, false);
}
//移除该View实例原始背景Drawable的动画监听接口
mBackground.setCallback(null);
//取消该View实例原始背景Drawable的所有事件
unscheduleDrawable(mBackground);
}
if (background != null) {
****
//设置background的布局方向和View实例一致，
//Drawable.setLayoutDirection见上一篇文章
background.setLayoutDirection(getLayoutDirection());
if (background.getPadding(padding)) {
//如果Drawable实例background有padding
resetResolvedPaddingInternal();
switch (background.getLayoutDirection()) {
case LAYOUT_DIRECTION_RTL:
//布局方向从右至左
mUserPaddingLeftInitial = padding.right;
mUserPaddingRightInitial = padding.left;
internalSetPadding(padding.right, padding.top, padding.left, padding.bottom);
break;
case LAYOUT_DIRECTION_LTR:
default:
//布局方向从左至右
mUserPaddingLeftInitial = padding.left;
mUserPaddingRightInitial = padding.right;
//internalSetPadding会将四个参数值和View实例的padding进行比对，若不同则会重新布局+重建View的外部轮廓
internalSetPadding(padding.left, padding.top, padding.right, padding.bottom);
}
mLeftPaddingDefined = false;
mRightPaddingDefined = false;
}
if (mBackground == null
|| mBackground.getMinimumHeight() != background.getMinimumHeight()
|| mBackground.getMinimumWidth() != background.getMinimumWidth()) {
requestLayout = true;
}
//设置当前View实例的背景为传入的Drawable实例 background
mBackground = background;
if (background.isStateful()) {
//如果background会根据状态值变更外观，则设置其状态为
//当前View实例的state
background.setState(getDrawableState());
}
if (isAttachedToWindow()) {
//如果当前View实例已经被绘制到屏幕上
//且实例和实例的父控件及递归获得的根布局都处于可见状态，
//则设置background开启动画效果
background.setVisible(getWindowVisibility() == VISIBLE && isShown(), false);
}
applyBackgroundTint();
//设置background动画接口监听为View实例本身（View实现了 Drawable.Callback）：
//public class View implements Drawable.Callback
background.setCallback(this);
if ((mPrivateFlags & PFLAG_SKIP_DRAW) != 0) {
mPrivateFlags &= ~PFLAG_SKIP_DRAW;
//需要重新布局
requestLayout = true;
}
} else {
mBackground = null;
if ((mViewFlags & WILL_NOT_DRAW) != 0
&& (mForegroundInfo == null || mForegroundInfo.mDrawable == null)) {
mPrivateFlags |= PFLAG_SKIP_DRAW;
}
requestLayout = true;
}
computeOpaqueFlags();
if (requestLayout) {
//重新布局
requestLayout();
}
mBackgroundSizeChanged = true;
//重绘View实例
invalidate(true);
//重建View实例的外部轮廓
invalidateOutline();
}
}由此可见，setBackgroundDrawable方法，调用了Drawable实例的一系列方法，最终引发了View实例的重新布局（requestLayout()）重绘（invalidate(true)）及重建View实例的外部轮廓（invalidateOutline()）。
invalidate会触发draw方法，我们继续看View.draw方法的关键代码：
public void draw(Canvas canvas) {
****
/* 翻译可能不甚准确，欢迎英语好的同学留言指正O(∩_∩)O~ Draw方法会执行以下几个步骤，且必须按顺序执行： 1：绘制View实例的背景 2：如有必要，保存画布图层以备褪色 3：绘制View实例的内容 4：绘制View实例的中的子控件 5：如有必要，绘制边缘并恢复图层 6：绘制滚动条 * 1. Draw the background * 2. If necessary, save the canvas' layers to prepare for fading * 3. Draw view's content * 4. Draw children * 5. If necessary, draw the fading edges and restore layers * 6. Draw decorations (scrollbars for instance) */
//从步骤顺序上看，和Drawable相关的就是第1步，只看第1步代码
// Step 1, draw the background, if needed
int saveCount;
if (!dirtyOpaque) {
//绘制背景
drawBackground(canvas);
}
****
}
一路追踪下去：
private void drawBackground(Canvas canvas) {
//mBackground就是之前setBackgroundDrawable传入的Drawable实例
final Drawable background = mBackground;
if (background == null) {
return;
}
//设置background绘制范围为View实例的所在范围
setBackgroundBounds();
****
final int scrollX = mScrollX;
final int scrollY = mScrollY;
if ((scrollX | scrollY) == 0) {
//最终调用Drawable.draw(Canvas canvas)将Drawable实例
//绘制到屏幕上
background.draw(canvas);
} else {
canvas.translate(scrollX, scrollY);
//最终调用Drawable.draw(Canvas canvas)将Drawable实例
//绘制到屏幕上
background.draw(canvas);
canvas.translate(-scrollX, -scrollY);
}
}由此可见，View实例的背景Drawable实例最终还是调用自身的Drawable.draw(@NonNull Canvas canvas)方法绘制到屏幕上。
继续查看Drawable.draw方法：
public abstract class Drawable {
//Drawable中的draw是一个抽象方法，应该是为了众多的
//子类Drawable拥有自定义的绘制逻辑进行重写
public abstract void draw(@NonNull Canvas canvas);
}
在分析Resource.getDrawable时候已经知道，
对于普通的图片资源，获取到的是一个BitmapDrawable实例，
我们就来看看BitmapDrawable的draw具体的绘制逻辑：
public class BitmapDrawable extends Drawable {
@Override
public void draw(Canvas canvas) {
****
if (shader == null) {
****
//最终调用了Canvas.drawBitmap方法，将Drawable实例中的bitmap绘制到View实例关联的画布上
canvas.drawBitmap(bitmap, null, mDstRect, paint);
if (needMirroring) {
canvas.restore();
}
} ****
}
}至此，将获取的Drawable实例当做背景设置给View，和Drawable相关的一系列逻辑就分析完了，大致如下：
- 1：setBackgroundDrawable方法，调用了Drawable的一系列方法，设置了Drawable实例一系列属性值，最终引发了View实例的重新布局（requestLayout()），重绘（invalidate(true)）及重建View实例的外部轮廓（invalidateOutline()）
- 2：在View实例重绘过程的第一步，将得到的Drawable实例（View实例的背景）绘制到屏幕上，实质是调用了Drawable.draw(@NonNull Canvas canvas)
- 3：Drawable.draw本身是个抽象方法，绘制具体逻辑由其子类实现。
我们以之前获得的BitmapDrawable为例进行分析：
最终调用了Canvas.drawBitmap方法，将Drawable实例中的bitmap绘制到View实例关联的画布上
Drawable绘制流程今天先写到这儿，现在是2017/03/07 20:41，加班码字到现在有点累了，明后天继续把ImageView和Drawable关联的部分写完吧！
未完待续…
以上就是个人分析的一点结果，若有错误，请各位同学留言告知！
That’s all !
