Android Orientation Sensor（方向传感器）详解与应用

一、前言

本篇blog是我的“Android进阶”的第一篇文章，从初学Android到现在断断续续也有4个多月时间了，也算是有了一些自己的心得体会，也能自己独立做一些东西了，这都要感谢我们公司的安卓开发璟博和无所不能的鸿洋给我的帮助和指点。本系列blog将记录我在开发中、学习中遇到的较为重点的、值得记录的知识点和技巧，简单的说就不再是基础教程了。由于项目中需要用到方向传感器，所以就借此机会来学一学Android的传感器部分的知识了，自然也就是本篇blog的内容了。

二、传感器基础

官方文档说的很清楚，Android平台支持三大类的传感器，它们分别是：

a. Motion sensors

b. Environmental sensors

c. Position sensors

从另一个角度划分，安卓的传感器又可以分为基于硬件的和基于软件的。基于硬件的传感器往往是通过物理组件去实现的，他们通常是通过去测量特殊环境的属性获取数据，比如：重力加速度、地磁场强度或方位角度的变化。而基于软件的传感器并不依赖物理设备，尽管它们是模仿基于硬件的传感器的。基于软件的传感器通常是通过一个或更多的硬件传感器获取数据，并且有时会调用虚拟传感器或人工传感器等等，线性加速度传感器和重力传感器就是基于软件传感器的例子。下面通过官方的一张图看看安卓平台支持的所有传感器类型：

使用传感器的话那么首先需要了解的必然是传感器API了，在Android中传感器类是通过Sensor类来表示的，它属于android.hardware包下的类，顾名思义，和硬件相关的类。传感器的API不复杂，包含3个类和一个接口。

右上角标有1的是在Android1.5版本添加的，并且在Android2.3之后就无法使用。

右上角标有2的是已经过时的。

很明显，我们需要用到的方向传感器TYPE_ORIENTATION就已经过时了，后面再说用什么来替代它。

最后看一下常用的传感器的方法：

1.实例化SensorManager

?

1

SensorManager mSensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);

2.获取设备支持的全部Sensor的List

?

1

List<sensor> deviceSensors = mSensorManager.getSensorList(Sensor.TYPE_ALL);</sensor>

下面就通过这两个方法看一下手机支持哪些传感器，并以列表数据展示出来，代码很简单：

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

packagecom.example.sensordemo;

 

importjava.util.ArrayList;

importjava.util.List;

 

importandroid.app.Activity;

importandroid.content.Context;

importandroid.hardware.Sensor;

importandroid.hardware.SensorManager;

importandroid.os.Bundle;

importandroid.widget.ArrayAdapter;

importandroid.widget.ListView;

 

publicclass MainActivity extendsActivity {

 

    privateSensorManager mSensorManager;

    privateListView sensorListView;

    privateList<sensor> sensorList;

 

    @Override

    protectedvoid onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        setContentView(R.layout.activity_main);

        sensorListView = (ListView) findViewById(R.id.lv_all_sensors);

        // 实例化传感器管理者

        mSensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);

        // 得到设置支持的所有传感器的List

        sensorList = mSensorManager.getSensorList(Sensor.TYPE_ALL);

        List<string> sensorNameList = newArrayList<string>();

        for(Sensor sensor : sensorList) {

            sensorNameList.add(sensor.getName());

        }

        ArrayAdapter<string> adapter = newArrayAdapter<string>(this,

                android.R.layout.simple_list_item_1, sensorNameList);

        sensorListView.setAdapter(adapter);

    }

 

}

</string></string></string></string></sensor>

最后看一下真机的效果图：

了解了传感器的基础知识，下面我们就具体看看我们需要用到的Orientation Sensor。

三、Orientation Sensor

安卓平台提供了2个传感器用于让我们判断设备的位置，分别是地磁场传感器（the geomagnetic field sensor）和方向传感器（the orientation sensor）。关于Orientation Sensor在官方文档中的概述里有这样一句话：

The orientation sensor is software-based and derives its data from the accelerometer and the geomagnetic field sensor. （方向传感器是基于软件的，并且它的数据是通过加速度传感器和磁场传感器共同获得的）

至于具体算法Android平台已经封装好了我们不必去关心实现，下面在了解方向传感器之前我们还需要了解一个重要的概念：传感器坐标系统（Sensor Coordinate System）。

