转- android硬件传感器

纯属转载：http://dev.10086.cn/cmdn/bbs/thread-41843-1-1.html 
1、传感器入门 
自从苹果公司在2007年发布第一代iPhone以来，以前看似和手机挨不着边的传感器也逐渐成为手机硬件的重要组成部分。如果读者使用过iPhone、HTC Dream、HTC Magic、HTC Hero以及其他的Android手机，会发现通过将手机横向或纵向放置，屏幕会随着手机位置的不同而改变方向。这种功能就需要通过重力传感器来实现，除了重力传感器，还有很多其他类型的传感器被应用到手机中，例如磁阻传感器就是最重要的一种传感器。虽然手机可以通过GPS来判断方向，但在GPS信号不好或根本没有GPS信号的情况下，GPS就形同虚设。这时通过磁阻传感器就可以很容易判断方向（东、南、西、北）。有了磁阻传感器，也使罗盘（俗称指向针）的电子化成为可能。 
在Android应用程序中使用传感器要依赖于android.hardware.SensorEventListener接口。通过该接口可以监听传感器的各种事件。SensorEventListener接口的代码如下： 

Java代码  

1. package android.hardware;  
2.   
3. public interface SensorEventListener   
4.   
5. {  
6.   
7.     public void onSensorChanged(SensorEvent event);  
8.   
9.     public void onAccuracyChanged(Sensor sensor, int accuracy);      
10.   
11. }  

在SensorEventListener接口中定义了两个方法：onSensorChanged和onAccuracyChanged。当传感器的值发生变化时，例如磁阻传感器的方向改变时会调用onSensorChanged方法。当传感器的精度变化时会调用onAccuracyChanged方法。 
onSensorChanged方法只有一个SensorEvent类型的参数event，其中SensorEvent类有一个values变量非常重要，该变量的类型是float[]。但该变量最多只有3个元素，而且根据传感器的不同，values变量中元素所代表的含义也不同。 


在解释values变量中元素的含义之前，先来介绍一下Android的坐标系统是如何定义X、Y、Z轴的。 

X轴的方向是沿着屏幕的水平方向从左向右。如果手机不是正方形的话，较短的边需要水平放置，较长的边需要垂直放置。 
Y轴的方向是从屏幕的左下角开始沿着屏幕的垂直方向指向屏幕的顶端。 
将手机平放在桌子上，Z轴的方向是从手机里指向天空。 

下面是values变量的元素在主要的传感器中所代表的含义。 


1.1方向传感器 

在方向传感器中values变量的3个值都表示度数，它们的含义如下： 

values[0]：该值表示方位，也就是手机绕着Z轴旋转的角度。0表示北（North）；90表示东（East）；180表示南（South）；270表示西（West）。如果values[0]的值正好是这4个值，并且手机是水平放置，表示手机的正前方就是这4个方向。可以利用这个特性来实现电子罗盘，实例76将详细介绍电子罗盘的实现过程。 


values[1]：该值表示倾斜度，或手机翘起的程度。当手机绕着X轴倾斜时该值发生变化。values[1]的取值范围是-180≤values[1] 
≤180。假设将手机屏幕朝上水平放在桌子上，这时如果桌子是完全水平的，values[1]的值应该是0（由于很少有桌子是绝对水平的，因此，该值很可能不为0，但一般都是-5和5之间的某个值）。这时从手机顶部开始抬起，直到将手机沿X轴旋转180度（屏幕向下水平放在桌面上）。在这个旋转过程中，values[1]会在0到-180之间变化，也就是说，从手机顶部抬起时，values[1]的值会逐渐变小，直到等于-180。如果从手机底部开始抬起，直到将手机沿X轴旋转180度，这时values[1]会在0到180之间变化。也就是values[1]的值会逐渐增大，直到等于180。可以利用values[1]和下面要介绍的values[2]来测量桌子等物体的倾斜度。 


values[2]：表示手机沿着Y轴的滚动角度。取值范围是-90≤values[2]≤90。假设将手机屏幕朝上水平放在桌面上，这时如果桌面是平的，values[2]的值应为0。将手机左侧逐渐抬起时，values[2]的值逐渐变小，直到手机垂直于桌面放置，这时values[2]的值是-90。将手机右侧逐渐抬起时，values[2]的值逐渐增大，直到手机垂直于桌面放置，这时values[2]的值是90。在垂直位置时继续向右或向左滚动，values[2]的值会继续在-90至90之间变化。 

1.2加速传感器 

    该传感器的values变量的3个元素值分别表示X、Y、Z轴的加速值。例如，水平放在桌面上的手机从左侧向右侧移动，values[0]为负值；从右向左移动，values[0]为正值。读者可以通过本节的例子来体会加速传感器中的值的变化。要想使用相应的传感器，仅实现SensorEventListener接口是不够的，还需要使用下面的代码来注册相应的传感器。 

Java代码  

1. //  获得传感器管理器  
2.   
3. SensorManager sm = (SensorManager) getSystemService(SENSOR_SERVICE);  
4.   
5. //  注册方向传感器  
6.   
7. sm.registerListener(this,  
8.   
9. sm.getDefaultSensor(Sensor.TYPE_ORIENTATION),  
10.   
11. SensorManager.SENSOR_DELAY_FASTEST);  

如果想注册其他的传感器，可以改变getDefaultSensor方法的第1个参数值，例如，注册加速传感器可以使用Sensor.TYPE_ACCELEROMETER。在Sensor类中还定义了很多传感器常量，但要根据手机中实际的硬件配置来注册传感器。如果手机中没有相应的传感器硬件，就算注册了相应的传感器也不起任何作用。getDefaultSensor方法的第2个参数表示获得传感器数据的速度。SensorManager.SENSOR_DELAY_ FASTEST表示尽可能快地获得传感器数据。除了该值以外，还可以设置3个获得传感器数据的速度值，这些值如下： 

SensorManager.SENSOR_DELAY_NORMAL：默认的获得传感器数据的速度。 
SensorManager.SENSOR_DELAY_GAME：如果利用传感器开发游戏，建议使用该值。 
SensorManager.SENSOR_DELAY_UI：如果使用传感器更新UI中的数据，建议使用该值。 

1.3重力感应器 

加速度传感器的类型常量是Sensor.TYPE_GRAVITY。重力传感器与加速度传感器使用同一套坐标系。values数组中三个元素分别表示了X、Y、Z轴的重力大小。Android SDK定义了一些常量，用于表示星系中行星、卫星和太阳表面的重力。下面就来温习一下天文知识，将来如果在地球以外用Android手机，也许会用得上。 

Java代码  

1. public static final float GRAVITY_SUN= 275.0f;  
2.   
3. public static final float GRAVITY_MERCURY= 3.70f;  
4.   
5. public static final float GRAVITY_VENUS= 8.87f;  
6.   
7. public static final float GRAVITY_EARTH= 9.80665f;  
8.   
9. public static final float GRAVITY_MOON= 1.6f;  
10.   
11. public static final float GRAVITY_MARS= 3.71f;  
12.   
13. public static final float GRAVITY_JUPITER= 23.12f;  
14.   
15. public static final float GRAVITY_SATURN= 8.96f;  
16.   
17. public static final float GRAVITY_URANUS= 8.69f;  
18.   
19. public static final float GRAVITY_NEPTUNE= 11.0f;  
20.   
21. public static final float GRAVITY_PLUTO= 0.6f;  
22.   
23. public static final float GRAVITY_DEATH_STAR_I= 0.000000353036145f;  
24.   
25. public static final float GRAVITY_THE_ISLAND= 4.815162342f;  

1.4 光线传感器 

光线传感器的类型常量是Sensor.TYPE_LIGHT。values数组只有第一个元素（values[0]）有意义。表示光线的强度。最大的值是120000.0f。Android SDK将光线强度分为不同的等级，每一个等级的最大值由一个常量表示，这些常量都定义在SensorManager类中，代码如下： 

Java代码  

