AndroidL 传感器系统

通常在Android的Manager里都会维护对其管理Service的引用，用户程序提出Service操作申请，Manager将操作申请交由其管理的Service处理，然后将处理结果再交给用户程序或回调用户注册的监听接口。
整个传感器调用过程为APP --> SensorManager.java --> SensorService.java --> SensorDevice -->sensor

1.传感器的使用
通常编写一个传感器的应用程序有以下步骤：
void sensorTest(Context context) {
// 定义传感器监听器
SensorEventListener sensorEventListener = new SensorEventListener() {
// 传感器数值发生变化时调用此函数
@Override
public void onSensorChanged(SensorEvent paramSensorEvent) {
}

// 传感器精度发生变化时调用此函数
@Override
public void onAccuracyChanged(Sensor paramSensor, int paramInt) {
}
};

// 获取封装了SensorService的SensorManager对象
SensorManager sm = (SensorManager) context.getSystemService(SENSOR_SERVICE);
// 获得指定类型的传感器对象
Sensor tempSensor = sm.getDefaultSensor(Sensor.TYPE_TEMPERATURE);
// 注册传感器对象的监听器
sm.registerListener(sensorEventListener, tempSensor, SensorManager.SENSOR_DELAY_NORMAL);
}

2.SensorManager的获取,由下面分析可得服务是在第一次调用的时候才创建的
在上例中通过Context.getSystemService(SENSOR_SERVICE);来获取Sensor系统服务.
getSystemService方法是在frameworks/base/core/java/android/content/Context.java中定义的抽象函数,
具体是在frameworks/base/core/java/android/app/ContextImpl.java中实现的,
class ContextImpl extends Context {
    ........
    static class ServiceFetcher {
        int mContextCacheIndex = -1;

        // 从SYSTEM_SERVICE_MAP键值表查找与键值对应的对象ServiceFetcher
        public Object getService(ContextImpl ctx) {
            ArrayList<Object> cache = ctx.mServiceCache; // mServiceCache为服务的缓存
            Object service;
            synchronized (cache) {
                if (cache.size() == 0) { // 第一次进入时没有对象,所以size()为0
                    // 初始化cache
                    for (int i = 0; i < sNextPerContextServiceCacheIndex; i++) {
                        cache.add(null);
                    }
                } else {
                    service = cache.get(mContextCacheIndex); // 从缓存中读取服务
                    if (service != null) {
                        return service;
                    }
                }
                service = createService(ctx); // 创建服务
                cache.set(mContextCacheIndex, service); // 保存到缓存中
                return service;
            }
        }

        // 这个方法在子类中必须要重载，否则会在此抛异常
        public Object createService(ContextImpl ctx) {
            throw new RuntimeException("Not implemented");
        }
    }
    ........
    private static final HashMap<String, ServiceFetcher> SYSTEM_SERVICE_MAP =
            new HashMap<String, ServiceFetcher>(); // 定义SYSTEM_SERVICE_MAP哈希键值映射表
    private static int sNextPerContextServiceCacheIndex = 0; // sNextPerContextServiceCacheIndex为Android服务的索引值
    private static void registerService(String serviceName, ServiceFetcher fetcher) {// 注册服务
        if (!(fetcher instanceof StaticServiceFetcher)) {
            fetcher.mContextCacheIndex = sNextPerContextServiceCacheIndex++; 
        }
        SYSTEM_SERVICE_MAP.put(serviceName, fetcher); // 为哈希键值表SYSTEM_SERVICE_MAP赋值
    }
    static { // 静态注册三十多个服务
        ........
        registerService(SENSOR_SERVICE, new ServiceFetcher() {
                public Object createService(ContextImpl ctx) {
                    return new SystemSensorManager(ctx.getOuterContext(),
                      ctx.mMainThread.getHandler().getLooper()); // 此处用的是主线程的looper,共享消息队列
                }});
        ........
    }
    ........
    final ArrayList<Object> mServiceCache = new ArrayList<Object>(); // 定义mServiceCache,用于缓存服务
    ........
    @Override
    public Object getSystemService(String name) {       

        // 通过name获取哈希键值映射表SYSTEM_SERVICE_MAP中的值

        ServiceFetcher fetcher = SYSTEM_SERVICE_MAP.get(name);

        return fetcher == null ? null : fetcher.getService(this);
    }
}