在Android平台中，传感器框架通常是使用一个标准的三维坐标系去表示一个值的。以方向传感器为例，确定一个方向当然也需要一个三维坐标，毕竟我们的设备不可能永远水平端着吧，准确的说android给我们返回的方向值就是一个长度为3的float数组，包含三个方向的值。下面看一下官方提供的传感器API使用的坐标系统示意图：

仔细看一下这张图，不难发现，z是指向地心的方位角，x轴是仰俯角（由静止状态开始前后反转），y轴是翻转角（由静止状态开始左右反转）。下面切入正题，看看如何通过方向传感器API去获取方向。结合上面的图再看看官方提供的方向传感器事件的返回值：

这样就和上面提到的相吻合了，确实是通过一个长度为3的float数组去表示一个位置信息的，并且数组的第一个元素表示方位角（z轴），数组的第二个元素表示仰俯角（x轴），而数组的第三个元素表示翻转角（y轴），最后看看代码怎么写。

依旧参考官方文档Using the Orientation Sensor部分内容，首先是实例化一个方向传感器：

?

1

mOrientation = mSensorManager.getDefaultSensor(Sensor.TYPE_ORIENTATION);

虽然这样做没错，但是如果你在IDE中写了这样一行代码的话，不难发现它已经过期了，但是没关系，我们先用这个看看，后面再介绍代替它的方法。

下面是创建一个自定义传感器事件监听接口：

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

classMySensorEventListener implementsSensorEventListener {

 

    @Override

    publicvoid onSensorChanged(SensorEvent event) {

        // TODO Auto-generated method stub

        floata = event.values[0];

        azimuthAngle.setText(a + "");

        floatb = event.values[1];

        pitchAngle.setText(b + "");

        floatc = event.values[2];

        rollAngle.setText(c + "");

    }

 

    @Override

    publicvoid onAccuracyChanged(Sensor sensor, intaccuracy) {

        // TODO Auto-generated method stub

 

    }

 

}

最后通过SensorManager为Sensor注册监听即可：

?

1

2

mSensorManager.registerListener(newMySensorEventListener(),

                mOrientation, SensorManager.SENSOR_DELAY_NORMAL);

当设备位置发生变化时触发监听，界面上的值改变，由于模拟器无法演示传感器效果，真机也没有root没法用屏幕投影啥的，所以就贴一张截图象征性看一下，这几个值无时无刻都在变化：

由于我在截图的时候手机是水平端平的，所以后两个值都接近于0，而第一个方位角就代表当前的方向了，好了，现在功能基本算实现了，那么现在就解决一下Sensor类的常量过期的问题。不难发现，在IDE中这行代码是这样的：

mOrientation = mSensorManager.getDefaultSensor(Sensor.TYPE_ORIENTATION);

既然过期了必定有新的东西去替代它，我们打开源代码可以看到这样的注释：

显而易见，官方推荐我们用SensorManager.getOrientation()这个方法去替代原来的TYPE_ORITNTATION。那我们继续在源码中看看这个方法：

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

publicstatic float[] getOrientation(float[] R, floatvalues[]) {

    /*

     * 4x4 (length=16) case:

     *   /  R[ 0]   R[ 1]   R[ 2]   0  \

     *   |  R[ 4]   R[ 5]   R[ 6]   0  |

     *   |  R[ 8]   R[ 9]   R[10]   0  |

     *   \      0       0       0   1  /

     *

     * 3x3 (length=9) case:

     *   /  R[ 0]   R[ 1]   R[ 2]  \

     *   |  R[ 3]   R[ 4]   R[ 5]  |

     *   \  R[ 6]   R[ 7]   R[ 8]  /

     *

     */

    if(R.length == 9) {

        values[0] = (float)Math.atan2(R[1], R[4]);

        values[1] = (float)Math.asin(-R[7]);

        values[2] = (float)Math.atan2(-R[6], R[8]);

    }else{

        values[0] = (float)Math.atan2(R[1], R[5]);

        values[1] = (float)Math.asin(-R[9]);

        values[2] = (float)Math.atan2(-R[8], R[10]);

    }

    returnvalues;

}

再看一下这个方法的注释中的一句话：

第一行讲了这个方法的作用，计算设备的方向基于旋转矩阵，这个旋转矩阵我们当成一种计算方向的算法就OK了，不必深究，下面再看我标出来的这句话，很明显说明了我们通常不需要这个方法的返回值，这个方法会根据参数R[ ]的数据填充values[ ]而后者就是我们想要的。既然不需要返回值，那么就是参数的问题了，这两个参数：float[ ] R 和 float[ ] values该怎么获取呢？继续看注释，首先是第一个参数R：