1. public static final float LIGHT_SUNLIGHT_MAX =120000.0f;  
2.   
3. public static final float LIGHT_SUNLIGHT=110000.0f;  
4.   
5. public static final float LIGHT_SHADE=20000.0f;  
6.   
7. public static final float LIGHT_OVERCAST= 10000.0f;  
8.   
9. public static final float LIGHT_SUNRISE= 400.0f;  
10.   
11. public static final float LIGHT_CLOUDY= 100.0f;  
12.   
13. public static final float LIGHT_FULLMOON= 0.25f;  
14.   
15. public static final float LIGHT_NO_MOON= 0.001f;  

上面的八个常量只是临界值。读者在实际使用光线传感器时要根据实际情况确定一个范围。例如，当太阳逐渐升起时，values[0]的值很可能会超过LIGHT_SUNRISE，当values[0]的值逐渐增大时，就会逐渐越过LIGHT_OVERCAST，而达到LIGHT_SHADE，当然，如果天特别好的话，也可能会达到LIGHT_SUNLIGHT，甚至更高。 

1.5陀螺仪传感器 
   陀螺仪传感器的类型常量是Sensor.TYPE_GYROSCOPE。values数组的三个元素表示的含义如下：values[0]：延X轴旋转的角速度。 
values[1]：延Y轴旋转的角速度。 
values[2]：延Z轴旋转的角速度。 
当手机逆时针旋转时，角速度为正值，顺时针旋转时，角速度为负值。陀螺仪传感器经常被用来计算手机已转动的角度，代码如下：private static final float NS2S = 1.0f / 1000000000.0f; 

Java代码  

1. private float timestamp;  
2.   
3. public void onSensorChanged(SensorEvent event)  
4.   
5. {  
6.   
7.     if (timestamp != 0)   
8.   
9.     {  
10.   
11.     //  event.timesamp表示当前的时间，单位是纳秒（1百万分之一毫秒）  
12.   
13.               final float dT = (event.timestamp - timestamp) * NS2S;  
14.   
15.               angle[0] += event.values[0] * dT;  
16.   
17.               angle[1] += event.values[1] * dT;  
18.   
19.               angle[2] += event.values[2] * dT;  
20.   
21.      }  
22.   
23.      timestamp = event.timestamp;  
24.   
25. }  

上面代码中通过陀螺仪传感器相邻两次获得数据的时间差（dT）来分别计算在这段时间内手机延X、 Y、Z轴旋转的角度，并将值分别累加到angle数组的不同元素上。 


1.6其他传感器 
其他传感器在前面几节介绍了加速度传感器、重力传感器、光线传感器、陀螺仪传感器以及方向传感器。除了这些传感器外，Android SDK还支持如下的几种传感器。关于这些传感器的使用方法以及与这些传感器相关的常量、方法，读者可以参阅官方文档。 

近程传感器（Sensor.TYPE_PROXIMITY） 
线性加速度传感器（Sensor.TYPE_LINEAR_ACCELERATION） 
旋转向量传感器（Sensor.TYPE_ROTATION_VECTOR） 
磁场传感器（Sensor.TYPE_MAGNETIC_FIELD） 
压力传感器（Sensor.TYPE_PRESSURE） 
温度传感器（Sensor.TYPE_TEMPERATURE） 

虽然AndroidSDK定义了十多种传感器，但并不是每一部手机都完全支持这些传感器。例如，Google Nexus S支持其中的9种传感器（不支持压力和温度传感器），而HTC G7只支持其中的5种传感器。如果使用了手机不支持的传感器，一般不会抛出异常，但也无法获得传感器传回的数据。读者在使用传感器时最好先判断当前的手机是否支持所使用的传感器。 


2. 测试手机中有哪些传感器（作者：银河使者） 
我们可以通过如下三步使用传感器。 
（1）编写一个截获传感器事件的类。该类必须实现android.hardware.SensorEventListener接口。 
（2）获得传感器管理对象（SensorManager对象）。 
（3）使用SensorManager.registerListener方法注册指定的传感器。 
通过上面三步已经搭建了传感器应用程序的框架。而具体的工作需要在SensorEventListener接口的onSensorChanged和onAccuracyChanged方法中完成。SensorEventListener接口的定义如下：packageandroid.hardware; 

Java代码  

1. public interfaceSensorEventListener   
2.   
3. {  
4.   
5. //传感器数据变化时调用  
6.   
7. public void onSensorChanged(SensorEventevent);  
8.   
9. //传感器精确度变化时调用  
10.   
11. public void onAccuracyChanged(Sensorsensor, int accuracy);  
12.   
13. }  

SensorManager对象通过getSystemService方法获得，代码如下：SensorManager sensorManager = (SensorManager) getSystemService(SENSOR_SERVICE); 
复制代码通常手机中包含了若干个传感器模块（如方向传感器、光线传感器等），因此，注册传感器需要指定传感器的类型，如下面的代码注册了光线传感器。

Java代码  

1. sensorManager.registerListener(this,sensorManager.getDefaultSensor(Sensor.TYPE_LIGHT),  
2.   
3. SensorManager.SENSOR_DELAY_FASTEST);  

registerListener方法有三个参数。第1个参数是实现SensorEventListener接口的对象。第2个参数用于指定传感器的类型。AndroidSDK预先定义了表示各种传感器的常量，这些常量都被放在Sensor类中。例如，上面代码中的Sensor.TYPE_LIGHT。第3个参数表示传感器获得数据的速度。该参数可设置的常量如下： 

SENSOR_DELAY_FASTEST：以最快的速度获得传感器数据。 
SENSOR_DELAY_GAME：适合于在游戏中获得传感器数据。 
SENSOR_DELAY_UI：适合于在UI控件中获得传感器数据。 
SENSOR_DELAY_NORMAL：以一般的速度获得传感器的数据。 

上面四种类型获得传感器数据的速度依次递减。从理论上说，获得传感器数据的速度越快，消耗的系统资源越大。因此建议读者根本实际情况选择适当的速度获得传感器的数据。 
如果想停止获得传感器数据，可以使用unregisterSensor方法注销传感器事件对象。

Java代码  

1. unregisterSensor方法的定义如下：  
2. public voidunregisterListener(SensorEventListener listener)  
3.   
4. public voidunregisterListener(SensorEventListener listener, Sensor sensor)  

unregisterSensor方法有两个重载形式。第一个重载形式用于注销所有的传感器对象。第二个重载形式用于注销指定传感器的事件对象。其中Sensor对象通过SensorManager.getDefaultSensor方法获得。getDefaultSensor方法只有一个int类型的参数，表示传感器的类型。如Sensor.TYPE_LIGHT表示光线传感器。 
注意：一个传感器对像可以处理多个传感器。也就是说，一个实现SensorEventListener接口的类可以接收多个传感器传回的数据。为了区分不同的传感器，需要使用Sensor.getType方法来获得传感器的类型。getType方法的将在本节的例子中详细介绍。 
通过SensorManager.getSensorList方法可以获得指定传感器的信息，也可以获得手机支持的所有传感器的信息，代码如下 

Java代码  

1. //获得光线传感器  
2.   
3. List<Sensor>sensors = sensorManager.getSensorList(Sensor.TYPE_LIGHT);  
4.   
5. //获得手机支持的所有传感器  
6.   
7. List<Sensor>sensors = sensorManager.getSensorList(Sensor.TYPE_ALL);  

下面给出一个完整的例子来演示如何获得传感器传回的数据。本例从如下4个传感器获得数据，同时输出了测试手机中支持的所有传感器名称。 

加速度传感器（Sensor.TYPE_ACCELEROMETER） 
磁场传感器（Sensor.TYPE_MAGNETIC_FIELD） 
光线传感器（Sensor.TYPE_LIGHT） 
方向传感器（TYPE_ORIENTATION） 

本例需要在真机上运行。由于不同的手机可能支持的传感器不同（有的手机并不支持Android SDK中定义的所有传感器），因此，如果运行程序后，无法显示某个传感器的数据，说明当前的手机并不支持这个传感器。笔者已使用Google Nexus S测试了本例。如果读者使用的也是GoogleNexus S，则会输出如图1类似的信息。 


图1 获得传感器传回的数据 




本例的完整代码如下： 

Java代码  

