(OK) android-5.0 sensor工作原理—sensorservice的启动(一)

http://blog.csdn.net/zsj100213/article/details/48179655

sensorservice的启动：

1. systemserver.Java的run函数：

[html] view plain copy

1.  private void run() {  
2.   
3. ……  
4.   
5.         // Initialize native services.  
6.         System.loadLibrary("android_servers");  
7.         nativeInit();  
8.   
9. ……  
10.   
11. ｝  

   Android在启动之后通过Zygote来管理和启动android server，他首先会运行SystemServer.java里面的run函数，这里主要是load android_server.so库，然后调用nativeInit()来启动sensorservice。

2. nativeInit()是本地方法，上层Java调用本地C++方法，需要通过JNI层的转化，在com_android_server_SystemServer.cpp中：

[html] view plain copy

1. static void android_server_SystemServer_nativeInit(JNIEnv* env, jobject clazz) {  
2.     char propBuf[PROPERTY_VALUE_MAX];  
3.     property_get("system_init.startsensorservice", propBuf, "1");  
4.     if (strcmp(propBuf, "1") == 0) {  
5.         // Start the sensor service  
6.         SensorService::instantiate();  
7.     }  
8. }  
9.   
10. /*  
11.  * JNI registration.  
12.  */  
13. static JNINativeMethod gMethods[] = {  
14.     /* name, signature, funcPtr */  
15.     { "nativeInit", "()V", (void*) android_server_SystemServer_nativeInit },  
16. };  
17.   
18. int register_android_server_SystemServer(JNIEnv* env)  
19. {  
20.     return jniRegisterNativeMethods(env, "com/android/server/SystemServer",  
21.             gMethods, NELEM(gMethods));  
22. }  

首先建立nativeInit()方法对本地方法android_server_SystemServer_nativeInit()的映射，然后jniRegisterNativeMethods注册该方法，在上层调用nativeInit()方法就可以调用本地方法android_server_SystemServer_nativeInit()通过SensorService::instantiate();来实例化sensorservice，主要是向servicemanager注册sensorservice。

[html] view plain copy

1.   static status_t publish(bool allowIsolated = false) {  
2.       sp<IServiceManager> sm(defaultServiceManager());  
3.       return sm->addService(  
4.               String16(SERVICE::getServiceName()),  
5.               new SERVICE(), allowIsolated);  
6.   }  
7. static void instantiate() { publish(); }  

addservice()方法主要是完成向servicemanager注册sensorservice服务，原型如下：

[html] view plain copy

1. virtual status_t            addService( const String16& name,  
2.                                            const sp<IBinder>& service,  
3.                                            bool allowIsolated = false) = 0;  

其第二个参数也就是new SERVICE()是强引用sp sensorservice，所以会调用到SensorService::onFirstRef()，这样就开始了sensorservice的一系列初始化工作。

3. SensorService::onFirstRef()

[cpp] view plain copy

1. void SensorService::onFirstRef()  
2. {  
3.     ALOGD("nuSensorService starting...");  
4.   
5.     SensorDevice& dev(SensorDevice::getInstance());  
6.   
7.     if (dev.initCheck() == NO_ERROR) {  
8.         sensor_t const* list;  
9.         ssize_t count = dev.getSensorList(&list);  
10.         if (count > 0) {  
11.             ssize_t orientationIndex = -1;  
12.             bool hasGyro = false;  
13.             uint32_t virtualSensorsNeeds =  
14.                     (1<<SENSOR_TYPE_GRAVITY) |  
15.                     (1<<SENSOR_TYPE_LINEAR_ACCELERATION) |  
16.                     (1<<SENSOR_TYPE_ROTATION_VECTOR);  
17.   
18.             mLastEventSeen.setCapacity(count);  
19.             for (ssize_t i=0 ; i<count ; i++) {  
20.                 registerSensor( new HardwareSensor(list[i]) );  
21.                 switch (list[i].type) {  
22.                     case SENSOR_TYPE_ORIENTATION:  
23.                         orientationIndex = i;  
24.                         break;  
25.                     case SENSOR_TYPE_GYROSCOPE:  
26.                     case SENSOR_TYPE_GYROSCOPE_UNCALIBRATED:  
27.                         hasGyro = true;  
28.                         break;  
29.                     case SENSOR_TYPE_GRAVITY:  
30.                     case SENSOR_TYPE_LINEAR_ACCELERATION:  
31.                     case SENSOR_TYPE_ROTATION_VECTOR:  
32.                         virtualSensorsNeeds &= ~(1<<list[i].type);  
33.                         break;  
34.                 }  
35.             }  
36.   
37.             // it's safe to instantiate the SensorFusion object here  
38.             // (it wants to be instantiated after h/w sensors have been  
39.             // registered)  
40.             const SensorFusion& fusion(SensorFusion::getInstance());  
41.   
42.             // build the sensor list returned to users  
43.             mUserSensorList = mSensorList;  
44.   
45.             if (hasGyro) {  
46.                 Sensor aSensor;  
47.   
48.                 // Add Android virtual sensors if they're not already  
49.                 // available in the HAL  
50.   
51.                 aSensor = registerVirtualSensor( new RotationVectorSensor() );  
52.                 if (virtualSensorsNeeds & (1<<SENSOR_TYPE_ROTATION_VECTOR)) {  
53.                     mUserSensorList.add(aSensor);  
54.                 }  
55.   
56.                 aSensor = registerVirtualSensor( new GravitySensor(list, count) );  
57.                 if (virtualSensorsNeeds & (1<<SENSOR_TYPE_GRAVITY)) {  
58.                     mUserSensorList.add(aSensor);  
59.                 }  
60.   
61.                 aSensor = registerVirtualSensor( new LinearAccelerationSensor(list, count) );  
62.                 if (virtualSensorsNeeds & (1<<SENSOR_TYPE_LINEAR_ACCELERATION)) {  
63.                     mUserSensorList.add(aSensor);  
64.                 }  
65.   
66.                 aSensor = registerVirtualSensor( new OrientationSensor() );  
67.                 if (virtualSensorsNeeds & (1<<SENSOR_TYPE_ROTATION_VECTOR)) {  
68.                     // if we are doing our own rotation-vector, also add  
69.                     // the orientation sensor and remove the HAL provided one.  
70.                     mUserSensorList.replaceAt(aSensor, orientationIndex);  
71.                 }  
72.   
73.                 // virtual debugging sensors are not added to mUserSensorList  
74.                 registerVirtualSensor( new CorrectedGyroSensor(list, count) );  
75.                 registerVirtualSensor( new GyroDriftSensor() );  
76.             }  
77.   
78.             // debugging sensor list  
79.             mUserSensorListDebug = mSensorList;  
80.   
81.             // Check if the device really supports batching by looking at the FIFO event  
82.             // counts for each sensor.  
83.             bool batchingSupported = false;  
84.             for (int i = 0; i < mSensorList.size(); ++i) {  
85.                 if (mSensorList[i].getFifoMaxEventCount() > 0) {  
86.                     batchingSupported = true;  
87.                     break;  
88.                 }  
89.             }  
90.   
91.             if (batchingSupported) {  
92.                 // Increase socket buffer size to a max of 100 KB for batching capabilities.  
93.                 mSocketBufferSize = MAX_SOCKET_BUFFER_SIZE_BATCHED;  
94.             } else {  
95.                 mSocketBufferSize = SOCKET_BUFFER_SIZE_NON_BATCHED;  
96.             }  
97.   
98.             // Compare the socketBufferSize value against the system limits and limit  
99.             // it to maxSystemSocketBufferSize if necessary.  
100.             FILE *fp = fopen("/proc/sys/net/core/wmem_max", "r");  
101.             char line[128];  
102.             if (fp != NULL && fgets(line, sizeof(line), fp) != NULL) {  
103.                 line[sizeof(line) - 1] = '\0';  
104.                 size_t maxSystemSocketBufferSize;  
105.                 sscanf(line, "%zu", &maxSystemSocketBufferSize);  
106.                 if (mSocketBufferSize > maxSystemSocketBufferSize) {  
107.                     mSocketBufferSize = maxSystemSocketBufferSize;  
108.                 }  
109.             }  
110.             if (fp) {  
111.                 fclose(fp);  
112.             }  
113.   
114.             mWakeLockAcquired = false;  
115.             mLooper = new Looper(false);  
116.             const size_t minBufferSize = SensorEventQueue::MAX_RECEIVE_BUFFER_EVENT_COUNT;  
117.             mSensorEventBuffer = new sensors_event_t[minBufferSize];  
118.             mSensorEventScratch = new sensors_event_t[minBufferSize];  
119.             mMapFlushEventsToConnections = new SensorEventConnection const * [minBufferSize];  
120.   
121.             mInitCheck = NO_ERROR;  
122.             run("SensorService", PRIORITY_URGENT_DISPLAY);  
123.         }  
124.     }  
125. }  

3.1 首先是sensorDevice的实例化：

[cpp] view plain copy

1. SensorDevice::SensorDevice()  
2.     :  mSensorDevice(0),  
3.        mSensorModule(0)  
4. {  
5.     status_t err = hw_get_module(SENSORS_HARDWARE_MODULE_ID,  
6.             (hw_module_t const**)&mSensorModule);  
7.     ALOGE_IF(err, "couldn't load %s module (%s)",  
8.             SENSORS_HARDWARE_MODULE_ID, strerror(-err));  
9.   
10.     if (mSensorModule) {  
11.         err = sensors_open_1(&mSensorModule->common, &mSensorDevice);  
12.   
13.         ALOGE_IF(err, "couldn't open device for module %s (%s)",  
14.                 SENSORS_HARDWARE_MODULE_ID, strerror(-err));  
15.   
16.         if (mSensorDevice) {  
17.             if (mSensorDevice->common.version == SENSORS_DEVICE_API_VERSION_1_1 ||  
18.                 mSensorDevice->common.version == SENSORS_DEVICE_API_VERSION_1_2) {  
19.                 ALOGE(">>>> WARNING <<< Upgrade sensor HAL to version 1_3");  
20.             }  
21.   
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(  
29.                         reinterpret_cast<struct sensors_poll_device_t *>(mSensorDevice),  
30.                         list[i].handle, 0);  
31.             }  
32.         }  
33.     }  
34. }  

