android sufaceview 预览 android view measure

===========================第一阶段============================

任何一个视图都不可能凭空突然出现在屏幕上，它们都是要经过非常科学的绘制流程后才能显示出来的。每一个视图的绘制过程都必须经历三个最主要的阶段，即onMeasure()、onLayout()和onDraw()，下面我们逐个对这三个阶段展开进行探讨。

一. onMeasure()

measure是测量的意思，那么onMeasure()方法顾名思义就是用于测量视图的大小的。View系统的绘制流程会从ViewRoot的performTraversals()方法中开始，在其内部调用View的measure()方法。measure()方法接收两个参数，widthMeasureSpec和heightMeasureSpec，这两个值分别用于确定视图的宽度和高度的规格和大小。

MeasureSpec的值由specSize和specMode共同组成的，其中specSize记录的是大小，specMode记录的是规格。specMode一共有三种类型，如下所示：

1. EXACTLY

表示父视图希望子视图的大小应该是由specSize的值来决定的，系统默认会按照这个规则来设置子视图的大小，开发人员当然也可以按照自己的意愿设置成任意的大小。

2. AT_MOST

表示子视图最多只能是specSize中指定的大小，开发人员应该尽可能小得去设置这个视图，并且保证不会超过specSize。系统默认会按照这个规则来设置子视图的大小，开发人员当然也可以按照自己的意愿设置成任意的大小。

3. UNSPECIFIED

表示开发人员可以将视图按照自己的意愿设置成任意的大小，没有任何限制。这种情况比较少见，不太会用到。

那么你可能会有疑问了，widthMeasureSpec和heightMeasureSpec这两个值又是从哪里得到的呢？通常情况下，这两个值都是由父视图经过计算后传递给子视图的，说明父视图会在一定程度上决定子视图的大小。但是最外层的根视图，它的widthMeasureSpec和heightMeasureSpec又是从哪里得到的呢？这就需要去分析ViewRoot中的源码了，观察performTraversals()方法可以发现如下代码：

[java]  view plain  copy

 

1. childWidthMeasureSpec = getRootMeasureSpec(desiredWindowWidth, lp.width);  
2. childHeightMeasureSpec = getRootMeasureSpec(desiredWindowHeight, lp.height);

可以看到，这里调用了getRootMeasureSpec()方法去获取widthMeasureSpec和heightMeasureSpec的值，注意方法中传入的参数，其中lp.width和lp.height在创建ViewGroup实例的时候就被赋值了，它们都等于MATCH_PARENT。然后看下getRootMeasureSpec()方法中的代码，如下所示：

[java]  view plain  copy

 

1. private int getRootMeasureSpec(int windowSize, int rootDimension) {  
2. int measureSpec;  
3. switch (rootDimension) {  
4. case ViewGroup.LayoutParams.MATCH_PARENT:  
5.         measureSpec = MeasureSpec.makeMeasureSpec(windowSize, MeasureSpec.EXACTLY);  
6. break;  
7. case ViewGroup.LayoutParams.WRAP_CONTENT:  
8.         measureSpec = MeasureSpec.makeMeasureSpec(windowSize, MeasureSpec.AT_MOST);  
9. break;  
10. default:  
11.         measureSpec = MeasureSpec.makeMeasureSpec(rootDimension, MeasureSpec.EXACTLY);  
12. break;  
13.     }  
14. return measureSpec;  
15. }

可以看到，这里使用了MeasureSpec.makeMeasureSpec()方法来组装一个MeasureSpec，当rootDimension参数等于MATCH_PARENT的时候，MeasureSpec的specMode就等于EXACTLY，当rootDimension等于WRAP_CONTENT的时候，MeasureSpec的specMode就等于AT_MOST。并且MATCH_PARENT和WRAP_CONTENT时的specSize都是等于windowSize的，也就意味着根视图总是会充满全屏的。

介绍了这么多MeasureSpec相关的内容，接下来我们看下View的measure()方法里面的代码吧，如下所示：

[java]  view plain  copy

 

1. public final void measure(int widthMeasureSpec, int heightMeasureSpec) {  
2. if ((mPrivateFlags & FORCE_LAYOUT) == FORCE_LAYOUT ||  
3.             widthMeasureSpec != mOldWidthMeasureSpec ||  
4.             heightMeasureSpec != mOldHeightMeasureSpec) {  
5.         mPrivateFlags &= ~MEASURED_DIMENSION_SET;  
6. if (ViewDebug.TRACE_HIERARCHY) {  
7. this, ViewDebug.HierarchyTraceType.ON_MEASURE);  
8.         }  
9.         onMeasure(widthMeasureSpec, heightMeasureSpec);  
10. if ((mPrivateFlags & MEASURED_DIMENSION_SET) != MEASURED_DIMENSION_SET) {  
11. throw new IllegalStateException("onMeasure() did not set the"  
12. " measured dimension by calling"  
13. " setMeasuredDimension()");  
14.         }  
15.         mPrivateFlags |= LAYOUT_REQUIRED;  
16.     }  
17.     mOldWidthMeasureSpec = widthMeasureSpec;  
18.     mOldHeightMeasureSpec = heightMeasureSpec;  
19. }

注意观察，measure()这个方法是final的，因此我们无法在子类中去重写这个方法，说明Android是不允许我们改变View的measure框架的。然后在第9行调用了onMeasure()方法，这里才是真正去测量并设置View大小的地方，默认会调用getDefaultSize()方法来获取视图的大小，如下所示：

[java]  view plain  copy

 

1. public static int getDefaultSize(int size, int measureSpec) {  
2. int result = size;  
3. int specMode = MeasureSpec.getMode(measureSpec);  
4. int specSize = MeasureSpec.getSize(measureSpec);  
5. switch (specMode) {  
6. case MeasureSpec.UNSPECIFIED:  
7.         result = size;  
8. break;  
9. case MeasureSpec.AT_MOST:  
10. case MeasureSpec.EXACTLY:  
11.         result = specSize;  
12. break;  
13.     }  
14. return result;  
15. }

这里传入的measureSpec是一直从measure()方法中传递过来的。然后调用MeasureSpec.getMode()方法可以解析出specMode，调用MeasureSpec.getSize()方法可以解析出specSize。接下来进行判断，如果specMode等于AT_MOST或EXACTLY就返回specSize，这也是系统默认的行为。之后会在onMeasure()方法中调用setMeasuredDimension()方法来设定测量出的大小，这样一次measure过程就结束了。

当然，一个界面的展示可能会涉及到很多次的measure，因为一个布局中一般都会包含多个子视图，每个视图都需要经历一次measure过程。ViewGroup中定义了一个measureChildren()方法来去测量子视图的大小，如下所示：

[java]  view plain  copy

 

1. protected void measureChildren(int widthMeasureSpec, int heightMeasureSpec) {  
2. final int size = mChildrenCount;  
3. final View[] children = mChildren;  
4. for (int i = 0; i < size; ++i) {  
5. final View child = children[i];  
6. if ((child.mViewFlags & VISIBILITY_MASK) != GONE) {  
7.             measureChild(child, widthMeasureSpec, heightMeasureSpec);  
8.         }  
9.     }  
10. }

这里首先会去遍历当前布局下的所有子视图，然后逐个调用measureChild()方法来测量相应子视图的大小，如下所示：

[java]  view plain  copy

 
    
 
1. protected void measureChild(View child, int parentWidthMeasureSpec,  
2. int parentHeightMeasureSpec) {  
3. final LayoutParams lp = child.getLayoutParams();  
4. final int childWidthMeasureSpec = getChildMeasureSpec(parentWidthMeasureSpec,  
5.             mPaddingLeft + mPaddingRight, lp.width);  
6. final int childHeightMeasureSpec = getChildMeasureSpec(parentHeightMeasureSpec,  
7.             mPaddingTop + mPaddingBottom, lp.height);  
8.     child.measure(childWidthMeasureSpec, childHeightMeasureSpec);  
9. }