1. package mobile.android. sensor;  
2.   
3. import java.util.List;  
4. import android.app.Activity;  
5. import android.hardware.Sensor;  
6. import android.hardware.SensorEvent;  
7. import android.hardware.SensorEventListener;  
8. import android.hardware.SensorManager;  
9. import android.os.Bundle;  
10. import android.widget.TextView;  
11.   
12. public class Main extends Activity implements SensorEventListener  
13. {  
14.     private TextView tvAccelerometer;  
15.     private TextView tvMagentic;  
16.     private TextView tvLight;  
17.     private TextView tvOrientation;  
18.     private TextView tvSensors;  
19.   
20.     @Override  
21.     public void onCreate(Bundle savedInstanceState)  
22.     {  
23.         super.onCreate(savedInstanceState);  
24.         setContentView(R.layout.main);  
25.         //  获得SensorManager对象  
26.         SensorManager sensorManager = (SensorManager) getSystemService(SENSOR_SERVICE);  
27.   
28.         //  注册加速度传感器  
29.         sensorManager.registerListener(this,  
30.                 sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER),  
31.                 SensorManager.SENSOR_DELAY_FASTEST);  
32.   
33.         //  注册磁场传感器  
34.         sensorManager.registerListener(this,  
35.                 sensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD),  
36.                 SensorManager.SENSOR_DELAY_FASTEST);  
37.   
38.         //  注册光线传感器  
39.         sensorManager.registerListener(this,  
40.                 sensorManager.getDefaultSensor(Sensor.TYPE_LIGHT),  
41.                 SensorManager.SENSOR_DELAY_FASTEST);  
42.   
43.         //  注册方向传感器  
44.         sensorManager.registerListener(this,  
45.                 sensorManager.getDefaultSensor(Sensor.TYPE_ORIENTATION),  
46.                 SensorManager.SENSOR_DELAY_FASTEST);  
47.   
48.         tvAccelerometer = (TextView) findViewById(R.id.tvAccelerometer);  
49.         tvMagentic = (TextView) findViewById(R.id.tvMagentic);  
50.         tvLight = (TextView) findViewById(R.id.tvLight);  
51.         tvOrientation = (TextView) findViewById(R.id.tvOrientation);  
52.         tvSensors = (TextView)findViewById(R.id.tvSensors);  
53.           
54.         //  获得当前手机支持的所有传感器  
55.         List<Sensor> sensors = sensorManager.getSensorList(Sensor.TYPE_ALL);  
56.         for(Sensor sensor:sensors)  
57.         {  
58.             //  输出当前传感器的名称  
59.             tvSensors.append(sensor.getName() + "\n");  
60.         }  
61.     }  
62.     @Override  
63.     public void onSensorChanged(SensorEvent event)  
64.     {  
65.         //  通过getType方法获得当前传回数据的传感器类型  
66.         switch (event.sensor.getType())  
67.         {  
68.             case Sensor.TYPE_ACCELEROMETER:            //  处理加速度传感器传回的数据  
69.                 String accelerometer = "加速度\n" + "X：" + event.values[0] + "\n"  
70.                         + "Y:" + event.values[1] + "\n" + "Z:" + event.values[2] + "\n";  
71.                 tvAccelerometer.setText(accelerometer);  
72.                 break;  
73.             case Sensor.TYPE_LIGHT:                    //  处理光线传感器传回的数据  
74.                 tvLight.setText("亮度：" + event.values[0]);  
75.                 break;  
76.             case Sensor.TYPE_MAGNETIC_FIELD:            //  处理磁场传感器传回的数据  
77.                 String magentic = "磁场\n" + "X：" + event.values[0] + "\n" + "Y:"  
78.                         + event.values[1] + "\n" + "Z:" + event.values[2] + "\n";  
79.                 tvMagentic.setText(magentic);  
80.                 break;  
81.             case Sensor.TYPE_ORIENTATION:                //  处理方向传感器传回的数据  
82.                 String orientation = "方向\n" + "X：" + event.values[0] + "\n"  
83.                         + "Y:" + event.values[1] + "\n" + "Z:" + event.values[2] + "\n";  
84.                 tvOrientation.setText(orientation);  
85.                 break;  
86.         }  
87.     }  
88.     @Override  
89.     public void onAccuracyChanged(Sensor sensor, int accuracy)  
90.     {  
91.     }  
92. }  

3.1电子罗盘 
电子罗盘又叫电子指南针。在实现本例之前，先看一下如图1所示的运行效果。 

图1 电子罗盘 
其中N、S、W和E分别表示北、南、西和东4个方向。 
本例只使用了onSensorChanged事件方法及values[0]。由于指南针图像上方是北，当手机前方是正北时（values[0]=0），图像不需要旋转。但如果不是正北，就需要将图像按一定角度旋转。假设当前values[0]的值是60，说明方向在东北方向。也就是说，手机顶部由北向东旋转。这时如果图像不旋转，N的方向正好和正北的夹角是60度，需要将图像逆时针（从东向北旋转）旋转60度，N才会指向正北方。因此，可以使用在11.2.3节介绍的旋转补间动画来旋转指南针图像，代码如下： 

Java代码  

1. public void onSensorChanged(SensorEvent event)  
2.   
3. {  
4.   
5.     if (event.sensor.getType() == Sensor.TYPE_ORIENTATION)  
6.   
7.     {    
8.   
9.         float degree = event.values[0];      
10.   
11.         //  以指南针图像中心为轴逆时针旋转degree度  
12.   
13.         RotateAnimation ra = new RotateAnimation(currentDegree, -degree,  
14.   
15.                 Animation.RELATIVE_TO_SELF, 0.5f,  
16.   
17.                 Animation.RELATIVE_TO_SELF, 0.5f);  
18.   
19.         //  在200毫秒之内完成旋转动作  
20.   
21.         ra.setDuration(200);  
22.   
23.         //  开始旋转图像  
24.   
25.         imageView.startAnimation(ra);   
26.   
27.         //  保存旋转后的度数，currentDegree是一个在类中定义的float类型变量  
28.   
29.         currentDegree = -degree;  
30.   
31. }  
32.   
33. }  

上面的代码中使用了event.values数组中的数据来获得传感器传回的数据。这个values数组非常重要，它的长度为3。但不一定每一个数组元素都有意义。对于不同的传感器，每个数组元素的含义不同。在下面的部分将详细介绍不同传感器中values数组各个元素的含义。 
注意：虽然使用Sensor.TYPE_ALL可以获得手机支持的所有传感器信息，但不能使用Sensor.TYPE_ALL注册所有的传感器，也就是getDefaultSensor方法的参数值必须是某个传感器的类型常量，而不能是Sensor.TYPE_ALL。 

3.2  计步器 

还可以利用方向传感器做出更有趣的应用，例如利用values[1]或values[2]的变化实现一个计步器。由于人在走路时会上下振动，因此，可以通过判断values[1]或values[2]中值的振荡变化进行计步。基本原理是在onSensorChanged方法中计算两次获得values[1]值的差，并根据差值在一定范围之外开始计数，代码如下： 

Java代码  

1. public void onSensorChanged(SensorEvent event)  
2.   
3. {  
4.   
5.     if (flag)  
6.   
7.     {  
8.   
9.         lastPoint = event.values[1];  
10.   
11.         flag = false;  
12.   
13.     }  
14.   
15.     //  当两个values[1]值之差的绝对值大于8时认为走了一步  
16.   
17.     if (Math.abs(event.values[1] - lastPoint) > 8)  
18.   
19.     {  
20.   
21.         //  保存最后一步时的values[1]的峰值  
22.   
23.         lastPoint = event.values[1];  
24.   
25.         //  将当前计数显示在TextView组件中  
26.   
27.         textView.setText(String.valueOf(++count));  
28.   
29.     }  
30.   
31. }  

本例设置3个按钮用于控制计步的状态，这3个按钮可以控制开始计步、重值（将计步数清0）和停止计步。这3个按钮的单击事件代码如下 

Java代码  