sensorDevice的实例化主要完成以下三项工作：

3.1.1. 主要是为了从/system/lib/hw或者/vendor/lib/hw路径load一个sensors.(platform).so的库文件，如sensors.mt6753.so，第一个参数是我们所获取的hardware模块的名字，第二个参数是我们所要获得的hw_module_t。

[cpp] view plain copy

1. hw_get_module(SENSORS_HARDWARE_MODULE_ID,  
2.             (hw_module_t const**)&mSensorModule);  

load()首先是通过dlopen()函数载入前面获取的path的动态链接库，如sensors.mt6753.so，然后使用dlsym()函数来获取.so文件中的符号HMI的地址，最后dlsym()函数返回hw_module_t的地址hmi，最后将hmi的值赋给参数*pHmi。load()函数的代码如下：

[cpp] view plain copy

1. /** 
2.  * Name of the hal_module_info 
3.  */  
4. #define HAL_MODULE_INFO_SYM         HMI  
5.   
6. /** 
7.  * Name of the hal_module_info as a string 
8.  */  
9. #define HAL_MODULE_INFO_SYM_AS_STR  "HMI"     //获取符号HMI的地址，然后dlsym()函数返回的是hw_module_t()的  

[cpp] view plain copy

1. static int load(const char *id,  
2.         const char *path,  
3.         const struct hw_module_t **pHmi)  
4. {  
5.     int status;  
6.     void *handle;  
7.     struct hw_module_t *hmi;  
8.   
9.     /* 
10.      * load the symbols resolving undefined symbols before 
11.      * dlopen returns. Since RTLD_GLOBAL is not or'd in with 
12.      * RTLD_NOW the external symbols will not be global 
13.      */  
14.     handle = dlopen(path, RTLD_NOW);  
15.     if (handle == NULL) {  
16.         char const *err_str = dlerror();  
17.         ALOGE("load: module=%s\n%s", path, err_str?err_str:"unknown");  
18.         status = -EINVAL;  
19.         goto done;  
20.     }  
21.   
22.     /* Get the address of the struct hal_module_info. */  
23.     const char *sym = HAL_MODULE_INFO_SYM_AS_STR;  
24.     hmi = (struct hw_module_t *)dlsym(handle, sym);  
25.     if (hmi == NULL) {  
26.         ALOGE("load: couldn't find symbol %s", sym);  
27.         status = -EINVAL;  
28.         goto done;  
29.     }  
30.   
31.     /* Check that the id matches */  
32.     if (strcmp(id, hmi->id) != 0) {  
33.         ALOGE("load: id=%s != hmi->id=%s", id, hmi->id);  
34.         status = -EINVAL;  
35.         goto done;  
36.     }  
37.   
38.     hmi->dso = handle;  
39.   
40.     /* success */  
41.     status = 0;  
42.   
43.     done:  
44.     if (status != 0) {  
45.         hmi = NULL;  
46.         if (handle != NULL) {  
47.             dlclose(handle);  
48.             handle = NULL;  
49.         }  
50.     } else {  
51.         ALOGV("loaded HAL id=%s path=%s hmi=%p handle=%p",  
52.                 id, path, *pHmi, handle);  
53.     }  
54.   
55.     *pHmi = hmi;  
56.   
57.     return status;  
58. }  

