6、View的绘制

（1）当测量好一个View之后，我们就可以简单的重写 onDraw（）方法，并在 Canvas 对象上来绘制所需要的图形。Canvas是onDraw（）方法的一个参数。要想在Android界面中绘制相应的图像，就必须在 Canvas 上进行绘制。 它就像一个画板，使用 Paint 就可以在上面作画了。
（2）通常我们要在onDraw外创建一个Canvas对象，创建时还要引入布局中的一个bitmap对象：

Canvas canvas = new Canvas(bitmap);  

这里必须是一个bitmap对象，他与Canvas画布是紧紧联系在一起的，这个过程叫做 装载画布。
（3）bitmap用来存储所有绘制在 Canvas 上的像素信息，都是设置给bitmap的。
举例：

//绘制两个bitmap：这两个是在onDraw中绘制的
canvas.drawBitmap(bitmap1,0,0,null);
canvas.drawBitmap(bitmap2.0,0,null);
<span style="white-space:pre">  </span>// 现在将bitmap2装载到onDrow（）之外的Canvas对象中：
<span style="white-space:pre">  </span>Canvas mCanvas = new Canvas(bitmap2);
<span style="white-space:pre">  </span>// 然后通过mCanvas对bitmap2进行绘图：
<span style="white-space:pre">  </span>mCanvas.drawXXX;

这样通过mCanvas对bitmap2的绘制，刷新View后bitmap2就会发生相应的改变了。所以说所有的Canvas的绘制都是作用在bitmap上的，与在哪里，与哪个Canvas无关。
（4）Draw过程比较简单，它的作用是将View绘制到屏幕上面。
（5）View的绘制过程遵循如下几步：
绘制背景 background.draw(canvas)
绘制自己 （onDraw）
绘制children （dispatchDraw）
绘制装饰 （onDrawScrollBars）
（6）下面看看draw方法的源码：
源码位置：sources\android\view\View.java。

/**
* 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.
*/
public void draw(Canvas canvas) {
   if (mClipBounds != null) {
       canvas.clipRect(mClipBounds);
   }
   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) {
       final Drawable background = mBackground;
       if (background != null) {
           final int scrollX = mScrollX;
           final int scrollY = mScrollY;

           if (mBackgroundSizeChanged) {
               background.setBounds(0, 0,  mRight - mLeft, mBottom - mTop);
               mBackgroundSizeChanged = false;
           }

           if ((scrollX | scrollY) == 0) {
               background.draw(canvas);
           } else {
               canvas.translate(scrollX, scrollY);
               background.draw(canvas);
               canvas.translate(-scrollX, -scrollY);
           }
       }
   }

   // 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 绘制Children
       dispatchDraw(canvas);

       // Step 6, draw decorations (scrollbars) 绘制装饰
       onDrawScrollBars(canvas);

       if (mOverlay != null && !mOverlay.isEmpty()) {
           mOverlay.getOverlayView().dispatchDraw(canvas);
       }

       // we're done...
       return;
   }

（8）在View.java中有dispatchDraw方法，但它是空的，其他的继承了View的比如说ViewGroup就要去重写这个方法去实现对子元素的绘制。

/**
 * Called by draw to draw the child views. This may be overridden
 * by derived classes to gain control just before its children are drawn
 * (but after its own view has been drawn).
 * @param canvas the canvas on which to draw the view
 */
protected void dispatchDraw(Canvas canvas) {

}

（9）ViewGroup通常不需要绘制，因为他本身就没有需要绘制的东西，如果不是指定了ViewGroup的背景颜色，那么ViewGroup的onDrow（）方法都不会被调用。
但是，ViewGroup会使用dispatchDraw（）方法绘制其子View，其过程同样是遍历所有的子View，并调用子View的绘制方法来完成绘制工作。
（10）View中还有一个特殊的方法：setWillNotDraw：

/**
 * If this view doesn't do any drawing on its own, set this flag to
 * allow further optimizations. By default, this flag is not set on
 * View, but could be set on some View subclasses such as ViewGroup.
 *
 * Typically, if you override {@link #onDraw(android.graphics.Canvas)}
 * you should clear this flag.
 *
 * @param willNotDraw whether or not this View draw on its own
 */
public void setWillNotDraw(boolean willNotDraw) {
    setFlags(willNotDraw ? WILL_NOT_DRAW : 0, DRAW_MASK);
}

如果一个View不需要绘制任何内容，那么设置这个标记位为true以后，系统就会进行相应的优化。默认情况下，View并没有启用这个优化标记位，但是ViewGroup会默认启用这个优化标记位。
这个标记位对实际开发的意义是：当我们的自定义控件继承于ViewGroup并且本身不具备绘制功能时，就可以开启这个标记位从而便于系统进行后续的优化。
当然，当明确知道一个ViewGroup需要通过onDraw来绘制内容时，我们需要显式的关闭WILL_NOT_DRAW 这个标志位。

7、自定义View

在自定义View时，我们通常会去重写 onDraw（）方法来绘制View的显示内容，如果该View还需要使用wrap_content 属性，那么还必须重写 onMeasure（）方法。

另外，通过自定义 attrs属性，还可以设置新的属性配置值。

在View通常有以下一些比较重要的回调方法：
（1）onFinishInflate（）：从XML加载组件后回调。
（2）onSizeChanged（）：组件大小改变时回调。
（3）onMeasure（）：回调该方法来进行测量。
（4）onLayout（）：回调该方法来确定显示的位置。
（5）onTouchEvent（）：监听到触摸事件时回调。

自定义View的注意点：
（1）让View支持wrap_content：
如果直接继承View或者ViewGroup的控件，如果不在onMeasure中对wrap_content做特殊处理，那么当外界在布局中使用wrap_content时，就无法达到预期的效果。
（2）如果有必要，让你的View支持padding：
如果直接继承View，如果不再draw方法中处理padding，那么padding属性是无法起到作用的。
另外，直接继承子ViewGroup的控件需要在onMeasure和onLayout中考虑padding和子元素的margin对其造成的影响，不然将导致padding和子元素margin失效。
（3）尽量不要在View中使用Handler，没必要：
因为View内部本身就提供了post系列的方法，完全可以替代Handler的作用，
当然除非你很明确要使用Handler来发送消息。
（4）View中如果有线程或者动画，需要及时停止，参考View#onDetachedFromWindow：
如果有动画或者线程需要停止时，那么onDetachedFromWindow是一个很好的时机。
当包含此View的Activity退出或者当前View被remove时，View的onDetachedFromWindow方法会被调用，
和onDetachedFromWindow方法对应的是onAttachedToWindow，
当包含此View的Activity启动时，View的onAttachedToWindow方法会被调用。
同时当View变得不可见时，我们也要停止线程和动画，
如果不及时处理这种问题，有可能会造成内存泄漏！！！！
（5）View带有滑动嵌套情形时，需要处理好滑动冲突

自定义View的分类：

