<4>Android4.2 G-Sensor工作流程

转载来自：http://blog.csdn.net/myarrow/article/details/9044689

1. 简介

    在了解Sensor工作流程以前，一直以为其事件是通过Event Hub来进行输送的，可是研究完Android4.0代码之后，才发现自己错了。

    其主要框架如下图所示：

 

2.功能模块

2.1 SensorManager.java

与下层接口功能：
1) 在SensorManager函数中
   (1) 调用native sensors_module_init初始化sensor list，即实例化native中的SensorManager

   (2) 创建SensorThread线程

2) 在类SensorThread中
   (1) 调用native sensors_create_queue创建队列
   (2) 在线程中dead loop地调用native sensors_data_poll以从队列sQueue中获取事件(float[] values = new float[3];)
   (3) 收到事件之后，报告sensor event给所有注册且关心此事件的listener

 

与上层的接口功能：

1) 在onPause时取消listener注册

2) 在onResume时注册listener

3) 把收到的事件报告给注册的listener

2.2 android_hardware_SensorManager.cpp

      实现SensorManager.java中的native函数，它主要调用SenrsorManager.cpp和SensorEventQueue.cpp中的类来完成相关的工作。

2.3 SensorManager.cpp

[cpp]  view plain copy

1. class SensorManager :  
2.     public ASensorManager,  
3.     public Singleton<SensorManager>  
4. {  
5. public:  
6.     SensorManager(); //调用assertStateLocked  
7.     ~SensorManager();  
8.     //调用assertStateLocked,并返回mSensorList  
9.     ssize_t getSensorList(Sensor const* const** list) const;  
10.   
11.     // 返回mSensorList中第一个类型与type一致的sensor      
12.     Sensor const* getDefaultSensor(int type);  
13.   
14.     // 调用mSensorServer->createSensorEventConnection创建一个连接(ISensorEventConnection)  
15.     // 并用此连接做为参数创建一个SensorEventQueue对象并返回  
16.     sp<SensorEventQueue> createEventQueue();  
17.   
18. private:  
19.     // DeathRecipient interface  
20.     void sensorManagerDied();  
21.     // 调用getService获取SensorService客户端并保存在mSensorServer中  
22.     // 调用mSensorServer->getSensorList获取sensor列表，并保存在mSensors和mSensorList中  
23.     status_t assertStateLocked() const;  
24.   
25. private:  
26.     mutable Mutex mLock;  
27.     mutable sp<ISensorServer> mSensorServer; // SensorService客户端  
28.     mutable Sensor const** mSensorList; // sensor列表  
29.     mutable Vector<Sensor> mSensors;    // sensor列表  
30.     mutable sp<IBinder::DeathRecipient> mDeathObserver;  
31. }  

 

[cpp]  view plain copy

1. class ISensorEventConnection : public IInterface  
2. {  
3. public:  
4.     DECLARE_META_INTERFACE(SensorEventConnection);  
5.   
6.     virtual sp<SensorChannel> getSensorChannel() const = 0;  
7.     virtual status_t enableDisable(int handle, bool enabled) = 0;  
8.     virtual status_t setEventRate(int handle, nsecs_t ns) = 0;  
9. };  

2.4 SensorService.cpp

       SensorService作为一个轻量级的system service，它运行于SystemServer内，即在system_init<system_init.cpp>调用SensorService::instantiate();

      SensorService主要功能如下：
          1) SensorService::instantiate创建实例对象，并增加到ServiceManager中，且创建并启动线程，并执行threadLoop
          2) threadLoop从sensor驱动获取原始数据，然后通过SensorEventConnection把事件发送给客户端
          3) BnSensorServer的成员函数负责让客户端获取sensor列表和创建SensorEventConnection

      SensorService与客户端的接口定义如下：

[cpp]  view plain copy

1. class ISensorServer : public IInterface  
2. {  
3. public:  
4.     DECLARE_META_INTERFACE(SensorServer);  
5.   
6.     virtual Vector<Sensor> getSensorList() = 0;  
7.     virtual sp<ISensorEventConnection> createSensorEventConnection() = 0;  
8. };  

    SensorService定义如下：

[cpp]  view plain copy

