android 6.0 高通平台sensor 工作机制及流程(原创)

最近工作上有碰到sensor的相关问题，正好分析下其流程作个笔记。

这个笔记分三个部分：

1. sensor硬件和驱动的工作机制
2. sensor 上层app如何使用
3. 从驱动到上层app这中间的流程是如何

Sensor硬件和驱动的工作机制

先看看Accerometer ＋Gyro Sensor的原理图：

总结起来分四个部分（电源，地，通信接口，中断脚）。电源和地与平台和芯片本身有关系，与我们分析的没有多少关系，根据sensor的特性保证sensor正常工作的上电时序。关于通信接口，sensor与ap之间通信一般有两种接口（I2C／SPI）。因sensor数据量不大，I2C的速度足矣，目前使用I2C的居多。SDA是I2C的数据线，SCL是I2C的clock线。关于中断脚就是INT。Sensor有两个工作模式。一种是主动上报数据（每时每刻将获取到的数据上报给系统），另个一种是中断模式（当数据的变化大于了之前设置的触发条件），比如手机翻转大于45度，就会将当前的变化及当前数据上报给系统。

Sensor上层app的使用

先要注册指定sensor的事件监听，然在在有事件上报上来时，获取上报的数据。

具体代码如下：

 1 SensorManager　mSensorManager = (SensorManager)mContext.getSystemService(Context.SENSOR_SERVICE);
 2 Sensor　mSensor = mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
 3
 4 mSensorManager.registerListener(mSensorListener, mSensor, SensorManager.SENSOR_DELAY_GAME);
 5 /*
 6     public static final int SENSOR_DELAY_FASTEST = 0;
 7     public static final int SENSOR_DELAY_GAME = 1;
 8     public static final int SENSOR_DELAY_UI = 2;
 9     public static final int SENSOR_DELAY_NORMAL = 3;
10 上报的速度可以根据需求来选择
11 */
12
13 SensorEventListener mSensorListener = new SensorEventListener(){
14       public void onAccuracyChanged(Sensor arg0, int arg1){
15     }
16
17     public void onSensorChanged(SensorEvent event){
18         if(event.sensor == null){
19             return;
20         }
21         Log.d(TAG, "onSensorChanged");
22         if(Sensor.TYPE_ACCELEROMETER == event.sensor.getType()) {
23             mGsensor = (float)event.values[SensorManager.DATA_Z];
24             mSensorManager.unregisterListener(this);
25             Log.e(TAG, "mgsensor = " + mGsensor);
26             mOnSensorChangedFlag = false;
27         }
28     }
29 }

从驱动到上层App这中间的流程如何

前面二段分别说了驱动上报数据和app读取数据，但中间的流程是如何的呢，这个是此篇博客的重点了。

驱动层上报数据后，HAL层怎么处理呢？这个属于input　hal层的接收和分发了。来，我们来啃啃这个骨头：

frameworks/base/core/java/android/app/SystemServiceRegistry.java

         registerService(Context.SENSOR_SERVICE, SensorManager.class,
                 new CachedServiceFetcher<SensorManager>() {
             @Override
             public SensorManager createService(ContextImpl ctx) {
                 return new SystemSensorManager(ctx.getOuterContext(),
                   ctx.mMainThread.getHandler().getLooper());
             }});

mContext.getSystemService(Context.SENSOR_SERVICE) 返回的就是SystemSensorManager 的对象（也是继承SensorManager 类）。

frameworks/base/core/java/android/hardware/SensorManager.java

     public Sensor getDefaultSensor(int type) {
......................................................................
         List<Sensor> l = getSensorList(type);
         boolean wakeUpSensor = false;

          if (type == Sensor.TYPE_PROXIMITY || type == Sensor.TYPE_SIGNIFICANT_MOTION ||
                  type == Sensor.TYPE_TILT_DETECTOR || type == Sensor.TYPE_WAKE_GESTURE ||
                  type == Sensor.TYPE_GLANCE_GESTURE || type == Sensor.TYPE_PICK_UP_GESTURE ||
                  type == Sensor.TYPE_WRIST_TILT_GESTURE) {
              wakeUpSensor = true;
          }
  //返回支持唤醒的sensor
          for (Sensor sensor : l) {
              if (sensor.isWakeUpSensor() == wakeUpSensor) return sensor;
          }
}