1、继承特定的View，比如TextView：（对现有控件进行拓展）

用于扩展已有的View的功能。
这种方法不需要自己支持wrap_content和padding等。

2、继承View重新onDraw方法：（重写View来实现全新的控件）

主要用于实现一些不规则的效果，比如绘制一个圆啊，方框啊什么的。
采用这种方式需要自己支持wrap_content，并且padding需要自己处理。

3、继承特定的ViewGroup，比如LinearLayout：（创建复合控件）

不需要处理ViewGroup的测量和布局。

4、继承ViewGroup派生特殊的Layout：（自定义ViewGroup）

用于实现自定义布局，即除了LinearLayout、RelativeLayout、FrameLayout这几种系统的布局之外，我们重新定义一种新的布局。
当某种效果看起来很像几种View组合在一起的时候，可以采用这种方法来实现。
这种方式需要合适地处理 ViewGroup的测量、布局这两个过程，并同时处理子元素的测量和布局过程。

7.1、对现有控件进行拓展：

一般来说，在onDraw（）方法中对原生控件行为进行拓展。

举例1：让一个TextView的背景更加丰富，给其多绘制几层背景：

/**
 * 初始化画笔等
 */
private void initPaint() {
    // 蓝色线条
    paint1 = new Paint();
    paint1.setColor(getResources().getColor(
            android.R.color.holo_blue_bright));
    paint1.setStyle(Paint.Style.FILL);
    // 绿色背景
    paint2 = new Paint();
    paint2.setColor(getResources()
            .getColor(android.R.color.holo_green_dark));
    paint2.setStyle(Paint.Style.FILL);
}

/**
 * 我们可以在在调用super.onDraw(canvas)之前和之后实现自己的逻辑，
 * 分别在系统绘制文字前后，完成自己的操作
 */
@Override
protected void onDraw(Canvas canvas) {
    
    // TODO 回调父类方法super.onDraw(canvas)前，对TextView来说即是绘制文本内容之前
    /*
     * 在绘制文字之下，绘制两个大小不同的矩形，形成一个重叠的效果，
     * 再让系统调用super.onDraw方法，执行绘制文字的工作。
     * */
    // 绘制一个外层矩形，蓝色那个
    canvas.drawRect(
            0, 
            0, 
            getMeasuredWidth(), 
            getMeasuredHeight(), 
            paint1);
    // 绘制一个内层矩形，绿色那个
    canvas.drawRect(
            10, 
            10, 
            getMeasuredWidth() - 10,
            getMeasuredHeight() - 10, 
            paint2);
    canvas.save();
    // 绘制文字前平移10px
    canvas.translate(10, 0);
    
    super.onDraw(canvas);
    
    // TODO 回调父类方法后，对TextView来说即是绘制文本内容之后
    canvas.restore();
    
}

举例2：闪动的文字效果

要想实现这个效果，要充分利用Android中Paint对象的Shader渲染器。通过设置一个不断变化的 LinearGradient，并使用带有该属性的Paint对象来绘制要显示的文字。
首先，在onSizeChanged(),中进行一些对象的初始化工作，根据view的宽设置一个LinearGradient渐变渲染器。

private int mViewWidth;  
private Paint mPaint;  
private Linear Gradient linearGradient;  
private Matrix matrix;  
private int mTranslate;  
  
  
@Override  
protected void onSizeChanged(int w, int h, int oldw, int oldh) {  
<span style="white-space:pre">    </span>  
    super.onSizeChanged(w, h, oldw, oldh);  
      
    if(mViewWidth==0){  
        mViewWidth = getMeasuredWidth();//系统里的函数  
          
        if(mViewWidth>0){  
        <span style="white-space:pre">    </span>// 获取当前绘制TextView的Paint对象  
        <span style="white-space:pre">    </span>mPaint = getPaint();  
            // 给这个paint对象设置原生TextView没有的LinearGradient属性：  
            linearGradient = new LinearGradient(  
            0,   
            0,   
            mViewWidth,   
            0,   
                    new int[]{Color.BLUE,0xffffffff,Color.GREEN},   
                    new float[]{0,1,2},   
                    Shader.TileMode.MIRROR);  
            paint.setShader(linearGradient);  
            matrix = new Matrix();  
        }  
    }  
}  
/** 
 * 在onDraw中通过矩阵的方式来不断平移渐变效果，从而在绘制文字时，产生动态的闪动的效果： 
 */  
@Override  
protected void onDraw(Canvas canvas) {  
    // TODO 回调父类方法super.onDraw(canvas)前，对TextView来说即是绘制文本内容之前  
    super.onDraw(canvas);  
    // TODO 回调父类方法后，对TextView来说即是绘制文本内容之后  
    Log.e("mess", "------onDraw----");  
    if (matrix != null) {  
        mTranslate += mViewWidth / 5;  
        if (mTranslate > 2 * mViewWidth) {  
            mTranslate = -mViewWidth;  
        }  
        matrix.setTranslate(mTranslate, 0);  
        linearGradient.setLocalMatrix(matrix);  
        postInvalidateDelayed(100);  
        }  
    }  
}  

这个例子需要注意的地方是在onSizeChanged方法中，mPaint = getPaint();
这是什么意思呢，在第一个例子中，我们的Paint都是在程序中创建的新的，而这个例子中是同个getPaint（）方法获取的。
也就是说，第一个例子中创建的Paint是要画在已有的TextView上的，而第二个例子中我们获取了TextView它本身自己的Paint，然后在它的基础上进行修改，这样就可以将效果加载在TextView本身的文字上了。

7.2、创建复合控件

这种方式通常需要继承一个已有的ViewGroup，再给它添加指定功能的控件，从而组合成新的复合控件。
复合控件，最常见的其实就是我们的TitleBar了，一般就是一个left+title+right组合。
（1）定义属性：
为一个View提供可自定义的属性非常简单，只需要在res资源目录的values目录下创建一个attrs.xml的属性定义文件，并在该文件中通过如下代码定义相应的属性即可：

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <declare-styleable name="TitleBar">
        <!-- 定义title文字，大小，颜色 -->
        <attr name="title" format="string" />
        <attr name="titleTextSize" format="dimension"/>
        <attr name="titleTextColor" format="color" />
        <!-- 定义left 文字，大小，颜色，背景 -->
        <attr name="leftText" format="string" />
        <attr name="leftTextSize" format="dimension" />
        <attr name="leftTextColor" format="color" />
        <!-- 表示背景可以是颜色，也可以是引用 -->
        <attr name="leftBackGround" format="color|reference" />
        <!-- 定义right 文字，大小，颜色，背景 -->
        <attr name="rightText" format="string" />
        <attr name="rightTextSize" format="dimension"/>
        <attr name="rightTextColor" format="color" />
        <attr name="rightBackGround" format="color|reference" />
    </declare-styleable>
</resources>