3.SystemSensorManager对象创建过程
在上面注册的三十多个服务,其中就有一个是SensorManager的子类SystemSensorManager
// frameworks/base/core/java/android/hardware/SystemSensorManager.java
public class SystemSensorManager extends SensorManager {
    private static native void nativeClassInit();  //【见详解】
    private static native int nativeGetNextSensor(Sensor sensor, int next); // 【见详解】

    private static boolean sSensorModuleInitialized = false; // 标志Sensor module是否已初始化
    private static final Object sSensorModuleLock = new Object();
    private static final ArrayList<Sensor> sFullSensorsList = new ArrayList<Sensor>();// Sensor缓存
    ........
    private final Looper mMainLooper; // 保存主线程的Looper
    private final int mTargetSdkLevel;
    
    public SystemSensorManager(Context context, Looper mainLooper) {
        mMainLooper = mainLooper; // 由上可得此处传入的是主线程Activity的Looper  
        mTargetSdkLevel = context.getApplicationInfo().targetSdkVersion;
        synchronized(sSensorModuleLock) {
            if (!sSensorModuleInitialized) { // 如果Sensor module未初始化
                sSensorModuleInitialized = true;

                nativeClassInit(); // 调用本地方法初始化本地变量

                // initialize the sensor list
                final ArrayList<Sensor> fullList = sFullSensorsList; // sFullSensorsList用于保存下面创建的sensor
                int i = 0;
                do {
                    Sensor sensor = new Sensor(); // 创建Sensor对象
                    i = nativeGetNextSensor(sensor, i); // 调用本地方法初始化
                    if (i>=0) {
                        // 将创建的Sensor对象添加到缓存中
                        fullList.add(sensor);
                        sHandleToSensor.append(sensor.getHandle(), sensor);
                    }
                } while (i>0);
            }
        }
    }

    @Override
    protected List<Sensor> getFullSensorList() { // 获取Sensor缓存
        return sFullSensorsList;
    }
}

// SensorManager中getDefaultSensor的实现
// frameworks/base/core/java/android/hardware/SensorManager.java
public abstract class SensorManager {
    ........
    private final SparseArray<List<Sensor>> mSensorListByType =
            new SparseArray<List<Sensor>>(); // 稀疏数组mSensorListByType用于缓存前面获取过的传感器列表
    private LegacySensorManager mLegacySensorManager;
    // 以下定义了十几种传感器
    public static final int SENSOR_ORIENTATION = 1 << 0;
    public static final int SENSOR_ACCELEROMETER = 1 << 1;
    public static final int SENSOR_TEMPERATURE = 1 << 2;
    ........
    // 定义SensorListener#onSensorChanged获取到的数组中值的索引
    public static final int DATA_X = 0;
    public static final int DATA_Y = 1;
    public static final int DATA_Z = 2;
    ........
    // 定义各种物理常量
    public static final float STANDARD_GRAVITY = 9.80665f;
    public static final float GRAVITY_SUN             = 275.0f;
    public static final float GRAVITY_MERCURY         = 3.70f;
    ........
    // 定义获取传感器值的频率常量
    public static final int SENSOR_DELAY_FASTEST = 0; 
    public static final int SENSOR_DELAY_GAME = 1; 
    public static final int SENSOR_DELAY_UI = 2; 
    public static final int SENSOR_DELAY_NORMAL = 3; 
    
