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

class SensorManager :    public ASensorManager,    public Singleton
    
     {
   public:    SensorManager(); //调用assertStateLocked    ~SensorManager();    //调用assertStateLocked,并返回mSensorList    ssize_t getSensorList(Sensor const* const** list) const;    // 返回mSensorList中第一个类型与type一致的sensor     Sensor const* getDefaultSensor(int type);    // 调用mSensorServer->createSensorEventConnection创建一个连接(ISensorEventConnection)    // 并用此连接做为参数创建一个SensorEventQueue对象并返回    sp
     
       createEventQueue();private:    // DeathRecipient interface    void sensorManagerDied();    // 调用getService获取SensorService客户端并保存在mSensorServer中    // 调用mSensorServer->getSensorList获取sensor列表，并保存在mSensors和mSensorList中    status_t assertStateLocked() const;private:    mutable Mutex mLock;    mutable sp
      
        mSensorServer; // SensorService客户端    mutable Sensor const** mSensorList; // sensor列表    mutable Vector
       
         mSensors;    // sensor列表    mutable sp
        
          mDeathObserver;}
        
       
      
     
    

 

class ISensorEventConnection : public IInterface{
   public:    DECLARE_META_INTERFACE(SensorEventConnection);    virtual sp
    
      getSensorChannel() const = 0;    virtual status_t enableDisable(int handle, bool enabled) = 0;    virtual status_t setEventRate(int handle, nsecs_t ns) = 0;};
    

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与客户端的接口定义如下：

class ISensorServer : public IInterface{
   public:    DECLARE_META_INTERFACE(SensorServer);    virtual Vector
    
      getSensorList() = 0;    virtual sp
     
       createSensorEventConnection() = 0;};
     
    

    SensorService定义如下：

