Android View相关介绍

1- View的draw和onDraw的区别

大概扫一下源码就可以明白，draw()这个函数本身会做很多事情，

         *      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)
在第三步的时候，它就会调用onDraw()方法，来绘制view的内容。也就是draw会调用onDraw。

所以看需要，一般情况下，直接用onDraw绘制view的content就可以了，如果绘制多一点的内容，可以调用draw()，不过Android官方推荐用只用onDraw就可以了。“When implementing a view, do not override this method; instead, you should implement onDraw”

代码片段：

<span style="font-family:SimSun;font-size:18px;"> // 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);

            // Step 6, draw decorations (scrollbars)
            onDrawScrollBars(canvas);
</span>

二- View的刷新机制

在Android的布局体系中，父View负责刷新、布局显示子View；而当子View需要刷新时，则是通知父View来完成。

子view执行 invalidate函数， 会调用父View的invalidateChild函数，

有个Do while循环， 以此向上寻找到父view进行判断，每个父view调用自己的invalidateChildInParent

计算dirty区域

这个向上回溯的过程直到ViewRoot那里结束，由ViewRoot对这个最终的刷新区域做刷新。

<span style="font-family:SimSun;font-size:18px;">void invalidate(boolean invalidateCache) {  
          final AttachInfo ai = mAttachInfo;  
          final ViewParent p = mParent;  
          //noinspection PointlessBooleanExpression,ConstantConditions  
          if (!HardwareRenderer.RENDER_DIRTY_REGIONS) {  
              if (p != null && ai != null && ai.mHardwareAccelerated) {  
                  // fast-track for GL-enabled applications; just invalidate the whole hierarchy  
                  // with a null dirty rect, which tells the ViewAncestor to redraw everything  
                  p.invalidateChild(this, null);  
                  return;  
              }  
          }  
  
          if (p != null && ai != null) {  
              final Rect r = ai.mTmpInvalRect;  
              r.set(0, 0, mRight - mLeft, mBottom - mTop);  
              // Don't call invalidate -- we don't want to internally scroll  
              // our own bounds  
              p.invalidateChild(this, r);  
          }  
      }  
  }  </span>

<span style="font-family:SimSun;font-size:18px;">public final void invalidateChild(View child, final Rect dirty) {  
    ViewParent parent = this;  
  
    final AttachInfo attachInfo = mAttachInfo;  
    if (attachInfo != null) {  
        final int[] location = attachInfo.mInvalidateChildLocation;  
        // 需要刷新的子View的位置   
        location[CHILD_LEFT_INDEX] = child.mLeft;  
        location[CHILD_TOP_INDEX] = child.mTop;  
  
        // If the child is drawing an animation, we want to copy this flag onto  
        // ourselves and the parent to make sure the invalidate request goes through  
        final boolean drawAnimation = (child.mPrivateFlags & DRAW_ANIMATION) == DRAW_ANIMATION;  
  
        // Check whether the child that requests the invalidate is fully opaque  
        final boolean isOpaque = child.isOpaque() && !drawAnimation && child.getAnimation() != null;  
        // Mark the child as dirty, using the appropriate flag  
        // Make sure we do not set both flags at the same time  
        final int opaqueFlag = isOpaque ? DIRTY_OPAQUE : DIRTY;  
  
        <span style="color:#ff0000;">do {  </span>
            View view = null;  
            if (parent instanceof View) {  
                view = (View) parent;  
            }  
  
            if (drawAnimation) {  
                if (view != null) {  
                        view.mPrivateFlags |= DRAW_ANIMATION;  
                } else if (parent instanceof ViewRoot) {  
                        ((ViewRoot) parent).mIsAnimating = true;  
                }  
            }  
  
                // If the parent is dirty opaque or not dirty, mark it dirty with the opaque  
                // flag coming from the child that initiated the invalidate  
            if (view != null && (view.mPrivateFlags & DIRTY_MASK) != DIRTY) {  
                view.mPrivateFlags = (view.mPrivateFlags & ~DIRTY_MASK) | opaqueFlag;  
            }  
  
            parent = parent.invalidateChildInParent(location, dirty);  
       <span style="color:#ff0000;"> } while (parent != null);  </span>
    }  
}  
   
