Android onMeasure，onFocusChanged方法介绍

onMeasure方法在控件的父元素正要放置它的子控件时调用.它会问一个问题，“你想要用多大地方啊？”，然后传入两个参数——widthMeasureSpec和heightMeasureSpec.

　　它们指明控件可获得的空间以及关于这个空间描述的元数据.
　　比返回一个结果要好的方法是你传递View的高度和宽度到setMeasuredDimension方法里.

　　接下来的代码片段给出了如何重写onMeasure.注意，调用的本地空方法是来计算高度和宽度的.它们会译解widthHeightSpec和heightMeasureSpec值，并计算出合适的高度和宽度值.

java代码：

1. @Override
   
2. protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
   
3. 
   
4. int measuredHeight = measureHeight(heightMeasureSpec);
   
5. int measuredWidth = measureWidth(widthMeasureSpec);
   
6. setMeasuredDimension(measuredHeight, measuredWidth);
   
7. }
   
8. 
   
9. private int measureHeight(int measureSpec) {
   
10. 
    
11. 
    
12. // Return measured widget height.
    
13. }
    
14. 
    
15. private int measureWidth(int measureSpec) {
    
16. 
    
17. // Return measured widget width.
    
18. }

复制代码

       边界参数——widthMeasureSpec和heightMeasureSpec ，效率的原因以整数的方式传入。

      

     MeasureSpec封装了父布局传递给子布局的布局要求，每个MeasureSpec代表了一组宽度和高度的要求。一个MeasureSpec由大小和模式组成。

    它有三种模式：

                    UNSPECIFIED(未指定),     父元素不对自元素施加任何束缚，子元素可以得到任意想要的大小；

                    EXACTLY(完全)，父元素决定自元素的确切大小，子元素将被限定在给定的边界里而忽略它本身大小；

                    AT_MOST(至多)，子元素至多达到指定大小的值。

   它常用的三个函数：

　　  1.static int getMode(int measureSpec):根据提供的测量值(格式)提取模式(上述三个模式之一)

　　2.static int getSize(int measureSpec):根据提供的测量值(格式)提取大小值(这个大小也就是我们通常所说的大小)

　　3.static int makeMeasureSpec(int size,int mode):根据提供的大小值和模式创建一个测量值(格式)

     这个类的使用呢，通常在view组件的onMeasure方法里面调用但也有少数例外

 

       在它们使用之前，首先要做的是使用MeasureSpec类的静态方法getMode和getSize来译解，如下面的片段所示：

java代码：

1. int specMode = MeasureSpec.getMode(measureSpec);
   
2. int specSize = MeasureSpec.getSize(measureSpec);

复制代码

       依据specMode的值，如果是AT_MOST，specSize 代表的是最大可获得的空间；如果是EXACTLY，specSize 代表的是精确的尺寸；如果是UNSPECIFIED，对于控件尺寸来说，没有任何参考意义。
　　当以EXACT方式标记测量尺寸，父元素会坚持在一个指定的精确尺寸区域放置View。在父元素问子元素要多大空间时，AT_MOST指示者会说给我最大的范围。在很多情况下，你得到的值都是相同的。
　　在两种情况下，你必须绝对的处理这些限制。在一些情况下，它可能会返回超出这些限制的尺寸，在这种情况下，你可以让父元素选择如何对待超出的View，使用裁剪还是滚动等技术。

　　接下来的框架代码给出了处理View测量的典型实现：

java代码：

1. @Override
   
2. 
   
3. protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
   
4. 
   
5. int measuredHeight = measureHeight(heightMeasureSpec);
   
6. 
   
7. int measuredWidth = measureWidth(widthMeasureSpec);
   
8. 
   
9. setMeasuredDimension(measuredHeight, measuredWidth);
   
10. 
    
11. }
    
12. 
    
13. private int measureHeight(int measureSpec) {
    
14. 
    
15. int specMode = MeasureSpec.getMode(measureSpec);
    
16. int specSize = MeasureSpec.getSize(measureSpec);
    
17. 
    
18. // Default size if no limits are specified.
    
19. 
    
20. int result = 500;
    
21. if (specMode == MeasureSpec.AT_MOST){
    
22. 
    
23. // Calculate the ideal size of your
    
24. // control within this maximum size.
    
25. // If your control fills the available
    
26. // space return the outer bound.
    
27. 
    
28. result = specSize;
    
29. }
    
30. else if (specMode == MeasureSpec.EXACTLY){
    
31. 
    
32. // If your control can fit within these bounds return that value.
    
33. result = specSize;
    
34. }
    
35. 
    
36. return result;
    
37. }
    
38. 
    