下面需要创建一个类，叫TitleBar，并且它继承自RelativeLayout中。在这个类中：
（2）获取自定义属性集
TypedArray typed = context.obtainStyledAttributes(attrs, R.styleable.TitleBar);
系统提供了 TypedArray 这样的数据结构来获取自定义属性集，后面引用的 styleable 的TitleBar ，就是我们在XML中通过<declare-styleable name="TitleBar">所指定的name名。接下来通过TypedArray对象的getString（）、getColor（）等方法，就可以获取这些定义的属性值：

/**
 * 获取自定义的属性
 * 
 * @param context
 */
private int leftTextColor;
private Drawable leftBackGround;
private String leftText;
private float leftTextSize;

private int rightTextColor;
private String rightText;
private float rightTextSize;

private int titleTextColor;
private String titleText;
private float titleTextSize;

/**
 * 通过这个方法，将你在attrs.xml中定义的 declare_styleable的
 * 所有属性的值存储到TypedArray中：
 * @param context
 * @param attrs
 */
private void initAttr(Context context, AttributeSet attrs) {
    
    // 得到TypedArray对象typed
    TypedArray typed = context.obtainStyledAttributes(attrs, R.styleable.TitleBar);
    
    // 从typed中取出对应的值为要设置的属性赋值，第二个参数是未指定时的默认值
    // 这里第一个参数是 R.styleable.name_attrname 耶
    leftTextColor = typed.getColor(R.styleable.TitleBar_leftTextColor, 0XFFFFFFFF);
    leftBackGround = typed.getDrawable(R.styleable.TitleBar_leftBackGround);
    leftText = typed.getString(R.styleable.TitleBar_leftText);
    leftTextSize = typed.getDimension(R.styleable.TitleBar_leftTextSize, 20);

    rightTextColor = typed.getColor(R.styleable.TitleBar_rightTextColor, 0XFFFFFFFF);
    rightText = typed.getString(R.styleable.TitleBar_rightText);
    rightTextSize = typed.getDimension(R.styleable.TitleBar_rightTextSize, 20);

    titleTextColor = typed.getColor(R.styleable.TitleBar_titleTextColor, 0XFFFFFFFF);
    titleText = typed.getString(R.styleable.TitleBar_title);
    titleTextSize = typed.getDimension(R.styleable.TitleBar_titleTextSize, 20);
    
    // 不要忘记调用,用来避免重新创建的时候的错误。
    typed.recycle();
}

（3）组合控件（在UI模板类中）
UI模版TitleBar实际上由三个控件组成，即左边的点击按钮mLeftButton，右边的点击按钮mRightButton和中间的标题栏mTitleView。通过动态添加控件的方式，使用addView方法将这三个控件加入到定义的TitleBar模版中，并给它们设置我们前面所获取到的具体的属性值，比如标题的文字颜色、大小等：
这里要注意啦，下面的各种setXXX中，括号里都是刚刚上面initAttr中获取的值。

private TextView titleView;  
private Button leftButton;  
private Button rightButton;    
private RelativeLayout.LayoutParams leftParams;  
private RelativeLayout.LayoutParams rightParams;  
private RelativeLayout.LayoutParams titleParams;  
  
  
/** 
 * 代码布局 
 *  
 * @param context 
 */  
@SuppressWarnings("deprecation")  
private void initView(Context context) {  
<span style="white-space:pre">    </span>// TitleBar上的三个控件  
    titleView = new TextView(context);  
    leftButton = new Button(context);  
    rightButton = new Button(context);  
  
    // 为创建的组件赋值，标题栏  
    titleView.setText(titleText);  
    titleView.setTextSize(titleTextSize);  
    titleView.setTextColor(titleTextColor);  
    titleView.setGravity(Gravity.CENTER);  
  
    // 为创建的组件赋值，左边按钮  
    leftButton.setText(leftText);  
    leftButton.setTextColor(leftTextColor);  
    leftButton.setBackgroundDrawable(leftBackGround);  
    leftButton.setTextSize(leftTextSize);  
  
    // 为创建的组件赋值，右边按钮  
    rightButton.setText(rightText);  
    rightButton.setTextSize(rightTextSize);  
    rightButton.setTextColor(rightTextColor);  
  
    // 为组件元素设置相应的布局元素，设置大小和位置  
    // 在左边  
    leftParams = new LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.MATCH_PARENT);  
    leftParams.addRule(RelativeLayout.ALIGN_PARENT_LEFT, RelativeLayout.TRUE);  
    // 添加到ViewGroup中：  
    addView(leftButton, leftParams);  
  
    // 在右边  
    rightParams = new LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.MATCH_PARENT);  
    rightParams.addRule(RelativeLayout.ALIGN_PARENT_RIGHT, RelativeLayout.TRUE);  
    addView(rightButton, rightParams);  
  
    //中间  
    titleParams = new LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.MATCH_PARENT);  
    rightParams.addRule(RelativeLayout.CENTER_IN_PARENT, RelativeLayout.TRUE);  
    addView(titleView, titleParams);  
  
    //添加点击监听，（下面讲述如何引入的）  
    /* 
     * 这里的setOnClickListener是系统的关于一个Button的自带的点击事件 
     * */  
    leftButton.setOnClickListener(new OnClickListener() {  
        @Override  
        public void onClick(View v) {  
        /* 
         * 在对点击事件做相应以前，在调用这的MainActivity中，就已经把listenr传入进来了， 
         * 在这里只需要直接调用就可以了。 
         * 其中listener是一个setTitleBarClickListener接口方法的对象。 
         * */  
            if (listener != null) {  
            //正常设置它们的点击事件处理onClick，只是在onClick中让它们执行我们设定的处理。  
                listener.leftClick();  
            }  
        }  
    });  
  
  
    rightButton.setOnClickListener(new OnClickListener() {  
        @Override  
        public void onClick(View v) {  
            if (listener != null) {  
                listener.rightClick();  
            }  
        }  
    });  
}  

（4）定义接口（在UI模板类中）
那么如何给这两个左右按钮设计点击事件呢？既然是UI模版，那么每个调用者所需要这些按钮能够实现的功能都是不一样的，因此，不能直接在UI模板中添加具体的实现逻辑，只能通过接口回调的思想，将具体的实现逻辑交给调用者：

/* 
 * 这是一个接口方法，这个接口中有两个为实现的方法。 
 * */  
public interface TitleBarClickListener{  
    //左点击  
    void leftClick();  
    //右点击  
    void rightClick();  
}  

也就是模板类中的这两个方法需要在具体的调用者的代码中实现。
（5）暴露接口给调用者

/**
 * 暴露一个方法给调用者来注册接口回调，通过接口来获得回调者对接口方法TitleBarClickListener的实现
 * 这里的参数是一个TitleBarClickListener接口的接口对象。
 * @param listener
 */
public void setTitleBarClickListener(TitleBarClickListener listener) {
     this.listener = listener;
}

还包括上面（3）中的两个调用
（6）实现接口的回调
就是说在调用者MainActivity的代码中重写接口中的leftClick（）方法和rightClick（）方法来实现具体的逻辑：

