深入浅出 - Android系统移植与平台开发（十三） - Sensor HAL框架分析之三
作者：唐老师,华清远见嵌入式学院讲师。
让我们来看看SensorManager的代码
SensorManager框架层代码
@frameworks/base/core/java/android/hardware/SensorManager.java
[java] view plaincopyprint?
1. public SensorManager(Looper mainLooper) {
2. mMainLooper = mainLooper; // 上面说了，这是Activity的Looper
3.
4. synchronized(sListeners) {
5. if(!sSensorModuleInitialized) {
6. sSensorModuleInitialized = true;
7. nativeClassInit(); // 好像是调用本地方法初始化
8. sWindowManager = IWindowManager.Stub.asInterface(
9. ServiceManager.getService("window")); // 获得Windows服务，不管它
10. if (sWindowManager != null) {
11. // if it's null we're running in the system process
12. // which won't get the rotated values
13. try {
14. sRotation = sWindowManager.watchRotation(
15. newIRotationWatcher.Stub() {
16. public voidonRotationChanged(int rotation) {
17. SensorManager.this.onRotationChanged(rotation);
18. }
19. }
20. );
21. } catch (RemoteException e) {
22. }
23. }
24.
25. // initialize the sensor list
26. sensors_module_init(); // 初始化sensor module
27. final ArrayList fullList = sFullSensorsList; // SensorManager维护的Sensor列表
28. int i = 0;
29. do {
30. Sensor sensor = new Sensor(); // 创建sensor对象，这个是传递给App的哦
31. //调用module的方法，获得每一个sensor设备
32. i = sensors_module_get_next_sensor(sensor, i);
33. if (i>=0) {
34. //Log.d(TAG, "found sensor: " + sensor.getName() +
35. // ", handle=" +sensor.getHandle());
36. sensor.setLegacyType(getLegacySensorType(sensor.getType()));
37. fullList.add(sensor); // 添加到SM维护的Sensor列表（嘿嘿）
38. sHandleToSensor.append(sensor.getHandle(), sensor);
39. }
40. }while (i>0);
41.
42. sPool= new SensorEventPool( sFullSensorsList.size()*2 );
43. sSensorThread = new SensorThread(); // 哟，创建线程了好像
44. }
45. }
46. }
很明显nativeClassInit()，sensors_module_init()，sensors_module_get_next_sensor()都是本地实现的方法。
[java] view plaincopyprint?
1. private static native void nativeClassInit();
2. private static native int sensors_module_init();
3. private static native intsensors_module_get_next_sensor(Sensor sensor, int next);
根据之前看代码的经验可知，很可能在frameworks/base/core/对应一个jni目录下的存在其对应的本地代码：
[java] view plaincopyprint?
1. frameworks/base/core/java/android/hardware/SensorManager.java
2. frameworks/base/core/jni/android_hardware_SensorManager.cpp
果不其然，在jni存在其本地代码，让我们来看下nativeClassInit函数：
@frameworks/base/core/jni/android_hardware_SensorManager.cpp
[cpp] view plaincopyprint?
1. static void
2. nativeClassInit (JNIEnv *_env, jclass _this)
3. {
4. jclasssensorClass = _env->FindClass("android/hardware/Sensor");
5. SensorOffsets& sensorOffsets = gSensorOffsets;
6. sensorOffsets.name =_env->GetFieldID(sensorClass, "mName", "Ljava/lang/String;");
7. sensorOffsets.vendor =_env->GetFieldID(sensorClass, "mVendor", "Ljava/lang/String;");
8. sensorOffsets.version =_env->GetFieldID(sensorClass, "mVersion", "I");
9. sensorOffsets.handle =_env->GetFieldID(sensorClass, "mHandle", "I");
10. sensorOffsets.type = _env->GetFieldID(sensorClass,"mType", "I");
11. sensorOffsets.range =_env->GetFieldID(sensorClass, "mMaxRange", "F");
12. sensorOffsets.resolution =_env->GetFieldID(sensorClass, "mResolution","F");
13. sensorOffsets.power =_env->GetFieldID(sensorClass, "mPower", "F");
14. sensorOffsets.minDelay =_env->GetFieldID(sensorClass, "mMinDelay", "I");
15. }
其代码比较简单，将Java框架层的Sensor类中的成员保存在本地代码中的gSensorOffsets 结构体中将来使用。
sensors_module_init()本地方法的实现：
[cpp] view plaincopyprint?
1. static jint
2. sensors_module_ini(JNIEnv *env, jclass clazz)
3. {
4. SensorManager::getInstance();
5. return 0;
6. }
在本地代码中调用了SensorManager的getInstance方法，这又是一个典型的单例模式获得类的对象，注意这儿的SensorManager是本地的类，而不是Java层的SensorManager类。
本地SensorManager的定义
@frameworks/base/include/gui/SensorManager.h
[cpp] view plaincopyprint?
1. class SensorManager :
2. publicASensorManager,
3. publicSingleton<SensorManager>
4. {
5. public:
6. SensorManager();
7. ~SensorManager();
8.
9. ssize_tgetSensorList(Sensor const* const** list) const;
10.
11. Sensor const*getDefaultSensor(int type);
12. sp<SensorEventQueue> createEventQueue();
13. private:
14. //DeathRecipient interface
15. voidsensorManagerDied();
16. status_tassertStateLocked() const;
17. private:
18. mutable MutexmLock;
19. mutablesp<ISensorServer> mSensorServer;
20. mutableSensor const** mSensorList;
21. mutableVector<Sensor> mSensors;
22. mutablesp<IBinder::DeathRecipient> mDeathObserver;
23. };
注意SensorManager又继承了ASensorManager和泛型类Singleton<SensorManager>，而SensorManager类定义里没有getInstance所以其定义肯定是在ASensorManager或Singleton中。
@frameworks/base/include/utils/Singleton.h
[cpp] view plaincopyprint?
1. template <typename TYPE>
2. class ANDROID_API Singleton
3. {
4. public:
5.
6. staticTYPE& getInstance() {
7. Mutex::Autolock _l(sLock);
8. TYPE*instance = sInstance;
9. if(instance == 0) {
10. instance = new TYPE();
11. sInstance = instance;
12. }
13.
14. return*instance;
15. }
16.
17. static boolhasInstance() {
18. Mutex::Autolock _l(sLock);
19. returnsInstance != 0;
20. }
21.
22. protected:
23. ~Singleton(){ };
24. Singleton() {};
25.
26. private:
27. Singleton(const Singleton&);
28. Singleton& operator = (const Singleton&);
29. static MutexsLock;
30. static TYPE*sInstance;
31. };
32. //---------------------------------------------------------------------------
33. }; // namespace android
第一次调用getInstance方法时，创建泛型对象即：SensorManager，随后再调用该方法时返回第一次创建的泛型对象。
1)本地SensorManager的创建
本地SensorManager是一个单例模式，其构造方法相对比较简单，它的主要工作交给了assertStateLocked方法：
@frameworks/base/libs/gui/SensorManager.cpp
[cpp] view plaincopyprint?
1. SensorManager::SensorManager()
2. :mSensorList(0)
3. {
4. // okay we'renot locked here, but it's not needed during construction
5. assertStateLocked();
6. }
7.
8. status_t SensorManager::assertStateLocked() const {
9. if(mSensorServer == NULL) {
10. // try for one second
11. constString16 name("sensorservice");
12. for (inti=0 ; i<4 ; i++) {
13. status_t err = getService(name,&mSensorServer);
14. if(err == NAME_NOT_FOUND) {
15. usleep(250000);
16. continue;
17. }
18.
19. if(err != NO_ERROR) {
20. return err;
21. }
22. break;
23. }
24.
25. classDeathObserver : public IBinder::DeathRecipient {
26. SensorManager& mSensorManger;
27. virtual void binderDied(const wp<IBinder>& who) {
28. LOGW("sensorservice died [%p]", who.unsafe_get());
29. mSensorManger.sensorManagerDied();
30. }
31. public:
32. DeathObserver(SensorManager& mgr) : mSensorManger(mgr) { }
33. };
34.
35. mDeathObserver = new DeathObserver(*const_cast<SensorManager*>(this));
36. mSensorServer->asBinder()->linkToDeath(mDeathObserver);
37.
38. mSensors= mSensorServer->getSensorList();
39. size_tcount = mSensors.size();
40. mSensorList = (Sensor const**)malloc(count * sizeof(Sensor*));
41. for(size_t i=0 ; i<count ; i++) {
42. mSensorList[i] = mSensors.array() + i;
43. }
44. }
45.
46. returnNO_ERROR;
47. }
在assertStateLocked方法里，先通过getService获得SensorService对象，然后注册了对SensorService的死亡监听器，SensorManager与SensorService不求同年同月同日，只求同年同月同日死。拜完了兄弟之后，调用getSensorList得到所有传感器的对象，存放到mSensorList中，保存在本地空间里。
2) 本地SensorManager中列表的获取
在上面函数调用中首先调用getService来获得SensorService服务，然后执行mSensorServer->getSensorList来获得服务提供的传感器列表：
[cpp] view plaincopyprint?
1. Vector SensorService::getSensorList()
2. {
3. return mUserSensorList;
4. }
大家要注意啊，上面的getSensorList函数只是返回了mUserSensorList，而这个变量是在什么时候初始化的呢？
根据2.1节可知，SensorService在本地被初始化时，构造函数里并没有对mUserSensorList进行初始化，而SensorService里有一个onFirstRef方法，这个方法当SensorService第一次被强引用时被自动调用。那SensorService第一次被强引用是在什么时候呢？
在SensorManager::assertStateLocked方法里调用getService获得SensorService保存到mSensorServer成员变量中。
mSensorServer的定义在frameworks/base/include/gui/SensorManager.h中：
[cpp] view plaincopyprint?
1. class SensorManager :
2. public ASensorManager,
3. public Singleton<SensorManager>
4. {
5. mutable sp<ISensorServer>mSensorServer;
6. mutable Sensorconst** mSensorList;
7. mutable Vector<Sensor> mSensors;
8. };
可以看出mSensroServer为强引用类型。所以在创建本地中的SensorManager类对象时，自动强引用SensorService，自动调用onFirstRef方法：
@frameworks/base/services/sensorservice/SensorService.cpp的onFirstRef简化方法如下：
[cpp] view plaincopyprint?
1. void SensorService::onFirstRef()
2. {
3. LOGD("nuSensorService starting...");
4. SensorDevice& dev(SensorDevice::getInstance()); //创建SensorDevice对象dev
5.
6.
7. if(dev.initCheck() == NO_ERROR) {
8. sensor_tconst* list;
9. ssize_tcount = dev.getSensorList(&list); //获得传感器设备列表
10. if (count> 0) {
11. …
12. for(ssize_t i=0 ; i<count ; i++) {
13. registerSensor( new HardwareSensor(list[i]) ); // 注册在本地获得的传感器
14. …
15. }
16. constSensorFusion& fusion(SensorFusion::getInstance());
17.
18. if(hasGyro) { // 如果有陀螺仪设备，则先注册和陀螺仪有关的虚拟传感器设备
19. registerVirtualSensor( newRotationVectorSensor() ); // 虚拟旋转传感器
20. registerVirtualSensor( new GravitySensor(list, count) ); // 虚拟重力传感器
21. registerVirtualSensor( new LinearAccelerationSensor(list, count) ); // 虚拟加速器
22.
23. // these are optional
24. registerVirtualSensor( new OrientationSensor() ); // 虚拟方向传感器
25. registerVirtualSensor( new CorrectedGyroSensor(list, count) ); // 真正陀螺仪
26.
27. // virtual debugging sensors...
28. char value[PROPERTY_VALUE_MAX];
29. property_get("debug.sensors", value, "0");
30. if (atoi(value)) {
31. registerVirtualSensor( new GyroDriftSensor() ); // 虚拟陀螺测漂传感器
32. }
33. }
34.
35. // build the sensor list returned tousers
36. mUserSensorList = mSensorList;
37. if(hasGyro &&
38. (virtualSensorsNeeds & (1<<SENSOR_TYPE_ROTATION_VECTOR))) {
39. // if we have the fancy sensor fusion, and it's not provided by the
40. // HAL, use our own (fused) orientation sensor by removing the
41. // HAL supplied one form the user list.
42. if (orientationIndex >= 0) {
43. mUserSensorList.removeItemsAt(orientationIndex);
44. }
45. }
46.
47. run("SensorService",PRIORITY_URGENT_DISPLAY);
48. mInitCheck = NO_ERROR;
49. }
50. }
51. }
上面代码首先通过SensorDevice::getInstance()创建对象dev，调用dev.getSensorList(&list)获得传感器列表，将取出的sensor_t类型list传感器列表，塑造了HardwareSensor对象，传递给了registerSensor方法，通过registerSensor注册传感器，然后通过单例模型创建了SensorFusion对象，创建并注册了一系列的虚拟传感器，疑惑，极大的疑惑，怎么传感器还有虚拟的？？其实你注意看这几个传感器最前面的条件，if(hasGyro)，表示如果存在陀螺仪的话，会创建这些虚拟设备，再看这些虚拟设备：旋转，重力，加速器，方向等，这些设备都对应一个物理硬件：陀螺仪，所以这些逻辑上存在，物理上不存在的设备叫虚拟设备。在初始化了虚拟设备后，将mSensorList传感器列表赋值给mUserSensorList，mSensorList是由registerSensor初始化的，mUserSensorList是要提交给Java框架层的传感器列表，最后通过run方法运行了SensorService线程，我们先来看下registerSensor的代码：
[cpp] view plaincopyprint?
1. void SensorService::registerSensor(SensorInterface* s)
2. {
3. sensors_event_t event;
4. memset(&event,0, sizeof(event));
5.
6. const Sensorsensor(s->getSensor());
7. // add to thesensor list (returned to clients)
8. mSensorList.add(sensor);
9. // add to ourhandle->SensorInterface mapping
10. mSensorMap.add(sensor.getHandle(), s);
11. // create anentry in the mLastEventSeen array
12. mLastEventSeen.add(sensor.getHandle(), event);
13. }
通过分析上面代码可知，将传入的HardwareSensor对象塑造了Sensor，添加到mSensorList向量表里，然后将HardwareSensor对象添加到mSensroMap键值对里，将新建的传感器事件数据封装对象event添加到mLastEventSeen键值对中。我们通过下面的时序图来看下Sensor列表的获取过程。
1) SensorService监听线程及传感器事件的捕获
让我们再来看看SensorService线程，还记得前面SensorService的父类中有一个Thread类，当调用run方法时会创建线程并调用threadLoop方法。
[cpp] view plaincopyprint?
1. bool SensorService::threadLoop()
2. {
3. LOGD("nuSensorService thread starting...");
4.
5. const size_tnumEventMax = 16 * (1 + mVirtualSensorList.size());
6. sensors_event_t buffer[numEventMax];
7. sensors_event_t scratch[numEventMax];
8. SensorDevice& device(SensorDevice::getInstance());
9. const size_tvcount = mVirtualSensorList.size();
10.
11. ssize_tcount;
12. do {
13. // 调用SensorDevice的poll方法看样子要多路监听了
14. count = device.poll(buffer,numEventMax);
15. if(count<0) {
16. LOGE("sensor poll failed (%s)", strerror(-count));
17. break;
18. }
19. // 记录poll返回的每一个传感器中的最后一个数据信息到mLastEventSeen中
20. recordLastValue(buffer, count);
21.
22. // handlevirtual sensors 处理虚拟传感器数据
23. if (count&& vcount) {
24. sensors_event_t const * const event = buffer;
25. // 获得虚拟传感器列表
26. constDefaultKeyedVector<int, SensorInterface*> virtualSensors(
27. getActiveVirtualSensors());
28. constsize_t activeVirtualSensorCount = virtualSensors.size(); // 虚拟传感器个数
29. if(activeVirtualSensorCount) {
30. size_t k = 0;
31. SensorFusion& fusion(SensorFusion::getInstance());
32. if (fusion.isEnabled()) {
33. for (size_t i=0 ; i<size_t(count) ; i++) {
34. fusion.process(event[i]); //处理虚拟传感器设备事件
35. }
36. }
37. for (size_t i=0 ; i<size_t(count) ; i++) {
38. for (size_t j=0 ; j<activeVirtualSensorCount ; j++) {
39. sensors_event_t out;
40. if (virtualSensors.valueAt(j)->process(&out, event[i])) {
41. buffer[count + k] =out;
42. k++;
43. }
44. }
45. }
46. if (k) {
47. // record the last synthesized values
48. recordLastValue(&buffer[count], k);
49. count += k;
50. // sort the buffer by time-stamps
51. sortEventBuffer(buffer, count);
52. }
53. }
54. }
55.
56. // sendour events to clients...
57. // 获得传感器连接对象列表
58. constSortedVector< wp<SensorEventConnection> > activeConnections(
59. getActiveConnections());
60. size_tnumConnections = activeConnections.size();
61. for(size_t i=0 ; i<numConnections ; i++) {
62. sp<SensorEventConnection> connection(
63. activeConnections[i].promote());
64. if(connection != 0) {
65. // 向指定的传感器连接客户端发送传感器数据信息
66. connection->sendEvents(buffer, count, scratch);
67. }
68. }
69. } while (count>= 0 || Thread::exitPending()); // 传感器循环监听线程
70.
71. LOGW("Exiting SensorService::threadLoop => aborting...");
72. abort();
73. return false;
74. }
我们看到device.poll方法，阻塞在了SensorDevice的poll方法上，它肯定就是读取Sensor硬件上的数据了，将传感器数据保存在buff中，然后调用recordLastValue方法，只保存同一类型传感器的最新数据（最后采集的一组数据）到键值对象mLastEventSeen里对应传感器的值域中。如果传感器设备是虚拟设备则调用SensorFusion.Process（）方法对虚拟设备数据进行处理。SensorFusion关联一个SensorDevice，它是虚拟传感器设备的一个加工类，负责虚拟传感器数据的计算、处理、设备激活、设置延迟、获得功耗信息等操作。让我们来回顾下整个过程吧。
1. SensorManager对象创建并调用assertStateLocked方法
2. 在assertStateLocked方法中调用getService，获得SensorService服务
3. 当SensorService第一次强引用时，自动调用OnFirstRef方法
4．获得SensorDevice单例对象
6. 调用SensorDevice.getSensorList方法sensor_t列表保存在SensorService中
8. 调用registerSensor注册传感器，添加到mSensorList列表中
9. 启动SensorService线程，准备监听所有注册的传感器设备
12. 多路监听注册的传感器设备，当有传感器事件时，返回sensor_event_t封装的事件信息
16. 记录产生传感器事件的设备信息
17. 调用getActiveConnections获得所有的活动的客户端SensorEventConnection类对象
19.向客户端发送传感器事件信息
文章来源：华清远见嵌入式学院，原文地址：http://www.embedu.org/Column/Column794.htm
更多相关嵌入式免费资料查看华清远见讲师博文>>