class SensorService :        public BinderService
    
     , //创建SensorService对象，并增加到ServiceManager中        public BnSensorServer, // 申明了SensorService与客户端(SensorManager)间的binder接口        protected Thread // 线程辅助类，调用run创建并启动线程，然后在线程主函数内回调threadLoop函数,                         // 所以在使用它时，做一个派生，并根据需要重写threadLoop即可                    {   friend class BinderService
     
      ;   static const nsecs_t MINIMUM_EVENTS_PERIOD =   1000000; // 1000 Hz            SensorService();    virtual ~SensorService();       /*    在addService时，第一次构建sp强引用对象时，会调用onFirstRef函数     实现功能如下：     1) 获取SensorDevice实例     2) 调用SensorDevice.getSensorList获取sensor_t列表     3) 根据硬件sensor_t创建HardwareSensor,然后加入mSensorList(Sensor)            和mSensorMap(HardwareSensor)中     4) 根据硬件sensor_t创建对应的senosr(如GravitySensor),            然后加入mVirtualSensorList和mSensorList中     5) mUserSensorList = mSensorList;     6) run("SensorService", PRIORITY_URGENT_DISPLAY);运行线程，并执行threadLoop    */    virtual void onFirstRef();     // Thread interface    /*      1) 调用SensorDevice.poll获取sensors_event_t事件      2) 获取已经激活的sensor列表mActiveVirtualSensors      3) 对每一个事件，执行SensorFusion.process      4) 对每一个事件，执行HardwareSensor.process(事件无变化,直接copy)      5) 调用SensorService::SensorEventConnection::sendEvents，把事件发             送给所有的listener    */    virtual bool threadLoop();    // ISensorServer interface    // 返回mUserSensorList    virtual Vector
      
        getSensorList();        // 实例化SensorEventConnection并返回    virtual sp
       
         createSensorEventConnection();    virtual status_t dump(int fd, const Vector
        
         & args);    //====================================================================    //============== SensorEventConnection  start ========================    class SensorEventConnection : public BnSensorEventConnection {        virtual ~SensorEventConnection();        virtual void onFirstRef(); // 返回mChannel        virtual sp
         
           getSensorChannel() const; // 调用SensorService::enable或SensorService::disable        virtual status_t enableDisable(int handle, bool enabled);        // 调用SensorService::setEventRate        virtual status_t setEventRate(int handle, nsecs_t ns);        sp
          
            const mService; // 保存当前SensorService实例        sp
           
             const mChannel; // SensorChannel实例        mutable Mutex mConnectionLock;        // protected by SensorService::mLock        SortedVector
            
              mSensorInfo;    public:        /*          1) 把当前service保存在mService中          2) 创建SensorChannel实例，并保存在mChannel中             (在SensorChannel::SensorChannel中创建pipe,并把收和发都设置非阻塞)        */        SensorEventConnection(const sp
             
              & service);        // 调用连接中的mChannel->write (SensorChannel::write),把符合条件的事件写入pipe        status_t sendEvents(sensors_event_t const* buffer, size_t count,                sensors_event_t* scratch = NULL);        bool hasSensor(int32_t handle) const; //检查handle是否在mSensorInfo中        bool hasAnySensor() const;   //检查mSensorInfo中是否有sensor        bool addSensor(int32_t handle); //把handle增加到mSensorInfo列表中        bool removeSensor(int32_t handle); //把handle从mSensorInfo中删除    };    //============== SensorEventConnection  end ========================    //====================================================================    class SensorRecord {         SortedVector< wp
              
                > mConnections;    public:        SensorRecord(const sp
               
                & connection);        bool addConnection(const sp
                
                 & connection);        bool removeConnection(const wp
                 
                  & connection);        size_t getNumConnections() const { return mConnections.size(); }    };    SortedVector< wp
                  
                    > getActiveConnections() const;    DefaultKeyedVector
                   
                     getActiveVirtualSensors() const;    String8 getSensorName(int handle) const;    void recordLastValue(sensors_event_t const * buffer, size_t count);    static void sortEventBuffer(sensors_event_t* buffer, size_t count);    void registerSensor(SensorInterface* sensor);    void registerVirtualSensor(SensorInterface* sensor);    // constants    Vector
                    
                      mSensorList;  // Sensor列表    Vector
                     
                       mUserSensorList; //与mSensorList一样    DefaultKeyedVector
                      
                        mSensorMap; //其成员为HardwareSensor    Vector
                       
                         mVirtualSensorList; //其成员为HardwareSensor    status_t mInitCheck;    // protected by mLock    mutable Mutex mLock;    DefaultKeyedVector
                        
                          mActiveSensors; //成员为SensorRecord    DefaultKeyedVector
                         
                           mActiveVirtualSensors; //成员为HardwareSensor    SortedVector< wp
                          
                            > mActiveConnections;    // The size of this vector is constant, only the items are mutable    KeyedVector
                           
                             mLastEventSeen;public:    static char const* getServiceName() { return "sensorservice"; }    void cleanupConnection(SensorEventConnection* connection);    /*      1) 调用HardwareSensor::activate，即SensorDevice::activate      2) 然后创建SensorRecord并增加到列表mActiveSensors      3) 把此HardwareSensor增加到连接的mSensorInfo      4) 把此连接增加到mActiveConnections中    */    status_t enable(const sp
                            
                             & connection, int handle);    /*       1) 把此sensor从连接的mSensorInfo中删除       2) 把此连接从mActiveConnections中删除       3) 调用HardwareSensor::activate，即SensorDevice::activate    */    status_t disable(const sp
                             
                              & connection, int handle);    /*       1)调用HardwareSensor::setDelay，即SensorDevice::setDelay     */    status_t setEventRate(const sp
                              
                               & connection, int handle, nsecs_t ns);}
                              
                             
                            
                           
                          
                         
                        
                       
                      
                     
                    
                   
                  
                 
                
               
              
             
            
           
          
         
        
       
      
     
    