/**
 * 在调用者的代码中，调用者需要实现这样的一个接口，并完成接口中的方法，确定具体的实现逻辑
 * 并使用刚刚暴露的方法，将接口的对象传递进去，从而完成回调。
 * 通常情况下，可以使用匿名内部类的形式来实现接口中的方法：
 */
private TitleBar titlebar;


@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
     titlebar = (TitleBar) findViewById(R.id.titlebar);
     /*
     * setTitleBarClickListener是在TitleBar定义中的一个方法，它用来接收listener。
     * TitleBarClickListener是在TitleBar中定义的一个接口，
     * 这个接口中有两个为实现的方法rightClick和leftClick。
     * 这里重写了leftClick和rightClick方法。
     * */
     titlebar.setTitleBarClickListener(new TitleBar.TitleBarClickListener(){
 
        @Override
        public void rightClick(){
            Toast.makeText(this, "right---", Toast.LENGTH_LONG).show();
        }
      
        @Override
        public void leftClick(){
            Toast.makeText(this, "left---", Toast.LENGTH_LONG).show();
        }
     });
}

（7）引用UI模板
在引用前，都需要指定第三方控件的名字空间：

xmlns：android="http://schemas.android.com/apk/res/android"  

这行代码就是在指定引用的名字控件xmlns，即xml namespace。这里指定了名字控件为“android”，因此在接下来使用系统属性的时候，才可以使用“android：”来引用Android的系统属性。
那么如果需要使用自己自定义的属性，那么就需要创建自己的名字空间，在Android Studio中，第三方的控件都使用如下的代码来引入名字空间：

xmlns：android="http://schemas.android.com/apk/res-auto"  

其中android是我们的名字空间，这个是可以自己改的，自己设置的，比如可以起名称叫cumtom什么的。
使用自定义的VIew与系统原生的View最大的区别就是在申明控件时，需要指定完整的包名，而在引用自定义的属性时，需要使用自定义的xmlns名字：

<com.example.day_1.TitleBar xmlns：android="http://schemas.android.com/apk/res/android"
xmlns：custom="http://schemas.android.com/apk/res-auto"
android:id="@+id/titlebar"
android:layout_width="match_parent"
android:layout_height="100dp"
android:layout_alignParentBottom="true"
custom:leftBackGround="#ff000000"
custom:leftText="left"
custom:leftTextColor="#ffff6734"
custom:leftTextSize="25dp" 
custom:rightText="right"
custom:rightTextSize="25dp"
custom:rightTextColor="#ff123456"
custom:title="title"
custom:titleTextColor="#ff654321"/>

<com.example.day_1.TitleBar>

再更进一步，我们也可以将UI模板写到一个布局文件TitleBar.xml中：

<com.example.day_1.TitleBar xmlns：android="http://schemas.android.com/apk/res/android"
    xmlns：app="http://schemas.android.com/apk/res-auto"
    android:id="@+id/titlebar"
    android:layout_width="match_parent"
    android:layout_height="100dp"
    android:layout_alignParentBottom="true"
    app:leftBackGround="#ff000000"
    app:leftText="left"
    app:leftTextColor="#ffff6734"
    app:leftTextSize="25dp" 
    app:rightText="right"
    app:rightTextSize="25dp"
    app:rightTextColor="#ff123456"
    app:title="title"
    app:titleTextColor="#ff654321"/>

<com.example.day_1.TitleBar>

通过上面的代码，我们就可以在其他的局部文件中，通过<include>标签来引用这个UI模板View：

<include layout="@layout/TitleBar">  

7.3、重写VIew来实现全新的控件

创建自定义View的难点在于绘制控件和实现交互。通常需要继承View类，并重写它的 onDraw（）、onMeasure（）等方法来实现绘制逻辑，同时通过重写 onTouchEvent（）等触控事件来实现交互逻辑。我们还可以像实现控件方式那样，通过引入自定义属性，丰富自定义View的可定制性。

（1）例一：弧线展示图

这个view可以分为三个部分，中间的圆圈，中间显示的文字，外圈的圆弧。只要有了这样的思路，剩余的就是在onDraw()方法中去绘制了。首先我们这个自定义的View名叫CirclePregressView。

private int mMeasureHeigth;// 控件高度  
private int mMeasureWidth;// 控件宽度  
// 圆形  
private Paint mCirclePaint;  
private float mCircleXY;//圆心坐标  
private float mRadius;//圆形半径  
// 圆弧  
private Paint mArcPaint;  
private RectF mArcRectF;//圆弧的外切矩形  
private float mSweepAngle;//圆弧的角度  
private float mSweepValue = 50;// 用来计算圆弧的角度  
// 文字  
private Paint mTextPaint;  
private String mShowText;//文本内容  
private float mShowTextSize;//文本大小  
  
@Override  
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {  
//获取控件宽度  
    mMeasureWidth = MeasureSpec.getSize(widthMeasureSpec);  
    //获取控件高度  
    mMeasureHeigth = MeasureSpec.getSize(heightMeasureSpec);  
    // 设置大小  
    setMeasuredDimension(mMeasureWidth, mMeasureHeigth);  
    initView();  
}  
  
/** 
 *准备画笔， 
 */  
private void initView() {  
  
// View的长度为宽高的最小值：  
    float length = Math.min(mMeasureWidth,mMeasureHeigth);  
      
    /** 
     * 圆 
     */  
    // 确定圆心坐标  
    mCircleXY = length / 2;  
    // 确定圆的半径  
    mRadius = (float) (length * 0.5 / 2);  
    // 定义画笔  
    mCirclePaint = new Paint();  
    // 去锯齿  
    mCirclePaint.setAntiAlias(true);  
    // 设置颜色  
    mCirclePaint.setColor(getResources().getColor(android.R.color.holo_green_dark));  
  
    /** 
     * 圆弧 
     */  
    // 圆弧的外切矩形  
    mArcRectF = new RectF(  
          (float) (length * 0.1),   
          (float) (length * 0.1),   
          (float) (length * 0.9),  
          (float) (length * 0.9));  
    // 圆弧的角度  
    mSweepAngle = (mSweepValue / 100f) * 360f;  
    // 圆弧画笔  
    mArcPaint = new Paint();  
    // 设置颜色  
    mArcPaint.setColor(getResources().getColor(android.R.color.holo_blue_bright));  
    //圆弧宽度  
    mArcPaint.setStrokeWidth((float) (length * 0.1));  
    //圆弧  
    mArcPaint.setStyle(Style.STROKE);  
      
    /** 
     * 文字 
     */  
    mShowText = setShowText();  
    mShowTextSize = setShowTextSize();  
    mTextPaint = new Paint();  
    mTextPaint.setTextSize(mShowTextSize);  
    mTextPaint.setTextAlign(Paint.Align.CENTER);  
  
  
}  
  
/** 
 * 设置文字内容 
 * @return 
 */  