    // 定义传感器精度相关的值
    public static final int SENSOR_STATUS_NO_CONTACT = -1;              // 未连接到传感器
    public static final int SENSOR_STATUS_UNRELIABLE = 0;                  // 需要校准或者传感器不可读
    public static final int SENSOR_STATUS_ACCURACY_LOW = 1;         // 需要校准,精度低
    public static final int SENSOR_STATUS_ACCURACY_MEDIUM = 2;  // 平均精度,需要校准
    public static final int SENSOR_STATUS_ACCURACY_HIGH = 3;        // 精度高
    ........
    // getFullSensorList的定义地方
    protected abstract List<Sensor> getFullSensorList();
    ........
    // 获取指定类型的传感器
    public List<Sensor> getSensorList(int type) {
        // cache the returned lists the first time
        List<Sensor> list;
        final List<Sensor> fullList = getFullSensorList(); // 调用子类中的getFullSensorList()方法
        synchronized (mSensorListByType) {
            list = mSensorListByType.get(type); // 从稀疏数组中获取传入的类型
            if (list == null) { // 如果获取到结果不为空则直接返回,否则
                if (type == Sensor.TYPE_ALL) { // 如果要获取的是全部传感器,则返回从子类中获取到的fullList
                    list = fullList;
                } else { // 在子类中获取的传感器列表fullList中查找符合条件的传感器,并添加到稀疏数组mSensorListByType中
                    list = new ArrayList<Sensor>();
                    for (Sensor i : fullList) {
                        if (i.getType() == type)
                            list.add(i);
                    }
                }
                list = Collections.unmodifiableList(list);
                mSensorListByType.append(type, list);
            }
        }
        return list;
    }
    
    public Sensor getDefaultSensor(int type) {
        // 调用上面定义的getSensorList方法来获取指定类型的传感器列表
        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) {
            wakeUpSensor = true;
        }
        // 返回满足条件的第一个传感器
        for (Sensor sensor : l) {
            if (sensor.isWakeUpSensor() == wakeUpSensor) return sensor;
        }
        return null;
    }
}

4.SensorManager对应的JNI方法
// frameworks/base/core/jni/android_hardware_SensorManager.cpp
........
static void nativeClassInit (JNIEnv *_env, jclass _this)
{ 
    jclass sensorClass = _env->FindClass("android/hardware/Sensor"); // 获取Java框架层的Sensor类
    SensorOffsets& sensorOffsets = gSensorOffsets; // 定义一个SensorOffsets结构体对象
    // 将Java框架层的Sensor类中的成员保存在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");
    ........
}

static jint nativeGetNextSensor(JNIEnv *env, jclass clazz, jobject sensor, jint next)
{
    SensorManager& mgr(SensorManager::getInstance()); // 创建一个本地的SensorManager对象【见详解】
    ........
    return size_t(next) < count ? next : 0;
}
........
// 定义java与c++方法对应函数表
static JNINativeMethod gSystemSensorManagerMethods[] = {
    {"nativeClassInit",
            "()V",
            (void*)nativeClassInit },

    {"nativeGetNextSensor",
            "(Landroid/hardware/Sensor;I)I",
            (void*)nativeGetNextSensor },
};
........
int register_android_hardware_SensorManager(JNIEnv *env)
{
    // 注册上面定义的函数对应表
    jniRegisterNativeMethods(env, "android/hardware/SystemSensorManager",
            gSystemSensorManagerMethods, NELEM(gSystemSensorManagerMethods));
    ........
}

5.本地SensorManager的定义
// frameworks/base/include/gui/SensorManager.h
class SensorManager :
    public ASensorManager, 
    public Singleton<SensorManager> // 继承单例模式
{
public:
    SensorManager();
    ~SensorManager();
    ........
    // 强引用类型。在创建本地中的SensorManager类对象时，自动强引用SensorService，自动调用onFirstRef方法【见详解】
    mutable sp<ISensorServer> mSensorServer; 
    ........
}