2.5 SensorDevice.cpp

      SensorDevice封装了对SensorHAL层代码的调用，主要包含以下功能：

         1) 获取sensor列表(getSensorList)         2) 获取sensor事件(poll)         3) Enable或Disable sensor (activate)         4) 设置delay时间

 

class SensorDevice : public Singleton
    
      {    friend class Singleton
     
      ;    struct sensors_poll_device_t* mSensorDevice; // sensor设备    struct sensors_module_t* mSensorModule;    mutable Mutex mLock; // protect mActivationCount[].rates    // fixed-size array after construction    struct Info {
            Info() : delay(0) { }        KeyedVector
      
        rates;        nsecs_t delay;        status_t setDelayForIdent(void* ident, int64_t ns);        nsecs_t selectDelay();    };    DefaultKeyedVector
       
         mActivationCount;    /*      1) 调用hw_get_module(SENSORS_HARDWARE_MODULE_ID,..)获取sensors_module_t，             并保存在mSensorModule中      2) 调用mSensorModule->common->methods->open,以返回sensors_poll_device_t,             并保存在mSensorDevice中      3) 调用mSensorModule->get_sensors_list所有可访问的sensor_t      4) 调用mSensorDevice->activate激活所有的sensor    */    SensorDevice();public:    // 调用mSensorModule->get_sensors_list实现    ssize_t getSensorList(sensor_t const** list);    status_t initCheck() const;    // 调用mSensorDevice->poll实现    ssize_t poll(sensors_event_t* buffer, size_t count);    // 调用mSensorDevice->activate实现    status_t activate(void* ident, int handle, int enabled);        // 调用mSensorDevice->setDelay实现    status_t setDelay(void* ident, int handle, int64_t ns);    void dump(String8& result, char* buffer, size_t SIZE);};
       
      
     
    

2.6 Sensor HAL

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

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

2.6.1 struct sensors_poll_device_t 定义     

struct sensors_poll_device_t {
        struct hw_device_t common;    // Activate/deactivate one sensor.    int (*activate)(struct sensors_poll_device_t *dev,            int handle, int enabled);    // Set the delay between sensor events in nanoseconds for a given sensor.    int (*setDelay)(struct sensors_poll_device_t *dev,            int handle, int64_t ns);    // Returns an array of sensor data.    int (*poll)(struct sensors_poll_device_t *dev,            sensors_event_t* data, int count);};

2.6.2 struct sensors_module_t  定义

struct sensors_module_t {
        struct hw_module_t common;    /**     * Enumerate all available sensors. The list is returned in "list".     * @return number of sensors in the list     */    int (*get_sensors_list)(struct sensors_module_t* module,            struct sensor_t const** list);};

2.6.3  struct sensor_t 定义

struct sensor_t {
        /* name of this sensors */    const char*     name;    /* vendor of the hardware part */    const char*     vendor;    /* version of the hardware part + driver. The value of this field     * must increase when the driver is updated in a way that changes the     * output of this sensor. This is important for fused sensors when the     * fusion algorithm is updated.     */        int             version;    /* handle that identifies this sensors. This handle is used to activate     * and deactivate this sensor. The value of the handle must be 8 bits     * in this version of the API.      */    int             handle;    /* this sensor's type. */    int             type;    /* maximaum range of this sensor's value in SI units */    float           maxRange;    /* smallest difference between two values reported by this sensor */    float           resolution;    /* rough estimate of this sensor's power consumption in mA */    float           power;    /* minimum delay allowed between events in microseconds. A value of zero     * means that this sensor doesn't report events at a constant rate, but     * rather only when a new data is available */    int32_t         minDelay;    /* reserved fields, must be zero */    void*           reserved[8];};

2.6.4 struct sensors_event_t 定义

typedef struct {
        union {        float v[3];        struct {
                float x;            float y;            float z;        };        struct {
                float azimuth;            float pitch;            float roll;        };    };    int8_t status;    uint8_t reserved[3];} sensors_vec_t;/** * Union of the various types of sensor data * that can be returned. */typedef struct sensors_event_t {
        /* must be sizeof(struct sensors_event_t) */    int32_t version;    /* sensor identifier */    int32_t sensor;    /* sensor type */    int32_t type;    /* reserved */    int32_t reserved0;    /* time is in nanosecond */    int64_t timestamp;    union {        float           data[16];        /* acceleration values are in meter per second per second (m/s^2) */        sensors_vec_t   acceleration;        /* magnetic vector values are in micro-Tesla (uT) */        sensors_vec_t   magnetic;        /* orientation values are in degrees */        sensors_vec_t   orientation;        /* gyroscope values are in rad/s */        sensors_vec_t   gyro;        /* temperature is in degrees centigrade (Celsius) */        float           temperature;        /* distance in centimeters */        float           distance;        /* light in SI lux units */        float           light;        /* pressure in hectopascal (hPa) */        float           pressure;        /* relative humidity in percent */        float           relative_humidity;    };    uint32_t        reserved1[4];} sensors_event_t;

2.6.5 struct sensors_module_t 实现

#include 
    
