深入浅出 - Android系统移植与平台开发（十三） - Sensor HAL框架分析之三

版权声明：本文为博主原创文章，未经博主允许不得转载。

目录(?)[+]

让我们来看看SensorManager的代码

SensorManager框架层代码

@frameworks/base/core/Java/Android/hardware/SensorManager.java

[java] view
plain copy

public SensorManager(Looper mainLooper) {

mMainLooper = mainLooper; // 上面说了，这是Activity的Looper

synchronized(sListeners) {

if(!sSensorModuleInitialized) {

sSensorModuleInitialized = true;

nativeClassInit(); // 好像是调用本地方法初始化

sWindowManager = IWindowManager.Stub.asInterface(

ServiceManager.getService("window")); // 获得Windows服务，不管它

if (sWindowManager != null) {

// if it's null we're running in the system process

// which won't get the rotated values

try {

sRotation = sWindowManager.watchRotation(

newIRotationWatcher.Stub() {

public voidonRotationChanged(int rotation) {

SensorManager.this.onRotationChanged(rotation);

}

}

);

} catch (RemoteException e) {

}

}

// initialize the sensor list

sensors_module_init(); // 初始化sensor module

final ArrayList<Sensor> fullList = sFullSensorsList; // SensorManager维护的Sensor列表

int i = 0;

do {

Sensor sensor = new Sensor(); // 创建sensor对象，这个是传递给App的哦

//调用module的方法，获得每一个sensor设备

i = sensors_module_get_next_sensor(sensor, i);

if (i>=0) {

//Log.d(TAG, "found sensor: " + sensor.getName() +

// ", handle=" +sensor.getHandle());

sensor.setLegacyType(getLegacySensorType(sensor.getType()));

fullList.add(sensor); // 添加到SM维护的Sensor列表（嘿嘿）

sHandleToSensor.append(sensor.getHandle(), sensor);

}

}while (i>0);

sPool= new SensorEventPool( sFullSensorsList.size()*2 );

sSensorThread = new SensorThread(); // 哟，创建线程了好像

}

}

}

很明显nativeClassInit()，sensors_module_init()，sensors_module_get_next_sensor()都是本地实现的方法。

[java] view
plain copy

private static native void nativeClassInit();

private static native int sensors_module_init();

private static native intsensors_module_get_next_sensor(Sensor sensor, int next);

根据之前看代码的经验可知，很可能在frameworks/base/core/对应一个jni目录下的存在其对应的本地代码：

[java] view
plain copy

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

frameworks/base/core/jni/android_hardware_SensorManager.cpp

果不其然，在jni存在其本地代码，让我们来看下nativeClassInit函数：

@frameworks/base/core/jni/android_hardware_SensorManager.cpp

[cpp] view
plain copy

static void

nativeClassInit (JNIEnv *_env, jclass _this)

{

jclasssensorClass = _env->FindClass("android/hardware/Sensor");

SensorOffsets& sensorOffsets = gSensorOffsets;

sensorOffsets.name =_env->GetFieldID(sensorClass, "mName", "Ljava/lang/String;");

sensorOffsets.vendor =_env->GetFieldID(sensorClass, "mVendor", "Ljava/lang/String;");

sensorOffsets.version =_env->GetFieldID(sensorClass, "mVersion", "I");

sensorOffsets.handle =_env->GetFieldID(sensorClass, "mHandle", "I");

sensorOffsets.type = _env->GetFieldID(sensorClass,"mType", "I");

sensorOffsets.range =_env->GetFieldID(sensorClass, "mMaxRange", "F");

sensorOffsets.resolution =_env->GetFieldID(sensorClass, "mResolution","F");

sensorOffsets.power =_env->GetFieldID(sensorClass, "mPower", "F");

sensorOffsets.minDelay =_env->GetFieldID(sensorClass, "mMinDelay", "I");

}

其代码比较简单，将Java框架层的Sensor类中的成员保存在本地代码中的gSensorOffsets 结构体中将来使用。

sensors_module_init()本地方法的实现：

[cpp] view
plain copy

static jint

sensors_module_ini(JNIEnv *env, jclass clazz)

{

SensorManager::getInstance();

return 0;

}