既然这个方法是基于旋转矩阵去计算方向，那么第一个参数R自然就表示一个旋转矩阵了，实际上它是用来保存磁场和加速度的数据的，根据注释我们可以发现让我们通过getRotationMatrix这个方法来填充这个参数R[ ]，那我们就再去看看这个方法源码，依旧是SensorManager的一个静态方法：

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

publicstatic boolean getRotationMatrix(float[] R, float[] I,

        float[] gravity, float[] geomagnetic) {

    // TODO: move this to native code for efficiency

    floatAx = gravity[0];

    floatAy = gravity[1];

    floatAz = gravity[2];

    finalfloat Ex = geomagnetic[0];

    finalfloat Ey = geomagnetic[1];

    finalfloat Ez = geomagnetic[2];

    floatHx = Ey*Az - Ez*Ay;

    floatHy = Ez*Ax - Ex*Az;

    floatHz = Ex*Ay - Ey*Ax;

    finalfloat normH = (float)Math.sqrt(Hx*Hx + Hy*Hy + Hz*Hz);

    if(normH < 0.1f) {

        // device is close to free fall (or in space?), or close to

        // magnetic north pole. Typical values are  > 100.

        returnfalse;

    }

    finalfloat invH = 1.0f / normH;

    Hx *= invH;

    Hy *= invH;

    Hz *= invH;

    finalfloat invA = 1.0f / (float)Math.sqrt(Ax*Ax + Ay*Ay + Az*Az);

    Ax *= invA;

    Ay *= invA;

    Az *= invA;

    finalfloat Mx = Ay*Hz - Az*Hy;

    finalfloat My = Az*Hx - Ax*Hz;

    finalfloat Mz = Ax*Hy - Ay*Hx;

    if(R != null) {

        if(R.length == 9) {

            R[0] = Hx;     R[1] = Hy;     R[2] = Hz;

            R[3] = Mx;     R[4] = My;     R[5] = Mz;

            R[6] = Ax;     R[7] = Ay;     R[8] = Az;

        }elseif (R.length == 16) {

            R[0]  = Hx;    R[1]  = Hy;    R[2]  = Hz;   R[3]  = 0;

            R[4]  = Mx;    R[5]  = My;    R[6]  = Mz;   R[7]  = 0;

            R[8]  = Ax;    R[9]  = Ay;    R[10] = Az;   R[11] = 0;

            R[12] = 0;     R[13] = 0;     R[14] = 0;    R[15] = 1;

        }

    }

    if(I != null) {

        // compute the inclination matrix by projecting the geomagnetic

        // vector onto the Z (gravity) and X (horizontal component

        // of geomagnetic vector) axes.

        finalfloat invE = 1.0f / (float)Math.sqrt(Ex*Ex + Ey*Ey + Ez*Ez);

        finalfloat c = (Ex*Mx + Ey*My + Ez*Mz) * invE;

        finalfloat s = (Ex*Ax + Ey*Ay + Ez*Az) * invE;

        if(I.length == 9) {

            I[0] = 1;     I[1] = 0;     I[2] = 0;

            I[3] = 0;     I[4] = c;     I[5] = s;

            I[6] = 0;     I[7] =-s;     I[8] = c;

        }elseif (I.length == 16) {

            I[0] = 1;     I[1] = 0;     I[2] = 0;

            I[4] = 0;     I[5] = c;     I[6] = s;

            I[8] = 0;     I[9] =-s;     I[10]= c;

            I[3] = I[7] = I[11] = I[12] = I[13] = I[14] = 0;

            I[15] = 1;

        }

    }

    returntrue;

}

依旧是4个参数，请观察30~41行之间的代码，不难发现这个旋转矩阵无非就是一个3*3或4*4的数组，再观察一下if语句块中的代码，不难发现给数组元素依次赋值，而这些值是从哪里来的呢？我们29行倒着看，直到第4行，不难发现其实最后的数据源是通过这个方法的后两个参数提供的，即：float[] gravity, float[] geomagnetic，老规矩，看看这两个参数的注释：

到这里应该就清晰了吧，分别是从加速度传感器和地磁场传感器获取的值，那么很明显，应当在监听中的回调方法onSensorChanged中去获取数据，同时也验证了上面的判断方向需要两个传感器的说法，分别是：加速度传感器（Sensor.TYPE_ACCELEROMETER）和地磁场传感器（TYPE_MAGNETIC_FIELD）。