可以看到，在第4行和第6行分别调用了getChildMeasureSpec()方法来去计算子视图的MeasureSpec，计算的依据就是布局文件中定义的MATCH_PARENT、WRAP_CONTENT等值，这个方法的内部细节就不再贴出。然后在第8行调用子视图的measure()方法，并把计算出的MeasureSpec传递进去，之后的流程就和前面所介绍的一样了。

当然，onMeasure()方法是可以重写的，也就是说，如果你不想使用系统默认的测量方式，可以按照自己的意愿进行定制，比如：

[java]  view plain  copy

 

1. public class MyView extends View {  
2.   
3.     ......  
4.       
5. @Override  
6. protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {  
7. 200, 200);  
8.     }  
9.   
10. }

这样的话就把View默认的测量流程覆盖掉了，不管在布局文件中定义MyView这个视图的大小是多少，最终在界面上显示的大小都将会是200*200。

需要注意的是，在setMeasuredDimension()方法调用之后，我们才能使用getMeasuredWidth()和getMeasuredHeight()来获取视图测量出的宽高，以此之前调用这两个方法得到的值都会是0。

由此可见，视图大小的控制是由父视图、布局文件、以及视图本身共同完成的，父视图会提供给子视图参考的大小，而开发人员可以在XML文件中指定视图的大小，然后视图本身会对最终的大小进行拍板。

到此为止，我们就把视图绘制流程的第一阶段分析完了。

二. onLayout()

measure过程结束后，视图的大小就已经测量好了，接下来就是layout的过程了。正如其名字所描述的一样，这个方法是用于给视图进行布局的，也就是确定视图的位置。ViewRoot的performTraversals()方法会在measure结束后继续执行，并调用View的layout()方法来执行此过程，如下所示：

[java]  view plain  copy

 

1. host.layout(0, 0, host.mMeasuredWidth, host.mMeasuredHeight);

layout()方法接收四个参数，分别代表着左、上、右、下的坐标，当然这个坐标是相对于当前视图的父视图而言的。可以看到，这里还把刚才测量出的宽度和高度传到了layout()方法中。那么我们来看下layout()方法中的代码是什么样的吧，如下所示：

[java]  view plain  copy

 

1. public void layout(int l, int t, int r, int b) {  
2. int oldL = mLeft;  
3. int oldT = mTop;  
4. int oldB = mBottom;  
5. int oldR = mRight;  
6. boolean changed = setFrame(l, t, r, b);  
7. if (changed || (mPrivateFlags & LAYOUT_REQUIRED) == LAYOUT_REQUIRED) {  
8. if (ViewDebug.TRACE_HIERARCHY) {  
9. this, ViewDebug.HierarchyTraceType.ON_LAYOUT);  
10.         }  
11.         onLayout(changed, l, t, r, b);  
12.         mPrivateFlags &= ~LAYOUT_REQUIRED;  
13. if (mOnLayoutChangeListeners != null) {  
14.             ArrayList<OnLayoutChangeListener> listenersCopy =  
15.                     (ArrayList<OnLayoutChangeListener>) mOnLayoutChangeListeners.clone();  
16. int numListeners = listenersCopy.size();  
17. for (int i = 0; i < numListeners; ++i) {  
18. this, l, t, r, b, oldL, oldT, oldR, oldB);  
19.             }  
20.         }  
21.     }  
22.     mPrivateFlags &= ~FORCE_LAYOUT;  
23. }

在layout()方法中，首先会调用setFrame()方法来判断视图的大小是否发生过变化，以确定有没有必要对当前的视图进行重绘，同时还会在这里把传递过来的四个参数分别赋值给mLeft、mTop、mRight和mBottom这几个变量。接下来会在第11行调用onLayout()方法，正如onMeasure()方法中的默认行为一样，也许你已经迫不及待地想知道onLayout()方法中的默认行为是什么样的了。进入onLayout()方法，咦？怎么这是个空方法，一行代码都没有？！

没错，View中的onLayout()方法就是一个空方法，因为onLayout()过程是为了确定视图在布局中所在的位置，而这个操作应该是由布局来完成的，即父视图决定子视图的显示位置。既然如此，我们来看下ViewGroup中的onLayout()方法是怎么写的吧，代码如下：

[java]  view plain  copy

 

1. @Override  
2. protected abstract void onLayout(boolean changed, int l, int t, int r, int b);

可以看到，ViewGroup中的onLayout()方法竟然是一个抽象方法，这就意味着所有ViewGroup的子类都必须重写这个方法。没错，像LinearLayout、RelativeLayout等布局，都是重写了这个方法，然后在内部按照各自的规则对子视图进行布局的。由于LinearLayout和RelativeLayout的布局规则都比较复杂，就不单独拿出来进行分析了，这里我们尝试自定义一个布局，借此来更深刻地理解onLayout()的过程。

自定义的这个布局目标很简单，只要能够包含一个子视图，并且让子视图正常显示出来就可以了。那么就给这个布局起名叫做SimpleLayout吧，代码如下所示：

[java]  view plain  copy

 

1. public class SimpleLayout extends ViewGroup {  
2.   
3. public SimpleLayout(Context context, AttributeSet attrs) {  
4. super(context, attrs);  
5.     }  
6.   
7. @Override  
8. protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {  
9. super.onMeasure(widthMeasureSpec, heightMeasureSpec);  
10. if (getChildCount() > 0) {  
11. 0);  
12.             measureChild(childView, widthMeasureSpec, heightMeasureSpec);  
13.         }  
14.     }  
15.   
16. @Override  
17. protected void onLayout(boolean changed, int l, int t, int r, int b) {  
18. if (getChildCount() > 0) {  
19. 0);  
20. 0, 0, childView.getMeasuredWidth(), childView.getMeasuredHeight());  
21.         }  
22.     }  
23.   
24. }

代码非常的简单，我们来看下具体的逻辑吧。你已经知道，onMeasure()方法会在onLayout()方法之前调用，因此这里在onMeasure()方法中判断SimpleLayout中是否有包含一个子视图，如果有的话就调用measureChild()方法来测量出子视图的大小。

接着在onLayout()方法中同样判断SimpleLayout是否有包含一个子视图，然后调用这个子视图的layout()方法来确定它在SimpleLayout布局中的位置，这里传入的四个参数依次是0、0、childView.getMeasuredWidth()和childView.getMeasuredHeight()，分别代表着子视图在SimpleLayout中左上右下四个点的坐标。其中，调用childView.getMeasuredWidth()和childView.getMeasuredHeight()方法得到的值就是在onMeasure()方法中测量出的宽和高。

这样就已经把SimpleLayout这个布局定义好了，下面就是在XML文件中使用它了，如下所示：

[html]  view plain  copy

 

1. <com.example.viewtest.SimpleLayout xmlns:android="http://schemas.android.com/apk/res/android"  
2. android:layout_width="match_parent"  
3. android:layout_height="match_parent" >  
4.       
5. <ImageView   
6. android:layout_width="wrap_content"  
7. android:layout_height="wrap_content"  
8. android:src="@drawable/ic_launcher"  
9. />  
10.       
11. </com.example.viewtest.SimpleLayout>

可以看到，我们能够像使用普通的布局文件一样使用SimpleLayout，只是注意它只能包含一个子视图，多余的子视图会被舍弃掉。这里SimpleLayout中包含了一个ImageView，并且ImageView的宽高都是wrap_content。现在运行一下程序，结果如下图所示：

                               