在本地代码中调用了SensorManager的getInstance方法，这又是一个典型的单例模式获得类的对象，注意这儿的SensorManager是本地的类，而不是Java层的SensorManager类。

本地SensorManager的定义

@frameworks/base/include/gui/SensorManager.h

[cpp] view
plain copy

class SensorManager :

publicASensorManager,

publicSingleton<SensorManager>

{

public:

SensorManager();

~SensorManager();

ssize_tgetSensorList(Sensor const* const** list) const;

Sensor const*getDefaultSensor(int type);

sp<SensorEventQueue> createEventQueue();

private:

//DeathRecipient interface

voidsensorManagerDied();

status_tassertStateLocked() const;

private:

mutable MutexmLock;

mutablesp<ISensorServer> mSensorServer;

mutableSensor const** mSensorList;

mutableVector<Sensor> mSensors;

mutablesp<IBinder::DeathRecipient> mDeathObserver;

};

注意SensorManager又继承了ASensorManager和泛型类Singleton<SensorManager>，而SensorManager类定义里没有getInstance所以其定义肯定是在ASensorManager或Singleton中。

@frameworks/base/include/utils/Singleton.h

[cpp] view
plain copy

template <typename TYPE>

class ANDROID_API Singleton

{

public:

staticTYPE& getInstance() {

Mutex::Autolock _l(sLock);

TYPE*instance = sInstance;

if(instance == 0) {

instance = new TYPE();

sInstance = instance;

}

return*instance;

}

static boolhasInstance() {

Mutex::Autolock _l(sLock);

returnsInstance != 0;

}

protected:

~Singleton(){ };

Singleton() {};

private:

Singleton(const Singleton&);

Singleton& operator = (const Singleton&);

static MutexsLock;

static TYPE*sInstance;

};

//---------------------------------------------------------------------------

}; // namespace android

第一次调用getInstance方法时，创建泛型对象即：SensorManager，随后再调用该方法时返回第一次创建的泛型对象。

1) 本地SensorManager的创建

本地SensorManager是一个单例模式，其构造方法相对比较简单，它的主要工作交给了assertStateLocked方法：

@frameworks/base/libs/gui/SensorManager.cpp

[cpp] view
plain copy

SensorManager::SensorManager()

:mSensorList(0)

{

// okay we'renot locked here, but it's not needed during construction

assertStateLocked();

}

status_t SensorManager::assertStateLocked() const {

if(mSensorServer == NULL) {

// try for one second

constString16 name("sensorservice");

for (inti=0 ; i<4 ; i++) {

status_t err = getService(name,&mSensorServer);

if(err == NAME_NOT_FOUND) {

usleep(250000);

continue;

}

if(err != NO_ERROR) {

return err;

}

break;

}

classDeathObserver : public IBinder::DeathRecipient {

SensorManager& mSensorManger;

virtual void binderDied(const wp<IBinder>& who) {

LOGW("sensorservice died [%p]", who.unsafe_get());

mSensorManger.sensorManagerDied();

}

public:

DeathObserver(SensorManager& mgr) : mSensorManger(mgr) { }

};

mDeathObserver = new DeathObserver(*const_cast<SensorManager*>(this));

mSensorServer->asBinder()->linkToDeath(mDeathObserver);

mSensors= mSensorServer->getSensorList();

size_tcount = mSensors.size();

mSensorList = (Sensor const**)malloc(count * sizeof(Sensor*));

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

mSensorList[i] = mSensors.array() + i;

}

}

returnNO_ERROR;

}

在assertStateLocked方法里，先通过getService获得SensorService对象，然后注册了对SensorService的死亡监听器，SensorManager与SensorService不求同年同月同日，只求同年同月同日死。拜完了兄弟之后，调用getSensorList得到所有传感器的对象，存放到mSensorList中，保存在本地空间里。

2) 本地SensorManager中列表的获取

在上面函数调用中首先调用getService来获得SensorService服务，然后执行mSensorServer->getSensorList来获得服务提供的传感器列表：

[cpp] view
plain copy

Vector<Sensor> SensorService::getSensorList()

{

return mUserSensorList;

}

大家要注意啊，上面的getSensorList函数只是返回了mUserSensorList，而这个变量是在什么时候初始化的呢？

