鉴客从Android源码中学习传感器

SensorActivity.java

在应用程序中使用传感器需要用到hardware包中的SensorManager、SensorListener等相关的类，具体的实现代码如下：

01public class SensorActivity extends Activity {
02 
03    private static final String TAG="SensorActivity";
04    SensorManager mySM;
05 
06    SensorListener mySL=new SensorListener(){
07       public void onAccuracyChanged(int sensor, int accuracy) {
08 
09       }
10 
11  
12       public void onSensorChanged(int sensor, float[] values) {
13           switch(sensor) {
14           case SensorManager.SENSOR_ACCELEROMETER:
15              Log.i(TAG,"Accelerometer: "
16                     + values[0] + ", "
17                     + values[1] + ", "
18                     + values[2]);
19              break;
20           }                   
21       }
22    };
23 
24    
25    public void onCreate(Bundle savedInstanceState) {
26        super.onCreate(savedInstanceState);
27        setContentView(R.layout.main);
28        mySM=(SensorManager)getSystemService(SENSOR_SERVICE);
29    }
30 
31    
32    protected void onPause() {
33       mySM.unregisterListener(mySL);
34       super.onPause();
35    }
36 
37    
38    protected void onResume() {
39       mySM.registerListener(mySL,SensorManager.SENSOR_ACCELEROMETER,
40              SensorManager.SENSOR_DELAY_UI);
41       super.onResume();
42    }
43}

这段代码特别简单，利用了大家熟悉的观察者模式对传感器数据进行监听处理，接下来，我们就分析这段代码背后的机制，看看Android为我们做了什么，才把貌似复杂的传感器处理简化到了这样几行代码就可以实现的程度。

SensorManager.java

对应用程序来说，最重要的就是把SensorListener注册到SensorManager上，从而才能以观察者身份接收到数据的变化，因此，我们把目光落在SensorManager的构造函数、RegisterListener函数和通知机制相关的代码上。

先来看构造函数的代码：

01public SensorManager(Looper mainLooper) {
02 
03    mSensorService = ISensorService.Stub.asInterface(
04            ServiceManager.getService(Context.SENSOR_SERVICE));
05 
06               ……
07 
08    // initialize the sensor list
09    sensors_module_init();
10    final ArrayList<Sensor> fullList = sFullSensorsList;
11    int i = 0;
12 
13    do {
14 
15          Sensor sensor = new Sensor();
16          i = sensors_module_get_next_sensor(sensor, i);
17 
18          if (i>=0) {
19               sensor.setLegacyType(getLegacySensorType(sensor.getType()));
20               fullList.add(sensor);
21               sHandleToSensor.append(sensor.getHandle(), sensor);
22          }
23     } while (i>0);
24                ……
25     sSensorThread = new SensorThread();
26 
27}

在这段代码中我们关注三件事，一是利用ISensorService接口获取了对SensorService的引用；二是利用sensors_module_init()等函数完成了传感器列表的初始化；三是创建了一个SensorThread线程对象。

在此处，并没有启动SensorThread线程，也没有看到明显的操作传感器的动作，接下来，再分析一下registerListener()函数的代码：

01    public boolean registerListener(SensorEventListener listener, Sensor sensor, int rate,
02 
03            Handler handler) {
04                            ……
05            l = new ListenerDelegate(listener, sensor, handler);
06 
07            sListeners.add(l);
08            if (!sListeners.isEmpty()) {
09 
10                 result = sSensorThread.startLocked(mSensorService);
11                 if (result) {
12                      result = mSensorService.enableSensor(l, name, handle, delay);
13 
14                 }
15            }
16 
17……
18    }

在这段代码中值得注意的是SensorThread线程被启动，通过SensorService的EnableSensor方法传感器将被打开进入工作状态。

再来看一下SensorThread的代码，在它的构造函数中调用了sensors_data_init()函数，在startLocked()函数中启动了线程，在线程run()函数中调用了sensors_data_open()函数，然后

01while (true) {
02 
03    // wait for an event
04    final int sensor = sensors_data_poll(values, status, timestamp);
05 
06    final Sensor sensorObject = sHandleToSensor.get(sensor);
07 
08    if (sensorObject != null) {
09 
10        // report the sensor event to all listeners that
11        // care about it.
12        final int size = sListeners.size();
13 
14        for (int i=0 ; i<size ; i++) {
15 
16            ListenerDelegate listener = sListeners.get(i);
17            if (listener.hasSensor(sensorObject)) {
18 
19                 // this is asynchronous (okay to call
20                 // with sListeners lock held).
21                 listener.onSensorChangedLocked(sensorObject,
22 
23                                            values, timestamp, accuracy);
24            }
25         }
26     }
27}