public ViewParent invalidateChildInParent(final int[] location, final Rect dirty) {  
    if ((mPrivateFlags & DRAWN) == DRAWN) {  
        if ((mGroupFlags & (FLAG_OPTIMIZE_INVALIDATE | FLAG_ANIMATION_DONE)) !=  
                        FLAG_OPTIMIZE_INVALIDATE) {  
            // 根据父View的位置，偏移刷新区域   
            dirty.offset(location[CHILD_LEFT_INDEX] - mScrollX, location[CHILD_TOP_INDEX] - mScrollY);  
  
            final int left = mLeft;  
            final int top = mTop;  
            //计算实际可刷新区域   
            if (dirty.intersect(0, 0, mRight - left, mBottom - top) ||  
                        (mPrivateFlags & DRAW_ANIMATION) == DRAW_ANIMATION) {  
                mPrivateFlags &= ~DRAWING_CACHE_VALID;  
  
                location[CHILD_LEFT_INDEX] = left;  
                location[CHILD_TOP_INDEX] = top;  
                return mParent;  
            }  
        } else {  
            mPrivateFlags &= ~DRAWN & ~DRAWING_CACHE_VALID;  
  
            location[CHILD_LEFT_INDEX] = mLeft;  
            location[CHILD_TOP_INDEX] = mTop;  
  
           dirty.set(0, 0, mRight - location[CHILD_LEFT_INDEX],  
                        mBottom - location[CHILD_TOP_INDEX]);  
  
                return mParent;  
            }  
        }  
  
        return null;  
}  </span>

三- Android中View的绘制过程

当Activity获得焦点时，它将被要求绘制自己的布局，Android framework将会处理绘制过程，Activity只需提供它的布局的根节点。

绘制过程从布局的根节点开始，从根节点开始测量和绘制整个layout tree。

每一个ViewGroup 负责要求它的每一个孩子被绘制，每一个View负责绘制自己。

因为整个树是按顺序遍历的，所以父节点会先被绘制，而兄弟节点会按照它们在树中出现的顺序被绘制。

绘制是一个两遍（two pass）的过程：一个measure pass和一个layout pass。

测量过程（measuring pass）是在measure(int, int)中实现的，是从树的顶端由上到下进行的。

在这个递归过程中，每一个View会把自己的dimension specifications传递下去。

在measure pass的最后，每一个View都存储好了自己的measurements，即测量结果。

第二个是布局过程（layout pass），它发生在 layout(int, int, int, int)中，仍然是从上到下进行（top-down）。

在这一遍中，每一个parent都会负责用测量过程中得到的尺寸，把自己的所有孩子放在正确的地方。

尺寸的父子关系处理

当一个View对象的 measure() 方法返回时，它的 getMeasuredWidth() 和 getMeasuredHeight()值应该被设置好了，并且它的所有子孙的值也应该一起被设置好了。

一个View对象的measured width 和measured height的值必须考虑到它的父容器给它的限制。

这样就保证了在measure pass的最后，所有的parent都接受了它的所有孩子的measurements结果。

注意：一个parent可能会不止一次地对它的孩子调用measure()方法。

比如，第一遍的时候，一个parent可能测量它的每一个孩子，并没有指定尺寸，parent只是为了发现它们想要多大；

如果第一遍之后得知，所有孩子的无限制的尺寸总和太大或者太小，parent会再次对它的孩子调用measure()方法，这时候parent会设定规则，介入这个过程，使用实际的值。

（即，让孩子自由发展不成，于是家长介入）。

一个自定义View的例子

<span style="font-family:SimSun;font-size:18px;">/*
 * Copyright (C) 2007 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.example.android.apis.view;

// Need the following import to get access to the app resources, since this
// class is in a sub-package.
import android.content.Context;
import android.content.res.TypedArray;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.util.AttributeSet;
import android.view.View;

import com.example.android.apis.R;


/**
 * Example of how to write a custom subclass of View. LabelView
 * is used to draw simple text views. Note that it does not handle
 * styled text or right-to-left writing systems.
 *
 */
public class LabelView extends View {
    private Paint mTextPaint;
    private String mText;
    private int mAscent;
    
    /**
     * Constructor.  This version is only needed if you will be instantiating
     * the object manually (not from a layout XML file).
     * @param context
     */
    public LabelView(Context context) {
        super(context);
        initLabelView();
    }