OK！ImageView成功已经显示出来了，并且显示的位置也正是我们所期望的。如果你想改变ImageView显示的位置，只需要改变childView.layout()方法的四个参数就行了。

在onLayout()过程结束后，我们就可以调用getWidth()方法和getHeight()方法来获取视图的宽高了。说到这里，我相信很多朋友长久以来都会有一个疑问，getWidth()方法和getMeasureWidth()方法到底有什么区别呢？它们的值好像永远都是相同的。其实它们的值之所以会相同基本都是因为布局设计者的编码习惯非常好，实际上它们之间的差别还是挺大的。

首先getMeasureWidth()方法在measure()过程结束后就可以获取到了，而getWidth()方法要在layout()过程结束后才能获取到。另外，getMeasureWidth()方法中的值是通过setMeasuredDimension()方法来进行设置的，而getWidth()方法中的值则是通过视图右边的坐标减去左边的坐标计算出来的。

观察SimpleLayout中onLayout()方法的代码，这里给子视图的layout()方法传入的四个参数分别是0、0、childView.getMeasuredWidth()和childView.getMeasuredHeight()，因此getWidth()方法得到的值就是childView.getMeasuredWidth() - 0 = childView.getMeasuredWidth() ，所以此时getWidth()方法和getMeasuredWidth() 得到的值就是相同的，但如果你将onLayout()方法中的代码进行如下修改：

[java]  view plain  copy

 

1. @Override  
2. protected void onLayout(boolean changed, int l, int t, int r, int b) {  
3. if (getChildCount() > 0) {  
4. 0);  
5. 0, 0, 200, 200);  
6.     }  
7. }

这样getWidth()方法得到的值就是200 - 0 = 200，不会再和getMeasuredWidth()的值相同了。当然这种做法充分不尊重measure()过程计算出的结果，通常情况下是不推荐这么写的。getHeight()与getMeasureHeight()方法之间的关系同上，就不再重复分析了。

到此为止，我们把视图绘制流程的第二阶段也分析完了。

三. onDraw()

measure和layout的过程都结束后，接下来就进入到draw的过程了。同样，根据名字你就能够判断出，在这里才真正地开始对视图进行绘制。ViewRoot中的代码会继续执行并创建出一个Canvas对象，然后调用View的draw()方法来执行具体的绘制工作。draw()方法内部的绘制过程总共可以分为六步，其中第二步和第五步在一般情况下很少用到，因此这里我们只分析简化后的绘制过程。代码如下所示：

[java]  view plain  copy

 

1. public void draw(Canvas canvas) {  
2. if (ViewDebug.TRACE_HIERARCHY) {  
3. this, ViewDebug.HierarchyTraceType.DRAW);  
4.     }  
5. final int privateFlags = mPrivateFlags;  
6. final boolean dirtyOpaque = (privateFlags & DIRTY_MASK) == DIRTY_OPAQUE &&  
7. null || !mAttachInfo.mIgnoreDirtyState);  
8.     mPrivateFlags = (privateFlags & ~DIRTY_MASK) | DRAWN;  
9. // Step 1, draw the background, if needed  
10. int saveCount;  
11. if (!dirtyOpaque) {  
12. final Drawable background = mBGDrawable;  
13. if (background != null) {  
14. final int scrollX = mScrollX;  
15. final int scrollY = mScrollY;  
16. if (mBackgroundSizeChanged) {  
17. 0, 0,  mRight - mLeft, mBottom - mTop);  
18. false;  
19.             }  
20. if ((scrollX | scrollY) == 0) {  
21.                 background.draw(canvas);  
22. else {  
23.                 canvas.translate(scrollX, scrollY);  
24.                 background.draw(canvas);  
25.                 canvas.translate(-scrollX, -scrollY);  
26.             }  
27.         }  
28.     }  
29. final int viewFlags = mViewFlags;  
30. boolean horizontalEdges = (viewFlags & FADING_EDGE_HORIZONTAL) != 0;  
31. boolean verticalEdges = (viewFlags & FADING_EDGE_VERTICAL) != 0;  
32. if (!verticalEdges && !horizontalEdges) {  
33. // Step 3, draw the content  
34. if (!dirtyOpaque) onDraw(canvas);  
35. // Step 4, draw the children  
36.         dispatchDraw(canvas);  
37. // Step 6, draw decorations (scrollbars)  
38.         onDrawScrollBars(canvas);  
39. // we're done...  
40. return;  
41.     }  
42. }

可以看到，第一步是从第9行代码开始的，这一步的作用是对视图的背景进行绘制。这里会先得到一个mBGDrawable对象，然后根据layout过程确定的视图位置来设置背景的绘制区域，之后再调用Drawable的draw()方法来完成背景的绘制工作。那么这个mBGDrawable对象是从哪里来的呢？其实就是在XML中通过android:background属性设置的图片或颜色。当然你也可以在代码中通过setBackgroundColor()、setBackgroundResource()等方法进行赋值。

接下来的第三步是在第34行执行的，这一步的作用是对视图的内容进行绘制。可以看到，这里去调用了一下onDraw()方法，那么onDraw()方法里又写了什么代码呢？进去一看你会发现，原来又是个空方法啊。其实也可以理解，因为每个视图的内容部分肯定都是各不相同的，这部分的功能交给子类来去实现也是理所当然的。

第三步完成之后紧接着会执行第四步，这一步的作用是对当前视图的所有子视图进行绘制。但如果当前的视图没有子视图，那么也就不需要进行绘制了。因此你会发现View中的dispatchDraw()方法又是一个空方法，而ViewGroup的dispatchDraw()方法中就会有具体的绘制代码。

以上都执行完后就会进入到第六步，也是最后一步，这一步的作用是对视图的滚动条进行绘制。那么你可能会奇怪，当前的视图又不一定是ListView或者ScrollView，为什么要绘制滚动条呢？其实不管是Button也好，TextView也好，任何一个视图都是有滚动条的，只是一般情况下我们都没有让它显示出来而已。绘制滚动条的代码逻辑也比较复杂，这里就不再贴出来了，因为我们的重点是第三步过程。

通过以上流程分析，相信大家已经知道，View是不会帮我们绘制内容部分的，因此需要每个视图根据想要展示的内容来自行绘制。如果你去观察TextView、ImageView等类的源码，你会发现它们都有重写onDraw()这个方法，并且在里面执行了相当不少的绘制逻辑。绘制的方式主要是借助Canvas这个类，它会作为参数传入到onDraw()方法中，供给每个视图使用。Canvas这个类的用法非常丰富，基本可以把它当成一块画布，在上面绘制任意的东西，那么我们就来尝试一下吧。

这里简单起见，我只是创建一个非常简单的视图，并且用Canvas随便绘制了一点东西，代码如下所示：

[java]  view plain  copy

 

1. public class MyView extends View {  
2.   
3. private Paint mPaint;  
4.   
5. public MyView(Context context, AttributeSet attrs) {  
6. super(context, attrs);  
7. new Paint(Paint.ANTI_ALIAS_FLAG);  
8.     }  
9.   
10. @Override  
11. protected void onDraw(Canvas canvas) {  
12.         mPaint.setColor(Color.YELLOW);  
13. 0, 0, getWidth(), getHeight(), mPaint);  
14.         mPaint.setColor(Color.BLUE);  
15. 20);  
16. "Hello View";  
17. 0, getHeight() / 2, mPaint);  
18.     }  
19. }