即通过sensors_data_poll()函数等待硬件传感器的事件，调用listener.onSensorChangedLocked()函数，在该函数中调用了SensorListener中的onSensorChanged()，即调到了应用程序的观察者接口。

至此，SensorManager中的主要逻辑已经理清了，还有两个部分，一是SensorService的逻辑还没有涉及；二是sensors_data_init()相关的一组函数做了什么还没涉及。先来看一下SensorService的相关部分。

SensorService.java

SensorService代码中可以看到，主要做的就是对传感器的控制，包括初始化、开、关、激活、设置延迟参数、睡眠几个动作，用的函数是一组类似_sensors_control_init()的函数，比如前文提到的enableSensor()的代码是：

1if (_sensors_control_activate(sensor, true) == false) {
2     Slog.w(TAG, "could not enable sensor " + sensor);
3     return false;
4}

在JAVA的代码里面，对于前文提到的两组函数sensor_data_XXX()和_sensor_control_XXX()都是采用native的方式进行的JNI调用，接下来就透过JNI，来看相关的CPP代码。

Sensors.h

在看CPP代码前，先来看一下Sensors.h文件，这个文件将被CPP包含，从文件里的信息来看，这个是HAL（硬件抽象层）的接口文件，里面提供了device的结构体封装及一些设备驱动应用提供的操作函数，注意这些函数将被传感器的驱动程序实现，在此不并心驱动的实现，只要知道驱动能提供这些函数供上层程序调用就可以了，这也就是HAL的作用，对不同的设备向上层提供统一的调用接口。

SensorManager.cpp

这个文件提供了对传感器数据部分的操作，实现了前文提到的一组sensor_data_XXX()函数，如果对驱动有点熟悉的话，可以看到

01static jint
02sensors_module_init(JNIEnv *env, jclass clazz)
03{
04 
05    int err = 0;
06 
07    sensors_module_t const* module;
08 
09    err = hw_get_module(SENSORS_HARDWARE_MODULE_ID, (const hw_module_t **)&module);
10 
11    if (err == 0)
12 
13        sSensorModule = (sensors_module_t*)module;
14 
15    return err;
16 
17}

这个函数通过hw_get_module加载了驱动程序。

01static jint
02sensors_data_poll(JNIEnv *env, jclass clazz,
03        jfloatArray values, jintArray status, jlongArray timestamp)
04{
05    sensors_data_t data;
06    int res = sSensorDevice->poll(sSensorDevice, &data);
07 
08    if (res >= 0) {
09        jint accuracy = data.vector.status;
10        env->SetFloatArrayRegion(values, 0, 3, data.vector.v);
11        env->SetIntArrayRegion(status, 0, 1, &accuracy);
12        env->SetLongArrayRegion(timestamp, 0, 1, &data.time);
13    }
14 
15    return res;
16 
17}

这个函数通过sSensorDevice->poll()函数等待设备的数据到来，并将数据通过JNI规则传递到上层的数组中去。

SensorService.cpp

这里的代码与SensorManager.cpp类似，比如：

1static jboolean
2android_activate(JNIEnv *env, jclass clazz, jint sensor, jboolean activate)
3{
4 
5    int active = sSensorDevice->activate(sSensorDevice, sensor, activate);
6 
7    return (active<0) ? false : true;
8 
9}

调用了sSensorDevice->activate()函数使能特定的传感器。其他函数就不一一列举了。

Sensors.c

最后，就是驱动程序了，利用硬件手册，遵循驱动程序的框架，将sensors.h中的结构体的函数指针赋值即可。不是本文的关注点，就不再详细解析了。

总结

1. 通过上述对源码的分析过程，可以对应到Android架构图的各个层次，是一次上下贯通的过程，参照架构图可以看到：

SensorActivity.java对应的是Application层，是应用程序。

SensorManager.java，SensorListener.java对应的是Frameworks层，是Android提供的应用程序开发接口，应用程序框架。与应用程序的调用是通过类实例化或类继承进行的。

SensorManager.cpp，SensorService.cpp对应的是Libraries层，是Android提供的底层库，与Frameworks的调用是通过JNI实现的跨语言调用。

Sensors.h是HAL层，即硬件抽象层，这里提供了Android独立于具体硬件的抽象接口。

Sensors.c是Linux Kernel层，是具体的硬件设备驱动程序。

2. 通过上述分析，可以进一步了解Android系统的Binder接口机制。这里使用了简化的IBinder接口，可能是原设计人员考虑到了这部分相对独立且简单，所以没有使用此前关于IPC机制学习中用到的Proxy模式，而只是用ISensorService.Stub接口直接使用了内核服务，但与前文了解到的IPC机制不冲突。

文章转自：http://blog.csdn.net/caowenbin/article/details/6059876

本站仅提供存储服务，所有内容均由用户发布，如发现有害或侵权内容，请点击举报。