此处的hw_get_module()最后返回的sensors_module_t是经过封装的hw_module_t，他除了包含一个hw_module_t还包含一个获取sensorlist的API这个结构体主要是几个API接口的定义，hw_module_t结构体的定义如下：

[cpp] view plain copy

1. struct sensors_module_t HAL_MODULE_INFO_SYM = {  
2.         common:{  
3.                 tag: HARDWARE_MODULE_TAG,  
4.                 version_major: 1,  
5.                 version_minor: 0,  
6.                 id: SENSORS_HARDWARE_MODULE_ID,  
7.                 name: "SPRD Sensor module",  
8.                 author: "Spreadtrum",  
9.                 methods: &sensors_module_methods,  
10.                 dso: 0,  
11.                 reserved:{},  
12.         },  
13.         get_sensors_list:sensors__get_sensors_list,  
14. };  
15.   
16. static struct hw_module_methods_t sensors_module_methods = {  
17. open:    open_sensors  
18. };  
19.   
20. static int sensors__get_sensors_list(struct sensors_module_t *module,  
21.                      struct sensor_t const **list)  
22. {  
23.     *list = sSensorList;  
24.     return numSensors;  
25. }  

3.1.2. 通过sensors_open_1(&mSensorModule->common, &mSensorDevice)函数新建并初始化系统所有的sensor。

