摘要
自定义控件在工作中时常有所接触，但始终是只得其形，不得其神。最近抽空系统学习了下这方面的知识，准备用“Android自定义控件”作为一个博客系列来记录我的学习心得。系列文中不乏引用到Android SDK源码，以API 25为准。最后，如有雷同，没错，就是我去抄的。
Android自定义控件系列目录
Android自定义控件 —— 事件分发
Android自定义控件 —— 三大流程
View的三大流程分为：测量（measure）、布局（layout）、绘制（draw），下面就一一进行探索吧。
measure
布局绘画涉及两个流程：测量流程和布局流程，测量流程通过measure(int, int)实现，是View树自顶向下的遍历，每个View在循环过程中将尺寸细节往下传递，当测量过程完成之后，所有的View都存储了自己的尺寸。第二个过程则是通过方法layout(int, int, int, int)来实现的，也是自顶向下的。在这个过程中，每个父容器ViewGroup负责通过计算好的尺寸放置它的子View。
前面讲过，onMeasure(int, int)是用来测量当前控件大小的，给onLayout(boolean, int, int, int, int)提供数值参考，需要特别注意的是，测量完成以后通过setMeasuredDimension(int,int)设置给系统。
MeasureSpec
这是一个View的内部类，介绍之前，先来看看源码
package android.view;
...
public class View implements Drawable.Callback, KeyEvent.Callback,
AccessibilityEventSource {
...
public static class MeasureSpec {
private static final int MODE_SHIFT = 30;
private static final int MODE_MASK = 0x3 << MODE_SHIFT;
/** @hide */
@IntDef({UNSPECIFIED, EXACTLY, AT_MOST})
@Retention(RetentionPolicy.SOURCE)
public @interface MeasureSpecMode {}
public static final int UNSPECIFIED = 0 << MODE_SHIFT;
public static final int EXACTLY = 1 << MODE_SHIFT;
public static final int AT_MOST = 2 << MODE_SHIFT;
public static int makeMeasureSpec(@IntRange(from = 0, to = (1 << MeasureSpec.MODE_SHIFT) - 1) int size,
@MeasureSpecMode int mode) {
if (sUseBrokenMakeMeasureSpec) {
return size + mode;
} else {
return (size & ~MODE_MASK) | (mode & MODE_MASK);
}
}
public static int makeSafeMeasureSpec(int size, int mode) {
if (sUseZeroUnspecifiedMeasureSpec && mode == UNSPECIFIED) {
return 0;
}
return makeMeasureSpec(size, mode);
}
@MeasureSpecMode
public static int getMode(int measureSpec) {
//noinspection ResourceType
return (measureSpec & MODE_MASK);
}
public static int getSize(int measureSpec) {
return (measureSpec & ~MODE_MASK);
}
static int adjust(int measureSpec, int delta) {
final int mode = getMode(measureSpec);
int size = getSize(measureSpec);
if (mode == UNSPECIFIED) {
// No need to adjust size for UNSPECIFIED mode.
return makeMeasureSpec(size, UNSPECIFIED);
}
size += delta;
if (size < 0) {
Log.e(VIEW_LOG_TAG, "MeasureSpec.adjust: new size would be negative! (" + size +
") spec: " + toString(measureSpec) + " delta: " + delta);
size = 0;
}
return makeMeasureSpec(size, mode);
}
public static String toString(int measureSpec) {
int mode = getMode(measureSpec);
int size = getSize(measureSpec);
StringBuilder sb = new StringBuilder("MeasureSpec: ");
if (mode == UNSPECIFIED)
sb.append("UNSPECIFIED ");
else if (mode == EXACTLY)
sb.append("EXACTLY ");
else if (mode == AT_MOST)
sb.append("AT_MOST ");
else
sb.append(mode).append(" ");
sb.append(size);
return sb.toString();
}
}
...
}作用
MeasureSpec是用来规范测量数值的。什么意思呢？MeasureSpec规定了，一个规范的测量数值（int型，32位）应该由mode和size两部分组成，即应该由一个32位的二进制数“mode（前两位） + size（后30位，即原始测量数值）”的形式组成。
mode分类
mode是用两位二进制表示的数，其分类如下
UPSPECIFIED：父元素不对子元素施加任何束缚，子元素可以得到任意想要的大小
EXACTLY：父元素决定子元素的确切大小，子元素将被限定在给定的边界里而忽略子元素本身的大小
AT_MOST：子元素至多达到指定大小的值
它们对应的二进制值分别是
UNSPECIFIED = 00
EXACTLY = 01
AT_MOST = 10
应用
在XML布局时，通过android:layout_width和android:layout_height来设置控件的宽高值，宽高值分为三种类型：wrap_content、match_parent、具体值，三种值类型所对应的mode为
wrap_content ——> MeasureSpec.AT_MOST
match_parent ——> MeasureSpec.EXACTLY
具体值 ——> MeasureSpec.EXACTLY
举个例子，测量的宽度值为50，那么其所对应的MeasureSpec规范数值就应该为：01 000000000000000000000000110010，其中，前两位（01）代表mode位，50对应的二进制数为110010，不足30位补位即可。
MeasureSpec和LayoutParams
上面了解了MeasureSpec这个类，那么该类是怎么创建来的呢？根据什么创建来的呢？现在就来深入了解一下。
对于普通View，其对应的MeasureSpec是由父容器的MeasureSpec和自身的LayoutParams来共同决定的。
普通View的measure过程由ViewGroup传递而来，那么来看看源码了解下MeasureSpec是怎么被创建出来的
package android.view;
...
public abstract class ViewGroup extends View implements ViewParent, ViewManager {
...
protected void measureChildWithMargins(View child,
int parentWidthMeasureSpec, int widthUsed,
int parentHeightMeasureSpec, int heightUsed) {
final MarginLayoutParams lp = (MarginLayoutParams) child.getLayoutParams();
final int childWidthMeasureSpec = getChildMeasureSpec(parentWidthMeasureSpec,
mPaddingLeft + mPaddingRight + lp.leftMargin + lp.rightMargin
+ widthUsed, lp.width);
final int childHeightMeasureSpec = getChildMeasureSpec(parentHeightMeasureSpec,
mPaddingTop + mPaddingBottom + lp.topMargin + lp.bottomMargin
+ heightUsed, lp.height);
child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
}
...
}上述方法，首先获取到了子元素的LayoutParams，然后根据当前子元素的LayoutParams和父容器的MeasureSpec来获取子元素的 MeasureSpec，最后调用了子元素的measure(int, int)。
来看看getChildMeasureSpec(int, int, int)的具体实现
package android.view;
...
public abstract class ViewGroup extends View implements ViewParent, ViewManager {
...
public static int getChildMeasureSpec(int spec, int padding, int childDimension) {
int specMode = MeasureSpec.getMode(spec);
int specSize = MeasureSpec.getSize(spec);
int size = Math.max(0, specSize - padding);
int resultSize = 0;
int resultMode = 0;
switch (specMode) {
// Parent has imposed an exact size on us
case MeasureSpec.EXACTLY:
if (childDimension >= 0) {
resultSize = childDimension;
resultMode = MeasureSpec.EXACTLY;
} else if (childDimension == LayoutParams.MATCH_PARENT) {
// Child wants to be our size. So be it.
resultSize = size;
resultMode = MeasureSpec.EXACTLY;
} else if (childDimension == LayoutParams.WRAP_CONTENT) {
// Child wants to determine its own size. It can't be
// bigger than us.
resultSize = size;
resultMode = MeasureSpec.AT_MOST;
}
break;
// Parent has imposed a maximum size on us
case MeasureSpec.AT_MOST:
if (childDimension >= 0) {
// Child wants a specific size... so be it
resultSize = childDimension;
resultMode = MeasureSpec.EXACTLY;
} else if (childDimension == LayoutParams.MATCH_PARENT) {
// Child wants to be our size, but our size is not fixed.
// Constrain child to not be bigger than us.
resultSize = size;
resultMode = MeasureSpec.AT_MOST;
} else if (childDimension == LayoutParams.WRAP_CONTENT) {
// Child wants to determine its own size. It can't be
// bigger than us.
resultSize = size;
resultMode = MeasureSpec.AT_MOST;
}
break;
// Parent asked to see how big we want to be
case MeasureSpec.UNSPECIFIED:
if (childDimension >= 0) {
// Child wants a specific size... let him have it
resultSize = childDimension;
resultMode = MeasureSpec.EXACTLY;
} else if (childDimension == LayoutParams.MATCH_PARENT) {
// Child wants to be our size... find out how big it should
// be
resultSize = View.sUseZeroUnspecifiedMeasureSpec ? 0 : size;
resultMode = MeasureSpec.UNSPECIFIED;
} else if (childDimension == LayoutParams.WRAP_CONTENT) {
// Child wants to determine its own size.... find out how
// big it should be
resultSize = View.sUseZeroUnspecifiedMeasureSpec ? 0 : size;
resultMode = MeasureSpec.UNSPECIFIED;
}
break;
}
//noinspection ResourceType
return MeasureSpec.makeMeasureSpec(resultSize, resultMode);
}
...
}正如先前所说，上述方法主要是根据父容器的MeasureSpec同时结合子元素的LayoutParams来确定子元素的MeasureSpec。
由于UNSPECIFIED这个mode主要用于系统内部measure，一般来说，我们无须关注，所以排除掉UNSPECIFIED来总结一下就是
当子View采用固定宽高的时候，不管父容器的MeasureSpec是什么，子Ｖiew的mode都是EXACTLY，并且其大小遵循LayoutParams中的大小
当子View的宽高设为match_parent的时候，如果父容器的mode为EXACTLY，那么子View的mode也是EXACTLY，并且大小是父容器的剩余空间。如果父容器的mode为AT_MOST，那么子View的mode也是AT_MOST，并且大小不会超过父容器的剩余空间
当子View的宽高设为wrap_content的时候，不管父容器的mode是EXACTLY还是AT_MOST，子View的mode都是AT_MOST，并且大小不能够超过父容器的剩余空间
View的measure流程
View的测量流程是由measure(int, int)来完成的
package android.view;
...
public class View implements Drawable.Callback, KeyEvent.Callback,
AccessibilityEventSource {
...
public final void measure(int widthMeasureSpec, int heightMeasureSpec) {
boolean optical = isLayoutModeOptical(this);
if (optical != isLayoutModeOptical(mParent)) {
Insets insets = getOpticalInsets();
int oWidth = insets.left + insets.right;
int oHeight = insets.top + insets.bottom;
widthMeasureSpec = MeasureSpec.adjust(widthMeasureSpec, optical ? -oWidth : oWidth);
heightMeasureSpec = MeasureSpec.adjust(heightMeasureSpec, optical ? -oHeight : oHeight);
}
// Suppress sign extension for the low bytes
long key = (long) widthMeasureSpec << 32 | (long) heightMeasureSpec & 0xffffffffL;
if (mMeasureCache == null) mMeasureCache = new LongSparseLongArray(2);
final boolean forceLayout = (mPrivateFlags & PFLAG_FORCE_LAYOUT) == PFLAG_FORCE_LAYOUT;
// Optimize layout by avoiding an extra EXACTLY pass when the view is
// already measured as the correct size. In API 23 and below, this
// extra pass is required to make LinearLayout re-distribute weight.
final boolean specChanged = widthMeasureSpec != mOldWidthMeasureSpec
|| heightMeasureSpec != mOldHeightMeasureSpec;
final boolean isSpecExactly = MeasureSpec.getMode(widthMeasureSpec) == MeasureSpec.EXACTLY
&& MeasureSpec.getMode(heightMeasureSpec) == MeasureSpec.EXACTLY;
final boolean matchesSpecSize = getMeasuredWidth() == MeasureSpec.getSize(widthMeasureSpec)
&& getMeasuredHeight() == MeasureSpec.getSize(heightMeasureSpec);
final boolean needsLayout = specChanged
&& (sAlwaysRemeasureExactly || !isSpecExactly || !matchesSpecSize);
if (forceLayout || needsLayout) {
// first clears the measured dimension flag
mPrivateFlags &= ~PFLAG_MEASURED_DIMENSION_SET;
resolveRtlPropertiesIfNeeded();
int cacheIndex = forceLayout ? -1 : mMeasureCache.indexOfKey(key);
if (cacheIndex < 0 || sIgnoreMeasureCache) {
// measure ourselves, this should set the measured dimension flag back
onMeasure(widthMeasureSpec, heightMeasureSpec);
mPrivateFlags3 &= ~PFLAG3_MEASURE_NEEDED_BEFORE_LAYOUT;
} else {
long value = mMeasureCache.valueAt(cacheIndex);
// Casting a long to int drops the high 32 bits, no mask needed
setMeasuredDimensionRaw((int) (value >> 32), (int) value);
mPrivateFlags3 |= PFLAG3_MEASURE_NEEDED_BEFORE_LAYOUT;
}
// flag not set, setMeasuredDimension() was not invoked, we raise
// an exception to warn the developer
if ((mPrivateFlags & PFLAG_MEASURED_DIMENSION_SET) != PFLAG_MEASURED_DIMENSION_SET) {
throw new IllegalStateException("View with id " + getId() + ": "
+ getClass().getName() + "#onMeasure() did not set the"
+ " measured dimension by calling"
+ " setMeasuredDimension()");
}
mPrivateFlags |= PFLAG_LAYOUT_REQUIRED;
}
mOldWidthMeasureSpec = widthMeasureSpec;
mOldHeightMeasureSpec = heightMeasureSpec;
mMeasureCache.put(key, ((long) mMeasuredWidth) << 32 |
(long) mMeasuredHeight & 0xffffffffL); // suppress sign extension
}
...
}发现该方法是一个final型方法，所以不能被重写。不过在其中回调了onMeasure(int, int)，因此我们只需在View中重写onMeasure(int, int)方法来完成View的测量即可。那么View默认的onMeasure(int, int)实现是怎样的呢？
package android.view;
...
public class View implements Drawable.Callback, KeyEvent.Callback,
AccessibilityEventSource {
...
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
setMeasuredDimension(getDefaultSize(getSuggestedMinimumWidth(), widthMeasureSpec),
getDefaultSize(getSuggestedMinimumHeight(), heightMeasureSpec));
}
...
}可以看到，该方法的实现很简单，直接调用了setMeasuredDimension(int, int)来设置测量的尺寸。也就是说，关键就在于getDefaultSize(int, int)方法里
package android.view;
...
public class View implements Drawable.Callback, KeyEvent.Callback,
AccessibilityEventSource {
...
public static int getDefaultSize(int size, int measureSpec) {
int result = size;
int specMode = MeasureSpec.getMode(measureSpec);
int specSize = MeasureSpec.getSize(measureSpec);
switch (specMode) {
case MeasureSpec.UNSPECIFIED:
result = size;
break;
case MeasureSpec.AT_MOST:
case MeasureSpec.EXACTLY:
result = specSize;
break;
}
return result;
}
...
}很显然，getDefaultSize(int, int)方法返回的就是MeasureSpec的specSize（源码里的变量，即实际测量值）部分，而这个MeasureSpec是ViewGroup传递过来的。
到这里也就理解了，为什么当我们在布局中设置子View的宽高值为wrap_content的时候，如果不重写其onMeasure(int, int)方法，则默认大小就是父容器的可用大小了。
当我们在布局中设置子View的宽高值为wrap_content时，那么测量模式（即mode）就是AT_MOST，在该模式下，它的宽高值等于specSize。而specSize由ViewGroup传递过来时就是parentSize（自定义的变量名称），也就是父控件的可用大小。
当我们在布局中设置子View的宽高值为match_parent时，那么不用多说，宽高值当然也是parentSize。这时候，我们只需对AT_MOST测量模式进行处理
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
int widthMode = MeasureSpec.getMode(widthMeasureSpec);
int heightMode = MeasureSpec.getMode(heightMeasureSpec);
int widthSize = MeasureSpec.getSize(widthMeasureSpec);
int heightSize = MeasureSpec.getSize(heightMeasureSpec);
int width = 0;
int height = 0;
if(widthMode == MeasureSpec.AT_MOST){
width = ...
}
if(heightMode == MeasureSpec.AT_MOST){
height = ...
}
setMeasuredDimension(widthMode != MeasureSpec.AT_MOST ? widthSize : width,
heightMode != MeasureSpec.AT_MOST? heightSize : height);
}上述代码，判断当测量模式是AT_MOST时，自己计算View的宽高。其他情况，直接使用specSize。
至于UNSPECIFIED这种情况，则是使用的是getDefaultSize(int, int)的第一个参数的值，也就是getSuggestedMinimumWidth()和getSuggestedMinimumHeight()所返回的值，一般用于系统内部的测量过程，这两个方法的源码如下
package android.view;
...
public class View implements Drawable.Callback, KeyEvent.Callback,
AccessibilityEventSource {
...
protected int getSuggestedMinimumHeight() {
return (mBackground == null) ? mMinHeight : max(mMinHeight, mBackground.getMinimumHeight());
}
protected int getSuggestedMinimumWidth() {
return (mBackground == null) ? mMinWidth : max(mMinWidth, mBackground.getMinimumWidth());
}
...
}从源码看出，这是判断View有没有背景，没有背景的话，那么值就是View最小的宽度或高度，也就是对应XML布局中的android:minWidth和android:minHeight属性，如果属性没有指定的话，默认值为0；有背景的话，那么值就是View最小的宽度或高度和背景的最小宽度或高度，取两者中最大的一个值，这个值就是当测量模式是UNSPECIFIED时View的测量宽/高。
到这里就完成了整个View的measure过程，完成之后我们就可以通过getMeasuredWidth()和getMeasuredHeight()方法获取View正确的测量宽/高了。但是需要注意的是，在某些极端情况下，系统可能需要在多次measure过程后才能确定最终的测量宽/高，在这种情况下，直接在onMeasure(int, int)中获取的测量宽/高可能是不准确的，保险的做法是在onLayout(boolean, int, int, int, int)方法中去获取。
ViewGroup的measure流程
ViewGroup的measure流程和View不同，不仅需要完成自身的measure流程，还需要去遍历其所有子View，各个子元素再递归这个流程。ViewGroup提供了一个叫measureChildren(int, int)的方法
package android.view;
...
public abstract class ViewGroup extends View implements ViewParent, ViewManager {
...
protected void measureChildren(int widthMeasureSpec, int heightMeasureSpec) {
final int size = mChildrenCount;
final View[] children = mChildren;
for (int i = 0; i < size; ++i) {
final View child = children[i];
if ((child.mViewFlags & VISIBILITY_MASK) != GONE) {
measureChild(child, widthMeasureSpec, heightMeasureSpec);
}
}
}
...
}该方法遍历了所有的子View，判断如果子View没有GONE掉的时候，就继续执行measureChild(View, int, int)方法
package android.view;
...
public abstract class ViewGroup extends View implements ViewParent, ViewManager {
...
protected void measureChild(View child, int parentWidthMeasureSpec,
int parentHeightMeasureSpec) {
final LayoutParams lp = child.getLayoutParams();
final int childWidthMeasureSpec = getChildMeasureSpec(parentWidthMeasureSpec,
mPaddingLeft + mPaddingRight, lp.width);
final int childHeightMeasureSpec = getChildMeasureSpec(parentHeightMeasureSpec,
mPaddingTop + mPaddingBottom, lp.height);
child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
}
...
}该方法获取了子View的LayoutParams，然后通过getChildMeasureSpec(int, int, int)创建子View的MeasureSpec，创建好后，将MeasureSpec传给子VIew进行其measure 流程。
解读源码发现，ViewGroup并没有定义其具体的测量流程（即实现onMeasure(int, int)），这是因为ViewGroup是一个抽象类，它的测量流程需要其子类去实现不同的布局特性，没办法做统一实现，比如说像LinearLayout、RelativeLayout等。
layout
通过源码发现，layout流程的关键在于onLayout(boolean, int, int, int, int)，实现View的layout流程，就是实现该View的布局，而如果换成是ViewGroup，那么就实现其所有子控件的布局。
package android.view;
...
public class View implements Drawable.Callback, KeyEvent.Callback,
AccessibilityEventSource {
...
protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
}
...
}package android.view;
...
public abstract class ViewGroup extends View implements ViewParent, ViewManager {
...
@Override
protected abstract void onLayout(boolean changed,
int l, int t, int r, int b);
...
}draw
下面直接通过查看draw(Canvas)的源码，来分析下其draw流程
package android.view;
...
public class View implements Drawable.Callback, KeyEvent.Callback,
AccessibilityEventSource {
...
public void draw(Canvas canvas) {
...
/*
* Draw traversal performs several drawing steps which must be executed
* in the appropriate order:
*
* 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)
*/
// Step 1, draw the background, if needed
...
if (!dirtyOpaque) {
drawBackground(canvas);
}
// skip step 2 & 5 if possible (common case)
...
// Step 2, save the canvas' layers
...
int solidColor = getSolidColor();
if (solidColor == 0) {
final int flags = Canvas.HAS_ALPHA_LAYER_SAVE_FLAG;
if (drawTop) {
canvas.saveLayer(left, top, right, top + length, null, flags);
}
if (drawBottom) {
canvas.saveLayer(left, bottom - length, right, bottom, null, flags);
}
if (drawLeft) {
canvas.saveLayer(left, top, left + length, bottom, null, flags);
}
if (drawRight) {
canvas.saveLayer(right - length, top, right, bottom, null, flags);
}
} else {
scrollabilityCache.setFadeColor(solidColor);
}
// Step 3, draw the content
if (!dirtyOpaque) onDraw(canvas);
// Step 4, draw the children
dispatchDraw(canvas);
// Step 5, draw the fade effect and restore layers
...
if (drawTop) {
...
canvas.drawRect(left, top, right, top + length, p);
}
if (drawBottom) {
...
canvas.drawRect(left, bottom - length, right, bottom, p);
}
if (drawLeft) {
...
canvas.drawRect(left, top, left + length, bottom, p);
}
if (drawRight) {
...
canvas.drawRect(right - length, top, right, bottom, p);
}
...
// Step 6, draw decorations (foreground, scrollbars)
onDrawForeground(canvas);
}
...
}上面的源码注释写的很清晰，通过查看后我们了解到View的绘制共分为如下六步
绘制背景
如果需要，保存图层信息
绘制View的内容
如果View有子View，绘制View的子View
如果需要，绘制View的边缘（如阴影等）
绘制View的装饰（如滚动条等）
其中以上六步，第二步和第五步并不是必须的，所以我们只需重点分析其他四步即可。
绘制背景
绘制背景调用了drawBackground(Canvas)方法
package android.view;
...
public class View implements Drawable.Callback, KeyEvent.Callback,
AccessibilityEventSource {
...
private void drawBackground(Canvas canvas) {
// 获取背景 drawable
final Drawable background = mBackground;
if (background == null) {
return;
}
// 根据在 layout 过程中获取的 View 的位置参数，来设置背景的边界
setBackgroundBounds();
...
// 获取 mScrollX 和 mScrollY值
final int scrollX = mScrollX;
final int scrollY = mScrollY;
if ((scrollX | scrollY) == 0) {
background.draw(canvas);
} else {
// 如果 mScrollX 和 mScrollY 有值，则对 canvas 的坐标进行偏移
canvas.translate(scrollX, scrollY);
// 调用 Drawable 的 draw 方法绘制背景
background.draw(canvas);
canvas.translate(-scrollX, -scrollY);
}
}
...
}绘制内容
绘制内容调用了View#onDraw(Canvas)方法，由于View的内容各不相同，所以该方法是一个空实现，需要由子类去实现
package android.view;
...
public class View implements Drawable.Callback, KeyEvent.Callback,
AccessibilityEventSource {
...
protected void onDraw(Canvas canvas) {
}
...
}绘制子View
绘制子View调用了View#dispatchDraw(Canvas)方法，该方法同样是一个空实现
package android.view;
...
public class View implements Drawable.Callback, KeyEvent.Callback,
AccessibilityEventSource {
...
protected void dispatchDraw(Canvas canvas) {
}
...
}当只有包含子View的时候，才会去重写它，ViewGroup不正好符合条件吗？ 来看下ViewGroup对该方法的实现吧
package android.view;
...
public abstract class ViewGroup extends View implements ViewParent, ViewManager {
...
protected void dispatchDraw(Canvas canvas) {
...
final int childrenCount = mChildrenCount;
...
for (int i = 0; i < childrenCount; i++) {
...
if ((transientChild.mViewFlags & VISIBILITY_MASK) == VISIBLE ||
transientChild.getAnimation() != null) {
more |= drawChild(canvas, transientChild, drawingTime);
}
...
}
}
...
}ViewGroup#dispatchDraw(Canvas)方法的代码比较多，只分析重点，遍历了所有的子View并调用了ViewGroup#drawChild(Canvas, View, long)方法
package android.view;
...
public abstract class ViewGroup extends View implements ViewParent, ViewManager {
...
protected boolean drawChild(Canvas canvas, View child, long drawingTime) {
return child.draw(canvas, this, drawingTime);
}
...
}该方法最终还是调用了子View的draw(Canvas)方法。
由于ViewGroup已经为我们实现了该方法，所以我们一般都不需要重写该方法。
绘制装饰
绘制装饰调用了View#onDrawForeground(Canvas)方法，源码如下
package android.view;
...
public class View implements Drawable.Callback, KeyEvent.Callback,
AccessibilityEventSource {
...
public void onDrawForeground(Canvas canvas) {
onDrawScrollIndicators(canvas);
onDrawScrollBars(canvas);
final Drawable foreground = mForegroundInfo != null ? mForegroundInfo.mDrawable : null;
if (foreground != null) {
if (mForegroundInfo.mBoundsChanged) {
mForegroundInfo.mBoundsChanged = false;
final Rect selfBounds = mForegroundInfo.mSelfBounds;
final Rect overlayBounds = mForegroundInfo.mOverlayBounds;
if (mForegroundInfo.mInsidePadding) {
selfBounds.set(0, 0, getWidth(), getHeight());
} else {
selfBounds.set(getPaddingLeft(), getPaddingTop(),
getWidth() - getPaddingRight(), getHeight() - getPaddingBottom());
}
final int ld = getLayoutDirection();
Gravity.apply(mForegroundInfo.mGravity, foreground.getIntrinsicWidth(),
foreground.getIntrinsicHeight(), selfBounds, overlayBounds, ld);
foreground.setBounds(overlayBounds);
}
foreground.draw(canvas);
}
}
...
}该方法默认实现是绘制了滚动指示器、滚动条、和前景。
参考链接：
1. Android View 的绘制流程
2. 自定义控件三部曲视图篇（一）——测量与布局
3. Android 从0开始自定义控件之深入理解 MeasureSpec （六）
4. Android 从0开始自定义控件之 View 的 measure 过程（七）
5. Andriod 从0开始自定义控件之 View 的 layout 过程 （八）
6. Android 从0开始自定义控件之 View 的 draw 过程 （九）
扫一扫
241
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
