Android源码分析：传感器系统

Sensors in Android

   

总述

   

如下图，应用程序开发者使用几个sensor的几个API类进行应用程序的开发。Java的部分的API使用C/C++来实现，也就是调用到JNI层。左侧运行于应用程序的进程空间，右侧运行于system server进程空间。双方通过ISensorEventConnection/SensorChannel进行通讯。SensorService负责与Sensors的硬件适配层HAL进行通讯，后者与驱动和硬件进行交互。

   

Java API

   

Java层的API类有SensorManager，利用它才可以使用系统的各种感应器（sensor）。sensor的采样值、精确度、时间戳以及信息是自哪个感应器等信息封装在Java类SensorEvent中。Java类Sensor代表一个感应器，包含感应器的各种信息，它的成员数据与本地Sensor类以及HAL层的sensor_t对应（见后述章节）。作为父类的SensorEventListener是一个监听器接口，应用开发者编写它的一个子类可以实现对SensorEvent的监听并做出相应反应。

   

在获取sensor service创建SensorManager时，会创建一个线程去轮询（poll，调用sensors_data_poll）去取sensor的数据，然后以发送消息的形式将SensorEvent发送给ListenerDelegate中的Handler，由handler在新一轮的线程循环中调用对应的sensorListener进行处理。

   

 

   

JNI与native层

   

JNI层位于frameworks/base/core/jni/下面，主要就是一个文件android_hardware_SensorManager.cpp。它使用的类如Sensor、SensorChannel、SensorEventQueue、、ISensorEventConnection和ISensorServer则放在libgui.so中，见目录frameworks/base/libs/gui。

   

 

   

Java层在轮询之前，必须调用sensors_create_queue创建（见SensorThreadRunnable的open函数）一个本地的SensorEventQueue队列，这个C++对象的指针被转换为int型后保存为SensorManager的静态成员变量sQueue。当轮询时，将该队列传递给JNI层的sensors_data_poll，用于从该队列中读取Event数据（具体数据类型是ASensorEvent）。

   

本地SensorEventQueue类主要借助于两个类进行工作。一是封装了管道的SensorChannel类，event的读取和写入都是针对封装的管道进行的；二是libutils库中的Looper类，Looper类实现了在调用者线程中对文件描述符的轮询（内部使用的epoll），甚至可以注册回调函数，当有文件描述符对应的文件有数据到达时使用回调函数进行处理。这样，队列类SensorEventQueue使用Looper监听着管道对应的描述符，当有数据达到时，就可以读取，没有使用回调机制。整个过程是：在Java层的SensorManager的线程中不断调用sensors_data_poll查询数据，这导致其JNI层的native实现在队列上等待event事件（见队列的成员函数waitForEvent，它使用poll进行轮询），也就是说，直到有管道中有数据可用才返回。当没有发生错误返回时，表示有数据可读，然后对数据进行读取。一次读取单位为一个event。

   

下面是JNI层中的sensors_data_poll代码片段：

   

res = queue->read(&event, 1);

if (res == -EAGAIN) {

res = queue->waitForEvent();//等待有数据可读取

if (res != NO_ERROR)//检查是否发生错误

return -1;

res = queue->read(&event, 1);//没错误，进行数据读取

}

   

封装管道的SensorChannel类的对象由ISensorEventConnection接口获取。另外，对sensor的激活/去激活也是通过ISensorEventConnection调用到server侧的SensorService完成的。

   

C++类Sensor代表了一个sensor，它是HAL层sensor_t的封装，同时又为Java层的Sensor类中的数据成员变量提供数据"源"，也就是说，Java中的Sensor的成员变量信息是由该C++中的Sensor类设置，后者又是根据sensor_t而获取对应的sensor信息。Java中的Sensor是应用开发的API类。在C++中的Sensor类中定义了sensor的枚举类型：

   

enum {

TYPE_ACCELEROMETER = ASENSOR_TYPE_ACCELEROMETER, //加速度

TYPE_MAGNETIC_FIELD = ASENSOR_TYPE_MAGNETIC_FIELD, //磁场

TYPE_GYROSCOPE = ASENSOR_TYPE_GYROSCOPE, //陀螺仪

TYPE_LIGHT = ASENSOR_TYPE_LIGHT, //光传感器

TYPE_PROXIMITY = ASENSOR_TYPE_PROXIMITY //距离传感器

};

   

 

   

SensorService

   

在frameworks/base/services/sensorservice/下面给出sensorService的相关实现代码，它们最终生成libsensorservice.so库文件，作为service被注册到system server后，最终运行于system_server后台进程空间。

   

