Sensor系列四 Framework层分析_Service端

最新推荐文章于 2024-04-28 15:31:09 发布

frank_zyp

最新推荐文章于 2024-04-28 15:31:09 发布

阅读量1.6k

点赞数 3

分类专栏： 02-Android sensor系统

本文链接：https://blog.csdn.net/frank_zyp/article/details/53818345

版权

02-Android sensor系统专栏收录该内容

4 篇文章 8 订阅

订阅专栏

一、Sensor framwork service介绍

在上一节Framework层分析_Client端已经介绍了Sensor在framework中的框架结构，本文主要分析SensorService的启动流程和HAL层的交互工作。其中SensorService中主要包含以下类：

（1）SensorService.cpp

./frameworks/native/service/sensorservice/SensorService.cpp

SensorService是Android Sensor Framework最核心的模块，它实现了主要的Sensor控制流和数据流逻辑，完成Sensor参数的配置，数据分发，Client请求数据处理等功能。

（2）BinderService

./frameworks/native/include/binder/BinderService.h

BinderService是Android Service框架的主要类，它提供了Service的生命周期管理、进程将通信、请求响应处理等功能。Android总的大部分Service都会继承此类。

（3）SensorEventConnect

./framework/native/libs/gui/ISensorEventConnect.cpp

SensorEventConnect是sensor数据传输通道，当Client开始监听某一个Sensor时，一个对应的SensorEventConnect将会被创建，Server端在接收到Sensor数据后，通过写入到SensorEventConnect传输给Client端。

（4）SensorDevice

./framework/native/services/sensorservice/SensorDevice.cpp

该类主要负责与HAL层交互。下面看下程序走向图：

二、SensorService流程分析

在系统启动时，SystemServer中会启动需要开启的服务，系统服务通过调用startSensorService启动sensorService，调用JNI，通过SensorService::instantiate实例化SensorService对象。

SensorService创建之后，将会调用SensorService::onFirstRefs()方法，来完成初始化工作，首先通过SensorDevice::getInstance来创建对象dev，调用dev.getSensorList(&list)获取传感器列表，传入sensor_t类型的list，创建HardwareSensor对象，传递给registerSensor，注册传感器，下面看下SensorService的onFirstRef方法。