1. class SensorService :  
2.         public BinderService<SensorService>, //创建SensorService对象，并增加到ServiceManager中  
3.         public BnSensorServer, // 申明了SensorService与客户端(SensorManager)间的binder接口  
4.         protected Thread // 线程辅助类，调用run创建并启动线程，然后在线程主函数内回调threadLoop函数,  
5.                          // 所以在使用它时，做一个派生，并根据需要重写threadLoop即可  
6.                       
7. {  
8.    friend class BinderService<SensorService>;  
9.   
10.    static const nsecs_t MINIMUM_EVENTS_PERIOD =   1000000; // 1000 Hz  
11.   
12.             SensorService();  
13.     virtual ~SensorService();  
14.      
15.     /* 
16.     在addService时，第一次构建sp强引用对象时，会调用onFirstRef函数 
17.      实现功能如下： 
18.      1) 获取SensorDevice实例 
19.      2) 调用SensorDevice.getSensorList获取sensor_t列表 
20.      3) 根据硬件sensor_t创建HardwareSensor,然后加入mSensorList(Sensor) 
21.             和mSensorMap(HardwareSensor)中 
22.      4) 根据硬件sensor_t创建对应的senosr(如GravitySensor), 
23.             然后加入mVirtualSensorList和mSensorList中 
24.      5) mUserSensorList = mSensorList; 
25.      6) run("SensorService", PRIORITY_URGENT_DISPLAY);运行线程，并执行threadLoop 
26.     */  
27.     virtual void onFirstRef();   
28.   
29.     // Thread interface  
30.     /* 
31.       1) 调用SensorDevice.poll获取sensors_event_t事件 
32.       2) 获取已经激活的sensor列表mActiveVirtualSensors 
33.       3) 对每一个事件，执行SensorFusion.process 
34.       4) 对每一个事件，执行HardwareSensor.process(事件无变化,直接copy) 
35.       5) 调用SensorService::SensorEventConnection::sendEvents，把事件发 
36.              送给所有的listener 
37.     */  
38.     virtual bool threadLoop();  
39.   
40.     // ISensorServer interface  
41.     // 返回mUserSensorList  
42.     virtual Vector<Sensor> getSensorList();  
43.       
44.     // 实例化SensorEventConnection并返回  
45.     virtual sp<ISensorEventConnection> createSensorEventConnection();  
46.   
47.     virtual status_t dump(int fd, const Vector<String16>& args);  
48.   
49.     //====================================================================  
50.     //============== SensorEventConnection  start ========================  
51.     class SensorEventConnection : public BnSensorEventConnection {  
52.   
53.         virtual ~SensorEventConnection();  
54.         virtual void onFirstRef();  
55.   
56.     // 返回mChannel  
57.         virtual sp<SensorChannel> getSensorChannel() const;  
58.   
59.     // 调用SensorService::enable或SensorService::disable  
60.         virtual status_t enableDisable(int handle, bool enabled);  
61.   
62.         // 调用SensorService::setEventRate  
63.         virtual status_t setEventRate(int handle, nsecs_t ns);  
64.   
65.         sp<SensorService> const mService; // 保存当前SensorService实例  
66.         sp<SensorChannel> const mChannel; // SensorChannel实例  
67.         mutable Mutex mConnectionLock;  
68.   
69.         // protected by SensorService::mLock  
70.         SortedVector<int> mSensorInfo;  
71.   
72.     public:  
73.         /* 
74.           1) 把当前service保存在mService中 
75.           2) 创建SensorChannel实例，并保存在mChannel中 
76.              (在SensorChannel::SensorChannel中创建pipe,并把收和发都设置非阻塞) 
77.         */  
78.         SensorEventConnection(const sp<SensorService>& service);  
79.   
80.         // 调用连接中的mChannel->write (SensorChannel::write),把符合条件的事件写入pipe  
81.         status_t sendEvents(sensors_event_t const* buffer, size_t count,  
82.                 sensors_event_t* scratch = NULL);  
83.   
84.         bool hasSensor(int32_t handle) const; //检查handle是否在mSensorInfo中  
85.         bool hasAnySensor() const;   //检查mSensorInfo中是否有sensor  
86.         bool addSensor(int32_t handle); //把handle增加到mSensorInfo列表中  
87.         bool removeSensor(int32_t handle); //把handle从mSensorInfo中删除  
88.     };  
89.     //============== SensorEventConnection  end ========================  
90.     //====================================================================  
91.   
92.     class SensorRecord {  
93.         SortedVector< wp<SensorEventConnection> > mConnections;  
94.     public:  
95.         SensorRecord(const sp<SensorEventConnection>& connection);  
96.         bool addConnection(const sp<SensorEventConnection>& connection);  
97.         bool removeConnection(const wp<SensorEventConnection>& connection);  
98.         size_t getNumConnections() const { return mConnections.size(); }  
99.     };  
100.   
101.     SortedVector< wp<SensorEventConnection> > getActiveConnections() const;  
102.     DefaultKeyedVector<int, SensorInterface*> getActiveVirtualSensors() const;  
103.   
104.     String8 getSensorName(int handle) const;  
105.     void recordLastValue(sensors_event_t const * buffer, size_t count);  
106.     static void sortEventBuffer(sensors_event_t* buffer, size_t count);  
107.     void registerSensor(SensorInterface* sensor);  
108.     void registerVirtualSensor(SensorInterface* sensor);  
109.   
110.     // constants  
111.     Vector<Sensor> mSensorList;  // Sensor列表  
112.     Vector<Sensor> mUserSensorList; //与mSensorList一样  
113.     DefaultKeyedVector<int, SensorInterface*> mSensorMap; //其成员为HardwareSensor  
114.     Vector<SensorInterface *> mVirtualSensorList; //其成员为HardwareSensor  
115.     status_t mInitCheck;  
116.   
117.     // protected by mLock  
118.     mutable Mutex mLock;  
119.     DefaultKeyedVector<int, SensorRecord*> mActiveSensors; //成员为SensorRecord  
120.     DefaultKeyedVector<int, SensorInterface*> mActiveVirtualSensors; //成员为HardwareSensor  
121.     SortedVector< wp<SensorEventConnection> > mActiveConnections;  
122.   
123.     // The size of this vector is constant, only the items are mutable  
124.     KeyedVector<int32_t, sensors_event_t> mLastEventSeen;  
125.   
126. public:  
127.     static char const* getServiceName() { return "sensorservice"; }  
128.   
129.     void cleanupConnection(SensorEventConnection* connection);  
130.   
131.     /* 
132.       1) 调用HardwareSensor::activate，即SensorDevice::activate 
133.       2) 然后创建SensorRecord并增加到列表mActiveSensors 
134.       3) 把此HardwareSensor增加到连接的mSensorInfo 
135.       4) 把此连接增加到mActiveConnections中 
136.     */  
137.     status_t enable(const sp<SensorEventConnection>& connection, int handle);  
138.   
139.     /* 
140.        1) 把此sensor从连接的mSensorInfo中删除 
141.        2) 把此连接从mActiveConnections中删除 
142.        3) 调用HardwareSensor::activate，即SensorDevice::activate 
143.     */  
144.     status_t disable(const sp<SensorEventConnection>& connection, int handle);  
145.     /* 
146.        1)调用HardwareSensor::setDelay，即SensorDevice::setDelay 
147.      */  
148.     status_t setEventRate(const sp<SensorEventConnection>& connection, int handle, nsecs_t ns);  
149. }  