     #include "nusensors.h"/* * the AK8973 has a 8-bit ADC but the firmware seems to average 16 samples, * or at least makes its calibration on 12-bits values. This increases the * resolution by 4 bits. */static const struct sensor_t sSensorList[] = {
            { "MMA8452Q 3-axis Accelerometer",                 "Freescale Semiconductor",                1, SENSORS_HANDLE_BASE+ID_A,                SENSOR_TYPE_ACCELEROMETER, 4.0f*9.81f, (4.0f*9.81f)/256.0f, 0.2f, 0, { } },        { "AK8975 3-axis Magnetic field sensor",                "Asahi Kasei",                1, SENSORS_HANDLE_BASE+ID_M,                SENSOR_TYPE_MAGNETIC_FIELD, 2000.0f, 1.0f/16.0f, 6.8f, 0, { } },        { "AK8975 Orientation sensor",                "Asahi Kasei",                1, SENSORS_HANDLE_BASE+ID_O,                SENSOR_TYPE_ORIENTATION, 360.0f, 1.0f, 7.0f, 0, { } },  { "ST 3-axis Gyroscope sensor",          "STMicroelectronics",          1, SENSORS_HANDLE_BASE+ID_GY,          SENSOR_TYPE_GYROSCOPE, RANGE_GYRO, CONVERT_GYRO, 6.1f, 1190, { } },    { "AL3006Proximity sensor",  "Dyna Image Corporation",  1, SENSORS_HANDLE_BASE+ID_P,  SENSOR_TYPE_PROXIMITY,  PROXIMITY_THRESHOLD_CM, PROXIMITY_THRESHOLD_CM,  0.5f, 0, { } },          { "AL3006 light sensor",                "Dyna Image Corporation",                1, SENSORS_HANDLE_BASE+ID_L,                SENSOR_TYPE_LIGHT, 10240.0f, 1.0f, 0.5f, 0, { } },};static int open_sensors(const struct hw_module_t* module, const char* name,        struct hw_device_t** device);static int sensors__get_sensors_list(struct sensors_module_t* module,        struct sensor_t const** list){    *list = sSensorList;    return ARRAY_SIZE(sSensorList);}static struct hw_module_methods_t sensors_module_methods = {
        .open = open_sensors};const struct sensors_module_t HAL_MODULE_INFO_SYM = {
        .common = {        .tag = HARDWARE_MODULE_TAG,        .version_major = 1,        .version_minor = 0,        .id = SENSORS_HARDWARE_MODULE_ID,        .name = "MMA8451Q & AK8973A & gyro Sensors Module",        .author = "The Android Project",        .methods = &sensors_module_methods,    },    .get_sensors_list = sensors__get_sensors_list};static int open_sensors(const struct hw_module_t* module, const char* name,        struct hw_device_t** device){    return init_nusensors(module, device); //待后面讲解}
    

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 定义 

struct sensors_poll_context_t {
        struct sensors_poll_device_t device; // must be first        sensors_poll_context_t();        ~sensors_poll_context_t();    int activate(int handle, int enabled);    int setDelay(int handle, int64_t ns);    int pollEvents(sensors_event_t* data, int count);private:    enum {          light           = 0,        proximity       = 1,        mma             = 2,        akm             = 3,        gyro            = 4,        numSensorDrivers,        numFds,    };    static const size_t wake = numFds - 1;    static const char WAKE_MESSAGE = 'W';    struct pollfd mPollFds[numFds];    int mWritePipeFd;    SensorBase* mSensors[numSensorDrivers];    int handleToDriver(int handle) const {        switch (handle) {            case ID_A:                return mma;            case ID_M:   case ID_O:                return akm;             case ID_P:                return proximity;            case ID_L:                return light;    case ID_GY:    return gyro;        }        return -EINVAL;    }}

6.2) init_nusensors 实现

int init_nusensors(hw_module_t const* module, hw_device_t** device){    int status = -EINVAL;    sensors_poll_context_t *dev = new sensors_poll_context_t();    memset(&dev->device, 0, sizeof(sensors_poll_device_t));    dev->device.common.tag = HARDWARE_DEVICE_TAG;    dev->device.common.version  = 0;    dev->device.common.module   = const_cast
    
     (module);    dev->device.common.close    = poll__close;    dev->device.activate        = poll__activate;    dev->device.setDelay        = poll__setDelay;    dev->device.poll            = poll__poll;    *device = &dev->device.common;    status = 0;    return status;}
    

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

        (1)  poll__activate

        (2)   poll__setDelay

        (3)   poll__poll

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

6.3) struct sensors_poll_context_t 的实现