39. private int measureWidth(int measureSpec) {
    
40. int specMode = MeasureSpec.getMode(measureSpec);
    
41. int specSize = MeasureSpec.getSize(measureSpec);
    
42. 
    
43. // Default size if no limits are specified.
    
44. int result = 500;
    
45. if (specMode == MeasureSpec.AT_MOST){
    
46. // Calculate the ideal size of your control
    
47. // within this maximum size.
    
48. // If your control fills the available space
    
49. // return the outer bound.
    
50. result = specSize;
    
51. }
    
52. 
    
53. else if (specMode == MeasureSpec.EXACTLY){
    
54. // If your control can fit within these bounds return that value.
    
55. 
    
56. result = specSize;
    
57. }
    
58. 
    
59. return result;
    
60. }

——————————————————————————————————————

一个MeasureSpec封装了父布局传递给子布局的布局要求，每个MeasureSpec代表了一组宽度和高度的要求。一个MeasureSpec由大小和模式组成。它有三种模式：UNSPECIFIED(未指定),父元素部队自元素施加任何束缚，子元素可以得到任意想要的大小；EXACTLY(完全)，父元素决定自元素的确切大小，子元素将被限定在给定的边界里而忽略它本身大小；AT_MOST(至多)，子元素至多达到指定大小的值。

 

　　它常用的三个函数：

　　1.static int getMode(int measureSpec):根据提供的测量值(格式)提取模式(上述三个模式之一)

　　2.static int getSize(int measureSpec):根据提供的测量值(格式)提取大小值(这个大小也就是我们通常所说的大小)

　　3.static int makeMeasureSpec(int size,int mode):根据提供的大小值和模式创建一个测量值(格式)

这个类的使用呢，通常在view组件的onMeasure方法里面调用.

看看它的使用吧,ListView.measureItem(View child)

首先一个我们常用到的一个有用的函数，View.resolveSize(int size,int measureSpec)

[html] view plain copy

1. public static int resolveSize(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.              result = Math.min(size, specSize);  
11.              break;  
12.          case MeasureSpec.EXACTLY:  
13.              result = specSize;  
14.              break;  
15.          }  
16.          return result;  
17.      }  

9023         public static int makeMeasureSpec(int size, int mode) {
9024             return size + mode;
9025         }

[html] view plain copy

1. private void measureItem(View child) {  
2.          ViewGroup.LayoutParams p = child.getLayoutParams();  
3.          if (p == null) {  
4.              p = new ViewGroup.LayoutParams(  
5.                      ViewGroup.LayoutParams.MATCH_PARENT,  
6.                      ViewGroup.LayoutParams.WRAP_CONTENT);  
7.          }  
8.    
9.          int childWidthSpec = ViewGroup.getChildMeasureSpec(mWidthMeasureSpec,  
10.                  mListPadding.left + mListPadding.right, p.width);  
11.          int lpHeight = p.height;  
12.          int childHeightSpec;  
13.          if (lpHeight > 0) {  
14.              childHeightSpec = MeasureSpec.makeMeasureSpec(lpHeight, MeasureSpec.EXACTLY);  
15.          } else {  
16.              childHeightSpec = MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED);  
17.          }  
18.          child.measure(childWidthSpec, childHeightSpec);  
19.      }  

　注意，使用EXACTLY和AT_MOST通常是一样的效果，如果你要区别他们，那么你就要使用上面的函数View.resolveSize(int size,int measureSpec)返回一个size值，然后使用你的view调用setMeasuredDimension(int,int)函数。

 

8406     protected final void setMeasuredDimension(int measuredWidth, int measuredHeight) {
8407         mMeasuredWidth = measuredWidth;
8408         mMeasuredHeight = measuredHeight;
8409 
8410         mPrivateFlags |= MEASURED_DIMENSION_SET;
8411     }

　　然后你调用view.getMeasuredWidth，view.getMeasuredHeigth 返回的就是上面函数里的mMeasuredWidth,mMeasuredHeight的值。

————————————————————————————————————————————

在自定义View和ViewGroup的时候，我们经常会遇到int型的 MeasureSpec 来表示一个组件的大小，这个变量里面不仅有组件的尺寸大小，还有大小的模式。

这个大小的模式，有点难以理解。在系统中组件的大小模式有三种：

1.精确模式（MeasureSpec.EXACTLY）

在这种模式下，尺寸的值是多少，那么这个组件的长或宽就是多少。

2.最大模式（MeasureSpec.AT_MOST）

这个也就是父组件，能够给出的最大的空间，当前组件的长或宽最大只能为这么大，当然也可以比这个小。

3.未指定模式（MeasureSpec.UNSPECIFIED）

这个就是说，当前组件，可以随便用空间，不受限制。

    可能有很多人想不通，一个int型整数怎么可以表示两个东西（大小模式和大小的值），一个int类型我们知道有32位。而模式有三种，要表示三种状  态，至少得2位二进制位。于是系统采用了最高的2位表示模式。如图：