1. public void onClick(View view)  
2.   
3. {  
4.   
5.     String msg = "";  
6.   
7.     switch (view.getId())  
8.   
9.     {  
10.   
11.         //  开始计步  
12.   
13.         case R.id.btnStart:  
14.   
15.             sm = (SensorManager) getSystemService(SENSOR_SERVICE);  
16.   
17.             //  注册方向传感器  
18.   
19.             sm.registerListener(this, sm  
20.   
21.                     .getDefaultSensor(Sensor.TYPE_ORIENTATION),  
22.   
23.                     SensorManager.SENSOR_DELAY_FASTEST);  
24.   
25.             msg = "已经开始计步器.";  
26.   
27.             break;  
28.   
29.         //  重置计步器  
30.   
31.         case R.id.btnReset:  
32.   
33.             count = 0;  
34.   
35.             msg = "已经重置计步器.";  
36.   
37.             break;  
38.   
39.         //  停止计步  
40.   
41.         case R.id.btnStop:  
42.   
43.             //  注销方向传感器  
44.   
45.             sm.unregisterListener(this);  
46.   
47.             count = 0;  
48.   
49.             msg = "已经停止计步器.";  
50.   
51.             break;  
52.   
53.     }  
54.   
55.     textView.setText(String.valueOf(count));  
56.   
57.     Toast.makeText(this, msg, Toast.LENGTH_SHORT).show();  
58.   
59. }  

运行本例后，单击【开始】按钮，将手机放在兜里，再走两步看看 

3.3  一个更复杂的计步器 
程序运行界面如图4所示， 其中主窗体包括两个部分，上半部分用于显示最近7 天每天走过的步数， 以及今日走过的步数， 通过一个自定义的View 来实现； 下半部分用于摆放3个程序控制按钮。 

图1 计步器主界面 
在程序运行时自动连接数据库， 读取历史数据并将其可视化地显示到屏幕上。程序运行后会自动启动一个Service 组件， 用于检测手机的加速度状态， 当用户携带手机步行时， 传感器会捕获到这个动作并更新记录已走步数的计数器。如果此时程序正在前台显示， 那么在屏幕中除了刷新走过的步数之外， 还将播放一小段走路的动画。点击“删除数据” 按钮会删除掉数据库中存储的历史数据。点击“停止服务” 按钮会停止后台Service 的执行， 同时 
状态栏将不再显示计步器的Notification。点击“转为后台” 按钮将关闭程序界面， 但保留后台执行的Service。当用户按住手机屏幕的状态栏往下拖拉时， 会在展开的状态栏中看到本程序的Notification， 如图2 所示。 

图2  手机状态栏中的计步器 
本应用程序使用了Android 平台内置的SQLite 嵌入式数据库， 数据库中包含一张名为“step_table” 的表， 用来存放历史的已走步数信息， 表1 列出了step_table 表各个字段的情况。 

表1  step_table表的结构 
开发应用正式功能之前首先要开发对数据库访问的辅助类MySQLiteHelper， 其主要的功能为连接并打开SQLite 数据库，代码如下： 

Java代码  

1. package wyf.wpf; //声明所在包  
2.   
3. import android.content.Context; //引入相关类  
4.   
5. …//省略部分引入相关类的代码  
6.   
7. import android.database.sqlite.SQLiteOpenHelper;  
8.   
9. public class MySQLiteHelper extends SQLiteOpenHelper{  
10.   
11. public static final String TABLE_NAME = "step_table";  
12.   
13. public static final String ID = "id";  
14.   
15. public static final String STEP = "step";  
16.   
17. public static final String UPDATE_DATE = "up_date";  
18.   
19. public MySQLiteHelper(Context context, String name,  
20.   
21. CursorFactory factory,int version) {//构造器  
22.   
23. super(context, name, factory, version);  
24.   
25. }  
26.   
27. public void onCreate(SQLiteDatabase db) {  
28.   
29. db.execSQL ("create table if not exists " +  
30.   
31. TABLE_NAME + "(" //创建数据库表  
32.   
33. +ID+" integer primary key,"  
34.   
35. +STEP + " integer)");  
36.   
37. }  
38.   
39. public void onUpgrade(SQLiteDatabase db, int oldVersion  
40.   
41. , int newVersion) {}//对onUpgrade 方法的重写  
42.   
43. }  

在上述代码中创建了一个继承自SQLiteOpenHelper 类的子类， 并重写了其中的onCreate 和onUpgrade 方法。onCreate 方法将在数据库第一次被创建时调用， 本案例在该方法中执行了创建表的代码。onUpgrade 方法在数据库版本发生变化时调用。 
完成了数据库辅助类的开发后就可以开发WalkingActivity类了， 其是应用程序的用户界面， 主要功能是按照XML 布局文件的内容显示界面并与用户进行交互， 代码如下：

Java代码  

1. package wyf.wpf; //声明所在包  
2.   
3. import java.util.ArrayList; //引入相关类  
4.   
5. import android.app.Activity;  
6.   
7. …//省略部分引入相关类的代码   
8.   
9. import android.view.View.OnClickListener;  
10.   
11. import android.widget.Button;  
12.   
13. public class WalkingActivity extends Activity implements  
14.   
15. OnClickListener{  
16.   
17. WalkingView wv; //WalkingView 对象引用  
18.   
19. //数据库名称  
20.   
21. public static final String DB_NAME = "step.db";  
22.   
23. MySQLiteHelper mh; //声明数据库辅助类  
24.   
25. SQLiteDatabase db; //数据库对象  
26.   
27. Button btnToBackstage; //转入后台按钮  
28.   
29. Button btnStopService; //停止服务按钮  
30.   
31. Button btnDeleteData; //删除数据按钮  
32.   
33. StepUpdateReceiver receiver;  
34.   
35. //定义一个继承自BroadcastReceiver 的内部类  
36.   
37. StepUpdateReceiver 来接受传感器的信息  
38.   
39. public class StepUpdateReceiver extends BroadcastReceiver{  
40.   
41. public void onReceive(Context context, Intent intent) {  
42.   
43. Bundle bundle = intent.getExtras();//获得Bundle  
44.   
45. int steps = bundle.getInt("step");//读取步数  
46.   
47. wv.stepsToday = steps;  
48.   
49. wv.isMoving = true;  
50.   
51. wv.postInvalidate(); //刷新WalkingView  
52.   
53. }  
54.   
55. }  
56.   
57. //重写onCreate 方法，在Activity 被创建时调用  
58.   
59. public void onCreate(Bundle savedInstanceState) {  
60.   
61. super.onCreate(savedInstanceState);  
62.   
63. setContentView(R.layout.main);//设置当前屏幕  
64.   
65. wv = (WalkingView)  
66.   
67. findViewById(R.id.walkingView);  
68.   
69. btnToBackstage = (Button)  
70.   
71. findViewById(R.id.btnDispose);  
72.   
73. btnToBackstage.setOnClickListener(this);  
74.   
75. btnStopService =  
76.   
77. (Button)findViewById(R.id.btnStop);  
78.   
79. btnStopService.setOnClickListener(this);  
80.   
81. btnDeleteData =  
82.   
83. (Button)findViewById(R.id.btnDeleteData);  
84.   
85. btnDeleteData.setOnClickListener(this);  
86.   
87. //注册Receiver  
88.   
89. receiver = new StepUpdateReceiver();  
90.   
91. IntentFilter filter = new IntentFilter();  
92.   
93. filter.addAction("wyf.wpf.WalkingActivity");  
94.   
95. registerReceiver(receiver, filter);  
96.   
97. //启动注册了传感器监听的Service  
98.   
99. Intent i = new Intent(this,WalkingService.class);  
100.   
101. startService(i);  
102.   
103. mh=new MySQLiteHelper(this,DB_NAME,null,1);  
104.   
105. requireData(); //向Service 请求今日走过步数  
106.   
107. }  
108.   
109. //重写onDestroy 方法  
110.   
111. protected void onDestroy() {  
112.   
113. unregisterReceiver(receiver); //注销Receiver  
114.   
115. super.onDestroy();  
116.   
117. }  
118.   
119. //重写OnClickListener 接口的onClick 方法  
120.   
121. public void onClick(View view) {}  
122.   
123. //方法：向Service 请求今日走过的步数  
124.   
125. public void requireData(){}  
126.   
127. }  
128. 复制代码上述代码为Walking Activity 类的代码框架， 由WalkingActivity 实现了OnClickListener 接口， 所以需要对接中的onClick 方法进行重写， 重写的onClick 方法代码如下：public void onClick(View view) {}  
129.   
130. if(view == btnStopService){  
131.   
132. //停止后台服务  
133.   
134. Intent intent = new Intent();  
135.   
136. intent.setAction("wyf.wpf.WalkingService");  
137.   
138. intent.putExtra("cmd",  
139.   
140. WalkingService.CMD_STOP);  
141.   
142. sendBroadcast(intent);  
143.   
144. }  
145.   
146. else if(view == btnToBackstage){  
147.   
148. finish();//转到后台  
149.   
150. }  
151.   
152. else if(view == btnDeleteData){  
153.   
154. //查看历史数据  
155.   
156. SQLiteDatabase db = (SQLiteDatabase)  
157.   
158. openOrCreateDatabase(DB_NAME,  
159.   
160. Context.MODE_PRIVATE, null);  
161.   
162. db.delete(MySQLiteHelper.TABLE_NAME, null,  
163.   
164. null);  
165.   
166. db.close();  
167.   
168. wv.stepsInWeek = wv.getSQLData("7");  
169.   
170. wv.postInvalidate();  
171.   
172. }  
173.   
174. }  