可以看到，我们创建了一个自定义的MyView继承自View，并在MyView的构造函数中创建了一个Paint对象。Paint就像是一个画笔一样，配合着Canvas就可以进行绘制了。这里我们的绘制逻辑比较简单，在onDraw()方法中先是把画笔设置成黄色，然后调用Canvas的drawRect()方法绘制一个矩形。然后在把画笔设置成蓝色，并调整了一下文字的大小，然后调用drawText()方法绘制了一段文字。

就这么简单，一个自定义的视图就已经写好了，现在可以在XML中加入这个视图，如下所示：

[html]  view plain  copy

 

1. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"  
2. android:layout_width="match_parent"  
3. android:layout_height="match_parent" >  
4.   
5. <com.example.viewtest.MyView   
6. android:layout_width="200dp"  
7. android:layout_height="100dp"  
8. />  
9.   
10. </LinearLayout>

将MyView的宽度设置成200dp，高度设置成100dp，然后运行一下程序，结果如下图所示：

                      

图中显示的内容也正是MyView这个视图的内容部分了。由于我们没给MyView设置背景，因此这里看不出来View自动绘制的背景效果。

当然了Canvas的用法还有很多很多，这里我不可能把Canvas的所有用法都列举出来，剩下的就要靠大家自行去研究和学习了。

===========================第二阶段============================

相信大家在平时使用View的时候都会发现它是有状态的，比如说有一个按钮，普通状态下是一种效果，但是当手指按下的时候就会变成另外一种效果，这样才会给人产生一种点击了按钮的感觉。当然了，这种效果相信几乎所有的Android程序员都知道该如何实现，但是我们既然是深入了解View，那么自然也应该知道它背后的实现原理应该是什么样的，今天就让我们来一起探究一下吧。

一、视图状态

视图状态的种类非常多，一共有十几种类型，不过多数情况下我们只会使用到其中的几种，因此这里我们也就只去分析最常用的几种视图状态。

1. enabled

表示当前视图是否可用。可以调用setEnable()方法来改变视图的可用状态，传入true表示可用，传入false表示不可用。它们之间最大的区别在于，不可用的视图是无法响应onTouch事件的。

2. focused

表示当前视图是否获得到焦点。通常情况下有两种方法可以让视图获得焦点，即通过键盘的上下左右键切换视图，以及调用requestFocus()方法。而现在的Android手机几乎都没有键盘了，因此基本上只可以使用requestFocus()这个办法来让视图获得焦点了。而requestFocus()方法也不能保证一定可以让视图获得焦点，它会有一个布尔值的返回值，如果返回true说明获得焦点成功，返回false说明获得焦点失败。一般只有视图在focusable和focusable in touch mode同时成立的情况下才能成功获取焦点，比如说EditText。

3. window_focused

表示当前视图是否处于正在交互的窗口中，这个值由系统自动决定，应用程序不能进行改变。

4. selected

表示当前视图是否处于选中状态。一个界面当中可以有多个视图处于选中状态，调用setSelected()方法能够改变视图的选中状态，传入true表示选中，传入false表示未选中。

5. pressed

表示当前视图是否处于按下状态。可以调用setPressed()方法来对这一状态进行改变，传入true表示按下，传入false表示未按下。通常情况下这个状态都是由系统自动赋值的，但开发者也可以自己调用这个方法来进行改变。

我们可以在项目的drawable目录下创建一个selector文件，在这里配置每种状态下视图对应的背景图片。比如创建一个compose_bg.xml文件，在里面编写如下代码：

[html]  view plain  copy

 

 

1. <selector xmlns:android="http://schemas.android.com/apk/res/android">  
2.   
3. <item android:drawable="@drawable/compose_pressed" android:state_pressed="true"></item>  
4. <item android:drawable="@drawable/compose_pressed" android:state_focused="true"></item>  
5. <item android:drawable="@drawable/compose_normal"></item>  
6.   
7. </selector>

这段代码就表示，当视图处于正常状态的时候就显示compose_normal这张背景图，当视图获得到焦点或者被按下的时候就显示compose_pressed这张背景图。

创建好了这个selector文件后，我们就可以在布局或代码中使用它了，比如将它设置为某个按钮的背景图，如下所示：

[html]  view plain  copy

 

 

1. <?xml version="1.0" encoding="utf-8"?>  
2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"  
3. android:layout_width="match_parent"  
4. android:layout_height="match_parent"  
5. android:orientation="vertical" >  
6.       
7. <Button   
8. android:id="@+id/compose"  
9. android:layout_width="60dp"  
10. android:layout_height="40dp"  
11. android:layout_gravity="center_horizontal"  
12. android:background="@drawable/compose_bg"  
13. />  
14.       
15. </LinearLayout>

现在运行一下程序，这个按钮在普通状态和按下状态的时候就会显示不同的背景图片。

这样我们就用一个非常简单的方法实现了按钮按下的效果，但是它的背景原理到底是怎样的呢？这就又要从源码的层次上进行分析了。

我们都知道，当手指按在视图上的时候，视图的状态就已经发生了变化，此时视图的pressed状态是true。每当视图的状态有发生改变的时候，就会回调View的drawableStateChanged()方法，代码如下所示：

[java]  view plain  copy

 

 

1. protected void drawableStateChanged() {  
2.     Drawable d = mBGDrawable;  
3. if (d != null && d.isStateful()) {  
4.         d.setState(getDrawableState());  
5.     }  
6. }

1.  

在这里的第一步，首先是将mBGDrawable赋值给一个Drawable对象，那么这个mBGDrawable是什么呢？观察setBackgroundResource()方法中的代码，如下所示：

[java]  view plain  copy

 

 

1. public void setBackgroundResource(int resid) {  
2. if (resid != 0 && resid == mBackgroundResource) {  
3. return;  
4.     }  
5. null;  
6. if (resid != 0) {  
7.         d = mResources.getDrawable(resid);  
8.     }  
9.     setBackgroundDrawable(d);  
10.     m

BackgroundResource = resid;  

1. }  

可以看到，在第7行调用了Resource的getDrawable()方法将resid转换成了一个Drawable对象，然后调用了setBackgroundDrawable()方法并将这个Drawable对象传入，在setBackgroundDrawable()方法中会将传入的Drawable对象赋值给mBGDrawable。

而我们在布局文件中通过android:background属性指定的selector文件，效果等同于调用setBackgroundResource()方法。也就是说drawableStateChanged()方法中的mBGDrawable对象其实就是我们指定的selector文件。

接下来在drawableStateChanged()方法的第4行调用了getDrawableState()方法来获取视图状态，代码如下所示：

[java]  view plain  copy

 

 

1. public final int[] getDrawableState() {  
2. if ((mDrawableState != null) && ((mPrivateFlags & DRAWABLE_STATE_DIRTY) == 0)) {  
3. return mDrawableState;  
4. else {  
5. 0);  
6.         mPrivateFlags &= ~DRAWABLE_STATE_DIRTY;  
7. return mDrawableState;  
8.     }  
9. }

在这里首先会判断当前视图的状态是否发生了改变，如果没有改变就直接返回当前的视图状态，如果发生了改变就调用onCreateDrawableState()方法来获取最新的视图状态。视图的所有状态会以一个整型数组的形式返回。

在得到了视图状态的数组之后，就会调用Drawable的setState()方法来对状态进行更新，代码如下所示：

[java]  view plain  copy

 

 

1. public boolean setState(final int[] stateSet) {  
2. if (!Arrays.equals(mStateSet, stateSet)) {  
3.         mStateSet = stateSet;  
4. return onStateChange(stateSet);  
5.     }  
6. return false;  
7. }