private String setShowText() {  
    this.invalidate();  
    return "Android Skill";  
}  
  
/** 
 * 设置文字大小 
 * @return 
 */  
private float setShowTextSize() {  
    this.invalidate();  
    return 50;  
}  
  
/** 
 * 这个函数还不能缺少，至于invalidate的使用方法，我现在还不知道呢 
 */  
public void forceInvalidate() {  
    this.invalidate();  
}  
  
@Override  
protected void onDraw(Canvas canvas) {  
    super.onDraw(canvas);  
    // 绘制圆  
    canvas.drawCircle(mCircleXY, mCircleXY, mRadius, mCirclePaint);  
    // 绘制圆弧，逆时针绘制，角度跟  
    canvas.drawArc(mArcRectF, 90, mSweepAngle, false, mArcPaint);  
    // 绘制文字  
    canvas.drawText(mShowText, 0, mShowText.length(), mCircleXY, mCircleXY + mShowTextSize / 4, mTextPaint);  
}  

当然还可以这样让调用者来设置不同的状态值：
这个是写在自定义控件类中的：

/** 
 * 让调用者来设置不同的状态值，比如这里默认值为25 
 * @param sweepValue 
 */  
public void setSweepValue(float sweepValue) {  
    if (sweepValue != 0) {  
        mSweepValue = sweepValue;  
    } else {  
        mSweepValue = 25;  
    }  
    this.invalidate();  
}   

这个是写在主程序中的：

CircleProgressView circle = (CircleProgressView)findViewById(R.id.circle);  
circle.setSweepValue(70);  

（2）例二：音频条形图：

思路：绘制n个小矩形，每个矩形有些偏移即可

private int mWidth;//控件的宽度
private int mRectWidth;// 矩形的宽度
private int mRectHeight;// 矩形的高度
private Paint paint;
private int mRectCount;// 矩形的个数

private int offset = 5;// 偏移
private double mRandom;
private LinearGradient lg;// 渐变

private void initView() {
    paint = new Paint();
    paint.setColor(Color.GREEN);
    paint.setStyle(Paint.Style.FILL);
    mRectCount = 12;
}

/**
 * 设置渐变效果：用Shader。
 */
@Override
protected void onSizeChanged(int w, int h, int oldw, int oldh) {
    super.onSizeChanged(w, h, oldw, oldh);
    mWidth = getWidth();
    mRectHeight = getHeight();
    mRectWidth = (int) (mWidth * 0.6 / mRectCount);
    lg = new LinearGradient(
            0, 
            0, 
            mRectWidth, 
            mRectHeight, 
            Color.GREEN, 
            Color.BLUE, 
            TileMode.CLAMP);
    paint.setShader(lg);
}

/**
 * 
 */
@Override
protected void onDraw(Canvas canvas) {
    super.onDraw(canvas);
    // 随机的为每个矩形条计算高度，而后设置高度。
    for (int i = 0; i < mRectCount; i++) {
        mRandom = Math.random();
        float currentHeight = (int) (mRectHeight * mRandom);
        canvas.drawRect(
                (float) (mWidth * 0.4 / 2 + mRectWidth * i + offset * i), 
                currentHeight,
                (float) (mWidth * 0.4 / 2 + mRectWidth * (i + 1) + offset * i), 
                mRectHeight, 
                paint);
    }
    // 调用Invalidate（）方法通知View进行重绘。这里延缓1秒延迟重绘，比较容易看清楚。
    postInvalidateDelayed(1000);
}

8、自定义ViewGroup

自定义ViewGroup通常需要重写onMeasure（）方法来对子View进行测量，重写onLayout（）方法来确定子View的位置，重写onTouchEvent（）方法增加响应事件。
案例分析：自定义ViewGroup实现ScrollView所具有的上下滑动功能，但是在滑动的过程中，增加一个粘性效果，即当一个子View向上滑动大于一定距离后，松开手指，它将自动向上滑动，显示下一个子View。向下同理。

8.1、 首先实现类似Scrollview的功能

在ViewGroup能够滚动之前，需要先放置好它的子View。使用遍历的方式来通知子View对自身进行测量：

/**
 * 
 * 使用遍历的方式通知子view进行自测
 * 
 * */
@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
    super.onMeasure(widthMeasureSpec, heightMeasureSpec);
    int count = getChildCount();

    for (int i = 0; i < count; i++) {
        View childView = getChildAt(i);
        measureChild(childView, widthMeasureSpec, heightMeasureSpec);//让每个子View都显示完整的一屏
    }//这样在滑动的时候，可以比较好地实现后面的效果。
}

8.2、放置子view

/**
 * 计算屏幕高度
 * 
 * @return
 */
private int getScreenHeight() {
    WindowManager manager = (WindowManager) getContext().getSystemService(Context.WINDOW_SERVICE);
    DisplayMetrics dm = new DisplayMetrics();
    manager.getDefaultDisplay().getMetrics(dm);
    return dm.heightPixels;
}

/**
 * 每个view独占一屏 放置view的位置
 * 
 */
@Override
protected void onLayout(boolean changed, int l, int t, int r, int b) {
    
    // 设置ViewGroup的高度，在本例中，由于让每个子View占一屏的高度，因此整个ViewGroup的高度即子View的个数乘以屏幕的高度
    mScreenHeight = getScreenHeight();
    int childcount = getChildCount();
    MarginLayoutParams mlp = (MarginLayoutParams) getLayoutParams();
    mlp.height = childcount * mScreenHeight;
    setLayoutParams(mlp);

    //修改每个子VIew的top和bottom这两个属性，让它们能依次排列下来。
    for (int i = 0; i < childcount; i++) {
        View view = getChildAt(i);
        if (view.getVisibility() != View.GONE) {
            view.layout(l, i * mScreenHeight, r, (i + 1) * mScreenHeight);
        }
    }
}

8.3、响应滑动事件

重写触摸事件
使用scrollBy方法来辅助滑动：

