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事件傳遞機制之前有必要先看下源碼的一些關系，如下是幾個繼承關系圖：
看了官方這個繼承圖是不是明白了上面例子中說的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中的事件攔截機制，其實跟我們生活中的上下級委托任務很像，領導可以處理掉，也可以下發給下屬員工處理，如果員工處理的好，領導才敢給你下發任務，如果你處理不好，則領導也不敢把任務交給你，這就像在中途把下發的任務的中途攔截掉了。在弄清楚順序機制之后，再配合源碼看，會更加深入的理解，為什么流程會是這樣的，最先對流程有一個大致的認識之后，再去理解。