说完了getRotationMatrix方法的后两个参数，那么前两个参数R和I又该如何定义呢？其实很简单，第一个参数R就是getOrientation()方法中需要填充的那个数组，大小是9。而第二个参数I是用于将磁场数据转换进实际的重力坐标系中的，一般默认设置为NULL即可。到这里关于方向传感器基本就已经介绍完毕，最后看一个完整的例子：

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

packagecom.example.sensordemo;

 

importandroid.app.Activity;

importandroid.content.Context;

importandroid.hardware.Sensor;

importandroid.hardware.SensorEvent;

importandroid.hardware.SensorEventListener;

importandroid.hardware.SensorManager;

importandroid.os.Bundle;

importandroid.util.Log;

importandroid.widget.TextView;

 

publicclass MainActivity extendsActivity {

 

    privateSensorManager mSensorManager;

 

    privateSensor accelerometer; // 加速度传感器

    privateSensor magnetic; // 地磁场传感器

 

    privateTextView azimuthAngle;

 

    privatefloat[] accelerometerValues = newfloat[3];

    privatefloat[] magneticFieldValues = newfloat[3];

 

    privatestatic final String TAG = "---MainActivity";

 

    @Override

    protectedvoid onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        setContentView(R.layout.activity_main);

        // 实例化传感器管理者

        mSensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);

        // 初始化加速度传感器

        accelerometer = mSensorManager

                .getDefaultSensor(Sensor.TYPE_ACCELEROMETER);

        // 初始化地磁场传感器

        magnetic = mSensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD);

 

        azimuthAngle = (TextView) findViewById(R.id.azimuth_angle_value);

        calculateOrientation();

    }

 

    @Override

    protectedvoid onResume() {

        // TODO Auto-generated method stub

        // 注册监听

        mSensorManager.registerListener(newMySensorEventListener(),

                accelerometer, Sensor.TYPE_ACCELEROMETER);

        mSensorManager.registerListener(newMySensorEventListener(), magnetic,

                Sensor.TYPE_MAGNETIC_FIELD);

        super.onResume();

    }

 

    @Override

    protectedvoid onPause() {

        // TODO Auto-generated method stub

        // 解除注册

        mSensorManager.unregisterListener(newMySensorEventListener());

        super.onPause();

    }

 

    // 计算方向

    privatevoid calculateOrientation() {

        float[] values = newfloat[3];

        float[] R = newfloat[9];

        SensorManager.getRotationMatrix(R,null, accelerometerValues,

                magneticFieldValues);

        SensorManager.getOrientation(R, values);

        values[0] = (float) Math.toDegrees(values[0]);

 

        Log.i(TAG, values[0] + "");

        if(values[0] >= -5&& values[0] < 5) {

            azimuthAngle.setText("正北");

        }elseif (values[0] >= 5&& values[0] < 85) {

            // Log.i(TAG, "东北");

            azimuthAngle.setText("东北");

        }elseif (values[0] >= 85&& values[0] <= 95) {

            // Log.i(TAG, "正东");

            azimuthAngle.setText("正东");

        }elseif (values[0] >= 95&& values[0] < 175) {

            // Log.i(TAG, "东南");

            azimuthAngle.setText("东南");

        }elseif ((values[0] >= 175&& values[0] <= 180)

                || (values[0]) >= -180&& values[0] < -175) {

            // Log.i(TAG, "正南");

            azimuthAngle.setText("正南");

        }elseif (values[0] >= -175&& values[0] < -95) {

            // Log.i(TAG, "西南");

            azimuthAngle.setText("西南");

        }elseif (values[0] >= -95&& values[0] < -85) {

            // Log.i(TAG, "正西");

            azimuthAngle.setText("正西");

        }elseif (values[0] >= -85&& values[0] < -5) {

            // Log.i(TAG, "西北");

            azimuthAngle.setText("西北");

        }

    }

 

    classMySensorEventListener implementsSensorEventListener {

        @Override

        publicvoid onSensorChanged(SensorEvent event) {

            // TODO Auto-generated method stub

            if(event.sensor.getType() == Sensor.TYPE_ACCELEROMETER) {

                accelerometerValues = event.values;

            }

            if(event.sensor.getType() == Sensor.TYPE_MAGNETIC_FIELD) {

                magneticFieldValues = event.values;

            }

            calculateOrientation();

        }

 

        @Override

        publicvoid onAccuracyChanged(Sensor sensor, intaccuracy) {

            // TODO Auto-generated method stub

 

        }

 

    }

 

}

四、总结

第一次研究Android传感器感觉还是挺难的，继续努力吧，要学的东西还有很多，先去给Map项目集成指南针啦~