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

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

目录(?)[+]

让我们来看看SensorManager的代码

SensorManager框架层代码

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

 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()都是本地实现的方法。

 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目录下的存在其对应的本地代码：

 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

 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()本地方法的实现：

 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

 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

 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

 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来获得服务提供的传感器列表：

 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中：

 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简化方法如下：

 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的代码：

 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方法。

 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.向客户端发送传感器事件信息