2.5 SensorDevice.cpp

      SensorDevice封装了对SensorHAL层代码的调用，主要包含以下功能：
         1) 获取sensor列表(getSensorList)
         2) 获取sensor事件(poll)
         3) Enable或Disable sensor (activate)
         4) 设置delay时间

 

[cpp]  view plain copy

1. class SensorDevice : public Singleton<SensorDevice> {  
2.   
3.     friend class Singleton<SensorDevice>;  
4.   
5.     struct sensors_poll_device_t* mSensorDevice; // sensor设备  
6.   
7.     struct sensors_module_t* mSensorModule;  
8.   
9.     mutable Mutex mLock; // protect mActivationCount[].rates  
10.     // fixed-size array after construction  
11.     struct Info {  
12.         Info() : delay(0) { }  
13.         KeyedVector<void*, nsecs_t> rates;  
14.         nsecs_t delay;  
15.         status_t setDelayForIdent(void* ident, int64_t ns);  
16.         nsecs_t selectDelay();  
17.     };  
18.     DefaultKeyedVector<int, Info> mActivationCount;  
19.   
20.     /* 
21.       1) 调用hw_get_module(SENSORS_HARDWARE_MODULE_ID,..)获取sensors_module_t， 
22.              并保存在mSensorModule中 
23.       2) 调用mSensorModule->common->methods->open,以返回sensors_poll_device_t, 
24.              并保存在mSensorDevice中 
25.       3) 调用mSensorModule->get_sensors_list所有可访问的sensor_t 
26.       4) 调用mSensorDevice->activate激活所有的sensor 
27.     */  
28.     SensorDevice();  
29. public:  
30.     // 调用mSensorModule->get_sensors_list实现  
31.     ssize_t getSensorList(sensor_t const** list);  
32.   
33.     status_t initCheck() const;  
34.   
35.     // 调用mSensorDevice->poll实现  
36.     ssize_t poll(sensors_event_t* buffer, size_t count);  
37.   
38.     // 调用mSensorDevice->activate实现  
39.     status_t activate(void* ident, int handle, int enabled);  
40.       
41.     // 调用mSensorDevice->setDelay实现  
42.     status_t setDelay(void* ident, int handle, int64_t ns);  
43.     void dump(String8& result, char* buffer, size_t SIZE);  
44. };  

2.6 Sensor HAL

定义：/hardware/libhardware/include/hardware/sensors.h

实现：/hardware/mychip/sensor/st/sensors.c

2.6.1 struct sensors_poll_device_t 定义     

[cpp]  view plain copy

1. struct sensors_poll_device_t {  
2.     struct hw_device_t common;  
3.   
4.     // Activate/deactivate one sensor.  
5.     int (*activate)(struct sensors_poll_device_t *dev,  
6.             int handle, int enabled);  
7.   
8.     // Set the delay between sensor events in nanoseconds for a given sensor.  
9.     int (*setDelay)(struct sensors_poll_device_t *dev,  
10.             int handle, int64_t ns);  
11.   
12.     // Returns an array of sensor data.  
13.     int (*poll)(struct sensors_poll_device_t *dev,  
14.             sensors_event_t* data, int count);  
15. };  

2.6.2 struct sensors_module_t  定义

[cpp]  view plain copy

1. struct sensors_module_t {  
2.     struct hw_module_t common;  
3.   
4.     /** 
5.      * Enumerate all available sensors. The list is returned in "list". 
6.      * @return number of sensors in the list 
7.      */  
8.     int (*get_sensors_list)(struct sensors_module_t* module,  
9.             struct sensor_t const** list);  
10. };  