在WalkingActivity 的onCreate 方法的最后调用了require-Data 方法向Service 发送Intent 请求今日走过的步数， 该方法的代码如下： 

Java代码  

1. public void requireData(){  
2.   
3. Intent intent = new Intent(); //创建Intent  
4.   
5. intent.setAction("wyf.wpf.WalkingService");  
6.   
7. intent.putExtra("cmd",  
8.   
9. WalkingService.CMD_UPDATAE);  
10.   
11. sendBroadcast(intent); //发出消息广播  
12.   
13. }  

完成了WalkingActivity 类的开发后就需要开发用于显示计步器的历史数据及绘制今日走过的步数及走步时动画的自定义View———WalkingView 了， 其代码框架如下： 

Java代码  

1. package wyf.wpf;  
2.   
3. import java.util.ArrayList;  
4.   
5. …//省略部分引入相关类的代码  
6.   
7. import android.view.View;  
8.   
9. public class WalkingView extends View{  
10.   
11. ArrayList<String> stepsInWeek=null;//存历史数据  
12.   
13. int stepsToday=0; //记录今天走的步数  
14.   
15. int gapY = 8; //屏幕最上面留出的空隙  
16.   
17. int distY = 10; //每一条的间距  
18.   
19. int cellHeight = 30; //每一条的高度  
20.   
21. float STEP_MAX = 1000.0f; //每天最大的步数  
22.   
23. int maxStepWidth = 280; //最大步数在屏幕中宽度  
24.   
25. Bitmap [] sprite; //运动小人的图片数组  
26.   
27. Bitmap [] digit; //数字图片数组  
28.   
29. Bitmap back_cell; //颜色渐变条  
30.   
31. boolean isMoving = false;  
32.   
33. int frameIndex; //记录运动小人的帧索引  
34.   
35. MySQLiteHelper mh; //操作数据库的辅助类  
36.   
37. SQLiteDatabase db; //数据库操作对象  
38.   
39. public WalkingView(Context context, AttributeSet  
40.   
41. attrs) {  
42.   
43. super(context, attrs);  
44.   
45. sprite = new Bitmap[5];  
46.   
47. digit = new Bitmap[10];  
48.   
49. //初始化图片  
50.   
51. Resources res = getResources();  
52.   
53. sprite[0] = BitmapFactory  
54.   
55. .decodeResource(res, R.drawable.act_1);  
56.   
57. …//省略部分Bitmap 的创建代码  
58.   
59. back_cell = BitmapFactory  
60.   
61. .decodeResource(res, R.drawable.back_cell);  
62.   
63. //获取数据库中最近7 天内的数据  
64.   
65. mh = new MySQLiteHelper  
66.   
67. (context, WalkingActivity.DB_NAME, null,1);  
68.   
69. stepsInWeek = getSQLData("7");  
70.   
71. }  
72.   
73. protected void onDraw(Canvas canvas) {  
74.   
75. super.onDraw(canvas);  
76.   
77. drawPrevious(canvas);//画以前走过的步数  
78.   
79. drawToday(canvas); //画今天走过的步数  
80.   
81. }  
82.   
83. //画今天走的步数  
84.   
85. private void drawToday(Canvas canvas) {}  
86.   
87. //画之前走过的步数  
88.   
89. private void drawPrevious(Canvas canvas) {}  
90.   
91. //从数据库中获取历史数据  
92.   
93. public ArrayList<String> getSQLData(String limit){}  

上述为WalkingView 类的代码框架， 在WalkingView 类的构造器中将需要用到的图片资源初始化的同时， 调用getSQLData方法获取数据库中的历史数据。WalkingView 类重写了onDraw 方法， 该方法需要调用drawPrevious 和drawToday 方法分别对历史数据和今日走步情况进行绘制。这3 个方法以及在drawToday 方法中调用到的drawDigits 方法的详细代码如下：//画今天走的步数 

Java代码  

1. private void drawToday(Canvas canvas) {  
2.   
3. Paint paint = new Paint();  
4.   
5. paint.setColor(Color.CYAN);  
6.   
7. float strokewidth = paint.getStrokeWidth();  
8.   
9. Style s = paint.getStyle();  
10.   
11. paint.setStyle(Style.STROKE);  
12.   
13. paint.setStrokeWidth(2.0f);  
14.   
15. canvas.drawLine(0, 300, 320, 300, paint);  
16.   
17. paint.setStyle(s);  
18.   
19. paint.setStrokeWidth(strokewidth);//恢复画笔  
20.   
21. //把当前步数换算为在屏幕上绘制的条宽度  
22.   
23. int width = (int)(stepsToday/STEP_MAX*280);  
24.   
25. canvas.drawBitmap(back_cell, 0, 320, paint);  
26.   
27. paint.setColor(Color.BLACK);  
28.   
29. canvas.drawRect(width, 320, 320, 320+cellHeight, paint);  
30.   
31. //画出遮罩层  
32.   
33. if(isMoving){ //如果在运动，就切换帧序列  
34.   
35. canvas.drawBitmap(sprite[(++frameIndex)%5],  
36.   
37. width+20, 320,paint);  
38.   
39. isMoving = false;  
40.   
41. }  
42.   
43. else{ //如果没在走步，就绘制静止的那张图片  
44.   
45. canvas.drawBitmap(sprite[4], width+20,  
46.   
47. 320,paint);  
48.   
49. }  
50.   
51. drawDigit(canvas,width); //绘制数字  
52.   
53. }  
54.   
55. //画之前走过的步数  
56.   
57. private void drawPrevious(Canvas canvas) {  
58.   
59. Paint paint = new Paint();  
60.   
61. for(int i=0;i<stepsInWeek.size();i++){  
62.   
63. String os = stepsInWeek.get(i);  
64.   
65. int s = Integer.valueOf(os).intValue();  
66.   
67. int width = (int) (s/STEP_MAX * maxStep-  
68.   
69. Width); //求出指定的步数在统计条中占得宽度  
70.   
71. int tempY = (cellHeight+distY)*i;  
72.   
73. canvas.drawBitmap(back_cell, 0, (cellHeight+  
74.   
75. distY)*i, paint); //画出渐变条  
76.   
77. paint.setColor(Color.BLACK);  
78.   
79. canvas.drawRect(width, tempY, 320, tempY+cell-  
80.   
81. Height, paint);  
82.   
83. paint.setTextAlign(Align.LEFT);  
84.   
85. paint.setColor(Color.CYAN);  
86.   
87. paint.setAntiAlias(true);  
88.   
89. canvas.drawText("走了"  
90.   
91. +stepsInWeek.get(i)+"步", width, tempY+cellHeight/2,  
92.   
93. paint);  
94.   
95. }  
96.   
97. }  
98.   
99. //从数据库中获取历史数据  
100.   
101. public ArrayList<String> getSQLData(String limit){  
102.   
103. //获得SQLiteDatabase 对象  
104.   
105. db = mh.getReadableDatabase();  
106.   
107. String [] cols = {MySQLiteHelper.ID,MySQLiteHelper.  
108.   
109. STEP};  
110.   
111. Cursor c = db.query (MySQLiteHelper.TABLE_NAME,  
112.   
113. cols, null, null, null, null, MySQLiteHelper.ID+" DESC",limit);  
114.   
115. ArrayList<String> al = new ArrayList<String>();  
116.   
117. for(c.moveToFirst();! (c.isAfterLast());c.moveToNext()){  
118.   
119. al.add(c.getString(1));  
120.   
121. }  
122.   
123. c.close();  
124.   
125. db.close();  
126.   
127. return al;  
128.   
129. }  
130.   
131. //将数字通过数字图片绘制到屏幕上  
132.   
133. public void drawDigit(Canvas canvas,int width){  
134.   
135. String sStep = ""+stepsToday;  
136.   
137. int l = sStep.length();  
138.   
139. for(int i=0;i<l;i++){  
140.   
141. int index = sStep.charAt(i) - '0';  
142.   
143. canvas.drawBitmap(digit[index],  
144.   
145. width+20+40+32*i, 320, null);//绘制数字图片  
146.   
147. }  
148.   
149. }  
150.   
151. }  

