在实际开发中，我们仅仅了解常用的原生控件的使用方法是往往不够的，因为它是无法作出很复杂的View，这时就需要自定义View。一般自定义View的步骤就有那么几步：
1、View的测量过程（onMeasure）
2、布局过程（onLayout）
3、绘制过程（onDraw）
了解View和ViewGroup
View：代表用户界面组件基本构建块，view在屏幕中占据了一个矩形区域，而且负责相关绘制和事件处理，如常用的组件（buttom、TextView...）其父类都是View
ViewGroup：它也是View的子类，ViewGroup是所有布局父类，它可以包含其它view或者viewGroup
下面看一下相关时序图
说明：顶层视图代表应用程序窗口的视图对象（DecorView类型的对象），ViewRoot对应的是ViewRootImpl类
说明：下面用（）加数字表示对应上面第几步，如（1）则表示第1步
（9）获取顶层视图decor【DecorView类型的对象】
经过（11）（12）（13）这几步将decor传递给ViewRoot
经过上面步骤就实现了将ViewRoot和DecorView建立了关联；在（13）中，ViewRoot类的成员函数setView会调用ViewRoot类的另外一个成员函数requestLayout来请求 对顶层视图decor 作第一次布局以及显示。
顶层视图decor的三大流程
我们就从ViewRoot类的成员函数requestLayout开始，分析顶层视图decor的三大流程，如下图所示：
（5）调用ViewRootImpl类的performTraversals方法会依次调用performMeasure→performLayout→performDraw方法来完成顶层视图decor的测量（measure）、布局（layout）和绘制过程（draw）。
View的测量过程 （measure）
上图（9）则遍历每一个子View，被调用子View的measure方法（10）继续开始进行子View的测量过程（measure）
View类型的ViewGroup和非ViewGroup类型的View的测量过程是不同的？
非ViewGroup类型的View通过onMeasure方法就完成了其测量过程
ViewGroup类型的View除了通过onMeasure方法就完成自身的测量过程外，还要在onMeasure方法中完成遍历子View的measure方法，各个子View再去递归执行这个流程。
非ViewGroup类型的View的测量过程如图：
（1）执行View中的measure方法，该方法是一个final方法，这就意味着子类不能从写该方法，measure方法会调用View类的onMeasure方法，onMeasure方法：
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
setMeasuredDimension(getDefaultSize(getSuggestedMinimumWidth(), widthMeasureSpec),
getDefaultSize(getSuggestedMinimumHeight(), heightMeasureSpec));
}从上面的代码就对应上图中3、4、5、6、7步，先来看第3步对应的View类的getSuggestedMinimumWidth方法的源码：
protected int getSuggestedMinimumWidth() {
return (mBackground == null) ? mMinWidth : max(mMinWidth, mBackground.getMinimumWidth());
}法的源码：
public int getMinimumWidth() {
final int intrinsicWidth = getIntrinsicWidth();
return intrinsicWidth > 0 ? intrinsicWidth : 0;
}现在来总结一下getSuggestedMinimumWidth方法的逻辑，当View没有设置背景时，getSuggestedMinimumWidth方法的返回值为android: minWidth属性指定的值，这个值可以为0；当View设置了背景时，getSuggestedMinimumWidth方法的返回值为android: minWidth属性指定的值与View的背景的最小宽度中的最大值。
现在我们来看一下最关键的View类的getDefaultSize方法的源代码（对应第4步）：
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;
}上面的逻辑很简单，对于MeasureSpec.AT_MOST和MeasureSpec.EXACTLY测量模式，getDefaultSize直接返回测量后的值（即父View通过measure方法传递过来的测量值）；对于MeasureSpec.UNSPECIFIED测量模式，一般用于系统内部的测量过程，getDefaultSize返回值为getSuggestedMinimumWidth方法的返回值。
第7步中View类的setMeasuredDimension方法调用了第8步中View类的setMeasuredDimensionRaw方法，setMeasuredDimensionRaw方法的源码：
private void setMeasuredDimensionRaw(int measuredWidth, int measuredHeight) {
mMeasuredWidth = measuredWidth;
mMeasuredHeight = measuredHeight;
mPrivateFlags |= PFLAG_MEASURED_DIMENSION_SET;
}有上面的代码可知，View测量后的宽高被保存到View类的成员变量mMeasuredWidth和mMeasuredHeight中了，通过View类的getMeasuredWidth方法和getMeasuredHeight方法获取的就是mMeasuredWidth和mMeasuredHeight的值，需要注意的是，在某些极端情况下，系统可能需要多次measure才能确定最终的测量宽高，在这种情况下，在onMeasure方法中拿到的测量宽高很可能是不准确的，一个好的习惯是在onLayout方法中去获取View最终的测量宽高。上面只是说在自定义View中什么时机获取最终的测量宽高，那在Activity中什么时机获取View的测量宽高呢？有如下四种方法
1 在Activity/View#onWindowFocusChanged方法中获取
2 在Activity中的onStart方法中执行View.post获取
3 通过ViewTreeObserver获取
4 通过手动执行View.measure获取1>直接继承View的自定义控件需要重写onMeasure方法并且设置wrap_content时的自身大小，否者在布局中使用wrap_content就相当于使用math_parent，具体原因会在下一节进行说明。
2> 在自定义View时可以通过重写onMeasure方法设置View测量大小，这样的话你就抛弃了父容器通过measure方法传进来建议测量值MeasureSpec。
ViewGroup类型的View的测量过程
先通过如下的时序图，整体的看一下测量过程：
ViewGroup并没有定义其自身测量的具体过程(即没有onMeasure方法)，这是因为ViewGroup是一个抽象类，其测量过程的onMeasure方法需要各个子类去具体实现，所以上面展示了LinearLayout测量过程图
对于上面的步骤进行解析一下，第1步执行View类中的measure方法，该方法是一个final方法，这就意味着子类不能从写该方法，measure方法会调用LinearLayout类的onMeasure方法，onMeasure方法的实现代码如下所示：
@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
if (mOrientation == VERTICAL) {
measureVertical(widthMeasureSpec, heightMeasureSpec);
} else {
measureHorizontal(widthMeasureSpec, heightMeasureSpec);
}
}// See how tall everyone is. Also remember max width.
for (int i = 0; i < count; ++i) {
final View child = getVirtualChildAt(i);
// Determine how big this child would like to be. If this or
// previous children have given a weight, then we allow it to
// use all available space (and we will shrink things later
// if needed).
......
measureChildBeforeLayout(
child, i, widthMeasureSpec, 0, heightMeasureSpec,
totalWeight == 0 ? mTotalLength : 0);
if (oldHeight != Integer.MIN_VALUE) {
lp.height = oldHeight;
}
final int childHeight = child.getMeasuredHeight();
final int totalLength = mTotalLength;
mTotalLength = Math.max(totalLength, totalLength + childHeight + lp.topMargin +
lp.bottomMargin + getNextLocationOffset(child));
......
}
......
// Add in our padding
mTotalLength += mPaddingTop + mPaddingBottom;
int heightSize = mTotalLength;
// Check against our minimum height
heightSize = Math.max(heightSize, getSuggestedMinimumHeight());
// Reconcile our calculated size with the heightMeasureSpec
int heightSizeAndState = resolveSizeAndState(heightSize, heightMeasureSpec, 0);
heightSize = heightSizeAndState & MEASURED_SIZE_MASK;
......
setMeasuredDimension(resolveSizeAndState(maxWidth, widthMeasureSpec, childState),
heightSizeAndState);
.....public static int resolveSizeAndState(int size, int measureSpec, int childMeasuredState) {
final int specMode = MeasureSpec.getMode(measureSpec);
final int specSize = MeasureSpec.getSize(measureSpec);
final int result;
switch (specMode) {
case MeasureSpec.AT_MOST:
if (specSize < size) {
result = specSize | MEASURED_STATE_TOO_SMALL;
} else {
result = size;
}
break;
case MeasureSpec.EXACTLY:
result = specSize;
break;
case MeasureSpec.UNSPECIFIED:
default:
result = size;
}
return result | (childMeasuredState & MEASURED_STATE_MASK);
}void measureChildBeforeLayout(View child, int childIndex,
int widthMeasureSpec, int totalWidth, int heightMeasureSpec,
int totalHeight) {
measureChildWithMargins(child, widthMeasureSpec, totalWidth,
heightMeasureSpec, totalHeight);
}LinearLayout类的measureChildBeforeLayout方法会调用ViewGroup类的measureChildWithMargins方法，measureChildWithMargins方法的源码如下：
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);
}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);
}ViewGroup三种测量模式
ViewGroup类的getChildMeasureSpec方法的逻辑可以通过下表来说明，注意，表中的parentSize是指父容器目前可使用的大小
| childLayoutParams/parentSpecMode | EXACTLY | AT_MOST | UNSPECIFIED |
| dp/px | EXACTLY/childSize | EXACTLY/childSize | EXACTLY/childSize |
| MATCH_PARENT | EXACTLY/childSize | AT_MOST/parentSize | UNSPECIFIED/0 |
| WRAP_CONTENT | AT_MOST/parentSize | AT_MOST/parentSize | UNSPECIFIED/0 |
AT_MOST：表示子布局被限制在一个最大值内，一般当childView设置其宽、高为wrap_content时，ViewGroup会将其设置为AT_MOST；
UNSPECIFIED：表示子布局想要多大就多大，一般出现在AadapterView的item的heightMode中、ScrollView的childView的heightMode中；此种模式比较少见
ViewGroup类的getChildMeasureSpec方法返回子元素宽高的MeasureSpec，然后将子元素宽高的MeasureSpec作为measure方法的参数。
到此为止，非ViewGroup类型的View的测量过程和ViewGroup类型的View的测量过程已经分析完毕，进行如下总结：
1> 父View会遍历测量每一个子View(通常使用ViewGroup类的measureChildWithMargins方法)，然后调用子View的measure方法并且将测量后的宽高作为measure方法的参数，但是这只是父View的建议值，子View可以通过继承onMeasure来改变测量值。
2> 非ViewGroup类型的View自身的测量是在非ViewGroup类型的View的onMeasure方法中进行测量的
3> ViewGroup类型的View自身的测量是在ViewGroup类型的View的onMeasure方法中进行测量的
4>直接继承ViewGroup的自定义控件需要重写onMeasure方法并且设置wrap_content时的自身大小，否者在布局中使用wrap_content就相当于使用math_parent，具体原因通过上面的表格可以说明。
View的布局过程（layout）
decor的三大流程图的第16步会遍历每一个子元素，并且调用子元素的layout方法，继而开始进行子元素的布局过程。layout过程比measure过程简单多了，layout方法用来确定View本身的位置，而onLayout方法用来确定所有子元素的位置。ViewGroup类型的View和非ViewGroup类型的View的布局过程是不同的，非ViewGroup类型的View通过layout方法就完成了其布局过程，而ViewGroup类型的View除了通过layout方法就完成自身的布局过程外，还要调用onLayout方法去遍历子元素并且调用子元素的layout方法，各个子View再去递归执行这个流程。
非ViewGroup类型的View的布局过程
先通过如下的时序图，整体的看一下布局过程：
对上面的时序图进行一下解析，第1步执行View类的layout方法，代码如下：
public void layout(int l, int t, int r, int b) {
if ((mPrivateFlags3 & PFLAG3_MEASURE_NEEDED_BEFORE_LAYOUT) != 0) {
onMeasure(mOldWidthMeasureSpec, mOldHeightMeasureSpec);
mPrivateFlags3 &= ~PFLAG3_MEASURE_NEEDED_BEFORE_LAYOUT;
}
int oldL = mLeft;
int oldT = mTop;
int oldB = mBottom;
int oldR = mRight;
boolean changed = isLayoutModeOptical(mParent) ?
setOpticalFrame(l, t, r, b) : setFrame(l, t, r, b);
if (changed || (mPrivateFlags & PFLAG_LAYOUT_REQUIRED) == PFLAG_LAYOUT_REQUIRED) {
onLayout(changed, l, t, r, b);
mPrivateFlags &= ~PFLAG_LAYOUT_REQUIRED;
ListenerInfo li = mListenerInfo;
if (li != null && li.mOnLayoutChangeListeners != null) {
ArrayList<OnLayoutChangeListener> listenersCopy =
(ArrayList<OnLayoutChangeListener>)li.mOnLayoutChangeListeners.clone();
int numListeners = listenersCopy.size();
for (int i = 0; i < numListeners; ++i) {
listenersCopy.get(i).onLayoutChange(this, l, t, r, b, oldL, oldT, oldR, oldB);
}
}
}
mPrivateFlags &= ~PFLAG_FORCE_LAYOUT;
mPrivateFlags3 |= PFLAG3_IS_LAID_OUT;
}protected boolean setFrame(int left, int top, int right, int bottom) {
boolean changed = false;
if (mLeft != left || mRight != right || mTop != top || mBottom != bottom) {
changed = true;
int oldWidth = mRight - mLeft;
int oldHeight = mBottom - mTop;
int newWidth = right - left;
int newHeight = bottom - top;
boolean sizeChanged = (newWidth != oldWidth) || (newHeight != oldHeight);
// Invalidate our old position
invalidate(sizeChanged);
mLeft = left;
mTop = top;
mRight = right;
mBottom = bottom;
if (sizeChanged) {
sizeChange(newWidth, newHeight, oldWidth, oldHeight);
}
}
return changed;
}ViewGroup类型的View的布局过程
先通过如下的时序图，整体的看一下布局过程：
上面其实是LinearLayout的布局时序图，因为ViewGroup的onLayout方法是抽象方法，所以就选择了ViewGroup的子类LinearLayout进行分析。对上面的时序图进行一下解析，第1步执行ViewGroup类的layout方法，该方法是一个final方法，即子类无法重写该方法，源代码如下：第1步执行ViewGroup类的layout方法，该方法是一个final方法，即子类无法重写该方法，源代码如下：
@Override
public final void layout(int l, int t, int r, int b) {
if (!mSuppressLayout && (mTransition == null || !mTransition.isChangingLayout())) {
if (mTransition != null) {
mTransition.layoutChange(this);
}
super.layout(l, t, r, b);
} else {
// record the fact that we noop'd it; request layout when transition finishes
mLayoutCalledWhileSuppressed = true;
}
}@Override
protected void onLayout(boolean changed, int l, int t, int r, int b) {
if (mOrientation == VERTICAL) {
layoutVertical(l, t, r, b);
} else {
layoutHorizontal(l, t, r, b);
}
}void layoutVertical(int left, int top, int right, int bottom) {
final int paddingLeft = mPaddingLeft;
int childTop;
int childLeft;
// Where right end of child should go
final int width = right - left;
int childRight = width - mPaddingRight;
// Space available for child
int childSpace = width - paddingLeft - mPaddingRight;
final int count = getVirtualChildCount();
final int majorGravity = mGravity & Gravity.VERTICAL_GRAVITY_MASK;
final int minorGravity = mGravity & Gravity.RELATIVE_HORIZONTAL_GRAVITY_MASK;
switch (majorGravity) {
case Gravity.BOTTOM:
// mTotalLength contains the padding already
childTop = mPaddingTop + bottom - top - mTotalLength;
break;
// mTotalLength contains the padding already
case Gravity.CENTER_VERTICAL:
childTop = mPaddingTop + (bottom - top - mTotalLength) / 2;
break;
case Gravity.TOP:
default:
childTop = mPaddingTop;
break;
}
for (int i = 0; i < count; i++) {
final View child = getVirtualChildAt(i);
if (child == null) {
childTop += measureNullChild(i);
} else if (child.getVisibility() != GONE) {
final int childWidth = child.getMeasuredWidth();
final int childHeight = child.getMeasuredHeight();
final LinearLayout.LayoutParams lp =
(LinearLayout.LayoutParams) child.getLayoutParams();
int gravity = lp.gravity;
if (gravity < 0) {
gravity = minorGravity;
}
final int layoutDirection = getLayoutDirection();
final int absoluteGravity = Gravity.getAbsoluteGravity(gravity, layoutDirection);
switch (absoluteGravity & Gravity.HORIZONTAL_GRAVITY_MASK) {
case Gravity.CENTER_HORIZONTAL:
childLeft = paddingLeft + ((childSpace - childWidth) / 2)
+ lp.leftMargin - lp.rightMargin;
break;
case Gravity.RIGHT:
childLeft = childRight - childWidth - lp.rightMargin;
break;
case Gravity.LEFT:
default:
childLeft = paddingLeft + lp.leftMargin;
break;
}
if (hasDividerBeforeChildAt(i)) {
childTop += mDividerHeight;
}
childTop += lp.topMargin;
setChildFrame(child, childLeft, childTop + getLocationOffset(child),
childWidth, childHeight);
childTop += childHeight + lp.bottomMargin + getNextLocationOffset(child);
i += getChildrenSkipCount(child, i);
}
}
}private void setChildFrame(View child, int left, int top, int width, int height) {
child.layout(left, top, left + width, top + height);
}View的绘制过程（draw）
decor的三大流程图的第23步会遍历每一个子View，并且调用子元素的draw方法，继而开始进行子View的绘制过程。先通过如下的时序图，整体的看一下绘制过程：
上面其实是LinearLayout的绘制时序图，因为View的onDraw方法是空方法，所以就选择了ViewGroup的子类LinearLayout进行分析。
LinearLayout的绘制过程遵循如下几步：
1> 绘制背景
2> 绘制自己（绘制分割线）
3> 绘制子View（dispatchDraw）
4> 绘制前景
Android中是通过View类的draw方法来实现上面的4步，源码如下所示：
/**
* Manually render this view (and all of its children) to the given Canvas.
* The view must have already done a full layout before this function is
* called. When implementing a view, implement
* {@link #onDraw(android.graphics.Canvas)} instead of overriding this method.
* If you do need to override this method, call the superclass version.
*
* @param canvas The Canvas to which the View is rendered.
*/
@CallSuper
public void draw(Canvas canvas) {
final int privateFlags = mPrivateFlags;
final boolean dirtyOpaque = (privateFlags & PFLAG_DIRTY_MASK) == PFLAG_DIRTY_OPAQUE &&
(mAttachInfo == null || !mAttachInfo.mIgnoreDirtyState);
mPrivateFlags = (privateFlags & ~PFLAG_DIRTY_MASK) | PFLAG_DRAWN;
/*
* 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
int saveCount;
if (!dirtyOpaque) {
drawBackground(canvas);
}
// skip step 2 & 5 if possible (common case)
final int viewFlags = mViewFlags;
boolean horizontalEdges = (viewFlags & FADING_EDGE_HORIZONTAL) != 0;
boolean verticalEdges = (viewFlags & FADING_EDGE_VERTICAL) != 0;
if (!verticalEdges && !horizontalEdges) {
// Step 3, draw the content
if (!dirtyOpaque) onDraw(canvas);
// Step 4, draw the children
dispatchDraw(canvas);
// Overlay is part of the content and draws beneath Foreground
if (mOverlay != null && !mOverlay.isEmpty()) {
mOverlay.getOverlayView().dispatchDraw(canvas);
}
// Step 6, draw decorations (foreground, scrollbars)
onDrawForeground(canvas);
// we're done...
return;
}
.....
}@Override
protected void dispatchDraw(Canvas canvas) {
boolean usingRenderNodeProperties = canvas.isRecordingFor(mRenderNode);
final int childrenCount = mChildrenCount;
final View[] children = mChildren;
......
boolean more = false;
final long drawingTime = getDrawingTime();
if (usingRenderNodeProperties) canvas.insertReorderBarrier();
final int transientCount = mTransientIndices == null ? 0 : mTransientIndices.size();
int transientIndex = transientCount != 0 ? 0 : -1;
// Only use the preordered list if not HW accelerated, since the HW pipeline will do the
// draw reordering internally
final ArrayList<View> preorderedList = usingRenderNodeProperties
? null : buildOrderedChildList();
final boolean customOrder = preorderedList == null
&& isChildrenDrawingOrderEnabled();
for (int i = 0; i < childrenCount; i++) {
while (transientIndex >= 0 && mTransientIndices.get(transientIndex) == i) {
final View transientChild = mTransientViews.get(transientIndex);
if ((transientChild.mViewFlags & VISIBILITY_MASK) == VISIBLE ||
transientChild.getAnimation() != null) {
more |= drawChild(canvas, transientChild, drawingTime);
}
transientIndex++;
if (transientIndex >= transientCount) {
transientIndex = -1;
}
}
int childIndex = customOrder ? getChildDrawingOrder(childrenCount, i) : i;
final View child = (preorderedList == null)
? children[childIndex] : preorderedList.get(childIndex);
if ((child.mViewFlags & VISIBILITY_MASK) == VISIBLE || child.getAnimation() != null) {
more |= drawChild(canvas, child, drawingTime);
}
}
......
}protected boolean drawChild(Canvas canvas, View child, long drawingTime) {
return child.draw(canvas, this, drawingTime);
}onFocusChanged(boolean, int, android.graphics.Rect)：该方法在当前View获得或失去焦点时被回调。
onWindowFocusChanged(boolean)：该方法在包含当前View的window获得或失去焦点时被回调。
onAttachedToWindow()：该方法在当前View被附到一个window上时被回调。
onDetachedFromWindow()：该方法在当前View从一个window上分离时被回调。
onVisibilityChanged(View, int)：该方法在当前View或其祖先的可见性改变时被调用。
onWindowVisibilityChanged(int)：该方法在包含当前View的window可见性改变时被回调。
自定义View实例
自定义View的分类标准不唯一，而我把自定义View分为3类
1> 通过继承View或者ViewGroup实现自定义View
2> 通过继承已有的控件实现自定义View
3> 通过组合实现自定义View
我在下面只针对1>来实现自定义View，因为2>和3>相对于1>就比较简单了。
通过继承View实现环状进度条
实现上面效果代码
根据上面对非ViewGrop类型View三大流程的分析，第一步就是测量，由于是继承View类的，因此如果想要支持wrap_content属性，就必须重写onMeasure方法，如下所示（可以当做模板代码）：
@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
int widthSpecMode = MeasureSpec.getMode(widthMeasureSpec);
int widthSpecSize = MeasureSpec.getSize(widthMeasureSpec);
int heightSpecMode = MeasureSpec.getMode(heightMeasureSpec);
int heightSpecSize = MeasureSpec.getSize(heightMeasureSpec);
if (widthSpecMode == MeasureSpec.AT_MOST && heightSpecMode == MeasureSpec.AT_MOST) {
setMeasuredDimension(mWidth, mHeight);
} else if (widthSpecMode == MeasureSpec.AT_MOST) {
setMeasuredDimension(mWidth, heightSpecSize);
} else if (heightSpecMode == MeasureSpec.AT_MOST) {
setMeasuredDimension(widthSpecSize, mHeight);
} else {
super.onMeasure(widthMeasureSpec, heightMeasureSpec);
}
}第三步就是进行绘制，由于非ViewGrop类型View没有子View，所以不用考虑对子View的绘制，因此只要重写View类的onDraw方法对自身进行绘制即可，代码如下：
@Override
protected void onDraw(Canvas canvas) {
super.onDraw(canvas);
canvas.drawArc(new RectF(200,200,
mWidth + 200, mHeight + 200),
0, currentValue, false, paint);
}下面是自定义View完整代码：
public class SimpleView extends View {
private int mWidth = 300;
private int mHeight = 300;
private Paint paint = null;
private float currentValue = 0;
public SimpleView(Context context, AttributeSet attrs) {
super(context, attrs);
paint = new Paint(Paint.ANTI_ALIAS_FLAG);
paint.setColor(Color.BLUE);
paint.setStyle(Paint.Style.STROKE);//设置画笔为线条模式
paint.setStrokeWidth(10);
}
@Override
protected void onDraw(Canvas canvas) {
super.onDraw(canvas);
canvas.drawArc(new RectF(200,200,
mWidth + 200, mHeight + 200),
0, currentValue, false, paint);
}
public void startAnim(){
ValueAnimator valueAnimator = ValueAnimator.ofFloat(0,180);
valueAnimator.setDuration(3000);
valueAnimator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
@Override
public void onAnimationUpdate(ValueAnimator animation) {
currentValue = (float) animation.getAnimatedValue();
postInvalidate();
}
});
valueAnimator.start();
}
@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
int widthSpecMode = MeasureSpec.getMode(widthMeasureSpec);
int widthSpecSize = MeasureSpec.getSize(widthMeasureSpec);
int heightSpecMode = MeasureSpec.getMode(heightMeasureSpec);
int heightSpecSize = MeasureSpec.getSize(heightMeasureSpec);
if (widthSpecMode == MeasureSpec.AT_MOST && heightSpecMode == MeasureSpec.AT_MOST){
setMeasuredDimension(mWidth,mHeight);
}else if(widthSpecMode == MeasureSpec.AT_MOST){
setMeasuredDimension(mWidth,heightSpecSize);
}else if (heightSpecMode == MeasureSpec.AT_MOST){
setMeasuredDimension(widthSpecSize,mHeight);
}else{
super.onMeasure(widthMeasureSpec,heightMeasureSpec);
}
}
@Override
protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
super.onLayout(changed, left, top, right, bottom);
}
}<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:id="@+id/activity_main"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical">
<com.hh.person.customview.widget.SimpleView
android:id="@+id/custom_view"
android:layout_width="500dp"
android:layout_height="500dp"
android:background="#f0f"
/>
</LinearLayout>public class MainActivity extends Activity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
SimpleView simpleView = (SimpleView) findViewById(R.id.custom_view);
simpleView.startAnim();
}
}
通过继承ViewGroup实现流式布局（FlowLayout）
效果图
根据自定义三部曲来走
第一步先进行测量
//测量ViewGroup大小
@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
int widthSpecMode = MeasureSpec.getMode(widthMeasureSpec);
int widthSpecSize = MeasureSpec.getSize(widthMeasureSpec);
int heightSpecMode = MeasureSpec.getMode(heightMeasureSpec);
int heightSpecSize = MeasureSpec.getSize(heightMeasureSpec);
int maxWidth = 0; //记录最大的宽
int sumHeight = 0; //记录子View在垂直方向累加的高
// 记录每一行的宽度
int lineWidth = 0;
//记录一行中最高子View的高度
int lineHeight = 0;
// 获取子View总数
int childCount = getChildCount();
for (int i = 0; i < childCount; i++) {
View childView = getChildAt(i);
// 测量子View的宽和高
measureChild(childView, widthMeasureSpec, heightMeasureSpec);
// 得到子View的外边距
MarginLayoutParams lp = (MarginLayoutParams)childView.getLayoutParams();
// 子View占据的宽度
int childWidth = childView.getMeasuredWidth() + lp.leftMargin + lp.rightMargin;
// 子View占据的高度
int childHeight = childView.getMeasuredHeight() + lp.topMargin + lp.bottomMargin;
//换行情况
if (lineWidth + childWidth > widthSpecSize - getPaddingLeft() - getPaddingRight())
{
// 对比得到最大的宽度
maxWidth = Math.max(maxWidth, lineWidth);
sumHeight += lineHeight; // 累加高度
// 重置lineWidth和lineHeight值
lineWidth = childWidth;
lineHeight = childHeight;
}else{ //同行显示
// 叠加行宽
lineWidth += childWidth;
// 得到当前行最大的高度
lineHeight = Math.max(lineHeight, childHeight);
}
// 最后一个控件
if (i == childCount - 1)
{
maxWidth = Math.max(lineWidth, maxWidth);
sumHeight += lineHeight;
}
}
//宽高测量都是最大值模式(wrap_content)
if (widthSpecMode == MeasureSpec.AT_MOST && heightSpecMode == MeasureSpec.AT_MOST) {
setMeasuredDimension(maxWidth + getPaddingLeft() + getPaddingRight(),
sumHeight + getPaddingTop() + getPaddingBottom());
} else if (widthSpecMode == MeasureSpec.AT_MOST) { //宽测量模式
setMeasuredDimension(maxWidth + getPaddingLeft() + getPaddingRight(), heightSpecSize);
} else if (heightSpecMode == MeasureSpec.AT_MOST) { //高测量模式
setMeasuredDimension(widthSpecSize, sumHeight + getPaddingTop() + getPaddingBottom());
} else {
super.onMeasure(widthMeasureSpec, heightMeasureSpec);
}
}第二部子View布局
@Override
protected void onLayout(boolean changed, int l, int t, int r, int b) {
//重新对子View布局时，一定要清掉之前的数据，否则数据就有问题
mAllViews.clear();
mLineHeight.clear();
// 当前ViewGroup的宽度
int width = getWidth();
int lineWidth = 0;
int lineHeight = 0;
List<View> lineViews = new ArrayList<>();
int childCount = getChildCount();
for (int i = 0; i < childCount; i++)
{
View childView = getChildAt(i);
MarginLayoutParams lp = (MarginLayoutParams) childView.getLayoutParams();
int childWidth = childView.getMeasuredWidth() + lp.leftMargin + lp.rightMargin;
int childHeight = childView.getMeasuredHeight() + lp.topMargin + lp.bottomMargin;
// 换行
if (childWidth + lineWidth > width - getPaddingLeft() - getPaddingRight())
{
// 记录LineHeight
mLineHeight.add(lineHeight);
// 记录当前行的Views
mAllViews.add(lineViews);
// 重置lineWidth和lineHeight
lineWidth = 0;
lineHeight = childHeight;
// 重置lineViews集合
lineViews = new ArrayList<>();
}
lineWidth += childWidth;
lineHeight = Math.max(lineHeight, childHeight);
lineViews.add(childView);
}
// 处理最后一行
mLineHeight.add(lineHeight);
mAllViews.add(lineViews);
// 设置子View的位置
int left = getPaddingLeft();
int top = getPaddingTop();
// 行数
int lineNum = mAllViews.size();
for (int i = 0; i < lineNum; i++){
// 当前行的所有的View
lineViews = mAllViews.get(i);
lineHeight = mLineHeight.get(i); //对应lineViews当前行的行高
for (int j = 0; j < lineViews.size(); j++){
View childView = lineViews.get(j);
// 判断child的状态
if (childView.getVisibility() == View.GONE){
continue;
}
MarginLayoutParams lp = (MarginLayoutParams) childView.getLayoutParams();
int lc = left + lp.leftMargin;
int tc = top + lp.topMargin;
int rc = lc + childView.getMeasuredWidth();
int bc = tc + childView.getMeasuredHeight();
// 为子View进行布局
childView.layout(lc, tc, rc, bc);
left += childView.getMeasuredWidth() + lp.leftMargin + lp.rightMargin;
}
left = getPaddingLeft() ;
top += lineHeight ;
}
}完整源码
public class SimpleViewGroup extends ViewGroup {
public SimpleViewGroup(Context context, AttributeSet attrs) {
super(context, attrs);
}
//测量ViewGroup大小
@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
int widthSpecMode = MeasureSpec.getMode(widthMeasureSpec);
int widthSpecSize = MeasureSpec.getSize(widthMeasureSpec);
int heightSpecMode = MeasureSpec.getMode(heightMeasureSpec);
int heightSpecSize = MeasureSpec.getSize(heightMeasureSpec);
int maxWidth = 0; //记录最大的宽
int sumHeight = 0; //记录子View在垂直方向累加的高
// 记录每一行的宽度
int lineWidth = 0;
//记录一行中最高子View的高度
int lineHeight = 0;
// 获取子View总数
int childCount = getChildCount();
for (int i = 0; i < childCount; i++) {
View childView = getChildAt(i);
// 测量子View的宽和高
measureChild(childView, widthMeasureSpec, heightMeasureSpec);
// 得到子View的外边距
MarginLayoutParams lp = (MarginLayoutParams)childView.getLayoutParams();
// 子View占据的宽度
int childWidth = childView.getMeasuredWidth() + lp.leftMargin + lp.rightMargin;
// 子View占据的高度
int childHeight = childView.getMeasuredHeight() + lp.topMargin + lp.bottomMargin;
//换行情况
if (lineWidth + childWidth > widthSpecSize - getPaddingLeft() - getPaddingRight())
{
// 对比得到最大的宽度
maxWidth = Math.max(maxWidth, lineWidth);
sumHeight += lineHeight; // 累加高度
// 重置lineWidth和lineHeight值
lineWidth = childWidth;
lineHeight = childHeight;
}else{ //同行显示
// 叠加行宽
lineWidth += childWidth;
// 得到当前行最大的高度
lineHeight = Math.max(lineHeight, childHeight);
}
// 最后一个控件
if (i == childCount - 1)
{
maxWidth = Math.max(lineWidth, maxWidth);
sumHeight += lineHeight;
}
}
//宽高测量都是最大值模式(wrap_content)
if (widthSpecMode == MeasureSpec.AT_MOST && heightSpecMode == MeasureSpec.AT_MOST) {
setMeasuredDimension(maxWidth + getPaddingLeft() + getPaddingRight(),
sumHeight + getPaddingTop() + getPaddingBottom());
} else if (widthSpecMode == MeasureSpec.AT_MOST) { //宽测量模式
setMeasuredDimension(maxWidth + getPaddingLeft() + getPaddingRight(), heightSpecSize);
} else if (heightSpecMode == MeasureSpec.AT_MOST) { //高测量模式
setMeasuredDimension(widthSpecSize, sumHeight + getPaddingTop() + getPaddingBottom());
} else {
super.onMeasure(widthMeasureSpec, heightMeasureSpec);
}
}
//存储所有的View
private List<List<View>> mAllViews = new ArrayList<>();
//每一行的高度
private List<Integer> mLineHeight = new ArrayList<>();
@Override
protected void onLayout(boolean changed, int l, int t, int r, int b) {
//重新对子View布局时，一定要清掉之前的数据，否则数据就有问题
mAllViews.clear();
mLineHeight.clear();
// 当前ViewGroup的宽度
int width = getWidth();
int lineWidth = 0;
int lineHeight = 0;
List<View> lineViews = new ArrayList<>();
int childCount = getChildCount();
for (int i = 0; i < childCount; i++)
{
View childView = getChildAt(i);
MarginLayoutParams lp = (MarginLayoutParams) childView.getLayoutParams();
int childWidth = childView.getMeasuredWidth() + lp.leftMargin + lp.rightMargin;
int childHeight = childView.getMeasuredHeight() + lp.topMargin + lp.bottomMargin;
// 换行
if (childWidth + lineWidth > width - getPaddingLeft() - getPaddingRight())
{
// 记录LineHeight
mLineHeight.add(lineHeight);
// 记录当前行的Views
mAllViews.add(lineViews);
// 重置lineWidth和lineHeight
lineWidth = 0;
lineHeight = childHeight;
// 重置lineViews集合
lineViews = new ArrayList<>();
}
lineWidth += childWidth;
lineHeight = Math.max(lineHeight, childHeight);
lineViews.add(childView);
}
// 处理最后一行
mLineHeight.add(lineHeight);
mAllViews.add(lineViews);
// 设置子View的位置
int left = getPaddingLeft();
int top = getPaddingTop();
// 行数
int lineNum = mAllViews.size();
for (int i = 0; i < lineNum; i++){
// 当前行的所有的View
lineViews = mAllViews.get(i);
lineHeight = mLineHeight.get(i); //对应lineViews当前行的行高
for (int j = 0; j < lineViews.size(); j++){
View childView = lineViews.get(j);
// 判断child的状态
if (childView.getVisibility() == View.GONE){
continue;
}
MarginLayoutParams lp = (MarginLayoutParams) childView.getLayoutParams();
int lc = left + lp.leftMargin;
int tc = top + lp.topMargin;
int rc = lc + childView.getMeasuredWidth();
int bc = tc + childView.getMeasuredHeight();
// 为子View进行布局
childView.layout(lc, tc, rc, bc);
left += childView.getMeasuredWidth() + lp.leftMargin + lp.rightMargin;
}
left = getPaddingLeft() ;
top += lineHeight ;
}
}
/**
* 与当前ViewGroup对应的LayoutParams
*/
@Override
public LayoutParams generateLayoutParams(AttributeSet attrs)
{
return new MarginLayoutParams(getContext(), attrs);
}
}xml
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:id="@+id/activity_main"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical">
<com.hh.person.customview.widget.SimpleViewGroup
android:id="@+id/custom_vg"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:background="#555"
android:paddingLeft="12dp"
android:paddingTop="20dp"
android:paddingRight="12dp"
android:paddingBottom="10dp"/>
</LinearLayout>
MainActivity
public class MainActivity extends Activity {
private String[] mVals = new String[]
{ "夏朝", "商朝", "西周、东周（春秋、战国）","秦朝", "西汉、新朝、东汉",
"曹魏、蜀汉、孙吴", "西晋、东晋", "前赵（汉赵）、成汉、前凉、后赵、" +
"前燕、前秦、后秦、后燕、西秦、后凉、南凉、南燕、西凉、胡夏、北燕、" +
"北凉、冉魏、西燕、西蜀","【南朝】宋、齐、梁、陈 【北朝】东魏、西魏、北齐、北周",
"隋朝", "唐朝","后梁、后唐、后晋、后汉、后周、前蜀、后蜀、杨吴、" +
"南唐、吴越、闽国、马楚、南汉、南平、北汉","北宋、南宋",
"辽国", "大理", "西夏","金","元朝","明朝","清朝" };
private SimpleViewGroup simpleViewGroup;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
requestWindowFeature(Window.FEATURE_NO_TITLE);
setContentView(R.layout.activity_main);
simpleViewGroup = (SimpleViewGroup) findViewById(R.id.custom_vg);
LayoutInflater mInflater = LayoutInflater.from(this);
for (int i = 0; i < mVals.length; i++)
{
TextView tv = (TextView) mInflater.inflate(R.layout.tv,simpleViewGroup, false);
tv.setText(mVals[i]);
simpleViewGroup.addView(tv);
}
}
}
参考博文：http://www.qingpingshan.com/rjbc/az/121048.html
扫一扫
4428
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