void SensorService::onFirstRef()
{
    ALOGD("nuSensorService starting...");
    SensorDevice& dev(SensorDevice::getInstance());//实例化SensorDevice

    if (dev.initCheck() == NO_ERROR) {
        sensor_t const* list;
        ssize_t count = dev.getSensorList(&list);//获取sensorlist
        if (count > 0) {
            ssize_t orientationIndex = -1;
            bool hasGyro = false, hasAccel = false, hasMag = false;
            uint32_t virtualSensorsNeeds =
                    (1<<SENSOR_TYPE_GRAVITY) |
                    (1<<SENSOR_TYPE_LINEAR_ACCELERATION) |
                    (1<<SENSOR_TYPE_ROTATION_VECTOR);
           mLastEventSeen.setCapacity(count);
            for (ssize_t i=0 ; i<count ; i++) {
                registerSensor( new HardwareSensor(list[i]) );//为每一个sensor注册监听器
                switch (list[i].type) {
                    case SENSOR_TYPE_ACCELEROMETER:
                        hasAccel = true;
                        break;
                    case SENSOR_TYPE_MAGNETIC_FIELD:
                        hasMag = true;
                        break;
                    case SENSOR_TYPE_ORIENTATION:
                        orientationIndex = i;
                        break;
                    case SENSOR_TYPE_GYROSCOPE:
                    case SENSOR_TYPE_GYROSCOPE_UNCALIBRATED:
                        hasGyro = true;
                        break;
                    case SENSOR_TYPE_GRAVITY:
                    case SENSOR_TYPE_LINEAR_ACCELERATION:
                    case SENSOR_TYPE_ROTATION_VECTOR:
                        virtualSensorsNeeds &= ~(1<<list[i].type);
                        break;
                }
            }
            // it's safe to instantiate the SensorFusion object here
            // (it wants to be instantiated after h/w sensors have been
            // registered)
            const SensorFusion& fusion(SensorFusion::getInstance());

            // build the sensor list returned to users
            mUserSensorList = mSensorList;
            if (hasGyro && hasAccel && hasMag) {
                Sensor aSensor;

                // Add Android virtual sensors if they're not already
                // available in the HAL
                aSensor = registerVirtualSensor( new RotationVectorSensor() );//注册虚拟设备的监听器
                if (virtualSensorsNeeds & (1<<SENSOR_TYPE_ROTATION_VECTOR)) {
                    mUserSensorList.add(aSensor);
                }
                aSensor = registerVirtualSensor( new GravitySensor(list, count) );
                if (virtualSensorsNeeds & (1<<SENSOR_TYPE_GRAVITY)) {
                    mUserSensorList.add(aSensor);
                }

                aSensor = registerVirtualSensor( new LinearAccelerationSensor(list, count) );
                if (virtualSensorsNeeds & (1<<SENSOR_TYPE_LINEAR_ACCELERATION)) {
                    mUserSensorList.add(aSensor);
                }
                #if 0       
                aSensor = registerVirtualSensor( new OrientationSensor() );
                if (virtualSensorsNeeds & (1<<SENSOR_TYPE_ROTATION_VECTOR)) {
                    // if we are doing our own rotation-vector, also add
                    // the orientation sensor and remove the HAL provided one.
                    mUserSensorList.replaceAt(aSensor, orientationIndex);
                }
                #endif 
                // virtual debugging sensors are not added to mUserSensorList
                registerVirtualSensor( new CorrectedGyroSensor(list, count) );
                registerVirtualSensor( new GyroDriftSensor() );
            }

            // debugging sensor list
            mUserSensorListDebug = mSensorList;
            // Check if the device really supports batching by looking at the FIFO event
            // counts for each sensor.
            bool batchingSupported = false;
            for (size_t i = 0; i < mSensorList.size(); ++i) {
                if (mSensorList[i].getFifoMaxEventCount() > 0) {
                    batchingSupported = true;
                    break;
                }
            }
            if (batchingSupported) {
                // Increase socket buffer size to a max of 100 KB for batching capabilities.
                mSocketBufferSize = MAX_SOCKET_BUFFER_SIZE_BATCHED;
            } else {
                mSocketBufferSize = SOCKET_BUFFER_SIZE_NON_BATCHED;
            }
            // Compare the socketBufferSize value against the system limits and limit
            // it to maxSystemSocketBufferSize if necessary.
            FILE *fp = fopen("/proc/sys/net/core/wmem_max", "r");
            char line[128];
            if (fp != NULL && fgets(line, sizeof(line), fp) != NULL) {
                line[sizeof(line) - 1] = '\0';
                size_t maxSystemSocketBufferSize;
                sscanf(line, "%zu", &maxSystemSocketBufferSize);
                if (mSocketBufferSize > maxSystemSocketBufferSize) {
                    mSocketBufferSize = maxSystemSocketBufferSize;
                }
            }
            if (fp) {
                fclose(fp);
            }
            mWakeLockAcquired = false;
            mLooper = new Looper(false);
            const size_t minBufferSize = SensorEventQueue::MAX_RECEIVE_BUFFER_EVENT_COUNT;
            mSensorEventBuffer = new sensors_event_t[minBufferSize];
            mSensorEventScratch = new sensors_event_t[minBufferSize];
            mMapFlushEventsToConnections = new SensorEventConnection const * [minBufferSize];
            mCurrentOperatingMode = NORMAL;
            mNextSensorRegIndex = 0;
            for (int i = 0; i < SENSOR_REGISTRATIONS_BUF_SIZE; ++i) {
                mLastNSensorRegistrations.push();
            }

            mInitCheck = NO_ERROR;
            mAckReceiver = new SensorEventAckReceiver(this);
            mAckReceiver->run("SensorEventAckReceiver", PRIORITY_URGENT_DISPLAY);
            run("SensorService", PRIORITY_URGENT_DISPLAY);
        }
    }
}

总结而言，onFirstref主要完成了三项工作：

1、创建SensorDevice实例；

2、调用SensorDevice.getSensorList()，获取Sensor模块所有传感器列表；

3、为每一个传感器注册监听器，还同事注册实现了6个虚拟传感器。

在上面介绍了与HAL层交互的SensorDevice，下面看看方法调用的过程：

SensorDevice::SensorDevice()
    :  mSensorDevice(0),
       mSensorModule(0)
{
    //根据module_id加载hal层的so库
    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_1(&mSensorModule->common, &mSensorDevice);//打开设备

        ALOGE_IF(err, "couldn't open device for module %s (%s)",
                SENSORS_HARDWARE_MODULE_ID, strerror(-err));
        if (mSensorDevice) {
            if (mSensorDevice->common.version == SENSORS_DEVICE_API_VERSION_1_1 ||
                mSensorDevice->common.version == SENSORS_DEVICE_API_VERSION_1_2) {
                ALOGE(">>>> WARNING <<< Upgrade sensor HAL to version 1_3");
            }
            sensor_t const* list;
            ssize_t count = mSensorModule->get_sensors_list(mSensorModule, &list);//获取sensor数目
            mActivationCount.setCapacity(count);
            Info model;
            for (size_t i=0 ; i<size_t(count) ; i++) {
                mActivationCount.add(list[i].handle, model,
                mSensorDevice->activate(
		//使能每一个sensor
 reinterpret_cast<struct sensors_poll_device_t *>(mSensorDevice), list[i].handle, 0);
    } 
  } 
 }
}

在SensorDevice类中主要封装了HAL层的sensor操作接口，在SensorDevice的构造函数中主要完成了三个工作：
1、调用HAL层的hw_get_module()方法打开设备；
2、调用sensor.h的sensor_open_1方法打开设备；
3、调用sensor_poll_device_1_t->activate模块使能sensor。
sensor使能后，下面分析SensorService层中数据的传输。
三、SensorService数据传输