最高两位是00的时候表示"未指定模式"。即MeasureSpec.UNSPECIFIED

最高两位是01的时候表示"'精确模式"。即MeasureSpec.EXACTLY

最高两位是11的时候表示"最大模式"。即MeasureSpec.AT_MOST

很多人一遇到位操作头就大了，为了操作简便，于是系统给我提供了一个MeasureSpec工具类。

这个工具类有四个方法和三个常量（上面所示）供我们使用：

 

//这个是由我们给出的尺寸大小和模式生成一个包含这两个信息的int变量，这里这个模式这个参数，传三个常量中的一个。

public static int makeMeasureSpec(int size, int mode)

 

//这个是得到这个变量中表示的模式信息，将得到的值与三个常量进行比较。

public static int getMode(int measureSpec)

 

//这个是得到这个变量中表示的尺寸大小的值。

public static int getSize(int measureSpec)

 

//把这个变量里面的模式和大小组成字符串返回来，方便打日志

 public static String toString(int measureSpec)

 

 

 

MeasureSpec.EXACTLY：当我们将控件的layout_width或layout_height指定为具体数值时如andorid:layout_width="50dip"，或者为FILL_PARENT是，都是控件大小已经确定的情况，都是精确尺寸。

        MeasureSpec.AT_MOST是最大尺寸，当控件的layout_width或layout_height指定为WRAP_CONTENT时，控件大小一般随着控件的子空间或内容进行变化，此时控件尺寸只要不超过父控件允许的最大尺寸即可。因此，此时的mode是AT_MOST，size给出了父控件允许的最大尺寸。

        MeasureSpec.UNSPECIFIED是未指定尺寸，这种情况不多，一般都是父控件是AdapterView，通过measure方法传入的模式。

因此，在重写onMeasure方法时要根据模式不同进行尺寸计算。下面代码就是一种比较典型的方式：

[java] view plaincopy

1. @Override      
2. protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {      
3.     setMeasuredDimension(getMeasuredLength(widthMeasureSpec, true), getMeasuredLength(heightMeasureSpec, false));      
4. }      
5.       
6.       
7. private int getMeasuredLength(int length, boolean isWidth) {      
8.     int specMode = MeasureSpec.getMode(length);      
9.     int specSize = MeasureSpec.getSize(length);      
10.     int size;      
11.     int padding = isWidth ? getPaddingLeft() + getPaddingRight()      
12.             : getPaddingTop() + getPaddingBottom();      
13.     if (specMode == MeasureSpec.EXACTLY) {      
14.         size = specSize;      
15.     } else {      
16.         size = isWidth ? padding + mWave.length / 4 : DEFAULT_HEIGHT      
17.                 + padding;      
18.         if (specMode == MeasureSpec.AT_MOST) {      
19.             size = Math.min(size, specSize);      
20.         }      
21.     }      
22.     return size;      
23. }    

 

 

解决ScrollView嵌套ListView和GridView冲突的方法

[html] view plaincopy

1. public class MyListView extends ListView {  
2.         public MyListView(Context context) {  
3.                 super(context);  
4.         }  
5.         public MyListView(Context context, AttributeSet attrs) {  
6.                 super(context, attrs);  
7.         }  
8.         public MyListView(Context context, AttributeSet attrs, int defStyle) {  
9.                 super(context, attrs, defStyle);  
10.         }  
11.         @Override  
12.         protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {  
13.                 int expandSpec = MeasureSpec.makeMeasureSpec(Integer.MAX_VALUE >> 2,  
14.                                 MeasureSpec.AT_MOST);  
15.                 super.onMeasure(widthMeasureSpec, expandSpec);  
16.         }  
17. }  
18.   
19.   
20.    
21. public class MyGridView extends GridView {     
22.     private boolean haveScrollbar = true;     
23.     public MyGridView(Context context) {     
24.         super(context);     
25.     }     
26.     public MyGridView(Context context, AttributeSet attrs) {     
27.         super(context, attrs);     
28.     }     
29.     public MyGridView(Context context, AttributeSet attrs, int defStyle) {     
30.         super(context, attrs, defStyle);     
31.     }     
32.     /**    
33.      * 设置是否有ScrollBar，当要在ScollView中显示时，应当设置为false。 默认为 true    
34.      *     
35.      * @param haveScrollbars    
36.      */     
37.     public void setHaveScrollbar(boolean haveScrollbar) {     
38.         this.haveScrollbar = haveScrollbar;     
39.     }     
40.     @Override     
41.     protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {     
42.         if (haveScrollbars == false) {     
43.             int expandSpec = MeasureSpec.makeMeasureSpec(Integer.MAX_VALUE >> 2, MeasureSpec.AT_MOST);    
44.             super.onMeasure(widthMeasureSpec, expandSpec);     
45.         } else {     
46.             super.onMeasure(widthMeasureSpec, heightMeasureSpec);     
47.         }     
48.     }     
49. } 
    