这里会调用Arrays.equals()方法来判断视图状态的数组是否发生了变化，如果发生了变化则调用onStateChange()方法，否则就直接返回false。但你会发现，Drawable的onStateChange()方法中其实就只是简单返回了一个false，并没有任何的逻辑处理，这是为什么呢？这主要是因为mBGDrawable对象是通过一个selector文件创建出来的，而通过这种文件创建出来的Drawable对象其实都是一个StateListDrawable实例，因此这里调用的onStateChange()方法实际上调用的是StateListDrawable中的onStateChange()方法，那么我们赶快看一下吧：

[java]  view plain  copy

 

 

1. @Override  
2. protected boolean onStateChange(int[] stateSet) {  
3. int idx = mStateListState.indexOfStateSet(stateSet);  
4. if (DEBUG) android.util.Log.i(TAG, "onStateChange " + this + " states "  
5. " found " + idx);  
6. if (idx < 0) {  
7.         idx = mStateListState.indexOfStateSet(StateSet.WILD_CARD);  
8.     }  
9. if (selectDrawable(idx)) {  
10. return true;  
11.     }  
12. return super.onStateChange(stateSet);  
13. }

selectDrawable()方法并将下标传入，在这个方法中就会将视图的背景图设置为当前视图状态所对应的那张图片了。

那你可能会有疑问，在前面一篇文章中我们说到，任何一个视图的显示都要经过非常科学的绘制流程的，很显然，背景图的绘制是在draw()方法中完成的，那么为什么selectDrawable()方法能够控制背景图的改变呢？这就要研究一下视图重绘的流程了。

二、视图重绘

虽然视图会在Activity加载完成之后自动绘制到屏幕上，但是我们完全有理由在与Activity进行交互的时候要求动态更新视图，比如改变视图的状态、以及显示或隐藏某个控件等。那在这个时候，之前绘制出的视图其实就已经过期了，此时我们就应该对视图进行重绘。

调用视图的setVisibility()、setEnabled()、setSelected()等方法时都会导致视图重绘，而如果我们想要手动地强制让视图进行重绘，可以调用invalidate()方法来实现。当然了，setVisibility()、setEnabled()、setSelected()等方法的内部其实也是通过调用invalidate()方法来实现的，那么就让我们来看一看invalidate()方法的代码是什么样的吧。

View的源码中会有数个invalidate()方法的重载和一个invalidateDrawable()方法，当然它们的原理都是相同的，因此我们只分析其中一种，代码如下所示：

[java]  view plain  copy

 

 

 
 
1. void invalidate(boolean invalidateCache) {  
2. if (ViewDebug.TRACE_HIERARCHY) {  
3. this, ViewDebug.HierarchyTraceType.INVALIDATE);  
4.     }  
5. if (skipInvalidate()) {  
6. return;  
7.     }  
8. if ((mPrivateFlags & (DRAWN | HAS_BOUNDS)) == (DRAWN | HAS_BOUNDS) ||  
9.             (invalidateCache && (mPrivateFlags & DRAWING_CACHE_VALID) == DRAWING_CACHE_VALID) ||  
10.             (mPrivateFlags & INVALIDATED) != INVALIDATED || isOpaque() != mLastIsOpaque) {  
11.         mLastIsOpaque = isOpaque();  
12.         mPrivateFlags &= ~DRAWN;  
13.         mPrivateFlags |= DIRTY;  
14. if (invalidateCache) {  
15.             mPrivateFlags |= INVALIDATED;  
16.             mPrivateFlags &= ~DRAWING_CACHE_VALID;  
17.         }  
18. final AttachInfo ai = mAttachInfo;  
19. final ViewParent p = mParent;  
20. if (!HardwareRenderer.RENDER_DIRTY_REGIONS) {  
21. if (p != null && ai != null && ai.mHardwareAccelerated) {  
22. this, null);  
23. return;  
24.             }  
25.         }  
26. if (p != null && ai != null) {  
27. final Rect r = ai.mTmpInvalRect;  
28. 0, 0, mRight - mLeft, mBottom - mTop);  
29. this, r);  
30.         }  
31.     }  
32. }

在这个方法中首先会调用skipInvalidate()方法来判断当前View是否需要重绘，判断的逻辑也比较简单，如果View是不可见的且没有执行任何动画，就认为不需要重绘了。之后会进行透明度的判断，并给View添加一些标记位，然后在第22和29行调用 ViewParent的invalidateChild()方法，这里的ViewParent其实就是当前视图的父视图，因此会调用到ViewGroup的invalidateChild()方法中，代码如下所示：

[java]  view plain  copy

 

 

1. public final void invalidateChild(View child, final Rect dirty) {  
2. this;  
3. final AttachInfo attachInfo = mAttachInfo;  
4. if (attachInfo != null) {  
5. final boolean drawAnimation = (child.mPrivateFlags & DRAW_ANIMATION) == DRAW_ANIMATION;  
6. if (dirty == null) {  
7.             ......  
8. else {  
9.             ......  
10. do {  
11. null;  
12. if (parent instanceof View) {  
13.                     view = (View) parent;  
14. if (view.mLayerType != LAYER_TYPE_NONE &&  
15. instanceof View) {  
16. final View grandParent = (View) view.getParent();  
17.                         grandParent.mPrivateFlags |= INVALIDATED;  
18.                         grandParent.mPrivateFlags &= ~DRAWING_CACHE_VALID;  
19.                     }  
20.                 }  
21. if (drawAnimation) {  
22. if (view != null) {  
23.                         view.mPrivateFlags |= DRAW_ANIMATION;  
24. else if (parent instanceof ViewRootImpl) {  
25. true;  
26.                     }  
27.                 }  
28. if (view != null) {  
29. if ((view.mViewFlags & FADING_EDGE_MASK) != 0 &&  
30. 0) {  
31.                         opaqueFlag = DIRTY;  
32.                     }  
33. if ((view.mPrivateFlags & DIRTY_MASK) != DIRTY) {  
34.                         view.mPrivateFlags = (view.mPrivateFlags & ~DIRTY_MASK) | opaqueFlag;  
35.                     }  
36.                 }  
37.                 parent = parent.invalidateChildInParent(location, dirty);  
38. if (view != null) {  
39.                     Matrix m = view.getMatrix();  
40. if (!m.isIdentity()) {  
41.                         RectF boundingRect = attachInfo.mTmpTransformRect;  
42.                         boundingRect.set(dirty);  
43.                         m.mapRect(boundingRect);  
44. int) boundingRect.left, (int) boundingRect.top,  
45. int) (boundingRect.right + 0.5f),  
46. int) (boundingRect.bottom + 0.5f));  
47.                     }  
48.                 }  
49. while (parent != null);  
50.         }  
51.     }  
52. }

可以看到，这里在第10行进入了一个while循环，当ViewParent不等于空的时候就会一直循环下去。在这个while循环当中会不断地获取当前布局的父布局，并调用它的invalidateChildInParent()方法，在ViewGroup的 invalidateChildInParent()方法中主要是来计算需要重绘的矩形区域，这里我们先不管它，当循环到最外层的根布局后，就会调用ViewRoot的invalidateChildInParent()方法了，代码如下所示：

[java]  view plain  copy

 

 

1. public ViewParent invalidateChildInParent(final int[] location, final Rect dirty) {  
2. null, dirty);  
3. return null;  
4. }

这里的代码非常简单，仅仅是去调用了invalidateChild()方法而已，那我们再跟进去瞧一瞧吧：

[java]  view plain  copy

 

 

1. public void invalidateChild(View child, Rect dirty) {  
2.     checkThread();  
3. if (LOCAL_LOGV) Log.v(TAG, "Invalidate child: " + dirty);  
4.     mDirty.union(dirty);  
5. if (!mWillDrawSoon) {  
6.         scheduleTraversals();  
7.     }  
8. }