@Override
public boolean onTouchEvent(MotionEvent event) {
    
    int action = event.getAction();
    int y = (int) event.getY();
    
    switch (action) {
    
    case MotionEvent.ACTION_DOWN:
        mLastY = y;
        // 记录触摸起点
        mStart = getScrollY();
        break;
        
    case MotionEvent.ACTION_MOVE:
        if (!mScroller.isFinished()) {
            mScroller.abortAnimation();
        }
        // dy在这里：
        int dy = mLastY - y;
        //View移动到上边沿
        if (getScrollY() < 0) {
            dy = 0;
        }
        //view移动到下边沿
        if (getScrollY() > getHeight() - mScreenHeight) {
            dy = 0;
        }
        Log.e("mess", mScreenHeight+"-----height="+getHeight()+"-----------view="+(getHeight()-mScreenHeight));
        
        // 让手指滑动的时候让ViewGroup的所有子View也跟着滚动dy即可，计算dy的方法有很多：
        scrollBy(0, dy);
        
        mLastY = y;
        break;
        
    case MotionEvent.ACTION_UP:
        // 记录触摸终点
        mEnd = getScrollY();
        int dScrollY = mEnd - mStart;
        Log.e("mess", "---dscrollY="+dScrollY);
        
        if (dScrollY > 0) {// 上滑

            if (dScrollY < mScreenHeight / 3) {// 回彈效果
                mScroller.startScroll(0, getScrollY(), 0, -dScrollY);
            } else {// 滑到下一个view
                mScroller.startScroll(0, getScrollY(), 0, mScreenHeight - dScrollY);
            }
        } else {// 下滑
            if (-dScrollY < mScreenHeight / 3) {// 回彈
                mScroller.startScroll(0, getScrollY(), 0, -dScrollY);
            } else {
                mScroller.startScroll(0, getScrollY(), 0, -mScreenHeight - dScrollY);
            }
        }
        break;
    }
    
    //不要忘了，忘了这个有点坑了就
    postInvalidate();
    return true;
}

实现滚动

@Override
public void computeScroll() {
    super.computeScroll();
    if (mScroller.computeScrollOffset()) {
        scrollTo(0, mScroller.getCurrY());
        postInvalidate();
    }
}

9、事件拦截机制

9.1、MotionEvent-点击事件

当Android系统捕获到用户的各种输入事件后，要想准确的传递到真正需要这个事件的控件就需要使用到Android中的事件拦截机制。这里主要讲的是点击事件的拦截机制，首先，点击事件就是手指接触屏幕后产生的事件，Android的触摸事件封装了一个类：MotionEvent，只要重写触摸相关的方法，就得用到MotionEvent。MotionEvent中封装了很多方法，比如可以用event.getX()与event.getY()来获取坐标位置，它也包含了几种不同的Action：
•ACTION_DOWN：手指刚刚接触到屏幕。
•ACTION_MOVE：手指在屏幕上移动。
•ACTION_UP：手指离开屏幕。

在正常情况下，一次手指触摸屏幕的行为会触发一系列点击事件，考虑如下几种情况：
•点击屏幕后离开松开，事件序列为Down->Up
•点击屏幕滑动一会再松开，事件序列为Down->Move->......>Move->Up

那么，在MotionEvent里面封装了不少好东西，比如触摸点的坐标，可以通过event.getX()方法和event.getRawX()，这两者区别也很简单，getX()返回的是相对于当前View左上角的x坐标，getRawY()返回是相对于手机屏幕左上角的x坐标，同理，y坐标也是可以获取的，getY()和getRawY()方法，MotionEvent获得点击事件的类型，可以通过不同的Action来进行区分，并实现不同的逻辑。

例子：
触摸事件还是简单的，其实就是一个动作类型加坐标而已。但是我们知道，Android的View结构是树形结构，也就是说，View可以放在ViewGroup里面，通过不同的组合来实现不同的样式，那么如果View放在ViewGroup里面，这个ViewGroup又嵌套在另一个ViewGroup里面，甚至还有可能继续嵌套，一层层的叠加起来呢，我们先看一个例子，是通过一个按钮点击的。

XML文件

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:gravity="center"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:id="@+id/mylayout">
    <Button
        android:id="@+id/my_btn"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="click test"/>
</LinearLayout>

Activity文件

public class ListenerActivity extends Activity implements View.OnTouchListener, View.OnClickListener {
    private LinearLayout mLayout;
    private Button mButton;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        setContentView(R.layout.main);

        mLayout = (LinearLayout) this.findViewById(R.id.mylayout);
        mButton = (Button) this.findViewById(R.id.my_btn);

        mLayout.setOnTouchListener(this);
        mButton.setOnTouchListener(this);

        mLayout.setOnClickListener(this);
        mButton.setOnClickListener(this);
    }

    @Override
    public boolean onTouch(View v, MotionEvent event) {
        Log.i(null, "OnTouchListener--onTouch-- action="+event.getAction()+" --"+v);
        return false;
    }

    @Override
    public void onClick(View v) {
        Log.i(null, "OnClickListener--onClick--"+v);
    }
}

Activity中有一个LinearLayout（ViewGroup的子类，ViewGroup是View的子类）布局，布局中包含一个按钮（View的子类），然后分别对这两个控件设置了Touch与Click的监听事件，具体运行结果如下：

1，当稳稳的点击Button时

2，当稳稳的点击除过Button以外的其他地方时：

3，当收指点击Button时按在Button上晃动了一下松开后

我们看下onTouch和onClick，从参数都能看出来onTouch比onClick强大灵活，毕竟多了一个event参数。这样onTouch里就可以处理ACTION_DOWN、ACTION_UP、ACTION_MOVE等等的各种触摸。现在来分析下上面的打印结果；在1中，当我们点击Button时会先触发onTouch事件（之所以打印action为0,1各一次是因为按下抬起两个触摸动作被触发）然后才触发onClick事件；在2中也同理类似1；在3中会发现onTouch被多次调运后才调运onClick，是因为手指晃动了，所以触发了ACTION_DOWN->ACTION_MOVE…->ACTION_UP。

onTouch会有一个返回值，而且在上面返回了false。我们将上面的onTouch返回值改为ture，验证一下。如下：

@Override
public boolean onTouch(View v, MotionEvent event) {
   Log.i(null, "OnTouchListener--onTouch-- action="+event.getAction()+" --"+v);
   return true;
}

显示结果：

此时onTouch返回true，则onClick不会被调运了。
实例验证你可以总结发现：
1.Android控件的Listener事件触发顺序是先触发onTouch，其次onClick。
2.如果控件的onTouch返回true将会阻止事件继续传递，返回false事件会继续传递。

9.2、事件流程

看上面的例子是不是有点困惑，为何OnTouch返回True，onClick就不执行，事件传递就中断，在这里需要引进一个场景，这样解释起来就更形象生动。
首先，请想象一下生活中常见的场景：假如你所在的公司，有一个总经理，级别最高，它下面有个部长，级别次之，最底层就是干活的你，没有级别。现在总经理有一个任务，总经理将这个业务布置给部长，部长又把任务安排给你，当你完成这个任务时，就把任务反馈给部长，部长觉得这个任务完成的不错，于是就签了他的名字反馈给总经理，总经理看了也觉得不错，就也签了名字交给董事会，这样，一个任务就顺利完成了。这其实就是一个典型的事件拦截机制。

在这里我们先定义三个类：
一个总经理—MyViewGroupA，最外层的ViewGroup
一个部长—MyViewGroupB，中间的ViewGroup
一个你—MyView，在最底层

根据以上的场景，我们可以绘制以下流程图：

从图中，我们可以看到在ViewGroup中，比View多了一个方法—onInterceptTouchEvent()方法，这个是干嘛用的呢，是用来进行事件拦截的，如果被拦截，事件就不会往下传递了，不拦截则继续。
如果我们稍微改动下，如果总经理(MyViewGroupA)发现这个任务太简单，觉得自己就可以完成，完全没必要再找下属，因此MyViewGroupA就使用了onInterceptTouchEvent()方法把事件给拦截了，此时流程图：