2.6.3  struct sensor_t 定义

[cpp]  view plain copy

1. struct sensor_t {  
2.     /* name of this sensors */  
3.     const char*     name;  
4.     /* vendor of the hardware part */  
5.     const char*     vendor;  
6.     /* version of the hardware part + driver. The value of this field 
7.      * must increase when the driver is updated in a way that changes the 
8.      * output of this sensor. This is important for fused sensors when the 
9.      * fusion algorithm is updated. 
10.      */      
11.     int             version;  
12.     /* handle that identifies this sensors. This handle is used to activate 
13.      * and deactivate this sensor. The value of the handle must be 8 bits 
14.      * in this version of the API.  
15.      */  
16.     int             handle;  
17.     /* this sensor's type. */  
18.     int             type;  
19.     /* maximaum range of this sensor's value in SI units */  
20.     float           maxRange;  
21.     /* smallest difference between two values reported by this sensor */  
22.     float           resolution;  
23.     /* rough estimate of this sensor's power consumption in mA */  
24.     float           power;  
25.     /* minimum delay allowed between events in microseconds. A value of zero 
26.      * means that this sensor doesn't report events at a constant rate, but 
27.      * rather only when a new data is available */  
28.     int32_t         minDelay;  
29.     /* reserved fields, must be zero */  
30.     void*           reserved[8];  
31. };  

2.6.4 struct sensors_event_t 定义

[cpp]  view plain copy

1. typedef struct {  
2.     union {  
3.         float v[3];  
4.         struct {  
5.             float x;  
6.             float y;  
7.             float z;  
8.         };  
9.         struct {  
10.             float azimuth;  
11.             float pitch;  
12.             float roll;  
13.         };  
14.     };  
15.     int8_t status;  
16.     uint8_t reserved[3];  
17. } sensors_vec_t;  
18.   
19. /** 
20.  * Union of the various types of sensor data 
21.  * that can be returned. 
22.  */  
23. typedef struct sensors_event_t {  
24.     /* must be sizeof(struct sensors_event_t) */  
25.     int32_t version;  
26.   
27.     /* sensor identifier */  
28.     int32_t sensor;  
29.   
30.     /* sensor type */  
31.     int32_t type;  
32.   
33.     /* reserved */  
34.     int32_t reserved0;  
35.   
36.     /* time is in nanosecond */  
37.     int64_t timestamp;  
38.   
39.     union {  
40.         float           data[16];  
41.   
42.         /* acceleration values are in meter per second per second (m/s^2) */  
43.         sensors_vec_t   acceleration;  
44.   
45.         /* magnetic vector values are in micro-Tesla (uT) */  
46.         sensors_vec_t   magnetic;  
47.   
48.         /* orientation values are in degrees */  
49.         sensors_vec_t   orientation;  
50.   
51.         /* gyroscope values are in rad/s */  
52.         sensors_vec_t   gyro;  
53.   
54.         /* temperature is in degrees centigrade (Celsius) */  
55.         float           temperature;  
56.   
57.         /* distance in centimeters */  
58.         float           distance;  
59.   
60.         /* light in SI lux units */  
61.         float           light;  
62.   
63.         /* pressure in hectopascal (hPa) */  
64.         float           pressure;  
65.   
66.         /* relative humidity in percent */  
67.         float           relative_humidity;  
68.     };  
69.     uint32_t        reserved1[4];  
70. } sensors_event_t;  

2.6.5 struct sensors_module_t 实现

[cpp]  view plain copy