完成了数据库辅助类及界面部分的开发后就可以开发后台的服务类———WalkingService 了。WalkingService 继承自Service类， 其主要实现的功能包括如下几个方面： 
（1） 注册或注销传感器监听器。 
（2） 在手机屏幕状态栏显示Notification。 
（3） 定时将今日走过的步数写入数据库。 
（4） 与WalkingActivity 进行通信。 
下面将围绕这4 个功能对WalkingService 类的代码逐一进 
行介绍， 其类框架与成员声明的代码如下：package wyf.wpf; 

Java代码  

1. import java.util.Calendar;  
2.   
3. import android.app.Notification;  
4.   
5. …//省略部分引入相关类的代码  
6.   
7. import android.os.Message;  
8.   
9. import org.openintents.sensorsimulator.hardware.*;  
10.   
11. public class WalkingService extends Service{  
12.   
13. WalkingView wv;  
14.   
15. //SensorManager mySensorManager;  
16.   
17. SensorManagerSimulator mySensorManager;  
18.   
19. WalkingListener wl;  
20.   
21. int steps=0;  
22.   
23. boolean isActivityOn = false; //Activity 是否运行  
24.   
25. boolean isServiceOn = false;  
26.   
27. NotificationManager nm;//声明NotificationManager  
28.   
29. long timeInterval = 24*60*60*1000;  
30.   
31. //Handler 延迟发  
32.   
33. //送消息的时延  
34.   
35. final static int CMD_STOP = 0;  
36.   
37. final static int CMD_UPDATAE = 1;  
38.   
39. CommandReceiver receiver; //声明BroadcastReceiver  
40.   
41. Handler myHandler = new Handler(){//定时上传数据  
42.   
43. public void handleMessage(Message msg) {  
44.   
45. uploadData();  
46.   
47. super.handleMessage(msg);  
48.   
49. }  
50.   
51. };  

上述代码声明和创建了WalkingService 的成员变量。需要注意的是由于本案例将使用SensorSimulator 进行测试， 所以需要对正常代码进行修改。首先是成员变量mySensorManager 的声明， 代码中注释掉的部分为正常代码， 未被注释的是为了使用SensorSimulator 工具中相关类声明的引用。完成了类框架与成员声明代码的开发后就可以开发此Service的初始化方法onCreate 及其他相关功能方法了， 代码如下： 

Java代码  

1. public void onCreate() {  
2.   
3. super.onCreate();  
4.   
5. wl = new WalkingListener(this); //创建监听器类  
6.   
7. //初始化传感器  
8.   
9. // mySensorManager = (SensorManager)  
10.   
11. // getSystemService(SENSOR_SERVICE);  
12.   
13. mySensorManager = SensorManagerSimulator  
14.   
15. .getSystemService(this, SENSOR_SERVICE);  
16.   
17. mySensorManager.connectSimulator();  
18.   
19. //注册监听器  
20.   
21. mySensorManager.registerListener(wl,  
22.   
23. SensorManager.SENSOR_ACCELEROMETER,  
24.   
25. SensorManager.SENSOR_DELAY_UI);  
26.   
27. nm = (NotificationManager)  
28.   
29. getSystemService(NOTIFICATION_SERVICE);  
30.   
31. Calendar c = Calendar.getInstance();  
32.   
33. long militime = c.getTimeInMillis();  
34.   
35. //将Calendar 设置为第二天0 时  
36.   
37. c.set(Calendar.DAY_OF_MONTH,  
38.   
39. c.get(Calendar.DAY_OF_MONTH)+1);  
40.   
41. c.set(Calendar.HOUR_OF_DAY, 0);  
42.   
43. c.set(Calendar.MINUTE, 0);  
44.   
45. c.set(Calendar.SECOND, 0);  
46.   
47. long nextDay = c.getTimeInMillis();  
48.   
49. timeInterval = nextDay - militime;  
50.   
51. }  
52.   
53. public void onStart(Intent intent, int startId) {  
54.   
55. super.onStart(intent, startId);  
56.   
57. isServiceOn = true;  
58.   
59. showNotification();//添加Notification  
60.   
61. receiver = new CommandReceiver();  
62.   
63. IntentFilter filter1 = new IntentFilter();  
64.   
65. filter1.addAction("wyf.wpf.WalkingService");  
66.   
67. registerReceiver(receiver, filter1);  
68.   
69. //设定Message 并延迟到本日结束发送  
70.   
71. if(isServiceOn){  
72.   
73. Message msg =  
74.   
75. myHandler.obtainMessage();  
76.   
77. myHandler.sendMessageDelayed(msg,  
78.   
79. timeInterval);  
80.   
81. }  
82.   
83. }  
84.   
85. //重写onDestroy 方法  
86.   
87. public void onDestroy() {  
88.   
89. mySensorManager.unregisterListener(wl);  
90.   
91. wl = null;  
92.   
93. mySensorManager = null;  
94.   
95. nm.cancel(0);  
96.   
97. unregisterReceiver(receiver);  
98.   
99. super.onDestroy();  
100.   
101. }  
102.   
103. //重写onBind 方法  
104.   
105. public IBinder onBind(Intent arg0) {return null;}  
106.   
107. //方法：显示Notification  
108.   
109. private void showNotification() {}  
110.   
111. //方法：向数据库中插入今日走过的步数  
112.   
113. public void uploadData(){}  
114.   
115. //开发继承自BroadcastReceiver 的子类接收广播消息  
116.   
117. class CommandReceiver extends BroadcastReceiver{}  

上述代码包括了WalkingService 的几个成员方法， 可以看到在onCreate 方法中， 同样为了使用SensorSimulator 工具测试案例而注释掉了正常代码并将其替换为使用SensorSimulator 的相关代码。同时在onCreate 方法中， 还计算了从Service 被启动时刻到这一天的结束之间的时间间隔， 并将该时间间隔作为Handler对象发送消息的延迟， 这样在本天过完之后， 会及时地向数据库中插入数据。在Service 的onStart 方法中调用了showNotification 方法，该方法将会在手机的状态栏(显示信号强度、电池等状态的区域) 
显示本程序的Notification， 展开状态栏并点击Notification 后会启动WalkingActivity。showNotification 方法的代码如下 

Java代码  

1. //方法：显示Notification  
2.   
3. private void showNotification() {  
4.   
5. Intent intent = new Intent(this,WalkingActivity.class);  
6.   
7. PendingIntent pi = PendingIntent.getActivity(this,  
8.   
9. 0, intent, 0);  
10.   
11. Notification myNotification = new Notification();  
12.   
13. myNotification.icon = R.drawable.icon;  
14.   
15. myNotification.defaults = otification.DEFAULT_ALL;  
16.   
17. myNotification.setLatestEventInfo(this,  
18.   
19. "计步器运行中", "点击查看", pi);  
20.   
21. nm.notify(0,myNotification);  
22.   
23. }  

本程序使用Handler 来定时发送消息， 收到消息后会调用uploadData 方法将今日走过的步数插入到数据库， 该方法的代码如下：//方法：向数据库中插入今日走过的步数 

Java代码  

1. public void uploadData(){  
2.   
3. MySQLiteHelper mh = new MySQLiteHelper  
4.   
5. (this,WalkingActivity.DB_NAME,null,1);  
6.   
7. SQLiteDatabase db = mh.getWritableDatabase();  
8.   
9. ContentValues values = new ContentValues();  
10.   
11. values.put(MySQLiteHelper.STEP, this.steps);  
12.   
13. db.insert(MySQLiteHelper.TABLE_NAME,  
14.   
15. MySQLiteHelper.ID, values);  
16.   
17. Cursor c = db.query(MySQLiteHelper.TABLE_NAME,  
18.   
19. null, null, null, null, null, null);  
20.   
21. c.close();  
22.   
23. db.close(); //关闭数据库  
24.   
25. mh.close();  
26.   
27. if(isServiceOn){//设置24 小时后再发同样的消息  
28.   
29. Message msg = myHandler.obtainMessage();  
30.   
31. myHandler.sendMessageDelayed(msg,  
32.   
33. 24*60*60*1000);  
34.   
35. }  
36.   
37. }  

、、 
WalkingService 和WalingActivity 进行通信是通过注册CommandReceiver 组件来实现的， CommandReceiver 继承自BroadcastReceiver， 负责接收WalingActivity 发来的Intent。 
CommandReceiver 类的代码如下： 

Java代码  

1. //开发继承自BroadcastReceiver 的子类接收广播消息  
2.   
3. class CommandReceiver extends BroadcastReceiver{  
4.   
5. public void onReceive(Context context, Intent intent) {  
6.   
7. int cmd = intent.getIntExtra("cmd", -1);  
8.   
9. switch(cmd){  
10.   
11. case WalkingService.CMD_STOP://停止服务  
12.   
13. stopSelf();  
14.   
15. break;  
16.   
17. case WalkingService.CMD_UPDATAE: //传数据  
18.   
19. isActivityOn = true;  
20.   
21. Intent i = new Intent();  
22.   
23. i.setAction("wyf.wpf.WalkingActivity");  
24.   
25. i.putExtra("step", steps);  
26.   
27. sendBroadcast(i);  
28.   
29. break;  
30.   
31. }  
32.   
33. }  
34.   
35. }  
36.   
37. }  