这个方法也不长，它在第6行又调用了scheduleTraversals()这个方法，那么我们继续跟进：

[java]  view plain  copy

 

 

1. public void scheduleTraversals() {  
2. if (!mTraversalScheduled) {  
3. true;  
4.         sendEmptyMessage(DO_TRAVERSAL);  
5.     }  
6. }

可以看到，这里调用了sendEmptyMessage()方法，并传入了一个DO_TRAVERSAL参数。了解Android异步消息处理机制的朋友们都会知道，任何一个Handler都可以调用sendEmptyMessage()方法来发送消息，并且在handleMessage()方法中接收消息，而如果你看一下ViewRoot的类定义就会发现，它是继承自Handler的，也就是说这里调用 sendEmptyMessage()方法出的消息，会在ViewRoot的handleMessage()方法中接收到。那么赶快看一下handleMessage()方法的代码吧，如下所示：

[java]  view plain  copy

 

 

1. public void handleMessage(Message msg) {  
2. switch (msg.what) {  
3. case DO_TRAVERSAL:  
4. if (mProfile) {  
5. "ViewRoot");  
6.         }  
7.         performTraversals();  
8. if (mProfile) {  
9.             Debug.stopMethodTracing();  
10. false;  
11.         }  
12. break;  
13.     ......  
14. }

performTraversals()方法中，然后重新执行绘制流程。

了解了这些之后，我们再回过头来看看刚才的selectDrawable()方法中到底做了什么才能够控制背景图的改变，代码如下所示：

[java]  view plain  copy

 

 

1. public boolean selectDrawable(int idx) {  
2. if (idx == mCurIndex) {  
3. return false;  
4.     }  
5. final long now = SystemClock.uptimeMillis();  
6. if (mDrawableContainerState.mExitFadeDuration > 0) {  
7. if (mLastDrawable != null) {  
8. false, false);  
9.         }  
10. if (mCurrDrawable != null) {  
11.             mLastDrawable = mCurrDrawable;  
12.             mExitAnimationEnd = now + mDrawableContainerState.mExitFadeDuration;  
13. else {  
14. null;  
15. 0;  
16.         }  
17. else if (mCurrDrawable != null) {  
18. false, false);  
19.     }  
20. if (idx >= 0 && idx < mDrawableContainerState.mNumChildren) {  
21.         Drawable d = mDrawableContainerState.mDrawables[idx];  
22.         mCurrDrawable = d;  
23.         mCurIndex = idx;  
24. if (d != null) {  
25. if (mDrawableContainerState.mEnterFadeDuration > 0) {  
26.                 mEnterAnimationEnd = now + mDrawableContainerState.mEnterFadeDuration;  
27. else {  
28.                 d.setAlpha(mAlpha);  
29.             }  
30. true);  
31.             d.setDither(mDrawableContainerState.mDither);  
32.             d.setColorFilter(mColorFilter);  
33.             d.setState(getState());  
34.             d.setLevel(getLevel());  
35.             d.setBounds(getBounds());  
36.         }  
37. else {  
38. null;  
39. 1;  
40.     }  
41. if (mEnterAnimationEnd != 0 || mExitAnimationEnd != 0) {  
42. if (mAnimationRunnable == null) {  
43. new Runnable() {  
44. @Override public void run() {  
45. true);  
46.                     invalidateSelf();  
47.                 }  
48.             };  
49. else {  
50.             unscheduleSelf(mAnimationRunnable);  
51.         }  
52. true);  
53.     }  
54.     invalidateSelf();  
55. return true;  
56. }

这里前面的代码我们可以都不管，关键是要看到在第54行一定会调用invalidateSelf()方法，这个方法中的代码如下所示：

[java]  view plain  copy

 

 

1. public void invalidateSelf() {  
2. final Callback callback = getCallback();  
3. if (callback != null) {  
4. this);  
5.     }  
6. }

可以看到，这里会先调用getCallback()方法获取Callback接口的回调实例，然后再去调用回调实例的invalidateDrawable()方法。那么这里的回调实例又是什么呢？观察一下View的类定义其实你就知道了，如下所示：

[java]  view plain  copy

 

 

1. public class View implements Drawable.Callback, Drawable.Callback2, KeyEvent.Callback,  
2. AccessibilityEventSource {  
3.     ......  
4. }

View类正是实现了 Callback接口，所以刚才其实调用的就是View中的invalidateDrawable()方法，之后就会按照我们前面分析的流程执行重绘逻辑，所以视图的背景图才能够得到改变的。

另外需要注意的是，invalidate()方法虽然最终会调用到performTraversals()方法中，但这时measure和layout流程是不会重新执行的，因为视图没有强制重新测量的标志位，而且大小也没有发生过变化，所以这时只有draw流程可以得到执行。而如果你希望视图的绘制流程可以完完整整地重新走一遍，就不能使用invalidate()方法，而应该调用requestLayout()了。这个方法中的流程比invalidate()方法要简单一些，但中心思想是差不多的，这里也就不再详细进行分析了。

===========================第 三 阶段============================

自定义View的实现方法。

一些接触Android不久的朋友对自定义View都有一丝畏惧感，总感觉这是一个比较高级的技术，但其实自定义View并不复杂，有时候只需要简单几行代码就可以完成了。

如果说要按类型来划分的话，自定义View的实现方式大概可以分为三种，自绘控件、组合控件、以及继承控件。那么下面我们就来依次学习一下，每种方式分别是如何自定义View的。

一、自绘控件

自绘控件的意思就是，这个View上所展现的内容全部都是我们自己绘制出来的。绘制的代码是写在onDraw()方法中的。

下面我们准备来自定义一个计数器View，这个View可以响应用户的点击事件，并自动记录一共点击了多少次。新建一个CounterView继承自View，代码如下所示：

[java]  view plain  copy

 

 

1. public class CounterView extends View implements OnClickListener {  
2.   
3. private Paint mPaint;  
4.       
5. private Rect mBounds;  
6.   
7. private int mCount;  
8.       
9. public CounterView(Context context, AttributeSet attrs) {  
10. super(context, attrs);  
11. new Paint(Paint.ANTI_ALIAS_FLAG);  
12. new Rect();  
13. this);  
14.     }  
15.   
16. @Override  
17. protected void onDraw(Canvas canvas) {  
18. super.onDraw(canvas);  
19.         mPaint.setColor(Color.BLUE);  
20. 0, 0, getWidth(), getHeight(), mPaint);  
21.         mPaint.setColor(Color.YELLOW);  
22. 30);  
23.         String text = String.valueOf(mCount);  
24. 0, text.length(), mBounds);  
25. float textWidth = mBounds.width();  
26. float textHeight = mBounds.height();  
27. 2 - textWidth / 2, getHeight() / 2  
28. 2, mPaint);  
29.     }  
30.   
31. @Override  
32. public void onClick(View v) {  
33.         mCount++;  
34.         invalidate();  
35.     }  
36.   
37. }

可以看到，首先我们在CounterView的构造函数中初始化了一些数据，并给这个View的本身注册了点击事件，这样当CounterView被点击的时候，onClick()方法就会得到调用。而onClick()方法中的逻辑就更加简单了，只是对mCount这个计数器加1，然后调用invalidate()方法。 调用invalidate()方法会导致视图进行重绘，因此onDraw()方法在稍后就将会得到调用。