1. #include <hardware/sensors.h>  
2. #include "nusensors.h"  
3.   
4. /* 
5.  * the AK8973 has a 8-bit ADC but the firmware seems to average 16 samples, 
6.  * or at least makes its calibration on 12-bits values. This increases the 
7.  * resolution by 4 bits. 
8.  */  
9. static const struct sensor_t sSensorList[] = {  
10.         { "MMA8452Q 3-axis Accelerometer",      
11.                 "Freescale Semiconductor",  
12.                 1, SENSORS_HANDLE_BASE+ID_A,  
13.                 SENSOR_TYPE_ACCELEROMETER, 4.0f*9.81f, (4.0f*9.81f)/256.0f, 0.2f, 0, { } },  
14.         { "AK8975 3-axis Magnetic field sensor",  
15.                 "Asahi Kasei",  
16.                 1, SENSORS_HANDLE_BASE+ID_M,  
17.                 SENSOR_TYPE_MAGNETIC_FIELD, 2000.0f, 1.0f/16.0f, 6.8f, 0, { } },  
18.         { "AK8975 Orientation sensor",  
19.                 "Asahi Kasei",  
20.                 1, SENSORS_HANDLE_BASE+ID_O,  
21.                 SENSOR_TYPE_ORIENTATION, 360.0f, 1.0f, 7.0f, 0, { } },   
22.   
23.     { "ST 3-axis Gyroscope sensor",  
24.           "STMicroelectronics",  
25.           1, SENSORS_HANDLE_BASE+ID_GY,  
26.           SENSOR_TYPE_GYROSCOPE, RANGE_GYRO, CONVERT_GYRO, 6.1f, 1190, { } },  
27.               
28.     { "AL3006Proximity sensor",  
29.         "Dyna Image Corporation",  
30.         1, SENSORS_HANDLE_BASE+ID_P,  
31.         SENSOR_TYPE_PROXIMITY,  
32.         PROXIMITY_THRESHOLD_CM, PROXIMITY_THRESHOLD_CM,  
33.         0.5f, 0, { } },  
34.           
35.         { "AL3006 light sensor",  
36.                 "Dyna Image Corporation",  
37.                 1, SENSORS_HANDLE_BASE+ID_L,  
38.                 SENSOR_TYPE_LIGHT, 10240.0f, 1.0f, 0.5f, 0, { } },  
39.   
40. };  
41.   
42. static int open_sensors(const struct hw_module_t* module, const char* name,  
43.         struct hw_device_t** device);  
44.   
45. static int sensors__get_sensors_list(struct sensors_module_t* module,  
46.         struct sensor_t const** list)  
47. {  
48.     *list = sSensorList;  
49.     return ARRAY_SIZE(sSensorList);  
50. }  
51.   
52. static struct hw_module_methods_t sensors_module_methods = {  
53.     .open = open_sensors  
54. };  
55.   
56. const struct sensors_module_t HAL_MODULE_INFO_SYM = {  
57.     .common = {  
58.         .tag = HARDWARE_MODULE_TAG,  
59.         .version_major = 1,  
60.         .version_minor = 0,  
61.         .id = SENSORS_HARDWARE_MODULE_ID,  
62.         .name = "MMA8451Q & AK8973A & gyro Sensors Module",  
63.         .author = "The Android Project",  
64.         .methods = &sensors_module_methods,  
65.     },  
66.     .get_sensors_list = sensors__get_sensors_list  
67. };  
68.   
69. static int open_sensors(const struct hw_module_t* module, const char* name,  
70.         struct hw_device_t** device)  
71. {  
72.     return init_nusensors(module, device); //待后面讲解  
73. }  

2.6.6 struct sensors_poll_device_t 实现

    实现代码位于：/hardware/mychip/sensor/st/nusensors.cpp

    从上面的代码中可以看出，当调用init_nusensors时，它将返回sensors_poll_device_t，然后就可以调用sensors_poll_device_t 的以下方法进行相关操作：

      1) activate  
      2) setDelay
      3) poll

6.1) struct sensors_poll_context_t 定义 

[cpp]  view plain copy

1. struct sensors_poll_context_t {  
2.     struct sensors_poll_device_t device; // must be first  
3.   
4.         sensors_poll_context_t();  
5.         ~sensors_poll_context_t();  
6.     int activate(int handle, int enabled);  
7.     int setDelay(int handle, int64_t ns);  
8.     int pollEvents(sensors_event_t* data, int count);  
9.   
10. private:  
11.     enum {        
12.         light           = 0,  
13.         proximity       = 1,  
14.         mma             = 2,  
15.         akm             = 3,  
16.         gyro            = 4,  
17.         numSensorDrivers,  
18.         numFds,  
19.     };  
20.   
21.     static const size_t wake = numFds - 1;  
22.     static const char WAKE_MESSAGE = 'W';  
23.     struct pollfd mPollFds[numFds];  
24.     int mWritePipeFd;  
25.     SensorBase* mSensors[numSensorDrivers];  
26.   
27.     int handleToDriver(int handle) const {  
28.         switch (handle) {  
29.             case ID_A:  
30.                 return mma;  
31.             case ID_M:  
32.             case ID_O:  
33.                 return akm;   
34.             case ID_P:  
35.                 return proximity;  
36.             case ID_L:  
37.                 return light;     
38.             case ID_GY:  
39.                 return gyro;  
40.         }  
41.         return -EINVAL;  
42.     }  
43. }  

6.2) init_nusensors 实现

[cpp]  view plain copy

1. int init_nusensors(hw_module_t const* module, hw_device_t** device)  
2. {  
3.     int status = -EINVAL;  
4.   
5.     sensors_poll_context_t *dev = new sensors_poll_context_t();  
6.     memset(&dev->device, 0, sizeof(sensors_poll_device_t));  
7.   
8.     dev->device.common.tag = HARDWARE_DEVICE_TAG;  
9.     dev->device.common.version  = 0;  
10.     dev->device.common.module   = const_cast<hw_module_t*>(module);  
11.     dev->device.common.close    = poll__close;  
12.     dev->device.activate        = poll__activate;  
13.     dev->device.setDelay        = poll__setDelay;  
14.     dev->device.poll            = poll__poll;  
15.   
16.     *device = &dev->device.common;  
17.     status = 0;  
18.     return status;  
19. }  

     由以上代码可见，sensors_poll_device_t的activate、setDelay和poll的实现函数分别为：

        (1)  poll__activate

        (2)   poll__setDelay

        (3)   poll__poll

     下面讲解以上三个关键函数的实现