[cpp] view plain copy

1. static inline int sensors_open_1(const struct hw_module_t* module,  
2.         sensors_poll_device_1_t** device) {  
3.     return module->methods->open(module,  
4.             SENSORS_HARDWARE_POLL, (struct hw_device_t**)device);  
5. }  

这里的open函数就是上一步hw_get_module()获取的sensors_module_t所定义的sensors_module_methods的open_sensors接口，open_sensors接口的代码如下：

[cpp] view plain copy

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

函数首先是通过sensors_poll_context_t()方法新建并初始化系统所有的sensor：

[cpp] view plain copy

1. sensors_poll_context_t::sensors_poll_context_t()  
2. {  
3. #ifndef ACC_NULL  
4.     mSensors[acc] = new AccSensor();  
5.     numSensors +=  
6.         mSensors[acc]->populateSensorList(sSensorList + numSensors);  
7.     mPollFds[acc].fd = mSensors[acc]->getFd();  
8.     mPollFds[acc].events = POLLIN;  
9.     mPollFds[acc].revents = 0;  
10.     ALOGD("AnumSensors=%d; %d", numSensors, AccSensor::numSensors);  
11. #endif  
12. #ifndef ORI_NULL  
13.     mSensors[ori] = new OriSensor();  
14.     numSensors +=  
15.         mSensors[ori]->populateSensorList(sSensorList + numSensors);  
16.     mPollFds[ori].fd = mSensors[ori]->getFd();  
17.     mPollFds[ori].events = POLLIN;  
18.     mPollFds[ori].revents = 0;  
19.     ALOGD("OnumSensors=%d; %d", numSensors, OriSensor::numSensors);  
20. #endif  
21. #ifdef SENSORHAL_PROXIMITY_STK  
22.     mSensors[stk_als] = <span style="color:#FF0000;">new STKLightSensor();</span>  
23.     numSensors +=  
24.         mSensors[stk_als]->populateSensorList(sSensorList + numSensors);  
25.     mPollFds[stk_als].fd = mSensors[stk_als]->getFd();  
26.     mPollFds[stk_als].events = POLLIN;  
27.     mPollFds[stk_als].revents = 0;  
28.       
29.     mSensors[stk_ps] = new STKProximitySensor();  
30.     numSensors +=  
31.         mSensors[stk_ps]->populateSensorList(sSensorList + numSensors);  
32.     mPollFds[stk_ps].fd = mSensors[stk_ps]->getFd();  
33.     mPollFds[stk_ps].events = POLLIN;  
34.     mPollFds[stk_ps].revents = 0;  
35. #else  
36. #ifndef PLS_NULL  
37.     mSensors[pls] = new PlsSensor();  
38.     numSensors +=  
39.         mSensors[pls]->populateSensorList(sSensorList + numSensors);  
40.     mPollFds[pls].fd = mSensors[pls]->getFd();  
41.     mPollFds[pls].events = POLLIN;  
42.     mPollFds[pls].revents = 0;  
43.     ALOGD("PnumSensors=%d; %d", numSensors, PlsSensor::numSensors);  
44. #endif  
45. #endif  
46.     int wakeFds[2];  
47.     int result = pipe(wakeFds);  
48.     ALOGE_IF(result < 0, "error creating wake pipe (%s)", strerror(errno));  
49.     fcntl(wakeFds[0], F_SETFL, O_NONBLOCK);  
50.     fcntl(wakeFds[1], F_SETFL, O_NONBLOCK);  
51.     mWritePipeFd = wakeFds[1];  
52.   
53.     mPollFds[wake].fd = wakeFds[0];  
54.     mPollFds[wake].events = POLLIN;  
55.     mPollFds[wake].revents = 0;  
56. }  