从下图中可以看出SensorClient和SensorService端各有一个线程用于数据的传输，SensorService端的线程复制从hal层读取数据，并将数据写入到Client端创建的管道中，SensorClient则通过管道读取数据，上报给app层。

其中SensorService数据的读取是在SensorService::threadLoop()方法中实现的：

bool SensorService::threadLoop()
{
    ALOGD("nuSensorService thread starting...");
    const size_t minBufferSize = SensorEventQueue::MAX_RECEIVE_BUFFER_EVENT_COUNT;
    const size_t numEventMax = minBufferSize / (1 + mVirtualSensorList.size());

    SensorDevice& device(SensorDevice::getInstance());
    const size_t vcount = mVirtualSensorList.size();
    const int halVersion = device.getHalDeviceVersion();
    do {
        ssize_t count = device.poll(mSensorEventBuffer, numEventMax);//调用hal层的 poll__poll获取数据
        if (count < 0) {
            ALOGE("sensor poll failed (%s)", strerror(-count));
            break;
        }
        // Reset sensors_event_t.flags to zero for all events in the buffer.
        for (int i = 0; i < count; i++) {
             mSensorEventBuffer[i].flags = 0;
        }
        SortedVector< sp<SensorEventConnection> > activeConnections;//获得传感器连接对象
        populateActiveConnections(&activeConnections);
        Mutex::Autolock _l(mLock);
        bool bufferHasWakeUpEvent = false;
        for (int i = 0; i < count; i++) {
            if (isWakeUpSensorEvent(mSensorEventBuffer[i])) {
                bufferHasWakeUpEvent = true;
                break;
            }
        }
        if (bufferHasWakeUpEvent && !mWakeLockAcquired) {
            setWakeLockAcquiredLocked(true);
	......
        // Map flush_complete_events in the buffer to SensorEventConnections which called
        // flush on the hardware sensor. mapFlushEventsToConnections[i] will be the
        // SensorEventConnection mapped to the corresponding flush_complete_event in
        // mSensorEventBuffer[i] if such a mapping exists (NULL otherwise).
        for (int i = 0; i < count; ++i) {
            mMapFlushEventsToConnections[i] = NULL;
            if (mSensorEventBuffer[i].type == SENSOR_TYPE_META_DATA) {
                const int sensor_handle = mSensorEventBuffer[i].meta_data.sensor;
                SensorRecord* rec = mActiveSensors.valueFor(sensor_handle);
                if (rec != NULL) {
                    mMapFlushEventsToConnections[i] = rec->getFirstPendingFlushConnection();
                    rec->removeFirstPendingFlushConnection();
                }
            }
        }
        // Send our events to clients. Check the state of wake lock for each client and release the
        // lock if none of the clients need it.
        bool needsWakeLock = false;
        size_t numConnections = activeConnections.size();
        for (size_t i=0 ; i < numConnections; ++i) {
            if (activeConnections[i] != 0) {
                activeConnections[i]->sendEvents(mSensorEventBuffer, count, mSensorEventScratch,
                        mMapFlushEventsToConnections);//将数据写入指定的sensor管道中，供client端使用
                needsWakeLock |= activeConnections[i]->needsWakeLock();
                // If the connection has one-shot sensors, it may be cleaned up after first trigger.
                // Early check for one-shot sensors.
                if (activeConnections[i]->hasOneShotSensors()) {
                    cleanupAutoDisabledSensorLocked(activeConnections[i], mSensorEventBuffer,
                            count);
                }
            }
        }

        if (mWakeLockAcquired && !needsWakeLock) {
            setWakeLockAcquiredLocked(false);
        }
    } while (!Thread::exitPending());//判断Thread是否结束

    ALOGW("Exiting SensorService::threadLoop => aborting...");
    abort();
    return false;
}

其实数据是以一个结构体sensors_event_t的形式从HAL层传到JNI层。看看HAL的sensors_event_t结构体，同时数据以相同的形式传递给Java层使用：

typedef struct sensors_event_t {
    int32_t version;
    int32_t sensor;            //标识符
    int32_t type;             //传感器类型
    int32_t reserved0;
    int64_t timestamp;        //时间戳
    union {
        float           data[16];
        sensors_vec_t   acceleration;   //加速度
        sensors_vec_t   magnetic;      //磁矢量
        sensors_vec_t   orientation;     //方向
        sensors_vec_t   gyro;          //陀螺仪
        float           temperature;     //温度
        float           distance;        //距离
        float           light;           //光照
        float           pressure;         //压力
        float           relative_humidity;  //相对湿度
    };
    uint32_t        reserved1[4];
} sensors_event_t;

到这里，SensorService的启动及数据传输就已经介绍完毕，由上可以总结，SensorService的主要工作是监听获取HAL层的数据，并将数据传输给SensorClient端，完成数据的传输工作。

作者：frank_zyp
您的支持是对博主最大的鼓励，感谢您的认真阅读。
本文无所谓版权，欢迎转载。