我们可以看到，事件就传递到MyVewGroupA这里就不继续传递下去了，就直接返回。
如果我们再改动下，总经理(MyViewGroupA)委托给部长(MyViewGroupB)，部长觉得自己就可以完成，完全没必要再找下属，因此MyViewGroupB就使用了onInterceptTouchEvent()方法把事件给拦截了，此时流程图：

我们可以看到，MyViewGroupB拦截后，就不继续传递了，同理如果，到干货的我们上(MyView)，也直接返回True的话，事件也是不会继续传递的，如图：

源码

分析Android View事件传递机制之前有必要先看下源码的一些关系，如下是几个继承关系图：

view9_9.png

看了官方这个继承图是不是明白了上面例子中说的LinearLayout是ViewGroup的子类，ViewGroup是View的子类，Button是View的子类关系呢？其实，在Android中所有的控件无非都是ViewGroup或者View的子类，说高尚点就是所有控件都是View的子类。

（1）、从View的dispatchTouchEvent方法说起

在Android中你只要触摸控件首先都会触发控件的dispatchTouchEvent方法（其实这个方法一般都没在具体的控件类中，而在他的父类View中），所以我们先来看下View的dispatchTouchEvent方法，如下：

public boolean dispatchTouchEvent(MotionEvent event) {
  // If the event should be handled by accessibility focus first.
   if (event.isTargetAccessibilityFocus()) {
       // We don't have focus or no virtual descendant has it, do not handle the event.
       if (!isAccessibilityFocusedViewOrHost()) {
           return false;
       }
       // We have focus and got the event, then use normal event dispatch.
       event.setTargetAccessibilityFocus(false);
   }

   boolean result = false;

   if (mInputEventConsistencyVerifier != null) {
       mInputEventConsistencyVerifier.onTouchEvent(event, 0);
   }

   final int actionMasked = event.getActionMasked();
   if (actionMasked == MotionEvent.ACTION_DOWN) {
       // Defensive cleanup for new gesture
       stopNestedScroll();
   }

   if (onFilterTouchEventForSecurity(event)) {
       //noinspection SimplifiableIfStatement
       ListenerInfo li = mListenerInfo;
       if (li != null && li.mOnTouchListener != null
               && (mViewFlags & ENABLED_MASK) == ENABLED
               && li.mOnTouchListener.onTouch(this, event)) {
           result = true;
       }

       if (!result && onTouchEvent(event)) {
           result = true;
       }
   }

   if (!result && mInputEventConsistencyVerifier != null) {
       mInputEventConsistencyVerifier.onUnhandledEvent(event, 0);
   }

   // Clean up after nested scrolls if this is the end of a gesture;
   // also cancel it if we tried an ACTION_DOWN but we didn't want the rest
   // of the gesture.
   if (actionMasked == MotionEvent.ACTION_UP ||
           actionMasked == MotionEvent.ACTION_CANCEL ||
           (actionMasked == MotionEvent.ACTION_DOWN && !result)) {
       stopNestedScroll();
   }

   return result;
}

dispatchTouchEvent的代码有点长，但可以挑几个重点讲讲，if (onFilterTouchEventForSecurity(event))语句判断当前View是否没被遮住等，然后定义ListenerInfo局部变量，ListenerInfo是View的静态内部类，用来定义一堆关于View的XXXListener等方法；接着if (li != null && li.mOnTouchListener != null && (mViewFlags & ENABLED_MASK) == ENABLED && li.mOnTouchListener.onTouch(this, event))语句就是重点，首先li对象自然不会为null，li.mOnTouchListener呢？你会发现ListenerInfo的mOnTouchListener成员是在哪儿赋值的呢？怎么确认他是不是null呢？通过在View类里搜索可以看到：

/**
 * Register a callback to be invoked when a touch event is sent to this view.
 * @param l the touch listener to attach to this view
 */
public void setOnTouchListener(OnTouchListener l) {
    getListenerInfo().mOnTouchListener = l;
}

li.mOnTouchListener是不是null取决于控件（View）是否设置setOnTouchListener监听，在上面的实例中我们是设置过Button的setOnTouchListener方法的，所以也不为null，接着通过位与运算确定控件（View）是不是ENABLED 的，默认控件都是ENABLED 的，接着判断onTouch的返回值是不是true。通过如上判断之后如果都为true则设置默认为false的result为true，那么接下来的if (!result && onTouchEvent(event))就不会执行，最终dispatchTouchEvent也会返回true。而如果if (li != null && li.mOnTouchListener != null && (mViewFlags & ENABLED_MASK) == ENABLED && li.mOnTouchListener.onTouch(this, event))语句有一个为false则if (!result && onTouchEvent(event))就会执行，如果onTouchEvent(event)返回false则dispatchTouchEvent返回false，否则返回true。

这下再看前面的实例部分明白了吧？控件触摸就会调运dispatchTouchEvent方法，而在dispatchTouchEvent中先执行的是onTouch方法，所以验证了实例结论总结中的onTouch优先于onClick执行道理。如果控件是ENABLE且在onTouch方法里返回了true则dispatchTouchEvent方法也返回true，不会再继续往下执行；反之，onTouch返回false则会继续向下执行onTouchEvent方法，且dispatchTouchEvent的返回值与onTouchEvent返回值相同

（2）、dispatchTouchEvent总结

在View的触摸屏传递机制中通过分析dispatchTouchEvent方法源码我们会得出如下基本结论：

1.触摸控件（View）首先执行dispatchTouchEvent方法。
2.在dispatchTouchEvent方法中先执行onTouch方法，后执行onClick方法（onClick方法在onTouchEvent中执行，下面会分析）。
3.如果控件（View）的onTouch返回false或者mOnTouchListener为null（控件没有设置setOnTouchListener方法）或者控件不是enable的情况下会调运onTouchEvent，dispatchTouchEvent返回值与onTouchEvent返回一样。
4.如果控件不是enable的设置了onTouch方法也不会执行，只能通过重写控件的onTouchEvent方法处理（上面已经处理分析了），dispatchTouchEvent返回值与onTouchEvent返回一样。
5.如果控件（View）是enable且onTouch返回true情况下，dispatchTouchEvent直接返回true，不会调用onTouchEvent方法。

（3）、onTouchEvent方法