    /**
     * Construct object, initializing with any attributes we understand from a
     * layout file. These attributes are defined in
     * SDK/assets/res/any/classes.xml.
     * 
     * @see android.view.View#View(android.content.Context, android.util.AttributeSet)
     */
    public LabelView(Context context, AttributeSet attrs) {
        super(context, attrs);
        initLabelView();

        TypedArray a = context.obtainStyledAttributes(attrs,
                R.styleable.LabelView);

        CharSequence s = a.getString(R.styleable.LabelView_text);
        if (s != null) {
            setText(s.toString());
        }

        // Retrieve the color(s) to be used for this view and apply them.
        // Note, if you only care about supporting a single color, that you
        // can instead call a.getColor() and pass that to setTextColor().
        setTextColor(a.getColor(R.styleable.LabelView_textColor, 0xFF000000));

        int textSize = a.getDimensionPixelOffset(R.styleable.LabelView_textSize, 0);
        if (textSize > 0) {
            setTextSize(textSize);
        }

        a.recycle();
    }

    private final void initLabelView() {
        mTextPaint = new Paint();
        mTextPaint.setAntiAlias(true);
        // Must manually scale the desired text size to match screen density
        mTextPaint.setTextSize(16 * getResources().getDisplayMetrics().density);
        mTextPaint.setColor(0xFF000000);
        setPadding(3, 3, 3, 3);
    }

    /**
     * Sets the text to display in this label
     * @param text The text to display. This will be drawn as one line.
     */
    public void setText(String text) {
        mText = text;
        requestLayout();
        invalidate();
    }

    /**
     * Sets the text size for this label
     * @param size Font size
     */
    public void setTextSize(int size) {
        // This text size has been pre-scaled by the getDimensionPixelOffset method
        mTextPaint.setTextSize(size);
        requestLayout();
        invalidate();
    }

    /**
     * Sets the text color for this label.
     * @param color ARGB value for the text
     */
    public void setTextColor(int color) {
        mTextPaint.setColor(color);
        invalidate();
    }

    /**
     * @see android.view.View#measure(int, int)
     */
    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        setMeasuredDimension(measureWidth(widthMeasureSpec),
                measureHeight(heightMeasureSpec));
    }

    /**
     * Determines the width of this view
     * @param measureSpec A measureSpec packed into an int
     * @return The width of the view, honoring constraints from measureSpec
     */
    private int measureWidth(int measureSpec) {
        int result = 0;
        int specMode = MeasureSpec.getMode(measureSpec);
        int specSize = MeasureSpec.getSize(measureSpec);

        if (specMode == MeasureSpec.EXACTLY) {
            // We were told how big to be
            result = specSize;
        } else {
            // Measure the text
            result = (int) mTextPaint.measureText(mText) + getPaddingLeft()
                    + getPaddingRight();
            if (specMode == MeasureSpec.AT_MOST) {
                // Respect AT_MOST value if that was what is called for by measureSpec
                result = Math.min(result, specSize);
            }
        }

        return result;
    }

    /**
     * Determines the height of this view
     * @param measureSpec A measureSpec packed into an int
     * @return The height of the view, honoring constraints from measureSpec
     */
    private int measureHeight(int measureSpec) {
        int result = 0;
        int specMode = MeasureSpec.getMode(measureSpec);
        int specSize = MeasureSpec.getSize(measureSpec);

        mAscent = (int) mTextPaint.ascent();
        if (specMode == MeasureSpec.EXACTLY) {
            // We were told how big to be
            result = specSize;
        } else {
            // Measure the text (beware: ascent is a negative number)
            result = (int) (-mAscent + mTextPaint.descent()) + getPaddingTop()
                    + getPaddingBottom();
            if (specMode == MeasureSpec.AT_MOST) {
                // Respect AT_MOST value if that was what is called for by measureSpec
                result = Math.min(result, specSize);
            }
        }
        return result;
    }

    /**
     * Render the text
     * 
     * @see android.view.View#onDraw(android.graphics.Canvas)
     */
    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        canvas.drawText(mText, getPaddingLeft(), getPaddingTop() - mAscent, mTextPaint);
    }
}</span>

Android view中的requestLayout和invalidate方法：
requestLayout：当view确定自身已经不再适合现有的区域时，该view本身调用这个方法要求parent view重新调用他的onMeasure onLayout来对重新设置自己位置。
特别的当view的layoutparameter发生改变，并且它的值还没能应用到view上，这时候适合调用这个方法。
invalidate：View本身调用迫使view重画。