// getInstance函数的定义
// system/core/include/utils/Singleton.h
template <typename TYPE>
class ANDROID_API Singleton
{
public:
    static TYPE& getInstance() {
        Mutex::Autolock _l(sLock);
        TYPE* instance = sInstance;
        if (instance == 0) {
            instance = new TYPE(); // 由此可得将会调用到TYPE的构造函数
            sInstance = instance;
        }
        return *instance;
    }
    ........
}

// frameworks/native/libs/gui/SensorManager.cpp
........
// 由上可得, SensorManager::getInstance()将会调用到此处
SensorManager::SensorManager()
    : mSensorList(0) // 初始化mSensorList为0
{
    assertStateLocked(); // 调用assertStateLocked函数
}
........
status_t SensorManager::assertStateLocked() const {
    if (mSensorServer == NULL) { // 第一次进入的时候为true
        // try for one second
        const String16 name("sensorservice");
        for (int i=0 ; i<4 ; i++) {
            status_t err = getService(name, &mSensorServer); // 获得SensorService保存到mSensorServer成员变量中【见详解】
            if (err == NAME_NOT_FOUND) {
                usleep(250000);
                continue;
            }
            if (err != NO_ERROR) {
                return err;
            }
            break;
        }

        // 注册对SensorService的死亡监听器，SensorManager与SensorService对象将会同时销毁
        class DeathObserver : public IBinder::DeathRecipient {
            SensorManager& mSensorManger;
            virtual void binderDied(const wp<IBinder>& who) {
                ALOGW("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(); // 提供mSensorServer的getSensorList方法来获取所有的Sensor
        size_t count = mSensors.size();
        mSensorList = (Sensor const**)malloc(count * sizeof(Sensor*));
        for (size_t i=0 ; i<count ; i++) {
            mSensorList[i] = mSensors.array() + i; // 将所有的Sensor保存到mSensorList中
        }
    }

    return NO_ERROR;
}

ssize_t SensorManager::getSensorList(Sensor const* const** list) const
{
    Mutex::Autolock _l(mLock);
    status_t err = assertStateLocked();
    if (err < 0) {
        return ssize_t(err);
    }
    *list = mSensorList; // 将assertStateLocked中获取的使用Sensor返回
    return mSensors.size();
}


6.getService的实现
// frameworks/native/include/binder/IServiceManager.h
// defaultServiceManager的定义
sp<IServiceManager> defaultServiceManager();
// getService的定义
template<typename INTERFACE>
status_t getService(const String16& name, sp<INTERFACE>* outService)
{
    const sp<IServiceManager> sm = defaultServiceManager(); // 调用defaultServiceManager()获取默认IServiceManager对象
    if (sm != NULL) {
        // 根据上面获取的IServiceManager对象以及name来获取服务,并保存到outService中
        *outService = interface_cast<INTERFACE>(sm->getService(name)); 
        if ((*outService) != NULL) return NO_ERROR;
    }
    return NAME_NOT_FOUND;
}

// frameworks/native/libs/binder/IServiceManager.c
// defaultServiceManager的实现
sp<IServiceManager> defaultServiceManager()
{
    if (gDefaultServiceManager != NULL) return gDefaultServiceManager;
    {
        AutoMutex _l(gDefaultServiceManagerLock);
        while (gDefaultServiceManager == NULL) {
            gDefaultServiceManager = interface_cast<IServiceManager>(
                ProcessState::self()->getContextObject(NULL));
            if (gDefaultServiceManager == NULL)
                sleep(1);
        }
    }
    
    return gDefaultServiceManager;
}


7.本地SensorService的定义
// frameworks/native/services/sensorservice/SensorService.h
class SensorService :
        public BinderService<SensorService>,
        public BnSensorServer,
        protected Thread // 继承于线程
{
    ........
    // Thread interface
    virtual bool threadLoop(); // 调用run的时候将会调用此方法
    ........
}

// frameworks/native/services/sensorservice/SensorService.cpp
// SensorService构造函数
SensorService::SensorService()
    : mInitCheck(NO_INIT), mSocketBufferSize(SOCKET_BUFFER_SIZE_NON_BATCHED),
      mWakeLockAcquired(false)
{
}

// 由上面SensorManager中mSensorServer为强引用得,在第一次构造SensorService对象的时候会调用此函数
void SensorService::onFirstRef()
{
    ALOGD("nuSensorService starting...");

    SensorDevice& dev(SensorDevice::getInstance()); // 创建SensorDevice对象dev【见详解】

    if (dev.initCheck() == NO_ERROR) {
        sensor_t const* list;
        ssize_t count = dev.getSensorList(&list); // 获得传感器设备列表并保存到list结构体中
        if (count > 0) {
            ........
            for (ssize_t i=0 ; i<count ; i++) {
                registerSensor( new HardwareSensor(list[i]) ); // 注册在本地获得的传感器
                ........
            }
            ........
            mUserSensorList = mSensorList; // 将传感器列表保存到mUserSensorList中,用于客户端访问
            if (hasGyro) { // 如果有陀螺仪设备，则先注册和陀螺仪有关的虚拟传感器设备  
                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);
                }
                // 虚拟方向传感器 
                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);
                }

                // 真正陀螺仪传感器
                registerVirtualSensor( new CorrectedGyroSensor(list, count) );
                // 虚拟陀螺测漂传感器
                registerVirtualSensor( new GyroDriftSensor() );
            }
            mUserSensorListDebug = mSensorList; // 将传感器列表保存到mUserSensorList中,用于调试
            ........
            run("SensorService", PRIORITY_URGENT_DISPLAY); // 运行SensorService线程,调用threadLoop
        }
    }
}
........