sensors_poll_context_t::sensors_poll_context_t(){     mSensors[light] = new LightSensor();    mPollFds[light].fd = mSensors[light]->getFd();    mPollFds[light].events = POLLIN;    mPollFds[light].revents = 0;    mSensors[proximity] = new ProximitySensor();    mPollFds[proximity].fd = mSensors[proximity]->getFd();    mPollFds[proximity].events = POLLIN;    mPollFds[proximity].revents = 0;     mSensors[mma] = new MmaSensor();  //下面MmmaSensor为例进行分析    mPollFds[mma].fd = mSensors[mma]->getFd();    mPollFds[mma].events = POLLIN;    mPollFds[mma].revents = 0;    mSensors[akm] = new AkmSensor();    mPollFds[akm].fd = mSensors[akm]->getFd();    mPollFds[akm].events = POLLIN;    mPollFds[akm].revents = 0; mSensors[gyro] = new GyroSensor();    mPollFds[gyro].fd = mSensors[gyro]->getFd();    mPollFds[gyro].events = POLLIN;    mPollFds[gyro].revents = 0;    int wakeFds[2];    int result = pipe(wakeFds);    LOGE_IF(result<0, "error creating wake pipe (%s)", strerror(errno));    fcntl(wakeFds[0], F_SETFL, O_NONBLOCK);    fcntl(wakeFds[1], F_SETFL, O_NONBLOCK);    mWritePipeFd = wakeFds[1];    mPollFds[wake].fd = wakeFds[0];    mPollFds[wake].events = POLLIN;    mPollFds[wake].revents = 0;}sensors_poll_context_t::~sensors_poll_context_t() {    for (int i=0 ; i
    
     enable(handle, enabled);    if (enabled && !err) {        const char wakeMessage(WAKE_MESSAGE);        int result = write(mWritePipeFd, &wakeMessage, 1);        LOGE_IF(result<0, "error sending wake message (%s)", strerror(errno));    }    return err;}int sensors_poll_context_t::setDelay(int handle, int64_t ns) {    int index = handleToDriver(handle);    if (index < 0) return index;    return mSensors[index]->setDelay(handle, ns);}int sensors_poll_context_t::pollEvents(sensors_event_t* data, int count){    int nbEvents = 0;    int n = 0;    do {        // see if we have some leftover from the last poll()        for (int i=0 ; count && i
     
      hasPendingEvents())) {                int nb = sensor->readEvents(data, count); // num of evens received.    D("nb = %d.", nb);                if (nb < count) {                    // no more data for this sensor                    mPollFds[i].revents = 0;                }                count -= nb;                nbEvents += nb;                data += nb;            }        }        if (count) {            // we still have some room, so try to see if we can get            // some events immediately or just wait if we don't have            // anything to return            n = poll(mPollFds, numFds, nbEvents ? 0 : -1);            if (n<0) {                LOGE("poll() failed (%s)", strerror(errno));                return -errno;            }            if (mPollFds[wake].revents & POLLIN) {                char msg;                int result = read(mPollFds[wake].fd, &msg, 1);                LOGE_IF(result<0, "error reading from wake pipe (%s)", strerror(errno));                LOGE_IF(msg != WAKE_MESSAGE, "unknown message on wake queue (0x%02x)", int(msg));                mPollFds[wake].revents = 0;            }        }        // if we have events and space, go read them    } while (n && count);    return nbEvents;}/*****************************************************************************/static int poll__close(struct hw_device_t *dev){    sensors_poll_context_t *ctx = (sensors_poll_context_t *)dev;    if (ctx) {        delete ctx;    }    return 0;}static int poll__activate(struct sensors_poll_device_t *dev,        int handle, int enabled) {    sensors_poll_context_t *ctx = (sensors_poll_context_t *)dev;    return ctx->activate(handle, enabled);}static int poll__setDelay(struct sensors_poll_device_t *dev,        int handle, int64_t ns) {    sensors_poll_context_t *ctx = (sensors_poll_context_t *)dev;    return ctx->setDelay(handle, ns);}static int poll__poll(struct sensors_poll_device_t *dev,        sensors_event_t* data, int count) {    sensors_poll_context_t *ctx = (sensors_poll_context_t *)dev;    return ctx->pollEvents(data, count);}
     
    

下面MmaSensor为例进行分析。

2.7 MmaSensor.cpp

1)  SensorBase的实现(SensorBase.cpp)