——————————————————————————————

     onFocusChanged方法简介

       前面介绍的各个方法都可以在View及Activity中重写，接下来介绍的onFocusChanged却只能在View中重写。该方法是焦点改变的回调方法，当某个控件重写了该方法后，当焦点发生变化时，会自动调用该方法来处理焦点改变的事件。该方法的签名如下。

       protected void onFocusChanged (boolean gainFocus, int direction, Rect previously FocusedRect)

       参数gainFocus：参数gainFocus表示触发该事件的View是否获得了焦点，当该控件获得焦点时，gainFocus等于true，否则等于false。

       参数direction：参数direction表示焦点移动的方向，用数值表示，有兴趣的读者可以重写View中的该方法打印该参数进行观察。

       参数previouslyFocusedRect：表示在触发事件的View的坐标系中，前一个获得焦点的矩形区域，即表示焦点是从哪里来的。如果不可用则为null。

       接下来同样通过一个简单的案例来介绍该方法的使用方法，该案例是向窗口中依次添加四个按钮，然后观察各个按钮获得焦点或失去焦点时DDMS中打印的日志信息。该案例的开发步骤如下。

Java代码：

1. 
   
2. package eoe.demo;
   
3. //声明所在包
   
4. import android.app.Activity;
   
5. //引入相关类
   
6. import android.content.Context;
   
7. //引入相关类
   
8. import android.graphics.Rect;
   
9. //引入相关类
   
10. import android.os.Bundle;
    
11. //引入相关类
    
12. import android.util.Log;
    
13. //引入相关类
    
14. import android.widget.Button;
    
15. //引入相关类
    
16. import android.widget.LinearLayout;
    
17. //引入相关类
    
18. 
    
19. public class Sample_7_3 extends Activity {
    
20. MyButton myButton01;
    
21. //声明myButton01的引用
    
22. MyButton myButton02;
    
23. //声明myButton02的引用
    
24. MyButton myButton03;
    
25. //声明myButton03的引用
    
26. MyButton myButton04;
    
27. //声明myButton04的引用
    
28. 
    
29. public void onCreate(Bundle savedInstanceState) {
    
30. super.onCreate(savedInstanceState);
    
31. myButton01 = new MyButton(this);
    
32. //初始化myButton01
    
33. myButton02 = new MyButton(this);
    
34. //初始化myButton02
    
35. myButton03 = new MyButton(this);
    
36. //初始化myButton03
    
37. myButton04 = new MyButton(this);
    
38. //初始化myButton04
    
39. myButton01.setText("myButton01");
    
40. //设置myButton01上的文字
    
41. myButton02.setText("myButton02");
    
42. //设置myButton02上的文字
    
43. myButton03.setText("myButton03");
    
44. //设置myButton03上的文字
    
45. myButton04.setText("myButton04");
    
46. //设置myButton04上的文字
    
47. LinearLayout LinearLayout1 = new LinearLayout(this);
    
48. //创建一个线性布局
    
49. LinearLayout1.setOrientation(LinearLayout.VERTICAL);
    
50. //设置其布局方式
    
51. LinearLayout1.addView(myButton01);
    
52. //将myButton01添加到布局中
    
53. LinearLayout1.addView(myButton02);
    
54. //将myButton02添加到布局中
    
55. LinearLayout1.addView(myButton03);
    
56. //将myButton03添加到布局中
    
57. LinearLayout1.addView(myButton04);
    
58. //将myButton04添加到布局中
    
59. setContentView(LinearLayout1);
    
60. //设置当前的用户界面
    
61. }
    
62. class MyButton extends Button{
    
63. //自定义Button
    
64. public MyButton(Context context) {
    
65. //构造器
    
66. super(context);
    
67. }
    
68. @Override
    
69. protected void onFocusChanged(booleanfocused, int direction,
    
70. Rect previouslyFocusedRect) {
    
71. //重写的焦点变化方法
    
72. Log.d("Button", this.getText() + ", focused = " + focused + ", direction = " + direction 40 + ", previouslyFocusedRect = " + previouslyFocusedRect);
    
73. super.onFocusChanged(focused, direction, previouslyFocusedRect);
    
74. }
    
75. 
    
76. }
    
77. 
    
78. }

复制代码

       第10~14行声明了四个按钮的引用。
       第16~19行初始化四个自定义的按钮控件，然后在第20~23行分别设置了各个按钮上的文字。
       第24~25行创建一个线性布局，并设置其布局方式为垂直。
       第26~29行将四个按钮控件依次添加到线性布局中，然后在第30行将该线性布局设置成当前显示的用户界面。
       第32~43行为自定义的Button类，在该类中，重写了onFocusChanged方法（第37~42行），在方法中将相关信息打印到日志中以便于观察与调试。