bool SensorService::threadLoop()
{
    ........
    do {
        // 调用SensorDevice的poll方法,实现多路监听
        ssize_t count = device.poll(mSensorEventBuffer, numEventMax);
        ........
        // 记录poll返回的每一个传感器中的最后一个数据信息到mLastEventSeen中
        recordLastValueLocked(mSensorEventBuffer, count);

        // 处理虚拟传感器数据 
        if (count && vcount) {
            sensors_event_t const * const event = mSensorEventBuffer;
            // 虚拟传感器个数
            const size_t activeVirtualSensorCount = mActiveVirtualSensors.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]); // 处理虚拟传感器设备事件
                    }
                }
                ........
            }
        }
        ........
        size_t numConnections = activeConnections.size(); // 获得传感器连接对象列表数量
        for (size_t i=0 ; i < numConnections; ++i) {
            if (activeConnections[i] != 0) { // 向指定的传感器连接客户端发送传感器数据信息  
                activeConnections[i]->sendEvents(mSensorEventBuffer, count, mSensorEventScratch,
                        mMapFlushEventsToConnections);
                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);
                }
            }
        }
        ........
    } while (!Thread::exitPending()); // 传感器循环监听线程  

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

// 注册传感器
Sensor SensorService::registerSensor(SensorInterface* s)
{
    sensors_event_t event;
    memset(&event, 0, sizeof(event));

    const Sensor sensor(s->getSensor());
    // add to the sensor list (returned to clients)
    mSensorList.add(sensor); // 将注册的传感器保存到mSensorList中
    // add to our handle->SensorInterface mapping
    mSensorMap.add(sensor.getHandle(), s);
    // create an entry in the mLastEventSeen array
    mLastEventSeen.add(sensor.getHandle(), event);

    return sensor;
}
........
// 获取所有的传感器
Vector<Sensor> SensorService::getSensorList()
{
    char value[PROPERTY_VALUE_MAX];
    property_get("debug.sensors", value, "0");
    const Vector<Sensor>& initialSensorList = (atoi(value)) ?
            mUserSensorListDebug : mUserSensorList; // 根据是否是debug模式来选择要过滤的传感器列表
    Vector<Sensor> accessibleSensorList;
    for (size_t i = 0; i < initialSensorList.size(); i++) {
        Sensor sensor = initialSensorList[i]; 
        if (canAccessSensor(sensor)) { // 将可访问的传感器添加到返回列表中
            accessibleSensorList.add(sensor);
        } else {
            String8 infoMessage;
            infoMessage.appendFormat(
                    "Skipped sensor %s because it requires permission %s",
                    sensor.getName().string(),
                    sensor.getRequiredPermission().string());
            ALOGI(infoMessage.string());
        }
    }
    return accessibleSensorList;
}