根据2.1节可知，SensorService在本地被初始化时，构造函数里并没有对mUserSensorList进行初始化，而SensorService里有一个onFirstRef方法，这个方法当SensorService第一次被强引用时被自动调用。那SensorService第一次被强引用是在什么时候呢？

在SensorManager::assertStateLocked方法里调用getService获得SensorService保存到mSensorServer成员变量中。

mSensorServer的定义在frameworks/base/include/gui/SensorManager.h中：

[cpp] view
plain copy

class SensorManager :

public ASensorManager,

public Singleton<SensorManager>

{

mutable sp<ISensorServer>mSensorServer;

mutable Sensorconst** mSensorList;

mutable Vector<Sensor> mSensors;

};

可以看出mSensroServer为强引用类型。所以在创建本地中的SensorManager类对象时，自动强引用SensorService，自动调用onFirstRef方法：

@frameworks/base/services/sensorservice/SensorService.cpp的onFirstRef简化方法如下：

[cpp] view
plain copy

void SensorService::onFirstRef()

{

LOGD("nuSensorService starting...");

SensorDevice& dev(SensorDevice::getInstance()); //创建SensorDevice对象dev

if(dev.initCheck() == NO_ERROR) {

sensor_tconst* list;

ssize_tcount = dev.getSensorList(&list); //获得传感器设备列表

if (count> 0) {

…

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

registerSensor( new HardwareSensor(list[i]) ); // 注册在本地获得的传感器

…

}

constSensorFusion& fusion(SensorFusion::getInstance());

if(hasGyro) { // 如果有陀螺仪设备，则先注册和陀螺仪有关的虚拟传感器设备

registerVirtualSensor( newRotationVectorSensor() ); // 虚拟旋转传感器

registerVirtualSensor( new GravitySensor(list, count) ); // 虚拟重力传感器

registerVirtualSensor( new LinearAccelerationSensor(list, count) ); // 虚拟加速器

// these are optional

registerVirtualSensor( new OrientationSensor() ); // 虚拟方向传感器

registerVirtualSensor( new CorrectedGyroSensor(list, count) ); // 真正陀螺仪

// virtual debugging sensors...

char value[PROPERTY_VALUE_MAX];

property_get("debug.sensors", value, "0");

if (atoi(value)) {

registerVirtualSensor( new GyroDriftSensor() ); // 虚拟陀螺测漂传感器

}

}

// build the sensor list returned tousers

mUserSensorList = mSensorList;

if(hasGyro &&

(virtualSensorsNeeds & (1<<SENSOR_TYPE_ROTATION_VECTOR))) {

// if we have the fancy sensor fusion, and it's not provided by the

// HAL, use our own (fused) orientation sensor by removing the

// HAL supplied one form the user list.

if (orientationIndex >= 0) {

mUserSensorList.removeItemsAt(orientationIndex);

}

}

run("SensorService",PRIORITY_URGENT_DISPLAY);

mInitCheck = NO_ERROR;

}

}

}

上面代码首先通过SensorDevice::getInstance()创建对象dev，调用dev.getSensorList(&list)获得传感器列表，将取出的sensor_t类型list传感器列表，塑造了HardwareSensor对象，传递给了registerSensor方法，通过registerSensor注册传感器，然后通过单例模型创建了SensorFusion对象，创建并注册了一系列的虚拟传感器，疑惑，极大的疑惑，怎么传感器还有虚拟的？？其实你注意看这几个传感器最前面的条件，if(hasGyro)，表示如果存在陀螺仪的话，会创建这些虚拟设备，再看这些虚拟设备：旋转，重力，加速器，方向等，这些设备都对应一个物理硬件：陀螺仪，所以这些逻辑上存在，物理上不存在的设备叫虚拟设备。在初始化了虚拟设备后，将mSensorList传感器列表赋值给mUserSensorList，mSensorList是由registerSensor初始化的，mUserSensorList是要提交给Java框架层的传感器列表，最后通过run方法运行了SensorService线程，我们先来看下registerSensor的代码：

[cpp] view
plain copy

void SensorService::registerSensor(SensorInterface* s)

{

sensors_event_t event;

memset(&event,0, sizeof(event));

const Sensorsensor(s->getSensor());

// add to thesensor list (returned to clients)

mSensorList.add(sensor);

// add to ourhandle->SensorInterface mapping

mSensorMap.add(sensor.getHandle(), s);

// create anentry in the mLastEventSeen array

mLastEventSeen.add(sensor.getHandle(), event);

}