既然CounterView是一个自绘视图，那么最主要的逻辑当然就是写在onDraw()方法里的了，下面我们就来仔细看一下。这里首先是将Paint画笔设置为蓝色，然后调用Canvas的drawRect()方法绘制了一个矩形，这个矩形也就可以当作是CounterView的背景图吧。接着将画笔设置为黄色，准备在背景上面绘制当前的计数，注意这里先是调用了getTextBounds()方法来获取到文字的宽度和高度，然后调用了drawText()方法去进行绘制就可以了。

这样，一个自定义的View就已经完成了，并且目前这个CounterView是具备自动计数功能的。那么剩下的问题就是如何让这个View在界面上显示出来了，其实这也非常简单，我们只需要像使用普通的控件一样来使用CounterView就可以了。比如在布局文件中加入如下代码：

[html]  view plain  copy

 

 

1. <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"  
2. android:layout_width="match_parent"  
3. android:layout_height="match_parent" >  
4.   
5. <com.example.customview.CounterView  
6. android:layout_width="100dp"  
7. android:layout_height="100dp"  
8. android:layout_centerInParent="true" />  
9.   
10. </RelativeLayout>

可以看到，这里我们将CounterView放入了一个RelativeLayout中，然后可以像使用普通控件来给CounterView指定各种属性，比如通过layout_width和layout_height来指定CounterView的宽高，通过android:layout_centerInParent来指定它在布局里居中显示。只不过需要注意，自定义的View在使用的时候一定要写出完整的包名，不然系统将无法找到这个View。

好了，就是这么简单，接下来我们可以运行一下程序，并不停地点击CounterView，效果如下图所示。

怎么样？是不是感觉自定义View也并不是什么高级的技术，简单几行代码就可以实现了。当然了，这个CounterView功能非常简陋，只有一个计数功能，因此只需几行代码就足够了，当你需要绘制比较复杂的View时，还是需要很多技巧的。

二、组合控件

组合控件的意思就是，我们并不需要自己去绘制视图上显示的内容，而只是用系统原生的控件就好了，但我们可以将几个系统原生的控件组合到一起，这样创建出的控件就被称为组合控件。

举个例子来说，标题栏就是个很常见的组合控件，很多界面的头部都会放置一个标题栏，标题栏上会有个返回按钮和标题，点击按钮后就可以返回到上一个界面。那么下面我们就来尝试去实现这样一个标题栏控件。

新建一个title.xml布局文件，代码如下所示：

[html]  view plain  copy

 

 

1. <?xml version="1.0" encoding="utf-8"?>  
2. <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"  
3. android:layout_width="match_parent"  
4. android:layout_height="50dp"  
5. android:background="#ffcb05" >  
6.   
7. <Button  
8. android:id="@+id/button_left"  
9. android:layout_width="60dp"  
10. android:layout_height="40dp"  
11. android:layout_centerVertical="true"  
12. android:layout_marginLeft="5dp"  
13. android:background="@drawable/back_button"  
14. android:text="Back"  
15. android:textColor="#fff" />  
16.   
17. <TextView  
18. android:id="@+id/title_text"  
19. android:layout_width="wrap_content"  
20. android:layout_height="wrap_content"  
21. android:layout_centerInParent="true"  
22. android:text="This is Title"  
23. android:textColor="#fff"  
24. android:textSize="20sp" />  
25.   
26. </RelativeLayout>

在这个布局文件中，我们首先定义了一个RelativeLayout作为背景布局，然后在这个布局里定义了一个Button和一个TextView，Button就是标题栏中的返回按钮，TextView就是标题栏中的显示的文字。

接下来创建一个TitleView继承自FrameLayout，代码如下所示：

[java]  view plain  copy

 

 

 
 
1. public class TitleView extends FrameLayout {  
2.   
3. private Button leftButton;  
4.   
5. private TextView titleText;  
6.   
7. public TitleView(Context context, AttributeSet attrs) {  
8. super(context, attrs);  
9. this);  
10.         titleText = (TextView) findViewById(R.id.title_text);  
11.         leftButton = (Button) findViewById(R.id.button_left);  
12. new OnClickListener() {  
13. @Override  
14. public void onClick(View v) {  
15.                 ((Activity) getContext()).finish();  
16.             }  
17.         });  
18.     }  
19.   
20. public void setTitleText(String text) {  
21.         titleText.setText(text);  
22.     }  
23.   
24. public void setLeftButtonText(String text) {  
25.         leftButton.setText(text);  
26.     }  
27.   
28. public void setLeftButtonListener(OnClickListener l) {  
29.         leftButton.setOnClickListener(l);  
30.     }  
31.   
32. }

TitleView中的代码非常简单，在TitleView的构建方法中，我们调用了LayoutInflater的inflate()方法来加载刚刚定义的title.xml布局 。

接下来调用findViewById()方法获取到了返回按钮的实例，然后在它的onClick事件中调用finish()方法来关闭当前的Activity，也就相当于实现返回功能了。

另外，为了让TitleView有更强地扩展性，我们还提供了setTitleText()、setLeftButtonText()、setLeftButtonListener()等方法，分别用于设置标题栏上的文字、返回按钮上的文字、以及返回按钮的点击事件。

到了这里，一个自定义的标题栏就完成了，那么下面又到了如何引用这个自定义View的部分，其实方法基本都是相同的，在布局文件中添加如下代码：

[html]  view plain  copy

 

 

1. <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"  
2. xmlns:tools="http://schemas.android.com/tools"  
3. android:layout_width="match_parent"  
4. android:layout_height="match_parent" >  
5.   
6. <com.example.customview.TitleView  
7. android:id="@+id/title_view"  
8. android:layout_width="match_parent"  
9. android:layout_height="wrap_content" >  
10. </com.example.customview.TitleView>  
11.   
12. </RelativeLayout>  
 
 
 这样就成功将一个标题栏控件引入到布局文件中了，运行一下程序，效果如下图所示：
 
 现在点击一下Back按钮，就可以关闭当前的Activity了。如果你想要修改标题栏上显示的内容，或者返回按钮的默认事件，只需要在Activity中通过findViewById()方法得到TitleView的实例，然后调用setTitleText()、setLeftButtonText()、setLeftButtonListener()等方法进行设置就OK了。
 
三、继承控件
 
 继承控件的意思就是，我们并不需要自己重头去实现一个控件，只需要去继承一个现有的控件，然后在这个控件上增加一些新的功能，就可以形成一个自定义的控件了。这种自定义控件的特点就是不仅能够按照我们的需求加入相应的功能，还可以保留原生控件的所有功能。
 为了能够加深大家对这种自定义View方式的理解，下面我们再来编写一个新的继承控件。ListView相信每一个Android程序员都一定使用过，这次我们准备对ListView进行扩展，加入在ListView上滑动就可以显示出一个删除按钮，点击按钮就会删除相应数据的功能。
 首先需要准备一个删除按钮的布局，新建delete_button.xml文件，代码如下所示：
 
 
   [html]  
   view plain  
   copy 
   
 
   
   
   
 
   
   
    
    
 
1. <?xml version="1.0" encoding="utf-8"?>  
2. <Button xmlns:android="http://schemas.android.com/apk/res/android"  
3. android:id="@+id/delete_button"  
4. android:layout_width="wrap_content"  
5. android:layout_height="wrap_content"  
6. android:background="@drawable/delete_button" >  
7.   
8. </Button>

这个布局文件很简单，只有一个按钮而已，并且我们给这个按钮指定了一张删除背景图。

接着创建MyListView继承自ListView，这就是我们自定义的View了，代码如下所示：

[java]  view plain  copy

 

 