WalkingService 和WalingActivity 在进行通信时， 被广播的Intent 对象中的action 必 
须和另一方的IntentFilter 设置的action相同， 并且为了保证action 的惟一性， 一般以应 
用程序包名后跟一个字符串来定义action。另外在开发了WalkingService 的代码之后， 还 
需要在AndroidManifest.xml 文件中声明该Service， 否则该Service 对Android系统是不可 
见的。 
完成了前面的大部分工作后， 就可以开发传感器监听接口的实现类——— 
WalkingListener 了。WalkingListener 实现了SensorListener接口， 其主要的功能是监听加速度传感器的变化并进行相应的处理， 代码如下： 

Java代码  

1. <pre name="code" class="java">package wyf.wpf;  
2.   
3. import android.content.Intent; //引入相关包  
4.   
5. import android.hardware.SensorListener;  
6.   
7. import android.hardware.SensorManager;  
8.   
9. public class WalkingListener implements SensorListener  
10.   
11. {  
12.   
13. WalkingService father; // WalkingService 引用  
14.   
15. float [] preCoordinate;  
16.   
17. double currentTime=0,lastTime=0; //记录时间  
18.   
19. float WALKING_THRESHOLD = 20;  
20.   
21. public WalkingListener(WalkingService father){  
22.   
23. this.father = father;  
24.   
25. }  
26.   
27. public void onAccuracyChanged(int arg0, int arg1) {}  
28.   
29. //传感器发生变化后调用该方法  
30.   
31. public void onSensorChanged(int sensor, float[] values) {  
32.   
33. if(sensor ==  
34.   
35. SensorManager.SENSOR_ACCELEROMETER){  
36.   
37. analyseData(values);//调用方法分析数据  
38.   
39. }  
40.   
41. }  
42.   
43. //方法：分析参数进行计算  
44.   
45. public void analyseData(float[] values){  
46.   
47. //获取当前时间  
48.   
49. currentTime=System.currentTimeMillis();  
50.   
51. //每隔200MS 取加速度力和前一个进行比较  
52.   
53. if(currentTime - lastTime >200){  
54.   
55. if(preCoordinate == null){//还未存过数据  
56.   
57. preCoordinate = new float[3];  
58.   
59. for(int i=0;i<3;i++){  
60.   
61. preCoordinate = values;  
62.   
63. }  
64.   
65. }  
66.   
67. else{ //记录了原始坐标的话，就进行比较  
68.   
69. int angle=  
70.   
71. calculateAngle(values,preCoordinate);  
72.   
73. if(angle >=  
74.   
75. WALKING_THRESHOLD){  
76.   
77. father.steps++; //步数增加  
78.   
79. updateData(); //更新步数  
80.   
81. }  
82.   
83. for(int i=0;i<3;i++){  
84.   
85. preCoordinate=values;  
86.   
87. }}  
88.   
89. lastTime = currentTime;//重新计时  
90.   
91. }  
92.   
93. }  
94.   
95. //方法：计算加速度矢量角度的方法  
96.   
97. public int calculateAngle(float[] newPoints,float[]  
98.   
99. oldPoints){}  
100.   
101. //方法：向Activity 更新步数  
102.   
103. public void updateData(){}  
104.   
105. }  
106. 复制代码WalkingListener 类的代码中， 主要是对SensorListener 接口中的onSensorChanged 方法进行了重写， 在该方法中将读取到的传感器采样值传给analyseData 方法进行分析。在analyseData 方法中， 调用了calculateAngle 方法来计算固定的时间间隔间手机加速度向量方向的夹角。calculateAngle方法的代码如下：//方法：计算两个加速度矢量夹角的方法  
107.   
108. public int calculateAngle(float[] newPoints,float[] oldPoints){  
109.   
110. int angle=0;  
111.   
112. float vectorProduct=0; //向量积  
113.   
114. float newMold=0; //新向量的模  
115.   
116. float oldMold=0; //旧向量的模  
117.   
118. for(int i=0;i<3;i++){  
119.   
120. vectorProduct +=  
121.   
122. newPoints*oldPoints;  
123.   
124. newMold += newPoints*newPoints;  
125.   
126. oldMold += oldPoints*oldPoints;  
127.   
128. }  
129.   
130. newMold = (float)Math.sqrt(newMold);  
131.   
132. oldMold = (float)Math.sqrt(oldMold);  
133.   
134. //计算夹角的余弦  
135.   
136. float cosineAngle=(float)  
137.   
138. (vectorProduct/(newMold*oldMold));  
139.   
140. //通过余弦值求角度  
141.   
142. float fangle = (float)  
143.   
144. Math.toDegrees(Math.acos(cosineAngle));  
145.   
146. angle = (int)fangle;  
147.   
148. return angle; //返回向量的夹角  
149.   
150. }</pre>  

如果calculateAngle 方法返回的加速度向量角度变化超过了程序中设定的阈值， 应用程序将WalkingService 中已走步数计数器加1， 并调用updateData 方法将更新的步数传递给WalkingActivity 显示到界面， 该方法代码如下：public void updateData(){ 

Intent intent = new Intent(); //创建Intent 对象 

intent.setAction("wyf.wpf.WalkingActivity"); 

intent.putExtra("step", father.steps);//添加步数 

father.sendBroadcast(intent); //发出广播 

} 
复制代码完成了应用程序代码的开发之后， 就可以将应用程序打包安装调试了。在Eclipse 中构建本项目， 完成构建后本应用程序项目文件夹下bin 目录中的JBQ.apk 即为本计步器应用程序的发布apk 包。将此apk 包安装到手机模拟器， 然后启动SensorSimulator桌面端， 如图3 所示。 