例如在new STKLightSensor()中主要定义了数据读取环形缓冲区的大小，sensor_event_t的初始化，以及input子系统上报事件所保存的路径。STKLightSensor()代码如下：

[cpp] view plain copy

1. STKLightSensor::STKLightSensor()  
2.     : SensorBase(NULL, "lightsensor-level"),  
3.       mEnabled(0),  
4.       mInputReader(4),  
5.       mHasPendingEvent(false) {  
6.     mPendingEvent.version = sizeof(sensors_event_t);  
7.     mPendingEvent.sensor = ID_L;  
8.     mPendingEvent.type = SENSOR_TYPE_LIGHT;  
9.     memset(mPendingEvent.data, 0, sizeof(mPendingEvent.data));  
10.   
11.     if (data_fd) {  
12. #if 1         
13.         strcpy(input_sysfs_path, "/sys/class/input/");  
14.         strcat(input_sysfs_path, input_name);  
15.         strcat(input_sysfs_path, "/device/driver/");               //此项目初始化文件节点所在文件夹目录为：/sys/class/input/input*/device/driver/  
16.         input_sysfs_path_len = strlen(input_sysfs_path);  
17. #else         
18.         strcpy(input_sysfs_path, INPUT_SYSFS_PATH_ALS);  
19. #endif  
20.         input_sysfs_path_len = strlen(input_sysfs_path);  
21.         LOGD("%s: input=%s", __func__, input_name);  
22.         LOGD("%s: input_sysfs_path = %s\n", __func__, input_sysfs_path);  
23.     }  
24.       
25. }  

open_sensors第二步是对sensors_poll_device_t结构体的初始化，主要是对sensor打开，关闭，以及数据获取的API 借口的定义，这几个API接口将在后面详细描述。

3.1.3.  mSensorModule->get_sensors_list(mSensorModule, &list)这个是前面获取的sensors_module_t中定义的get_sensor_list方法。他最终获取的是HAL层初始化好的sensor的列表，并返回sensor的数量，active方法打开sensor，

[cpp] view plain copy