Sensor service模块的核心部分是SensorService类。另外还定义了几个逻辑上的虚拟sensor：GravitySensor、LinearAccelerationSensor和RotationVectorSensor，它们的接口由抽象类SensorInterface定义，物理意义上实际传感器HardwareSensor也同样遵循该接口规范。

   

SensorInterface与四个子类继承关系图如下：

   

SensorInterface是个抽象类，定义了五个接口：

   

virtual bool process(sensors_event_t* outEvent,const sensors_event_t& event) = 0; //处理原始数据，换成上层应用希望得到的数据

   

virtual status_t activate(void* ident, bool enabled) = 0; //激活与去激活

   

virtual sttus_t setDelay(void* ident, int handle, int64_t ns) = 0;//设置报告处理频率

   

virtual Sensor getSensor() const = 0;//获取对应的sensor

   

virtual bool isVirtual() const = 0;//是否为虚拟的，即是否为逻辑（虚拟）传感器

   

GravitySensor和LinearAccelerationSensor，它们不是物理意义上的传感器，只是逻辑意义上的传感器，可称之为虚拟（virtual）传感器。它们实际上是将加速器（即gsensor）的值经过处理过滤后再上报。

   

RotationVectorSensor方向向量传感器，实际上它由加速器和磁场传感器(compass)组成，根据它们上报的值来判断是否旋转屏幕。

   

引入虚拟传感器的目的是方便上层程序的处理。在上层看来，它不需要关注设备上的传感器的某些原始数据，只需要经过加工处理后的数据，如是否旋转屏幕，它是依据虚拟的"传感器"sensorRotationVectorSensor得来的经过加工后的数据。这些虚拟传感器包含了处理原始数据的算法。算法包含在重载的process函数中。

   

HardwareSensor代表了真正的传感器，它继承自SensorInterface，实现了各个抽象接口，但其实现是借助于与位于下层的HAL层的sensor硬件模块打交道的类SensorDevice来完成的。

   

SensorDevice与HAL中的libsensors.so打交道，如获取对应的硬件module，打开sensor设备，参见其构造函数：

   

SensorDevice::SensorDevice()

: mSensorDevice(0),

mSensorModule(0)

{

status_t err = hw_get_module(SENSORS_HARDWARE_MODULE_ID,

(hw_module_t const**)&mSensorModule);//打开sensor硬件模块

   

LOGE_IF(err, "couldn't load %s module (%s)",

SENSORS_HARDWARE_MODULE_ID, strerror(-err));

   

if (mSensorModule) {

err = sensors_open(&mSensorModule->common, &mSensorDevice);//打开HAL层的poll设备

LOGE_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);//获取sensor_t列表

mActivationCount.setCapacity(count);

Info model;

for (size_t i=0 ; i<size_t(count) ; i++) {

mActivationCount.add(list[i].handle, model);

mSensorDevice->activate(mSensorDevice, list[i].handle, 0);

}

}

}

}

   

其结构图如下：

   

作为核心代码的SensorService类有三个父类：

   

BinderService<SensorService>：继承该父类使其成为一个标准的本地（native） service，将自己添加到系统的system server中去，其它感兴趣者可以使用该service。

   

BnSensorServer：意味着作为子类，SensorService是抽象类ISensorServer中定义的两个接口（getSensorList和createSensorEventConnection）的server侧的真正实现者。一个接口是用来获取系统的sensor列表，另一个则是创建一个事件连接（EventConnection），用于基于管道加上轮询方式的event传输。

   

 

   

 

   

 

   

Thread：意味着它也是一个线程类，在SensorService创建后，有个单独的线程去执行重载的threadLoop。

   

这个threadLoop可以说是整个sensor的调度处理中心，让sensor相关的模块都动起来。作为一个后台线程，它是个无限循环，不断去处理

   

bool SensorService::threadLoop()