6.3) struct sensors_poll_context_t 的实现

[cpp]  view plain copy

1. sensors_poll_context_t::sensors_poll_context_t()  
2. {     
3.     mSensors[light] = new LightSensor();  
4.     mPollFds[light].fd = mSensors[light]->getFd();  
5.     mPollFds[light].events = POLLIN;  
6.     mPollFds[light].revents = 0;  
7.   
8.     mSensors[proximity] = new ProximitySensor();  
9.     mPollFds[proximity].fd = mSensors[proximity]->getFd();  
10.     mPollFds[proximity].events = POLLIN;  
11.     mPollFds[proximity].revents = 0;  
12.       
13.   
14.     mSensors[mma] = new MmaSensor();  //下面MmmaSensor为例进行分析  
15.     mPollFds[mma].fd = mSensors[mma]->getFd();  
16.     mPollFds[mma].events = POLLIN;  
17.     mPollFds[mma].revents = 0;  
18.   
19.     mSensors[akm] = new AkmSensor();  
20.     mPollFds[akm].fd = mSensors[akm]->getFd();  
21.     mPollFds[akm].events = POLLIN;  
22.     mPollFds[akm].revents = 0;  
23.   
24.     mSensors[gyro] = new GyroSensor();  
25.     mPollFds[gyro].fd = mSensors[gyro]->getFd();  
26.     mPollFds[gyro].events = POLLIN;  
27.     mPollFds[gyro].revents = 0;  
28.   
29.     int wakeFds[2];  
30.     int result = pipe(wakeFds);  
31.     LOGE_IF(result<0, "error creating wake pipe (%s)", strerror(errno));  
32.     fcntl(wakeFds[0], F_SETFL, O_NONBLOCK);  
33.     fcntl(wakeFds[1], F_SETFL, O_NONBLOCK);  
34.     mWritePipeFd = wakeFds[1];  
35.   
36.     mPollFds[wake].fd = wakeFds[0];  
37.     mPollFds[wake].events = POLLIN;  
38.     mPollFds[wake].revents = 0;  
39. }  
40.   
41. sensors_poll_context_t::~sensors_poll_context_t() {  
42.     for (int i=0 ; i<numSensorDrivers ; i++) {  
43.         delete mSensors[i];  
44.     }  
45.     close(mPollFds[wake].fd);  
46.     close(mWritePipeFd);  
47. }  
48.   
49. int sensors_poll_context_t::activate(int handle, int enabled) {  
50.     int index = handleToDriver(handle);  
51.     if (index < 0) return index;  
52.     int err =  mSensors[index]->enable(handle, enabled);  
53.     if (enabled && !err) {  
54.         const char wakeMessage(WAKE_MESSAGE);  
55.         int result = write(mWritePipeFd, &wakeMessage, 1);  
56.         LOGE_IF(result<0, "error sending wake message (%s)", strerror(errno));  
57.     }  
58.     return err;  
59. }  
60.   
61. int sensors_poll_context_t::setDelay(int handle, int64_t ns) {  
62.   
63.     int index = handleToDriver(handle);  
64.     if (index < 0) return index;  
65.     return mSensors[index]->setDelay(handle, ns);  
66. }  
67.   
68. int sensors_poll_context_t::pollEvents(sensors_event_t* data, int count)  
69. {  
70.     int nbEvents = 0;  
71.     int n = 0;  
72.   
73.     do {  
74.         // see if we have some leftover from the last poll()  
75.         for (int i=0 ; count && i<numSensorDrivers ; i++) {  
76.             SensorBase* const sensor(mSensors[i]);  
77.             if ((mPollFds[i].revents & POLLIN) || (sensor->hasPendingEvents())) {  
78.                 int nb = sensor->readEvents(data, count);    // num of evens received.  
79.                 D("nb = %d.", nb);  
80.                 if (nb < count) {  
81.                     // no more data for this sensor  
82.                     mPollFds[i].revents = 0;  
83.                 }  
84.                 count -= nb;  
85.                 nbEvents += nb;  
86.                 data += nb;  
87.             }  
88.         }  
89.   
90.         if (count) {  
91.             // we still have some room, so try to see if we can get  
92.             // some events immediately or just wait if we don't have  
93.             // anything to return  
94.             n = poll(mPollFds, numFds, nbEvents ? 0 : -1);  
95.             if (n<0) {  
96.                 LOGE("poll() failed (%s)", strerror(errno));  
97.                 return -errno;  
98.             }  
99.             if (mPollFds[wake].revents & POLLIN) {  
100.                 char msg;  
101.                 int result = read(mPollFds[wake].fd, &msg, 1);  
102.                 LOGE_IF(result<0, "error reading from wake pipe (%s)", strerror(errno));  
103.                 LOGE_IF(msg != WAKE_MESSAGE, "unknown message on wake queue (0x%02x)", int(msg));  
104.                 mPollFds[wake].revents = 0;  
105.             }  
106.         }  
107.         // if we have events and space, go read them  
108.     } while (n && count);  
109.   
110.     return nbEvents;  
111. }  
112.   
113. /*****************************************************************************/  
114.   
115. static int poll__close(struct hw_device_t *dev)  
116. {  
117.     sensors_poll_context_t *ctx = (sensors_poll_context_t *)dev;  
118.     if (ctx) {  
119.         delete ctx;  
120.     }  
121.     return 0;  
122. }  
123.   
124. static int poll__activate(struct sensors_poll_device_t *dev,  
125.         int handle, int enabled) {  
126.     sensors_poll_context_t *ctx = (sensors_poll_context_t *)dev;  
127.     return ctx->activate(handle, enabled);  
128. }  
129.   
130. static int poll__setDelay(struct sensors_poll_device_t *dev,  
131.         int handle, int64_t ns) {  
132.     sensors_poll_context_t *ctx = (sensors_poll_context_t *)dev;  
133.     return ctx->setDelay(handle, ns);  
134. }  
135.   
136. static int poll__poll(struct sensors_poll_device_t *dev,  
137.         sensors_event_t* data, int count) {  
138.     sensors_poll_context_t *ctx = (sensors_poll_context_t *)dev;  
139.     return ctx->pollEvents(data, count);  
140. }  