通过分析上面代码可知，将传入的HardwareSensor对象塑造了Sensor，添加到mSensorList向量表里，然后将HardwareSensor对象添加到mSensroMap键值对里，将新建的传感器事件数据封装对象event添加到mLastEventSeen键值对中。
我们通过下面的时序图来看下Sensor列表的获取过程。

1) SensorService监听线程及传感器事件的捕获

让我们再来看看SensorService线程，还记得前面SensorService的父类中有一个Thread类，当调用run方法时会创建线程并调用threadLoop方法。

[cpp] view
plain copy

bool SensorService::threadLoop()

{

LOGD("nuSensorService thread starting...");

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

sensors_event_t buffer[numEventMax];

sensors_event_t scratch[numEventMax];

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

const size_tvcount = mVirtualSensorList.size();

ssize_tcount;

do {

// 调用SensorDevice的poll方法看样子要多路监听了

count = device.poll(buffer,numEventMax);

if(count<0) {

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

break;

}

// 记录poll返回的每一个传感器中的最后一个数据信息到mLastEventSeen中

recordLastValue(buffer, count);

// handlevirtual sensors 处理虚拟传感器数据

if (count&& vcount) {

sensors_event_t const * const event = buffer;

// 获得虚拟传感器列表

constDefaultKeyedVector<int, SensorInterface*> virtualSensors(

getActiveVirtualSensors());

constsize_t activeVirtualSensorCount = virtualSensors.size(); // 虚拟传感器个数

if(activeVirtualSensorCount) {

size_t k = 0;

SensorFusion& fusion(SensorFusion::getInstance());

if (fusion.isEnabled()) {

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

fusion.process(event[i]); //处理虚拟传感器设备事件

}

}

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

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

sensors_event_t out;

if (virtualSensors.valueAt(j)->process(&out, event[i])) {

buffer[count + k] =out;

k++;

}

}

}

if (k) {

// record the last synthesized values

recordLastValue(&buffer[count], k);

count += k;

// sort the buffer by time-stamps

sortEventBuffer(buffer, count);

}

}

}

// sendour events to clients...

// 获得传感器连接对象列表

constSortedVector< wp<SensorEventConnection> > activeConnections(

getActiveConnections());

size_tnumConnections = activeConnections.size();

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

sp<SensorEventConnection> connection(

activeConnections[i].promote());

if(connection != 0) {

// 向指定的传感器连接客户端发送传感器数据信息

connection->sendEvents(buffer, count, scratch);

}

}

} while (count>= 0 || Thread::exitPending()); // 传感器循环监听线程

LOGW("Exiting SensorService::threadLoop => aborting...");

abort();

return false;

}

我们看到device.poll方法，阻塞在了SensorDevice的poll方法上，它肯定就是读取Sensor硬件上的数据了，将传感器数据保存在buff中，然后调用recordLastValue方法，只保存同一类型传感器的最新数据（最后采集的一组数据）到键值对象mLastEventSeen里对应传感器的值域中。如果传感器设备是虚拟设备则调用SensorFusion.Process（）方法对虚拟设备数据进行处理。SensorFusion关联一个SensorDevice，它是虚拟传感器设备的一个加工类，负责虚拟传感器数据的计算、处理、设备激活、设置延迟、获得功耗信息等操作。

让我们来回顾下整个过程吧。



1. SensorManager对象创建并调用assertStateLocked方法

2. 在assertStateLocked方法中调用getService，获得SensorService服务

3. 当SensorService第一次强引用时，自动调用OnFirstRef方法

4．获得SensorDevice单例对象

6. 调用SensorDevice.getSensorList方法sensor_t列表保存在SensorService中

8. 调用registerSensor注册传感器，添加到mSensorList列表中

9. 启动SensorService线程，准备监听所有注册的传感器设备

12. 多路监听注册的传感器设备，当有传感器事件时，返回sensor_event_t封装的事件信息

16. 记录产生传感器事件的设备信息

17. 调用getActiveConnections获得所有的活动的客户端SensorEventConnection类对象
19.向客户端发送传感器事件信息