我们再看看getSensorList这里面有啥玩意。。。。

    public List<Sensor> getSensorList(int type) {
.......................................................................
        final List<Sensor> fullList = getFullSensorList();
        //然后再种所有sensor中找出对应的sensor
                    for (Sensor i : fullList) {
                        if (i.getType() == type)
                            list.add(i);
                    }
        return list；
｝

getFullSensorList这个函数返回的是mFullSensorsList。
mFullSensorList是SystemSensorManager 遍历所有的sensor得到的集合。
下一步我们再来看看registerListener是怎么回事。
frameworks/base/core/java/android/hardware/SystemSensorManager.java

    protected boolean registerListenerImpl(SensorEventListener listener, Sensor sensor, int delayUs, Handler handler, int maxBatchReportLatencyUs, int reservedFlags) {
        synchronized (mSensorListeners) {
            //先查看下此sensor的监听队列是否已经存在，如果不存在，就重新new个
            SensorEventQueue queue = mSensorListeners.get(listener);
            if (queue == null) {
                queue = new SensorEventQueue(listener, looper, this, fullClassName);
                mSensorListeners.put(listener, queue);
                return true;
            } else {
                return queue.addSensor(sensor, delayUs, maxBatchReportLatencyUs);
            }
｝

到这里就明显是一个消息队列回调的问题了，肯定是发现消息队列里有消息时就会回调具体的事件。我们继续撸代码。

static final class SensorEventQueue extends BaseEventQueue {
        protected void dispatchSensorEvent(int handle, float[] values, int inAccuracy,
                long timestamp) {
......................................................
            // call onAccuracyChanged() only if the value changes
            final int accuracy = mSensorAccuracies.get(handle);
            if ((t.accuracy >= ) && (accuracy != t.accuracy)) {
                mSensorAccuracies.put(handle, t.accuracy);
                mListener.onAccuracyChanged(t.sensor, t.accuracy);
            }
            mListener.onSensorChanged(t);
        }
}

从这里就可以看我们listener里实现的onAccuracyChanged，onSensorChanged是怎么被调用。

frameworks/base/core/java/android/hardware/SensorEventListener.java

public interface SensorEventListener {
    public void onSensorChanged(SensorEvent event);
    public void onAccuracyChanged(Sensor sensor, int accuracy);
｝

就是一个接口，里面声明两个函数。

看到回调是在dispatchSensorEvent里做的，看看是谁调用的。。。

frameworks/base/core/jni/android_hardware_SensorManager.cpp

class Receiver : public LooperCallback {
    virtual int handleEvent(int fd, int events, void* data) {

        ASensorEvent buffer[];
        while ((n = q->read(buffer, )) > ) {
            for (int i= ; i<n ; i++) {
                if (buffer[i].type == SENSOR_TYPE_META_DATA) {
                    // This is a flush complete sensor event. Call dispatchFlushCompleteEvent
                    // method.
                    if (receiverObj.get()) {
                        env->CallVoidMethod(receiverObj.get(),
                                            gBaseEventQueueClassInfo.dispatchFlushCompleteEvent,
                                            buffer[i].meta_data.sensor);
                    }
                } else {
                    if (receiverObj.get()) {
                        env->CallVoidMethod(receiverObj.get(),
                                            gBaseEventQueueClassInfo.dispatchSensorEvent,
                                            buffer[i].sensor,
                                            mScratch,
                                            status,
                                            buffer[i].timestamp);
                    }

              }
            }
        }
}

读到的数据，根据数据的类型去回调不同的接口。dispatchSensorEvent就是在这里被调用的。

handleEvent这个是一个典型的eventQueue这事件处理，具体就不在这里分析了。

 回调这些都有分析了，那事件是哪里加入到消息队列中的，那些消息又是怎么来的呢，话说问题问对了，就能找到往下查的路了。。哈哈

理论这些肯定会有sensor服务在开机的时候启动的，那服务在哪里，是怎么启动的呢。。。

frameworks/base/services/java/com/android/server/SystemServer.java

private void startBootstrapServices() {
...................................................
startSensorService();
}

这个startSensorService是个jni函数，调用的是：

frameworks/base/services/core/jni/com_android_server_SystemServer.cpp

static void android_server_SystemServer_startSensorService(JNIEnv* /* env */, jobject /* clazz */) {
//创建一个线程做sensorinit的工作
pthread_create( &sensor_init_thread, NULL, &sensorInit, NULL);
｝

void* sensorInit(void *arg) {
    SensorService::instantiate();
｝

sensorService服务就做初始化了,服务启动时会做threadLoop（），

bool SensorService::threadLoop()
{
    ALOGD("nuSensorService thread starting...");

    const size_t minBufferSize = SensorEventQueue::MAX_RECEIVE_BUFFER_EVENT_COUNT;
    const size_t numEventMax = minBufferSize / ( + mVirtualSensorList.size());

//device初始化
    SensorDevice& device(SensorDevice::getInstance());
    const size_t vcount = mVirtualSensorList.size();

    const int halVersion = device.getHalDeviceVersion();
    do {
//调用device.poll
        ssize_t count = device.poll(mSensorEventBuffer, numEventMax);
        if (count < ) {
            ALOGE("sensor poll failed (%s)", strerror(-count));
            break;
        }
}

再看看SensorDevice 里初始化和poll里做了啥　：

SensorDevice::SensorDevice()
    :  mSensorDevice(),
       mSensorModule()
{
　　//get HAL module
    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) {
　　　　　//open HAL module
        err = sensors_open_1(&mSensorModule->common, &mSensorDevice);
...................................................
}

SensorDevice初始化做了两个动作，一个是获取sensor HAL module，紧接着打开sensor hal module。

再一起看年poll里做啥了，

ssize_t SensorDevice::poll(sensors_event_t* buffer, size_t count) {
    if (!mSensorDevice) return NO_INIT;
    ssize_t c;
    do {
        c = mSensorDevice->poll(reinterpret_cast<struct sensors_poll_device_t *> (mSensorDevice),
                                buffer, count);
    } while (c == -EINTR);
    return c;
}

poll也是调用　的是Hal module里的poll。

那sensor HAL里做了啥呢，模块做了啥呢？

sensor　hal路径：hardware/libhardware/modules/sensors/

hardware/libhardware/modules/sensors/multihal.cpp

 static int open_sensors(const struct hw_module_t* hw_module, const char* name,
         struct hw_device_t** hw_device_out) {
     ALOGV("open_sensors begin...");
 //初始化加载高通的库
     lazy_init_modules();

     // Create proxy device, to return later.
     sensors_poll_context_t *dev = new sensors_poll_context_t();
     memset(dev, , sizeof(sensors_poll_device_1_t));
     dev->proxy_device.common.tag = HARDWARE_DEVICE_TAG;
     dev->proxy_device.common.version = SENSORS_DEVICE_API_VERSION_1_3;
     dev->proxy_device.common.module = const_cast<hw_module_t*>(hw_module);
     dev->proxy_device.common.close = device__close;
     dev->proxy_device.activate = device__activate;
     dev->proxy_device.setDelay = device__setDelay;
     dev->proxy_device.poll = device__poll;
     dev->proxy_device.batch = device__batch;
     dev->proxy_device.flush = device__flush;
.......................................
}

我们看看lazy_init_modules()这个,是把指定的的hal so加载起来。。

 /*
482  * Ensures that the sub-module array is initialized.
483  * This can be first called from get_sensors_list or from open_sensors.
484  */
 static void lazy_init_modules() {
     pthread_mutex_lock(&init_modules_mutex);
     if (sub_hw_modules != NULL) {
         pthread_mutex_unlock(&init_modules_mutex);
         return;
     }
     std::vector<std::string> *so_paths = new std::vector<std::string>();
 /*
482  * Ensures that the sub-module array is initialized.
483  * This can be first called from get_sensors_list or from open_sensors.
484  */
 static void lazy_init_modules() {
     pthread_mutex_lock(&init_modules_mutex);
     if (sub_hw_modules != NULL) {
         pthread_mutex_unlock(&init_modules_mutex);
         return;
     }
     std::vector<std::string> *so_paths = new std::vector<std::string>();
     get_so_paths(so_paths);

     // dlopen the module files and cache their module symbols in sub_hw_modules
     sub_hw_modules = new std::vector<hw_module_t *>();
     dlerror(); // clear any old errors
     const char* sym = HAL_MODULE_INFO_SYM_AS_STR;
     for (std::vector<std::string>::iterator it = so_paths->begin(); it != so_paths->end(); it++) {
         const char* path = it->c_str();
         void* lib_handle = dlopen(path, RTLD_LAZY);
         if (lib_handle == NULL) {
             ALOGW("dlerror(): %s", dlerror());
         } else {
             ALOGI("Loaded library from %s", path);
             ALOGV("Opening symbol \"%s\"", sym);
             // clear old errors
             dlerror();
             struct hw_module_t* module = (hw_module_t*) dlsym(lib_handle, sym);
             const char* error;
             if ((error = dlerror()) != NULL) {
                 ALOGW("Error calling dlsym: %s", error);
             } else if (module == NULL) {
                 ALOGW("module == NULL");
             } else {
                 ALOGV("Loaded symbols from \"%s\"", sym);
                 sub_hw_modules->push_back(module);
             }
         }
     }
     pthread_mutex_unlock(&init_modules_mutex);
 }
          //获取的要加载so库的路径：/system/etc/sensors/hals.conf
     get_so_paths(so_paths);

     // dlopen the module files and cache their module symbols in sub_hw_modules
     sub_hw_modules = new std::vector<hw_module_t *>();
     dlerror(); // clear any old errors
     const char* sym = HAL_MODULE_INFO_SYM_AS_STR;
     for (std::vector<std::string>::iterator it = so_paths->begin(); it != so_paths->end(); it++) {
         const char* path = it->c_str();
         void* lib_handle = dlopen(path, RTLD_LAZY);
         if (lib_handle == NULL) {
             ALOGW("dlerror(): %s", dlerror());
         } else {
             ALOGI("Loaded library from %s", path);
             ALOGV("Opening symbol \"%s\"", sym);
             // clear old errors
             dlerror();
             struct hw_module_t* module = (hw_module_t*) dlsym(lib_handle, sym);
             const char* error;
             if ((error = dlerror()) != NULL) {
                 ALOGW("Error calling dlsym: %s", error);
             } else if (module == NULL) {
                 ALOGW("module == NULL");
             } else {
                 ALOGV("Loaded symbols from \"%s\"", sym);
                 sub_hw_modules->push_back(module);
             }
         }
     }
     pthread_mutex_unlock(&init_modules_mutex);
 }

这个路径下就一个库：sensors.ssc.so

再来看看poll看名字就能猜到是从数据队列里等数据，看代码：

 int sensors_poll_context_t::poll(sensors_event_t *data, int maxReads) {
     ALOGV("poll");
     int empties = ;
     int queueCount = ;
     int eventsRead = ;   

     pthread_mutex_lock(&queue_mutex);
     queueCount = (int)this->queues.size();
     while (eventsRead == ) {
         while (empties < queueCount && eventsRead < maxReads) {
             SensorEventQueue* queue = this->queues.at(this->nextReadIndex);
             sensors_event_t* event = queue->peek();

确实是消息队列。。。

再来年看看加载的so库这个是高通的sensor hal库。

代码路径：vendor/qcom/proprietary/sensors/dsps/libhalsensors

看先从哪里插入数据的：

vendor/qcom/proprietary/sensors/dsps/libhalsensors/src/Utility.cpp

bool Utility::insertQueue(sensors_event_t const *data_ptr){
..........................
        if (q_head_ptr == NULL) {
        /* queue is empty */
            q_tail_ptr = q_ptr;
            q_head_ptr = q_ptr;
        } else {
        /* append to tail and update tail ptr */
            q_tail_ptr->next = q_ptr;
            q_tail_ptr = q_ptr;
        }
}

那看调用的有哪些呢？

Orientation.cpp (src): if (Utility::insertQueue(&la_sample)) {
PedestrianActivityMonitor.cpp (src): if (Utility::insertQueue(&sensor_data)) {
Pedometer.cpp (src): if (Utility::insertQueue(&la_sample)) {
PickUpGesture.cpp (src): if (Utility::insertQueue(&sensor_data)) {
QHeart.cpp (src): if (Utility::insertQueue(&la_sample)) {
RelativeMotionDetector.cpp (src): if (Utility::insertQueue(&sensor_data)) {
RotationVector.cpp (src): if (Utility::insertQueue(&la_sample)) {
Sensor.cpp (src): if (Utility::insertQueue(&flush_evt)){

....................................................................

都在各类sensor的processInd 这个函数中，每种sensor类型根据自身数据的特点，对其做数据结构做指定封装。也就是所谓的工厂模式。

有一个调用比较特别：SMGRSensor.cpp 中processReportInd函数，这个函数中

void SMGRSensor::processReportInd(Sensor** mSensors, sns_smgr_periodic_report_ind_msg_v01* smgr_ind){
...............................
    handle = getHandleFromInd(smgr_ind->ReportId, smgr_data->DataType,
                     smgr_data->SensorId);
    if (handle == - ) {
        HAL_LOG_ERROR(" %s: ReportId = %d  DataType = %d SensorId = %d ", __FUNCTION__,
            smgr_ind->ReportId, smgr_data->DataType, smgr_data->SensorId);
        goto error;
    }
     /* Corresponds to screen orientation req, fill in the right type */
    if ((handle == HANDLE_ACCELERATION) && (smgr_ind->ReportId == HANDLE_MOTION_ACCEL)) {
        sensor_data.type = SENSOR_TYPE_SCREEN_ORIENTATION;
        sensor_data.sensor = HANDLE_MOTION_ACCEL;
    }

    if (mSensors[handle] != NULL) {
        (static_cast<SMGRSensor*>(mSensors[handle]))->processReportInd(smgr_ind, smgr_data, sensor_data);
    }
................................
    if (Utility::insertQueue(&sensor_data)) {
        Utility::signalInd(data_cb);
    }
}

这里根据smgr_data->DataType又做了一次工厂模式的分发处理：

GyroscopeUncalibrated.cpp (src):  FUNCTION:  processReportInd
GyroscopeUncalibrated.cpp (src):void GyroscopeUncalibrated::processReportInd(
GyroscopeUncalibrated.cpp (src):    HAL_LOG_DEBUG("GyroscopeUncalibrated::processReportInd");
GyroscopeUncalibrated.h (inc):  FUNCTION:  processReportInd
GyroscopeUncalibrated.h (inc):    void processReportInd(sns_smgr_periodic_report_ind_msg_v01* smgr_ind,
HallEffect.cpp (src):  FUNCTION:  processReportInd
HallEffect.cpp (src):void HallEffect::processReportInd(sns_smgr_periodic_report_ind_msg_v01* smgr_ind,
HallEffect.h (inc):  FUNCTION:  processReportInd
HallEffect.h (inc):    void processReportInd(sns_smgr_periodic_report_ind_msg_v01* smgr_ind,
Humidity.cpp (src):  FUNCTION:  processReportInd
Humidity.cpp (src):void Humidity::processReportInd(sns_smgr_periodic_report_ind_msg_v01* smgr_ind,
Humidity.h (inc):  FUNCTION:  processReportInd
Humidity.h (inc):    void processReportInd(sns_smgr_periodic_report_ind_msg_v01* smgr_ind,
IRGesture.cpp (src):  FUNCTION:  processReportInd
IRGesture.cpp (src):void IRGesture::processReportInd(sns_smgr_periodic_report_ind_msg_v01* smgr_ind,
IRGesture.h (inc):  FUNCTION:  processReportInd
IRGesture.h (inc):    void processReportInd(sns_smgr_periodic_report_ind_msg_v01* smgr_ind,
Light.cpp (src):  FUNCTION:  processReportInd
Light.cpp (src):void Light::processReportInd(sns_smgr_periodic_report_ind_msg_v01* smgr_ind,
Light.h (inc):  FUNCTION:  processReportInd
Light.h (inc):    void processReportInd(sns_smgr_periodic_report_ind_msg_v01* smgr_ind,
Magnetic.cpp (src):  FUNCTION:  processReportInd
Magnetic.cpp (src):void Magnetic::processReportInd(sns_smgr_periodic_report_ind_msg_v01* smgr_ind,
Magnetic.h (inc):  FUNCTION:  processReportInd
Magnetic.h (inc):    void processReportInd(sns_smgr_periodic_report_ind_msg_v01* smgr_ind

又是根据类型不同，做了另一批类型sensor的处理。
继续反向推导，processReportInd其它这个也是processBufferingInd 调用的，processBufferingInd也是processInd　调用的。这就和其它的sensor到统一战线上了。都是processInd处理的。
关键就是这processInd了，这个是一个回调SMGRSensor_sensor1_cb函数里处理的。那这个回调是谁注册，又是什么调用的呢？
vendor/qcom/proprietary/sensors/dsps/libhalsensors/src/SensorsContext.cpp
这个里面会在SensorContext实例化时注册。

SensorsContext::SensorsContext()
    : active_sensors(),
      is_accel_available(false),
      is_gyro_available(false),
      is_mag_available(false),
      is_prox_available(false),
      smgr_version()
{
。。。。。。。。。。。。。。。。。。。

    err = sensor1_open(&sensor_info_sensor1_cb->sensor1_handle, &context_sensor1_cb, (intptr_t)this);
。。。。。。。。。
}

那得去撸代码啊，不然不知道啥时候回调context_sensor1_cb这个函数啊。。。

这个函数在另一个库中了libsensor1。。

这个函数做的事情比较多，分三部分：

sensor1_open( sensor1_handle_s **hndl,
              sensor1_notify_data_cb_t data_cbf,
              intptr_t cb_data )
{
.........................
  sensor1_init();
............................
sockfd = socket(AF_UNIX, SOCK_SEQPACKET, ))
 strlcpy(address.sun_path, SENSOR_CTL_SOCKET, UNIX_PATH_MAX);
connect(sockfd, (struct sockaddr *)&address, len)
.....................................
libsensor_add_waiting_client(&cli_data);
 libsensor_add_client( &new_cli, false )
.....................................
}

那第一步先看看sensor1_init做了啥？

相当于创建了一个读线程，一直在poll读消息队列里的消息，读到消息后，会封装数据，然后发一个信息去唤醒另外一个线程，唤醒的线程后面再说。

第二步再看看，创建了一个socket（一个客户端socket），去连接服务端的socket（服务端的socket又是什么东东），上个读线程读到的消息就是从socket读到的消息（libsensor_read_socket）,那一定是服务端socket发送过来的嘛。。。

第三步增加client，再看看这个又做了啥？

这里又创建了一个回调线程，等有消息来时，唤醒本线程，然后回调sensor.ssc.库里的context_sensor1_cb。这个线程就谁唤醒的呢，哈哈，大家就能想到就是init中的那个读线程嘛。

总结sensor1_open就是创建一个读线程从socket客户端中读数据，读到数据后，就回调sensor.ssc库中的context_sensor1_cb,进而上报数据做进一步回调。

那问题来了，那个socket服务端又是怎么回事呢。。。慢慢接近真相了。。。。

这时又出现了一个服务SensorDaemon：

代码路径：vendor/qcom/proprietary/sensors/dsps/sensordaemon

sns_main_setup 里创建了socket服务器端，然后监听客户端socket的监听，那什么时候往socket里写东西呢？

这就涉及另一个回调函数了sns_main_notify_cb。这个回调函数则好就是sensor1_open里注册的。这个sensor1_open 与　libsensor1里的sensor1_open不是同一个。

ok，那问题又来了，啥时候做的回调，和之前很类似，有一个读线程，初始化后处理polling状态，当收到消息时，就回调这个回调函数。

这个读线程的数据是从哪里来的呢，这就涉及到QMI service了。QMI service这部分代码就不是AP这边了，此份代码就在modem的adsp代码中了。

找时间再来续modem这边的adsp。