class SensorBase {
    protected:    const char* dev_name; // "/dev/mma8452_daemon"    const char* data_name; // "gsensor"    int         dev_fd; // 打开设备"/dev/mma8452_daemon"的fd        // 打开事件"/dev/input/eventx"的fd,其驱动的名字为"gsensor"    int         data_fd;         // 打开与"gsensor"对应的事件"/dev/input/eventx"    static int openInput(const char* inputName);     //通过clock_gettime获取当前时间    static int64_t getTimestamp();     static int64_t timevalToNano(timeval const& t) {        return t.tv_sec*1000000000LL + t.tv_usec*1000;    }    int open_device(); //打开设备"dev/mma8452_daemon"    int close_device(); //关闭设备"dev/mma8452_daemon"public:    // 调用openInput            SensorBase(                    const char* dev_name,                    const char* data_name);    virtual ~SensorBase();    virtual int readEvents(sensors_event_t* data, int count) = 0;    virtual bool hasPendingEvents() const;    virtual int getFd() const;  //返回data_fd    virtual int setDelay(int32_t handle, int64_t ns);    virtual int enable(int32_t handle, int enabled) = 0;};

2) MmaSensor的实现

class MmaSensor : public SensorBase {
   public:    /*      1) 设置dev_name为 "/dev/mma8452_daemon"      2) 设置data_name为 "gsensor"      3) open设备 "/dev/mma8452_daemon"    */            MmaSensor();    virtual ~MmaSensor();    enum {        Accelerometer   = 0,        numSensors    };    // 调用ioctl(MMA_IOCTL_APP_SET_RATE)    virtual int setDelay(int32_t handle, int64_t ns);    /*      1) Activate: ioctl(MMA_IOCTL_START)      2) Deactivate: ioctl(MMA_IOCTL_CLOSE)    */    virtual int enable(int32_t handle, int enabled);        /*      1) 从data_fd read input_event      2) 调用processEvent对事件进行处理      3) 把事件通过data返回    */    virtual int readEvents(sensors_event_t* data, int count);    void processEvent(int code, int value);private:    int update_delay();    uint32_t mEnabled;    uint32_t mPendingMask;    InputEventCircularReader mInputReader;    sensors_event_t mPendingEvents[numSensors];    uint64_t mDelays[numSensors];};

3. 加载HAL

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

#define HAL_LIBRARY_PATH1 "/system/lib/hw"#define HAL_LIBRARY_PATH2 "/vendor/lib/hw"#define SENSORS_HARDWARE_MODULE_ID "sensors"SensorDevice::SensorDevice()    :  mSensorDevice(0),       mSensorModule(0){    status_t err = hw_get_module(SENSORS_HARDWARE_MODULE_ID,            (hw_module_t const**)&mSensorModule);    ALOGE_IF(err, "couldn't load %s module (%s)",            SENSORS_HARDWARE_MODULE_ID, strerror(-err));    if (mSensorModule) {        err = sensors_open(&mSensorModule->common, &mSensorDevice);        ALOGE_IF(err, "couldn't open device for module %s (%s)",                SENSORS_HARDWARE_MODULE_ID, strerror(-err));        if (mSensorDevice) {            sensor_t const* list;            ssize_t count = mSensorModule->get_sensors_list(mSensorModule, &list);            mActivationCount.setCapacity(count);            Info model;            for (size_t i=0 ; i
    