图3  测试传感器 
运行SensorSimulator 桌面端之后， 还需要在模拟器上安装SensorSimulator 的客户端， 根据桌面端显示的IP 地址和端口号进行响应的配置。配置好SensorSimulator 之后， 就可以运行已经安装过的计步器程序。在SensorSimulator 的桌面端可以模拟手机的动作变化从而达到调试传感器应用程序的目的。要特别注意的是， 在调试完成真正发布应用程序前， 需要将WalkingService 类中使用SensorSimulator 的代码注释掉， 将真正使用物理传感器的代码去掉注释。最后再次构建项目， 这样得到的apk 包就是最终真正的发布版了。 
通过开发计步器应用程序， 读者应该对Android 平台下开发传感器应用的流程有了一定的了解。传感器的特性和Android平台的开放性结合在一起， 使得在移动手机终端上开发各种新奇有趣的传感器应用成为可能， 同时也为开发人员开辟一个新的应用领域。可以预见， 在不久的将来， Android 嵌入式平台下的传感器应用必将大放光彩。 

4在模拟器上模拟重力感应 
众所周知，Android系统支持重力感应，通过这种技术，可以利用手机的移动、翻转来实现更为有趣的程序。但遗憾的是，在Android模拟器上是无法进行重力感应测试的。既然Android系统支持重力感应，但又在模拟器上无法测试，该怎么办呢？别着急，天无绝人之路，有一些第三方的工具可以帮助我们完成这个工作，本节将介绍一种在模拟器上模拟重力感应的工具（sensorsimulator）。这个工具分为服务端和客户端两部分。服务端是一个在PC上运行的Java Swing GUI程序，客户端是一个手机程序（apk文件），在运行时需要通过客户端程序连接到服务端程序上才可以在模拟器上模拟重力感应。 
读者可以从下面的地址下载这个工具： 
http://code.google.com/p/openintents/downloads/list 
进入下载页面后，下载如图1所示的黑框中的zip文件。 

图1 
sensorsimulator下载页面 
将zip文件解压后，运行bin目录中的sensorsimulator.jar文件，会显示如图2所示的界面。界面的左上角是一个模拟手机位置的三维图形，右上角可以通过滑杆来模拟手机的翻转、移动等操作。 

图2 
sensorsimulator主界面 
下面来安装客户端程序，先启动Android模拟器，然后使用下面的命令安装bin目录中的SensorSimulatorSettings.apk文件。 
adb install SensorSimulatorSettings.apk 
如果安装成功，会在模拟器中看到如图3所示黑框中的图标。运行这个程序，会进入如图4所示的界面。在IP地址中输入如图3所示黑框中的IP（注意，每次启动服务端程序时这个IP可能不一样，应以每次启动服务端程序时的IP为准）。最后进入【Testing】页，单击【Connect】按钮，如果连接成功，会显示如图5所示的效果。 
                                                  
图3 安装客户端设置软件                                         图4进行客户端设置 
下面来测试一下SensorSimulator自带的一个demo，在这个demo中输出了通过模拟重力感应获得的数据。 
这个demo就在samples目录中，该目录有一个SensorDemo子目录，是一个Eclipse工程目录。读者可以直接使用Eclipse导入这个目录，并运行程序，如果显示的结果如图5所示，说明成功使用SensorSimulator在Android模拟器上模拟了重力感应。 
                            

5、手机翻转静音 
与手机来电一样，手机翻转状态（重力感应）也由系统服务提供。重力感应服务（android.hardware.SensorManager对象）可以通过如下代码获得：SensorManager sensorManager =(SensorManager)getSystemService(Context.SENSOR_SERVICE); 
复制代码本例需要在模拟器上模拟重力感应，因此，在本例中使用SensorSimulator中的一个类（SensorManagerSimulator）来获得重力感应服务，这个类封装了SensorManager对象，并负责与服务端进行通信，监听重力感应事件也需要一个监听器，该监听器需要实现SensorListener接口，并通过该接口的onSensorChanged事件方法获得重力感应数据。本例完整的代码如下：package net.blogjava.mobile; 

Java代码  

1. import org.openintents.sensorsimulator.hardware.SensorManagerSimulator;  
2.   
3. import android.app.Activity;  
4.   
5. import android.content.Context;  
6.   
7. import android.hardware.SensorListener;  
8.   
9. import android.hardware.SensorManager;  
10.   
11. import android.media.AudioManager;  
12.   
13. import android.os.Bundle;  
14.   
15. import android.widget.TextView;  
16.   
17.   
18.   
19. public class Main extends Activity implements SensorListener  
20.   
21. {  
22.   
23.     private TextView tvSensorState;  
24.   
25.     private SensorManagerSimulator sensorManager;  
26.   
27.     @Override  
28.   
29.     public void onAccuracyChanged(int sensor, int accuracy)  
30.   
31.     {  
32.   
33.     }  
34.   
35.     @Override  
36.   
37.     public void onSensorChanged(int sensor, float[] values)  
38.   
39.     {  
40.   
41.         switch (sensor)  
42.   
43.         {  
44.   
45.             case SensorManager.SENSOR_ORIENTATION:  
46.   
47.                 //  获得声音服务  
48.   
49.                 AudioManager audioManager = (AudioManager)   
50.   
51.                                      getSystemService(Context.AUDIO_SERVICE);  
52.   
53.                 //  在这里规定翻转角度小于-120度时静音，values[2]表示翻转角度，也可以设置其他角度  
54.   
55.                 if (values[2] < -120)  
56.   
57.                 {  
58.   
59.                     audioManager.setRingerMode(AudioManager.RINGER_MODE_SILENT);  
60.   
61.                 }  
62.   
63.                 else  
64.   
65.                 {  
66.   
67.                     audioManager.setRingerMode(AudioManager.RINGER_MODE_NORMAL);  
68.   
69.                 }  
70.   
71.                 tvSensorState.setText("角度：" + String.valueOf(values[2]));  
72.   
73.                 break;  
74.   
75.         }  
76.   
77.     }  
78.   
79.     @Override  
80.   
81.     protected void onResume()  
82.   
83.     {  
84.   
85.         //  注册重力感应监听事件  
86.   
87.         sensorManager.registerListener(this, SensorManager.SENSOR_ORIENTATION);  
88.   
89.         super.onResume();  
90.   
91.     }  
92.   
93.     @Override  
94.   
95.     protected void onStop()  
96.   
97.     {  
98.   
99.         //  取消对重力感应的监听   
100.   
101.         sensorManager.unregisterListener(this);  
102.   
103.         super.onStop();  
104.   
105.     }  
106.   
107.     @Override  
108.   
109.     public void onCreate(Bundle savedInstanceState)  
110.   
111.     {  
112.   
113.         super.onCreate(savedInstanceState);  
114.   
115.         setContentView(R.layout.main);  
116.   
117.         //  通过SensorManagerSimulator对象获得重力感应服务  
118.   
119.         sensorManager = (SensorManagerSimulator) SensorManagerSimulator  
120.   
121.                 .getSystemService(this, Context.SENSOR_SERVICE);  
122.   
123.         //  连接到服务端程序（必须执行下面的代码）  
124.   
125.         sensorManager.connectSimulator();  
126.   
127.     }  
128.   
129. }  

上面的代码中使用了一个SensorManagerSimulator类，该类在SensorSimulator工具包带的sensorsimulator-lib.jar文件中，可以在lib目录中找到这个jar文件。在使用SensorManagerSimulator类之前，必须在相应的Eclipse工程中引用这个jar文件。 
现在运行本例，并通过服务端主界面右侧的【Roll】滑动杆移动到指定的角度，例如，-74.0和-142.0，这时设置的角度会显示在屏幕上，如图1和图2所示。 

图1 翻转角度大于-120度  
                                          
图2 翻转角度小于-120度 
读者可以在如图1和图2所示的翻转状态下拨入电话，会发现翻转角度在-74.0度时来电仍然会响铃，而翻转角度在-142.0度时就不再响铃了。