public boolean onTouchEvent(MotionEvent event) {
    final float x = event.getX();
    final float y = event.getY();
    final int viewFlags = mViewFlags;

    if ((viewFlags & ENABLED_MASK) == DISABLED) {
        if (event.getAction() == MotionEvent.ACTION_UP && (mPrivateFlags & PFLAG_PRESSED) != 0) {
            setPressed(false);
        }
        // A disabled view that is clickable still consumes the touch
        // events, it just doesn't respond to them.
        return (((viewFlags & CLICKABLE) == CLICKABLE ||
                (viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE));
    }

    if (mTouchDelegate != null) {
        if (mTouchDelegate.onTouchEvent(event)) {
            return true;
        }
    }

    if (((viewFlags & CLICKABLE) == CLICKABLE ||
            (viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE)) {
        switch (event.getAction()) {
            case MotionEvent.ACTION_UP:
                boolean prepressed = (mPrivateFlags & PFLAG_PREPRESSED) != 0;
                if ((mPrivateFlags & PFLAG_PRESSED) != 0 || prepressed) {
                    // take focus if we don't have it already and we should in
                    // touch mode.
                    boolean focusTaken = false;
                    if (isFocusable() && isFocusableInTouchMode() && !isFocused()) {
                        focusTaken = requestFocus();
                    }

                    if (prepressed) {
                        // The button is being released before we actually
                        // showed it as pressed.  Make it show the pressed
                        // state now (before scheduling the click) to ensure
                        // the user sees it.
                        setPressed(true, x, y);
                   }

                    if (!mHasPerformedLongPress) {
                        // This is a tap, so remove the longpress check
                        removeLongPressCallback();

                        // Only perform take click actions if we were in the pressed state
                        if (!focusTaken) {
                            // Use a Runnable and post this rather than calling
                            // performClick directly. This lets other visual state
                            // of the view update before click actions start.
                            if (mPerformClick == null) {
                                mPerformClick = new PerformClick();
                            }
                            if (!post(mPerformClick)) {
                                performClick();
                            }
                        }
                    }

                    if (mUnsetPressedState == null) {
                        mUnsetPressedState = new UnsetPressedState();
                    }

                    if (prepressed) {
                        postDelayed(mUnsetPressedState,
                                ViewConfiguration.getPressedStateDuration());
                    } else if (!post(mUnsetPressedState)) {
                        // If the post failed, unpress right now
                        mUnsetPressedState.run();
                    }

                    removeTapCallback();
                }
                break;

            case MotionEvent.ACTION_DOWN:
                mHasPerformedLongPress = false;

                if (performButtonActionOnTouchDown(event)) {
                    break;
                }

                // Walk up the hierarchy to determine if we're inside a scrolling container.
                boolean isInScrollingContainer = isInScrollingContainer();

                // For views inside a scrolling container, delay the pressed feedback for
                // a short period in case this is a scroll.
                if (isInScrollingContainer) {
                    mPrivateFlags |= PFLAG_PREPRESSED;
                    if (mPendingCheckForTap == null) {
                        mPendingCheckForTap = new CheckForTap();
                    }
                    mPendingCheckForTap.x = event.getX();
                    mPendingCheckForTap.y = event.getY();
                    postDelayed(mPendingCheckForTap, ViewConfiguration.getTapTimeout());
                } else {
                    // Not inside a scrolling container, so show the feedback right away
                    setPressed(true, x, y);
                    checkForLongClick(0);
                }
                break;

            case MotionEvent.ACTION_CANCEL:
                setPressed(false);
                removeTapCallback();
                removeLongPressCallback();
                break;

            case MotionEvent.ACTION_MOVE:
                drawableHotspotChanged(x, y);

                // Be lenient about moving outside of buttons
                if (!pointInView(x, y, mTouchSlop)) {
                    // Outside button
                    removeTapCallback();
                    if ((mPrivateFlags & PFLAG_PRESSED) != 0) {
                        // Remove any future long press/tap checks
                        removeLongPressCallback();

                        setPressed(false);
                    }
                }
                break;
        }

        return true;
    }

    return false;
}

首先地6到14行可以看出，如果控件（View）是disenable状态，同时是可以clickable的则onTouchEvent直接消费事件返回true，反之如果控件（View）是disenable状态，同时是disclickable的则onTouchEvent直接false。多说一句，关于控件的enable或者clickable属性可以通过java或者xml直接设置，每个view都有这些属性。

接着22行可以看见，如果一个控件是enable且disclickable则onTouchEvent直接返回false了；反之，如果一个控件是enable且clickable则继续进入过于一个event的switch判断中，然后最终onTouchEvent都返回了true。switch的ACTION_DOWN与ACTION_MOVE都进行了一些必要的设置与置位，接着到手抬起来ACTION_UP时你会发现，首先判断了是否按下过，同时是不是可以得到焦点，然后尝试获取焦点，然后判断如果不是longPressed则通过post在UI Thread中执行一个PerformClick的Runnable，也就是performClick方法。具体如下：

 public boolean performClick() {
    final boolean result;
    final ListenerInfo li = mListenerInfo;
    if (li != null && li.mOnClickListener != null) {
        playSoundEffect(SoundEffectConstants.CLICK);
        li.mOnClickListener.onClick(this);
        result = true;
    } else {
        result = false;
    }

    sendAccessibilityEvent(AccessibilityEvent.TYPE_VIEW_CLICKED);
    return result;
}

这个方法也是先定义一个ListenerInfo的变量然后赋值，接着判断li.mOnClickListener是不是为null，决定执行不执行onClick。你指定现在已经很机智了，和onTouch一样，搜一下mOnClickListener在哪赋值的呗，结果发现：

public void setOnClickListener(OnClickListener l) {
   if (!isClickable()) {
        setClickable(true);
    }
    getListenerInfo().mOnClickListener = l;
}

控件只要监听了onClick方法则mOnClickListener就不为null，而且有意思的是如果调运setOnClickListener方法设置监听且控件是disclickable的情况下默认会帮设置为clickable。

(4)、onTouchEvent小结

1.onTouchEvent方法中会在ACTION_UP分支中触发onClick的监听。
2.当dispatchTouchEvent在进行事件分发的时候，只有前一个action返回true，才会触发下一个action。

9.3、小结

1.一个View一旦决定拦截，那么一个事件序列都会交给他处理，并且它的onInterceptTouchEvent不会被调用。
2.某个View一旦开始处理事件，如果它不消耗ACTION_DOWN事件，那么同一事件序列中的其他事件都不会交给它处理，事件将交给它的父元素处理。
3.ViewGroup默认不拦截任何事件，ViewGroup的onInterceptTouchEvent方法默认返回false。
4.事件传递是由内到外的，即事件总是先传递到父元素，然后再由父元素分发给子View，通过requestDisallowInterceptTouchEvent方法可以在子元素中干预父元素的分发过程，但是ACTION_DOWN事件除外。

通过以上总结，Android中的事件拦截机制，其实跟我们生活中的上下级委托任务很像，领导可以处理掉，也可以下发给下属员工处理，如果员工处理的好，领导才敢给你下发任务，如果你处理不好，则领导也不敢把任务交给你，这就像在中途把下发的任务的中途拦截掉了。在弄清楚顺序机制之后，再配合源码看，会更加深入的理解，为什么流程会是这样的，最先对流程有一个大致的认识之后，再去理解。