下面MmaSensor为例进行分析。

2.7 MmaSensor.cpp

1)  SensorBase的实现(SensorBase.cpp)

[cpp]  view plain copy

1. class SensorBase {  
2. protected:  
3.     const char* dev_name; // "/dev/mma8452_daemon"  
4.     const char* data_name; // "gsensor"  
5.     int         dev_fd; // 打开设备"/dev/mma8452_daemon"的fd  
6.       
7.     // 打开事件"/dev/input/eventx"的fd,其驱动的名字为"gsensor"  
8.     int         data_fd;   
9.       
10.     // 打开与"gsensor"对应的事件"/dev/input/eventx"  
11.     static int openInput(const char* inputName);   
12.   
13.     //通过clock_gettime获取当前时间  
14.     static int64_t getTimestamp();   
15.   
16.   
17.     static int64_t timevalToNano(timeval const& t) {  
18.         return t.tv_sec*1000000000LL + t.tv_usec*1000;  
19.     }  
20.   
21.     int open_device(); //打开设备"dev/mma8452_daemon"  
22.     int close_device(); //关闭设备"dev/mma8452_daemon"  
23.   
24. public:  
25.     // 调用openInput  
26.             SensorBase(  
27.                     const char* dev_name,  
28.                     const char* data_name);  
29.   
30.     virtual ~SensorBase();  
31.   
32.     virtual int readEvents(sensors_event_t* data, int count) = 0;  
33.     virtual bool hasPendingEvents() const;  
34.     virtual int getFd() const;  //返回data_fd  
35.     virtual int setDelay(int32_t handle, int64_t ns);  
36.     virtual int enable(int32_t handle, int enabled) = 0;  
37. };  

2) MmaSensor的实现

[cpp]  view plain copy

1. class MmaSensor : public SensorBase {  
2. public:  
3.     /* 
4.       1) 设置dev_name为 "/dev/mma8452_daemon" 
5.       2) 设置data_name为 "gsensor" 
6.       3) open设备 "/dev/mma8452_daemon" 
7.     */  
8.             MmaSensor();  
9.     virtual ~MmaSensor();  
10.   
11.     enum {  
12.         Accelerometer   = 0,  
13.         numSensors  
14.     };  
15.   
16.     // 调用ioctl(MMA_IOCTL_APP_SET_RATE)  
17.     virtual int setDelay(int32_t handle, int64_t ns);  
18.   
19.     /* 
20.       1) Activate: ioctl(MMA_IOCTL_START) 
21.       2) Deactivate: ioctl(MMA_IOCTL_CLOSE) 
22.     */  
23.     virtual int enable(int32_t handle, int enabled);  
24.       
25.     /* 
26.       1) 从data_fd read input_event 
27.       2) 调用processEvent对事件进行处理 
28.       3) 把事件通过data返回 
29.     */  
30.     virtual int readEvents(sensors_event_t* data, int count);  
31.   
32.     void processEvent(int code, int value);  
33.   
34. private:  
35.     int update_delay();  
36.     uint32_t mEnabled;  
37.     uint32_t mPendingMask;  
38.     InputEventCircularReader mInputReader;  
39.     sensors_event_t mPendingEvents[numSensors];  
40.     uint64_t mDelays[numSensors];  
41. };  

3. 加载HAL

HAL 为一个.so库，其加载过程相关代码如下：

[cpp]  view plain copy