8.本地SensorDevice的定义
SensorDevice是在本地代码中SensorService对Sensor设备的抽象类型封装，
它封装了传感器硬件的硬件操作，该类继承了Singleton类，通过getInstance方法获得单例模式设备操作对象
// frameworks/native/services/sensorservice/SensorDevice.h
class SensorDevice : public Singleton<SensorDevice> { // 由此可见SensorDevice也是单例模式 
    friend class Singleton<SensorDevice>;
    sensors_poll_device_1_t* mSensorDevice; // Sensor设备HAL层操作接口封装结构
    struct sensors_module_t* mSensorModule; // Sensor设备HAL层硬件模块封装结构
    ........
    DefaultKeyedVector<int, Info> mActivationCount; // 保存激活Sensor设备向量表

    SensorDevice(); // 构造方法
public:
    ssize_t getSensorList(sensor_t const** list); // 获得Sensor设备列表方法
    status_t initCheck() const;
    int getHalDeviceVersion() const;
    ssize_t poll(sensors_event_t* buffer, size_t count);    // Sensor设备多路监听方法
    status_t activate(void* ident, int handle, int enabled); // 设备激活方法
    status_t batch(void* ident, int handle, int flags, int64_t samplingPeriodNs,
                   int64_t maxBatchReportLatencyNs);
    // Call batch with timeout zero instead of calling setDelay() for newer devices.
    status_t setDelay(void* ident, int handle, int64_t ns); // 设备Sensor设备延迟方法
    status_t flush(void* ident, int handle);
    void autoDisable(void *ident, int handle);
    void dump(String8& result);
};

// frameworks/native/services/sensorservice/SensorDevice.cpp
// 由Singleton中getInstance定义得,SensorDevice::getInstance()将会调用SensorDevice的构造函数
SensorDevice::SensorDevice()
    :  mSensorDevice(0),
       mSensorModule(0)
{
    // 调用hardware.h中的hw_get_module获取Sensor设备HAL层操作接口封装结构
    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) {
        // 打开module设备，返回module设备的操作接口，保存在mSensorDevice中 【见详情】
        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模块的get_sensors_list方法获得传感器列表
            sensor_t const* list;
            ssize_t count = mSensorModule->get_sensors_list(mSensorModule, &list);
            mActivationCount.setCapacity(count);
            Info model;
            for (size_t i=0 ; i<size_t(count) ; i++) {
                // 依次激活这些设备并且添加到mActivationCount设备信息向量中
                mActivationCount.add(list[i].handle, model);
                mSensorDevice->activate(
                        reinterpret_cast<struct sensors_poll_device_t *>(mSensorDevice),
                        list[i].handle, 0);
            }
        }
    }
}
........
// 获取传感器设备
ssize_t SensorDevice::getSensorList(sensor_t const** list) {
    if (!mSensorModule) return NO_INIT;
    ssize_t count = mSensorModule->get_sensors_list(mSensorModule, list);
    return count;
}
// 检查SensorDevice是否初始化
status_t SensorDevice::initCheck() const {
    return mSensorDevice && mSensorModule ? NO_ERROR : NO_INIT;
}
// 实现多路监听
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;
}

// sensors_open_1的定义与实现
// hardware/libhardware/include/hardware/sensors.h
........
// 各种传感器类型的定义
#define SENSOR_TYPE_META_DATA                        (0)

#define SENSOR_TYPE_ACCELEROMETER                    (1)
#define SENSOR_STRING_TYPE_ACCELEROMETER             "android.sensor.accelerometer"