1. public class MyListView extends ListView implements OnTouchListener,  
2.         OnGestureListener {  
3.   
4. private GestureDetector gestureDetector;  
5.   
6. private OnDeleteListener listener;  
7.   
8. private View deleteButton;  
9.   
10. private ViewGroup itemLayout;  
11.   
12. private int selectedItem;  
13.   
14. private boolean isDeleteShown;  
15.   
16. public MyListView(Context context, AttributeSet attrs) {  
17. super(context, attrs);  
18. new GestureDetector(getContext(), this);  
19. this);  
20.     }  
21.   
22. public void setOnDeleteListener(OnDeleteListener l) {  
23.         listener = l;  
24.     }  
25.   
26. @Override  
27. public boolean onTouch(View v, MotionEvent event) {  
28. if (isDeleteShown) {  
29.             itemLayout.removeView(deleteButton);  
30. null;  
31. false;  
32. return false;  
33. else {  
34. return gestureDetector.onTouchEvent(event);  
35.         }  
36.     }  
37.   
38. @Override  
39. public boolean onDown(MotionEvent e) {  
40. if (!isDeleteShown) {  
41. int) e.getX(), (int) e.getY());  
42.         }  
43. return false;  
44.     }  
45.   
46. @Override  
47. public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX,  
48. float velocityY) {  
49. if (!isDeleteShown && Math.abs(velocityX) > Math.abs(velocityY)) {  
50.             deleteButton = LayoutInflater.from(getContext()).inflate(  
51. null);  
52. new OnClickListener() {  
53. @Override  
54. public void onClick(View v) {  
55.                     itemLayout.removeView(deleteButton);  
56. null;  
57. false;  
58.                     listener.onDelete(selectedItem);  
59.                 }  
60.             });  
61.             itemLayout = (ViewGroup) getChildAt(selectedItem  
62.                     - getFirstVisiblePosition());  
63. new RelativeLayout.LayoutParams(  
64.                     LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT);  
65.             params.addRule(RelativeLayout.ALIGN_PARENT_RIGHT);  
66.             params.addRule(RelativeLayout.CENTER_VERTICAL);  
67.             itemLayout.addView(deleteButton, params);  
68. true;  
69.         }  
70. return false;  
71.     }  
72.   
73. @Override  
74. public boolean onSingleTapUp(MotionEvent e) {  
75. return false;  
76.     }  
77.   
78. @Override  
79. public void onShowPress(MotionEvent e) {  
80.   
81.     }  
82.   
83. @Override  
84. public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX,  
85. float distanceY) {  
86. return false;  
87.     }  
88.   
89. @Override  
90. public void onLongPress(MotionEvent e) {  
91.     }  
92.       
93. public interface OnDeleteListener {  
94.   
95. void onDelete(int index);  
96.   
97.     }  
98.   
99. }

由于代码逻辑比较简单，我就没有加注释。这里在MyListView的构造方法中创建了一个GestureDetector的实例用于监听手势，然后给MyListView注册了touch监听事件。然后在onTouch()方法中进行判断，如果删除按钮已经显示了，就将它移除掉，如果删除按钮没有显示，就使用GestureDetector来处理当前手势。

当手指按下时，会调用OnGestureListener的onDown()方法，在这里通过pointToPosition()方法来判断出当前选中的是ListView的哪一行。当手指快速滑动时，会调用onFling()方法，在这里会去加载delete_button.xml这个布局，然后将删除按钮添加到当前选中的那一行item上。注意，我们还给删除按钮添加了一个点击事件，当点击了删除按钮时就会回调onDeleteListener的onDelete()方法，在回调方法中应该去处理具体的删除操作。

好了，自定义View的功能到此就完成了，接下来我们需要看一下如何才能使用这个自定义View。首先需要创建一个ListView子项的布局文件，新建my_list_view_item.xml，代码如下所示：

[html]  view plain  copy

 

 

1. <?xml version="1.0" encoding="utf-8"?>  
2. <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"  
3. android:layout_width="match_parent"  
4. android:layout_height="match_parent"  
5. android:descendantFocusability="blocksDescendants"  
6. android:orientation="vertical" >  
7.   
8. <TextView  
9. android:id="@+id/text_view"  
10. android:layout_width="wrap_content"  
11. android:layout_height="50dp"  
12. android:layout_centerVertical="true"  
13. android:gravity="left|center_vertical"  
14. android:textColor="#000" />  
15.   
16. </RelativeLayout>

1.  

然后创建一个适配器MyAdapter，在这个适配器中去加载my_list_view_item布局，代码如下所示：

[java]  view plain  copy

 

 

1. public class MyAdapter extends ArrayAdapter<String> {  
2.   
3. public MyAdapter(Context context, int textViewResourceId, List<String> objects) {  
4. super(context, textViewResourceId, objects);  
5.     }  
6.   
7. @Override  
8. public View getView(int position, View convertView, ViewGroup parent) {  
9.         View view;  
10. if (convertView == null) {  
11. null);  
12. else {  
13.             view = convertView;  
14.         }  
15.         TextView textView = (TextView) view.findViewById(R.id.text_view);  
16.         textView.setText(getItem(position));  
17. return view;  
18.     }  
19.   
20. }

到这里就基本已经完工了，下面在程序的主布局文件里面引入MyListView这个控件，如下所示：

[html]  view plain  copy

 

 

1. <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"  
2. xmlns:tools="http://schemas.android.com/tools"  
3. android:layout_width="match_parent"  
4. android:layout_height="match_parent" >  
5.   
6. <com.example.customview.MyListView  
7. android:id="@+id/my_list_view"  
8. android:layout_width="match_parent"  
9. android:layout_height="wrap_content" >  
10. </com.example.customview.MyListView>  
11.   
12. </RelativeLayout>

最后在Activity中初始化MyListView中的数据，并处理了onDelete()方法的删除逻辑，代码如下所示：

[java]  view plain  copy

 

 

1. public class MainActivity extends Activity {  
2.   
3. private MyListView myListView;  
4.   
5. private MyAdapter adapter;  
6.   
7. private List<String> contentList = new ArrayList<String>();  
8.   
9. @Override  
10. protected void onCreate(Bundle savedInstanceState) {  
11. super.onCreate(savedInstanceState);  
12.         requestWindowFeature(Window.FEATURE_NO_TITLE);  
13.         setContentView(R.layout.activity_main);  
14.         initList();  
15.         myListView = (MyListView) findViewById(R.id.my_list_view);  
16. new OnDeleteListener() {  
17. @Override  
18. public void onDelete(int index) {  
19.                 contentList.remove(index);  
20.                 adapter.notifyDataSetChanged();  
21.             }  
22.         });  
23. new MyAdapter(this, 0, contentList);  
24.         myListView.setAdapter(adapter);  
25.     }  
26.   
27. private void initList() {  
28. "Content Item 1");  
29. "Content Item 2");  
30. "Content Item 3");  
31. "Content Item 4");  
32. "Content Item 5");  
33. "Content Item 6");  
34. "Content Item 7");  
35. "Content Item 8");  
36. "Content Item 9");  
37. "Content Item 10");  
38. "Content Item 11");  
39. "Content Item 12");  
40. "Content Item 13");  
41. "Content Item 14");  
42. "Content Item 15");  
43. "Content Item 16");  
44. "Content Item 17");  
45. "Content Item 18");  
46. "Content Item 19");  
47. "Content Item 20");  
48.     }  
49.   
50. }

这样就把整个例子的代码都完成了，现在运行一下程序，会看到MyListView可以像ListView一样，正常显示所有的数据，但是当你用手指在MyListView的某一行上快速滑动时，就会有一个删除按钮显示出来，如下图所示：

点击一下删除按钮就可以将第6行的数据删除了。此时的MyListView不仅保留了ListView原生的所有功能，还增加了一个滑动进行删除的功能，确实是一个不折不扣的继承控件。