{

LOGD("nuSensorService thread starting…");

   

const size_t numEventMax = 16 * (1 + mVirtualSensorList.size());

sensors_event_t buffer[numEventMax];

sensors_event_t scratch[numEventMax];

SensorDevice& device(SensorDevice::getInstance());

const size_t vcount = mVirtualSensorList.size();

   

ssize_t count;

do {

count = device.poll(buffer, numEventMax);//轮询event数据到缓冲区

if (count<0) {

LOGE("sensor poll failed (%s)", strerror(-count));

break;

}

   

recordLastValue(buffer, count);//记录每个sensor最新的值，记入到mLastEventSeen这个KeyedVector（从sensor标识符到sensors_event_t的映射）中。

   

// handle virtual sensors

if (count && vcount) {//下面是处理虚拟sensors数据

const DefaultKeyedVector<int, SensorInterface*> virtualSensors( getActiveVirtualSensors());

   

const size_t activeVirtualSensorCount = virtualSensors.size();

   

if (activeVirtualSensorCount) {

size_t k = 0;

for (size_t i=0 ; i<size_t(count) ; i++) {

sensors_event_t const * const event = buffer;

for (size_t j=0 ; j<activeVirtualSensorCount ; j++) {

sensors_event_t out;

if (virtualSensors.valueAt(j)->process(&out, event[i])) {//处理原始数据，经过处理转换后的数据信息保存在out这个event中

buffer[count + k] = out;//将它们添加到buffer中

k++;

}

}

}

   

if (k) {

// record the last synthesized values

recordLastValue(&buffer[count], k);//同样对虚拟的sensor的event最新值添加到mLastEventSeen中

count += k;

// sort the buffer by time-stamps

sortEventBuffer(buffer, count);//按时间戳排序

}

}

}

   

// send our events to clients…

const SortedVector< wp<SensorEventConnection> > activeConnections(

getActiveConnections());

size_t numConnections = activeConnections.size();

for (size_t i=0 ; i<numConnections ; i++) {

sp<SensorEventConnection> connection(

activeConnections[i].promote());

if (connection != 0) {

connection->sendEvents(buffer, count, scratch);//发送给client端，实际是写入管道

}

}

} while (count >= 0 || Thread::exitPending());

   

LOGW("Exiting SensorService::threadLoop!");

return false;

}

   

因此，可以看出，SensorService的工作线程不断去轮询设备中是否有数据可用。当有数据可用时，将它们写入管道。对方的应用程序中的线程也不断轮询管道，当有数据时，便调用对应的listener进行处理。它们工作在不断的线程中，或使用looper，或使用handler，在不同的线程循环中进行处理，多次的异步操作构成了sensor的处理过程。

   

 

   

HAL

   

在Android HAL中只对sensors的数据结构进行了定义（见头文件hardware/libhardware/include/hardware/sensors.h），其具体实现应由芯片厂家给出。

   

在使用sensors的HAL时，首先使用HAL提供的hw_get_module函数，根据其模块ID字符串（SENSORS_HARDWARE_MODULE_ID）获取硬件模块sensors_module_t，然后借助于sensors_module_t枚举中设备中所带的所有sensors（sensor由结构体sensor_t定义）列表。

   

数据结构sensors_module_t定义了sensors硬件模块，其中的get_sensors_list函数指针用于枚举设备上的各种类型的sensor，实现由平台厂商给出。

   

同样，可以接着使用API函数sensors_open打开HAL中定义的sensors_poll_device_t类型的设备，该结构体定义三个API，用于激活/去激活sensor（见成员activate函数指针）、设置数据报告频率（见setDelay函数指针）和轮训（见poll函数指针）。同样，这三个函数也由平台厂家实现。

   

这样，我们可以使用hw_get_module函数打开硬件模块，并得到sensors列表，同时，也可以使用sensors_open打开sensors_poll_device_t类型的设备，对sensor进行激活/去激活，轮询读数和设置数据报告频率等基本操作。

   

结构体sensor_t代表了一个sensor，定义了sensor的各种属性，如：名称、厂家、版本、句柄、类型、最大值范围、解析度、功耗、数据上报频率等。其定义具体如下：

   

struct sensor_t {

/* name of this sensors */

const char* name;//sensor的名称

   

/* vendor of the hardware part */

const char* vendor;//厂家

   

/* version of the hardware part + driver. The value of this field is

* left to the implementation and doesn't have to be monotonically

* increasing.

*/

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;//句柄，用于标识是激活/去激活哪个sensor，亦即sensors_event_t中的int32_t sensor;它实际是由四个字符的ascii码值来填充

   

/* this sensor's type. */

int type;//sensor类型，在sensor.h中定义了多达12种类型（有的为逻辑上的sensor），并以注释的方式对它们进行了详细解释

   

/* 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;//估计的功耗，单位为mA

   

/* 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;//报告读数值的events时间间隔（单位：ms），若为0，意味着不按该频率报告，而是数据到来时才报告

   

/* reserved fields, must be zero */

void* reserved[8];//保留

};

   

sensor的采样值的上报可以按照某个固定的频率进行上报，也可以当有可用的数据时再上报（minDelay设为0）。上报数据以event的形式进行，见结构体sensors_event_t，它包含了sensor的标识符、类型、数据采样时间戳以及采样数据。因为各种sensor的采样值各式各样，它更多地是用联合体union来定义，根据不同的sensor来解释返回的值，比如，当是加速器sensor或磁场sensor时，就分别取联合体中的acceleration和magnetic两个字段，它们的类型是结构体sensors_vec_t，其中又包含有union联合体。这样，Android将各种sensor统一成一种接口，依据不同的sensor分别对其标识和类型对采样值进行解释。

转载于:https://www.cnblogs.com/postmaster/p/3660575.html