#define SENSOR_TYPE_GEOMAGNETIC_FIELD                (2)
#define SENSOR_TYPE_MAGNETIC_FIELD  SENSOR_TYPE_GEOMAGNETIC_FIELD
#define SENSOR_STRING_TYPE_MAGNETIC_FIELD            "android.sensor.magnetic_field"

#define SENSOR_TYPE_ORIENTATION                      (3)
#define SENSOR_STRING_TYPE_ORIENTATION               "android.sensor.orientation"
........
// 地球与太阳的重力常量
#define GRAVITY_SUN             (275.0f)
#define GRAVITY_EARTH           (9.80665f)
........
// 各种精度
#define SENSOR_STATUS_NO_CONTACT        -1
#define SENSOR_STATUS_UNRELIABLE        0
#define SENSOR_STATUS_ACCURACY_LOW      1
#define SENSOR_STATUS_ACCURACY_MEDIUM   2
#define SENSOR_STATUS_ACCURACY_HIGH     3
// 表示不同传感器数据向量的结构体
typedef struct {
    union {
        float v[3]; // 使用3个浮点数据表示
        struct {    // 使用轴坐标表示
            float x;
            float y;
            float z;
        };
        struct {    // 使用极坐标表示
            float azimuth;
            float pitch;
            float roll;
        };
    };
    int8_t status;  // 状态信息
    uint8_t reserved[3];
} sensors_vec_t;
........

// 每个传感器的数据由sensors_event_t结构体表示
typedef struct sensors_event_t {
    /* must be sizeof(struct sensors_event_t) */
    int32_t version;

    /* sensor identifier */
    int32_t sensor;

    /* sensor type */
    int32_t type;

    /* reserved */
    int32_t reserved0;
    ........
} sensors_event_t;

/* see SENSOR_TYPE_META_DATA */
typedef sensors_event_t sensors_meta_data_event_t;

........

// 传感器模块的定义结构体
struct sensors_module_t {
    struct hw_module_t common;

    // 获取传感器的列表
    int (*get_sensors_list)(struct sensors_module_t* module,
            struct sensor_t const** list);
};

// 对任意一个sensor设备都会有一个sensor_t结构体
struct sensor_t {
    /* Name of this sensor.
     * All sensors of the same "type" must have a different "name".
     */
    const char*     name;

    /* vendor of the hardware part */
    const char*     vendor;

    /* version of the hardware part + driver. The value of this field
     * must increase when the driver is updated in a way that changes the
     * output of this sensor. This is important for fused sensors when the
     * fusion algorithm is updated.
     */
    int             version;
    ........
};

// Sensor设备结构体,主要完成读取底层数据，并将数据存储在struct sensors_poll_device_t 结构体中
struct sensors_poll_device_t {
    struct hw_device_t common;
    int (*activate)(struct sensors_poll_device_t *dev,
            int sensor_handle, int enabled);
    int (*setDelay)(struct sensors_poll_device_t *dev,
            int sensor_handle, int64_t sampling_period_ns);
    // poll函数用来获取底层数据，调用时将被阻塞
    int (*poll)(struct sensors_poll_device_t *dev,
            sensors_event_t* data, int count);
};

........

// 制设备打开/关闭结构体定义如下
static inline int sensors_open(const struct hw_module_t* module,
        struct sensors_poll_device_t** device) {
    return module->methods->open(module,
            SENSORS_HARDWARE_POLL, (struct hw_device_t**)device);
}

static inline int sensors_close(struct sensors_poll_device_t* device) {
    return device->common.close(&device->common);
}

static inline int sensors_open_1(const struct hw_module_t* module,
        sensors_poll_device_1_t** device) {
    return module->methods->open(module,
            SENSORS_HARDWARE_POLL, (struct hw_device_t**)device);
}

static inline int sensors_close_1(sensors_poll_device_1_t* device) {
    return device->common.close(&device->common);

}