     activate(mSensorDevice, list[i].handle, 0);            }        }    }}int hw_get_module(const char *id, const struct hw_module_t **module){    return hw_get_module_by_class(id, NULL, module);}int hw_get_module_by_class(const char *class_id, const char *inst,                           const struct hw_module_t **module){    int status;    int i;    const struct hw_module_t *hmi = NULL;    char prop[PATH_MAX];    char path[PATH_MAX];    char name[PATH_MAX];    if (inst)        snprintf(name, PATH_MAX, "%s.%s", class_id, inst);    else        strlcpy(name, class_id, PATH_MAX);    /*     * Here we rely on the fact that calling dlopen multiple times on     * the same .so will simply increment a refcount (and not load     * a new copy of the library).     * We also assume that dlopen() is thread-safe.     */    /* Loop through the configuration variants looking for a module */    for (i=0 ; i
    

4. 启动SensorService

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

extern "C" status_t system_init(){    ....    property_get("system_init.startsensorservice", propBuf, "1");    if (strcmp(propBuf, "1") == 0) {        // Start the sensor service        SensorService::instantiate();    }    ...    return NO_ERROR;}

5. SensorManager注册Listener过程

private SensorManager mSensorManager = (SensorManager) getSystemService(SENSOR_SERVICE);registerListener(SensorManager.java)-> registerListenerImpl (SystemSensorManager.java)->  enableSensorLocked(SystemSensorManager.java)->   sensors_enable_sensor(android_hardware_SensorManager.cpp)->    SensorEventQueue::enableSensor(SensorEventQueue.cpp)->     1>SensorService::SensorEventConnection::enableDisable(handle, true) (SensorService.cpp)->         SensorService::enable(SensorService.cpp)->           HardwareSensor::activate(SensorInterface.cpp)->             SensorDevice::activate(SensorDevice.cpp)->               sensors_poll_device_t::activate(HAL)              2>SensorService::SensorEventConnection::setEventRate(SensorService.cpp)->