1. mSensorDevice->activate(  
2.                         reinterpret_cast<struct sensors_poll_device_t *>(mSensorDevice),  
3.                         list[i].handle, 0);  

mSensorDevice->activate()调用HAL层activate()方法，最后调用HAL层sensor厂商添加的setEnable()方法来打开对应sensor。通过open函数获取sensor在sysfs对应的文件节点，然后使用write函数往文件节点里面写1即可。

[cpp] view plain copy

1. static int poll__activate(struct sensors_poll_device_t *dev,  
2.               int handle, int enabled)  
3. {  
4.     sensors_poll_context_t *ctx = (sensors_poll_context_t *) dev;  
5.     return ctx->activate(handle, enabled);  
6. }  
7.   
8. int sensors_poll_context_t::activate(int handle, int enabled)  
9. {  
10.     int drv = handleToDriver(handle);                       //获取sensor的类型  
11.     int err;  
12.   
13.     switch (handle) {  
14.     case ID_A:  
15.     case ID_M:  
16.     case ID_L:  
17.     case ID_P:  
18.         /* No dependencies */  
19.         break;  
20.   
21.     case ID_O:  
22.         /* These sensors depend on ID_A and ID_M */  
23.         mSensors[handleToDriver(ID_A)]->setEnable(ID_A, enabled);  
24.         mSensors[handleToDriver(ID_M)]->setEnable(ID_M, enabled);  
25.         break;  
26.   
27.     default:  
28.         return -EINVAL;  
29.     }  
30.   
31.     ALOGD("activate handle=%d; drv=%d", handle, drv);  
32.   
33.     err = mSensors[drv]->setEnable(handle, enabled);                      //使用对应的sensor的setEnable方法  
34.   
35.     if (enabled && !err) {  
36.         const char wakeMessage(WAKE_MESSAGE);  
37.         int result = write(mWritePipeFd, &wakeMessage, 1);  
38.         ALOGE_IF(result < 0, "error sending wake message (%s)",  
39.              strerror(errno));  
40.     }  
41.     return err;  
42. }  
43.   
44. int STKLightSensor::setEnable(int32_t, int en) {  
45.    int flags = en ? 1 : 0;  
46.     if (flags != mEnabled) {  
47.         int fd;  
48.         strcpy(&input_sysfs_path[input_sysfs_path_len], "enable"); //初始化的input_sysfs_path是/sys/class/input/input*/device/driver/，此项目的文件节点是  
49. /sys/class/input/input*/device/driver/enable，所以使用strcpy在input_sysfs_path后面添加了enable节点。  
50.         fd = open(input_sysfs_path, O_RDWR);                        //打开对应的sysfs目录下的文件节点  
51.         LOGE("STKLightSensor enable path %s fd %d", input_sysfs_path, fd);  
52.         if (fd >= 0) {  
53.             char buf[2];  
54.             buf[1] = 0;  
55.             if (flags) {  
56.                 buf[0] = '1';  
57.             } else {  
58.                 buf[0] = '0';  
59.             }  
60.             write(fd, buf, sizeof(buf));                         //将buf的值写到sysfs的目录下面sensor对应的文件节点  
61.             close(fd);  
62.             mEnabled = flags;  
63.             if(flags)  
64.                 setInitialState();                        //处理sensor开启后的第一笔数据  
65.             return 0;  
66.         }  
67.         return -1;  
68.     }  
69.     return 0;   
70. }  

如果打开了sensor，则会调用setInitialState()通过ioctl来从data_fd中获取数据，然后将是否有待处理数据设置为“true”，在poll后面将要讲到的poll数据时会直接先处理这个数据。这里获取的数据个人理解是在sensor开启之后的第一笔数据。

[cpp] view plain copy

1. int STKLightSensor::setInitialState() {  
2.     struct input_absinfo absinfo;  
3.     if (!ioctl(data_fd, EVIOCGABS(ABS_MISC), &absinfo)) {  
4.         mPendingEvent.light = (float)absinfo.value;  
5.         mHasPendingEvent = true;  
6.     }  
7.     else  
8.         ALOGE("%s:ioctl failed!", __func__);          
9.     return 0;  
10. }  

至此，sensorDevice的实例化就完成了。下一篇将继续讲