1. #define HAL_LIBRARY_PATH1 "/system/lib/hw"  
2. #define HAL_LIBRARY_PATH2 "/vendor/lib/hw"  
3. #define SENSORS_HARDWARE_MODULE_ID "sensors"  
4.   
5. SensorDevice::SensorDevice()  
6.     :  mSensorDevice(0),  
7.        mSensorModule(0)  
8. {  
9.     status_t err = hw_get_module(SENSORS_HARDWARE_MODULE_ID,  
10.             (hw_module_t const**)&mSensorModule);  
11.   
12.     ALOGE_IF(err, "couldn't load %s module (%s)",  
13.             SENSORS_HARDWARE_MODULE_ID, strerror(-err));  
14.   
15.     if (mSensorModule) {  
16.         err = sensors_open(&mSensorModule->common, &mSensorDevice);  
17.   
18.         ALOGE_IF(err, "couldn't open device for module %s (%s)",  
19.                 SENSORS_HARDWARE_MODULE_ID, strerror(-err));  
20.   
21.         if (mSensorDevice) {  
22.             sensor_t const* list;  
23.             ssize_t count = mSensorModule->get_sensors_list(mSensorModule, &list);  
24.             mActivationCount.setCapacity(count);  
25.             Info model;  
26.             for (size_t i=0 ; i<size_t(count) ; i++) {  
27.                 mActivationCount.add(list[i].handle, model);  
28.                 mSensorDevice->activate(mSensorDevice, list[i].handle, 0);  
29.             }  
30.         }  
31.     }  
32. }  
33.   
34. int hw_get_module(const char *id, const struct hw_module_t **module)  
35. {  
36.     return hw_get_module_by_class(id, NULL, module);  
37. }  
38.   
39.   
40. int hw_get_module_by_class(const char *class_id, const char *inst,  
41.                            const struct hw_module_t **module)  
42. {  
43.     int status;  
44.     int i;  
45.     const struct hw_module_t *hmi = NULL;  
46.     char prop[PATH_MAX];  
47.     char path[PATH_MAX];  
48.     char name[PATH_MAX];  
49.   
50.     if (inst)  
51.         snprintf(name, PATH_MAX, "%s.%s", class_id, inst);  
52.     else  
53.         strlcpy(name, class_id, PATH_MAX);  
54.   
55.     /* 
56.      * Here we rely on the fact that calling dlopen multiple times on 
57.      * the same .so will simply increment a refcount (and not load 
58.      * a new copy of the library). 
59.      * We also assume that dlopen() is thread-safe. 
60.      */  
61.   
62.     /* Loop through the configuration variants looking for a module */  
63.     for (i=0 ; i<HAL_VARIANT_KEYS_COUNT+1 ; i++) {  
64.         if (i < HAL_VARIANT_KEYS_COUNT) {  
65.             if (property_get(variant_keys[i], prop, NULL) == 0) {  
66.                 continue;  
67.             }  
68.             snprintf(path, sizeof(path), "%s/%s.%s.so",  
69.                      HAL_LIBRARY_PATH2, name, prop);  
70.             if (access(path, R_OK) == 0) break;  
71.   
72.             snprintf(path, sizeof(path), "%s/%s.%s.so",  
73.                      HAL_LIBRARY_PATH1, name, prop);  
74.             if (access(path, R_OK) == 0) break;  
75.         } else {  
76.             snprintf(path, sizeof(path), "%s/%s.default.so",  
77.                      HAL_LIBRARY_PATH1, name);  
78.             if (access(path, R_OK) == 0) break;  
79.         }  
80.     }  
81.   
82.     status = -ENOENT;  
83.     if (i < HAL_VARIANT_KEYS_COUNT+1) {  
84.         /* load the module, if this fails, we're doomed, and we should not try 
85.          * to load a different variant. */  
86.         status = load(class_id, path, module);  
87.     }  
88.   
89.     return status;  
90. }  

4. 启动SensorService

    SensorService在SystemServer中启动(system_init.cpp)，其相关代码如下：

[cpp]  view plain copy

1. extern "C" status_t system_init()  
2. {  
3.     ....  
4.     property_get("system_init.startsensorservice", propBuf, "1");  
5.     if (strcmp(propBuf, "1") == 0) {  
6.         // Start the sensor service  
7.         SensorService::instantiate();  
8.     }  
9.     ...  
10.     return NO_ERROR;  
11. }  

5. SensorManager注册Listener过程

[cpp]  view plain copy

1. private SensorManager mSensorManager = (SensorManager) getSystemService(SENSOR_SERVICE);  
2. registerListener(SensorManager.java)->  
3.  registerListenerImpl (SystemSensorManager.java)->  
4.   enableSensorLocked(SystemSensorManager.java)->  
5.    sensors_enable_sensor(android_hardware_SensorManager.cpp)->  
6.     SensorEventQueue::enableSensor(SensorEventQueue.cpp)->  
7.      1>SensorService::SensorEventConnection::enableDisable(handle, true) (SensorService.cpp)->  
8.          SensorService::enable(SensorService.cpp)->  
9.            HardwareSensor::activate(SensorInterface.cpp)->  
10.              SensorDevice::activate(SensorDevice.cpp)->  
11.                sensors_poll_device_t::activate(HAL)  
12.            
13.      2>SensorService::SensorEventConnection::setEventRate(SensorService.cpp)->  
14.