SensorManager 基于Android 5.1源码分析：2016-04-23
1、Java层启动轮询线程的流程
SensorManager.java
这里有4个供上层APP使用的注册接口。
public boolean registerListener(SensorListener listener, int sensors)
public boolean registerListener(SensorListener listener, int sensors,int rate)//以上两个方法在5.1版本上已被废弃
public boolean registerListener(SensorEventListener listener, Sensor sensor,int samplingPeriodUs)
public boolean registerListener(SensorEventListener listener, Sensor sensor, int samplingPeriodUs,int maxReportLatencyUs){
int delay =getDelay(samplingPeriodUs);
return registerListenerImpl(listener, sensor, delay,null, maxReportLatencyUs, 0);//SensorManager类的registerListenerImpl方法是抽象法，真正的实现在其子类SystemSensorManager.java中。
}
SystemSensorManager.java
public class SystemSensorManagerextends SensorManager {//SystemSensorManager是SensorManager的子类。
@Override
protected boolean registerListenerImpl(SensorEventListener listener, Sensor sensor,
int delayUs, Handler handler,int maxBatchReportLatencyUs,int reservedFlags) {
......
synchronized (mSensorListeners) {
SensorEventQueue queue = mSensorListeners.get(listener);
if (queue ==null) {
Looper looper = (handler !=null) ? handler.getLooper() : mMainLooper;
queue = new SensorEventQueue(listener, looper,this);//将looper传入启动轮询线程。
......
mSensorListeners.put(listener, queue);
return true;
} else {
return queue.addSensor(sensor, delayUs, maxBatchReportLatencyUs, reservedFlags);
}
}
}
}
//SensorEventQueue构造方法中调用父类构造方法。
static final class SensorEventQueue extends BaseEventQueue {
private final SensorEventListener mListener;
private final SparseArray<SensorEvent> mSensorsEvents = new SparseArray<SensorEvent>();
public SensorEventQueue(SensorEventListener listener, Looper looper,
SystemSensorManager manager) {
super(looper, manager);
mListener = listener;
}
}
//SensorEventQueue和TriggerEventQueue是BaseEventQueue的两个子类。在BaseEventQueue类中声明了以下几个native方法
private static abstract class BaseEventQueue {
private native long nativeInitBaseEventQueue(BaseEventQueue eventQ, MessageQueue msgQ,
float[] scratch);
private static native int nativeEnableSensor(long eventQ,int handle,int rateUs,
int maxBatchReportLatencyUs,int reservedFlags);
private static native int nativeDisableSensor(long eventQ,int handle);
private static native void nativeDestroySensorEventQueue(long eventQ);
private static native int nativeFlushSensor(long eventQ);
BaseEventQueue(Looper looper, SystemSensorManager manager) {
nSensorEventQueue = nativeInitBaseEventQueue(this, looper.getQueue(), mScratch);//调用JNI native中的消息队列初始化
mCloseGuard.open("dispose");
mManager = manager;
}
}
2、native中的消息队列初始化流程
android_hardware_SensorManager.cpp
static JNINativeMethod gBaseEventQueueMethods[] = {
{"nativeInitBaseEventQueue",
"(Landroid/hardware/SystemSensorManager$BaseEventQueue;Landroid/os/MessageQueue;[F)J",
(void*)nativeInitSensorEventQueue},//对应的native函数nativeInitSensorEventQueue指针
{"nativeEnableSensor",
"(JIIII)I",
(void*)nativeEnableSensor },
{"nativeDisableSensor",
"(JI)I",
(void*)nativeDisableSensor },
{"nativeDestroySensorEventQueue",
"(J)V",
(void*)nativeDestroySensorEventQueue },
{"nativeFlushSensor",
"(J)I",
(void*)nativeFlushSensor },
};
static jlongnativeInitSensorEventQueue(JNIEnv *env, jclass clazz, jobject eventQ, jobject msgQ, jfloatArray scratch) {
SensorManager& mgr(SensorManager::getInstance());//单例模式（通过继承Singleton实现）,所调用的构造函数在SensorManager.cpp中
sp<SensorEventQueue> queue(mgr.createEventQueue());//创建消息队列
......
sp<Receiver> receiver = new Receiver(queue, messageQueue, eventQ, scratch);
receiver->incStrong((void*)nativeInitSensorEventQueue);
return jlong(receiver.get());
}
SensorManager.h
class SensorManager :
public AsensorManager,//ASensorManager是NDK的接口，应该是个结构体，c++是可以继承结构体的
public Singleton<SensorManager>//Singleton是一个单例泛型类（详见附1节），提供了getInstance与hasInstance两个方法
{
……
mutable sp<ISensorServer> mSensorServer;//注意，sp是强引用，要关注onFirstRef回调，这个变量的初始化是在SensorManager::assertStateLocked()中
……
}
SensorManager.cpp
SensorManager::SensorManager()
: mSensorList(0)
{
// okay we're not locked here, but it's not needed during construction
assertStateLocked();
}
status_t SensorManager::assertStateLocked()const {
if (mSensorServer == NULL) {
// try for one second
const String16 name("sensorservice");
for (int i=0 ; i<4 ; i++) {
status_t err = getService(name, &mSensorServer);
//得到服务SensorService，注意mSensorServer是强引用类型，要关注onFirstRef回调
//另外getService定义在IServiceManager.h中，是一个全局函数，不属于任何类，但会通过另一个全局函数defaultServiceManager()调用到IServiceManager.cpp中的BpServiceManager::getService
//而服务也是通过defaultServiceManager()调用IServiceManager.cpp中的BpServiceManager::addService注册的（详见第4节开头）
if (err == NAME_NOT_FOUND) {
usleep(250000);
continue;
}
if (err != NO_ERROR) {
return err;
}
break;
}
class DeathObserver :public IBinder::DeathRecipient {//服务SensorService的死亡监听
SensorManager& mSensorManger;
virtual void binderDied(const wp<IBinder>& who) {
ALOGW("sensorservice died [%p]", who.unsafe_get());
mSensorManger.sensorManagerDied();//若服务SensorService死亡，则同时结束SensorManager
}
public:
DeathObserver(SensorManager& mgr) : mSensorManger(mgr) { }
};
//注册服务SensorService的死亡监听
mDeathObserver = new DeathObserver(*const_cast<SensorManager *>(this));
mSensorServer->asBinder()->linkToDeath(mDeathObserver);
//从服务SensorService获取sensor列表，并保存在SensorManager中
mSensors = mSensorServer->getSensorList();
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;
}
}
return NO_ERROR;
}
SensorManager.cpp
sp<SensorEventQueue> SensorManager::createEventQueue()
{
sp<SensorEventQueue> queue;
Mutex::Autolock _l(mLock);
while (assertStateLocked() == NO_ERROR) {
sp<ISensorEventConnection> connection =
mSensorServer->createSensorEventConnection();//创建连接接口（详见第2.1节），需要注意：这是客户端在调用服务端的接口
if (connection == NULL) {
// SensorService just died.
ALOGE("createEventQueue: connection is NULL. SensorService died.");
usleep(100000);
continue;
}
queue = new SensorEventQueue(connection);//创建消息队列（详见第2.2节）
break;
}
return queue;
}
2.1、创建连接接口的过程
SensorService.cpp
sp<ISensorEventConnection> SensorService::createSensorEventConnection()
{
uid_t uid = IPCThreadState::self()->getCallingUid();
sp<SensorEventConnection> result(new SensorEventConnection(this, uid));
return result;
}
SensorService::SensorEventConnection::SensorEventConnection(
const sp<SensorService>& service, uid_t uid)
: mService(service), mUid(uid), mWakeLockRefCount(0), mHasLooperCallbacks(false),
mDead(false), mEventCache(NULL), mCacheSize(0), mMaxCacheSize(0) {
mChannel = new BitTube(mService->mSocketBufferSize);
//BitTube的作用是创建一对管道（详见附2节）
//sp<BitTube> const mChannel;保存的管道会在SensorService::SensorEventConnection::sendEvents中用到，而sendEvents在native服务线程中用到（详见4.2节）
2.2、创建消息队列的过程
SensorEventQueue.h
class SensorEventQueue : public ASensorEventQueue, public RefBase
SensorEventQueue.cpp
SensorEventQueue::SensorEventQueue(const sp<ISensorEventConnection>& connection)
: mSensorEventConnection(connection), mRecBuffer(NULL), mAvailable(0), mConsumed(0),
mNumAcksToSend(0) {
mRecBuffer = new ASensorEvent[MAX_RECEIVE_BUFFER_EVENT_COUNT];//赋值
}
3、SystemSensorManager的初始化流程
3.1、从开机到实例化SystemSensorManager
SystemServer.java
public final class SystemServer {
......
/**
* Called to initialize native system services.
*/
private static native void nativeInit();
/**
* The main entry point from zygote.
*/
public static void main(String[] args) {
new SystemServer().run();
}
private void run() {
......
// Initialize native services.
System.loadLibrary("android_servers");
nativeInit();//第1步，JNI到com_android_server_SystemServer.cpp中去
......
// Create the system service manager.
mSystemServiceManager = new SystemServiceManager(mSystemContext);
LocalServices.addService(SystemServiceManager.class, mSystemServiceManager);
// Start services.
try {
startBootstrapServices();
startCoreServices();
startOtherServices();
} catch (Throwable ex) {
Slog.e("System", "******************************************");
Slog.e("System", "************ Failure starting system services", ex);
/// M: RecoveryManagerService @{
if (mRecoveryManagerService !=null && exinstanceof RuntimeException) {
mRecoveryManagerService.handleException((RuntimeException)ex,true);
}
/// @}
}
private void startBootstrapServices() {
......
mPowerManagerService = mSystemServiceManager.startService(PowerManagerService.class);//第4步
......
}
}
private void startOtherServices() {
......
mPowerManagerService.systemReady(mActivityManagerService.getAppOpsService());//第5步
......
}
}
PowerManagerService.cpp
public final class PowerManagerServiceextends SystemServiceimplements Watchdog.Monitor {
......
public void systemReady(IAppOpsService appOps) {
synchronized (mLock) {
......
SensorManager sensorManager =new SystemSensorManager(mContext, mHandler.getLooper()); //第6步，实例化SystemSensorManager
......
}
......
}
com_android_server_SystemServer.cpp
static void android_server_SystemServer_nativeInit(JNIEnv* env, jobject clazz) {//第2步
char propBuf[PROPERTY_VALUE_MAX];
property_get("system_init.startsensorservice", propBuf, "1");
if (strcmp(propBuf, "1") == 0) {
// Start the sensor service
SensorService::instantiate(); //第3步SensorService实例化启动
}
static JNINativeMethod gMethods[] = { //函数签名信息
/* name, signature, funcPtr */
{ "nativeInit", "()V", (void*)android_server_SystemServer_nativeInit },
};
int register_android_server_SystemServer(JNIEnv* env)//动态注册JNI函数
{
return jniRegisterNativeMethods(env, "com/android/server/SystemServer",
gMethods, NELEM(gMethods));
}
3.2、实例化SystemSensorManager
SystemSensorManager.java
public class SystemSensorManager extends SensorManager {
......
public SystemSensorManager(Context context, Looper mainLooper) {
mMainLooper = mainLooper;
mTargetSdkLevel = context.getApplicationInfo().targetSdkVersion;
synchronized(sSensorModuleLock) {
if (!sSensorModuleInitialized) {
sSensorModuleInitialized = true;
nativeClassInit();//编号3.2.1 JNI调用android_hardware_SensorManager.cpp中的方法
// initialize the sensor list
final ArrayList<Sensor> fullList = sFullSensorsList;
int i = 0;
do {
Sensor sensor = new Sensor();
i = nativeGetNextSensor(sensor, i);//编号3.2.2 JNI调用android_hardware_SensorManager.cpp中的方法；并最终将sensor列表保存在sHandleToSensor变量中
if (i>=0) {
//Log.d(TAG, "found sensor: " + sensor.getName() +
// ", handle=" + sensor.getHandle());
fullList.add(sensor);
sHandleToSensor.append(sensor.getHandle(), sensor);
}
} while (i>0);
}
}
}
}
android_hardware_SensorManager.cpp
static JNINativeMethod gSystemSensorManagerMethods[] = {
{"nativeClassInit",
"()V",
(void*)nativeClassInit },
{"nativeGetNextSensor",
"(Landroid/hardware/Sensor;I)I",
(void*)nativeGetNextSensor },
};
3.2.1
android_hardware_SensorManager.cpp
struct SensorOffsets
{
jfieldID name;
jfieldID vendor;
jfieldID version;
jfieldID handle;
jfieldID type;
jfieldID range;
jfieldID resolution;
jfieldID power;
jfieldID minDelay;
jfieldID fifoReservedEventCount;
jfieldID fifoMaxEventCount;
jfieldID stringType;
jfieldID requiredPermission;
jfieldID maxDelay;
jfieldID flags;
} gSensorOffsets;//用于保存java类中数据域的FieldID，而非具体java对象的ID
static void
nativeClassInit (JNIEnv *_env, jclass _this)
{
jclass sensorClass = _env->FindClass("android/hardware/Sensor");//Sensor.java
SensorOffsets& sensorOffsets = gSensorOffsets;//这里使用的是C++的引用，即下面是对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");
sensorOffsets.fifoReservedEventCount =
_env->GetFieldID(sensorClass, "mFifoReservedEventCount", "I");
sensorOffsets.fifoMaxEventCount = _env->GetFieldID(sensorClass, "mFifoMaxEventCount", "I");
sensorOffsets.stringType = _env->GetFieldID(sensorClass, "mStringType", "Ljava/lang/String;");
sensorOffsets.requiredPermission = _env->GetFieldID(sensorClass, "mRequiredPermission",
"Ljava/lang/String;");
sensorOffsets.maxDelay = _env->GetFieldID(sensorClass, "mMaxDelay", "I");
sensorOffsets.flags = _env->GetFieldID(sensorClass, "mFlags", "I");
}
Sensor.java
public final class Sensor {
......
/* Some of these fields are set only by the native bindings in
* SensorManager.
*/
private String mName;
private String mVendor;
private int mVersion;
private int mHandle;
private int mType;
private float mMaxRange;
private float mResolution;
private float mPower;
private int mMinDelay;
private int mFifoReservedEventCount;
private int mFifoMaxEventCount;
private String mStringType;
private String mRequiredPermission;
private int mMaxDelay;
private int mFlags;
......
}
3.2.2
android_hardware_SensorManager.cpp
static jint
nativeGetNextSensor(JNIEnv *env, jclass clazz, jobject sensor, jint next)
{
SensorManager& mgr(SensorManager::getInstance());
Sensor const*const* sensorList;
size_t count = mgr.getSensorList(&sensorList);//通过SensorManager获取sensor列表，SensorManager的列表是在SensorManager初始化时从SensorService获得到的
if (size_t(next) >= count)
return -1;
Sensor const*const list = sensorList[next];
const SensorOffsets& sensorOffsets(gSensorOffsets);
jstring name = env->NewStringUTF(list->getName().string());
jstring vendor = env->NewStringUTF(list->getVendor().string());
jstring stringType = env->NewStringUTF(list->getStringType().string());
jstring requiredPermission = env->NewStringUTF(list->getRequiredPermission().string());
env->SetObjectField(sensor, sensorOffsets.name, name);
env->SetObjectField(sensor, sensorOffsets.vendor, vendor);
env->SetIntField(sensor, sensorOffsets.version, list->getVersion());
env->SetIntField(sensor, sensorOffsets.handle, list->getHandle());
env->SetIntField(sensor, sensorOffsets.type, list->getType());
env->SetFloatField(sensor, sensorOffsets.range, list->getMaxValue());
env->SetFloatField(sensor, sensorOffsets.resolution, list->getResolution());
env->SetFloatField(sensor, sensorOffsets.power, list->getPowerUsage());
env->SetIntField(sensor, sensorOffsets.minDelay, list->getMinDelay());
env->SetIntField(sensor, sensorOffsets.fifoReservedEventCount,
list->getFifoReservedEventCount());
env->SetIntField(sensor, sensorOffsets.fifoMaxEventCount,
list->getFifoMaxEventCount());
env->SetObjectField(sensor, sensorOffsets.stringType, stringType);
env->SetObjectField(sensor, sensorOffsets.requiredPermission,
requiredPermission);
env->SetIntField(sensor, sensorOffsets.maxDelay, list->getMaxDelay());
env->SetIntField(sensor, sensorOffsets.flags, list->getFlags());
next++;
return size_t(next) < count ? next : 0;
}
4、服务端的初始化流程
//启动过程类似于，可参考3.1节中前3步的流程
com_android_server_SystemServer.cpp
static void android_server_SystemServer_nativeInit(JNIEnv* env, jobject clazz) {
char propBuf[PROPERTY_VALUE_MAX];
property_get("system_init.startsensorservice", propBuf, "1");//property_get()是c/c++的接口，对应的java接口是SystemProperties_get*()，读取build.prop中的值
if (strcmp(propBuf, "1") == 0) {//判断是否要启动服务，默认是启动
// Start the sensor service
SensorService::instantiate(); //SensorService继承了模板类BinderService<SensorService>，instantiate就是模板类的方法
}
BinderService.h
template<typename SERVICE>
class BinderService
{
public:
static status_t publish(bool allowIsolated = false) {
sp<IServiceManager> sm(defaultServiceManager());//defaultServiceManager()定义在IServiceManager.cpp中
return sm->addService(String16(SERVICE::getServiceName()), new SERVICE(), allowIsolated);
//new了一个SensorService的实例，并将其添加到系统服务管理器中
//这样就可以用defaultServiceManager:getService()获取到Sensor服务的实例
}
……
static void instantiate() { publish(); }
……
};
IServiceManager.h
sp<IServiceManager> defaultServiceManager();//这是原型定义，实体在IServiceManager.cpp中
template<typename INTERFACE>
status_t getService(const String16& name, sp<INTERFACE>* outService)
{
const sp<IServiceManager> sm = defaultServiceManager();
if (sm != NULL) {
*outService = interface_cast<INTERFACE>(sm->getService(name));//getService与addService都是接口IServiceManager中定义的方法
if ((*outService) != NULL) return NO_ERROR;
}
return NAME_NOT_FOUND;
}
SensorService.h
class SensorService :
public BinderService<SensorService>,
public BnSensorServer,
protected Thread//线程类，在SensorService::onFirstRef()中由run方法启动
{
……
// ISensorServer interface
virtual Vector<Sensor> getSensorList();//sensor列表，在SensorService::getSensorList()中获取，在SensorService::onFirstRef()中赋值
virtual sp<ISensorEventConnection> createSensorEventConnection();
……
}
SensorService.cpp
Vector<Sensor> SensorService::getSensorList()
{
char value[PROPERTY_VALUE_MAX];
property_get("debug.sensors", value, "0");
const Vector<Sensor>& initialSensorList = (atoi(value)) ?//atoi是字符串转整型的意思
mUserSensorListDebug : mUserSensorList;//在SensorService::onFirstRef()中赋值
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;
}
void SensorService::onFirstRef()
{
ALOGD("nuSensorService starting...");
SensorDevice& dev(SensorDevice::getInstance());//编号4.1 单例创建SensorDevice
if (dev.initCheck() == NO_ERROR) {//获得sensor列表
sensor_t const* list;
ssize_t count = dev.getSensorList(&list);
if (count > 0) {
ssize_t orientationIndex = -1;
bool hasGyro = false;//硬件上是否有陀螺仪的标志
uint32_t virtualSensorsNeeds =//是否需要记录某些sensor的标志
(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++) {//扫描sensor列表
registerSensor( new HardwareSensor(list[i]) );
switch (list[i].type) {
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());//单例创建SensorFusion
// build the sensor list returned to users
mUserSensorList = mSensorList;//Sensor列表赋值
//如果有陀螺仪设备，则先注册和陀螺仪有关的虚拟传感器设备
//旋转，重力，加速器，方向等，这些设备都对应同一个物理硬件――陀螺仪
//这些逻辑上存在，物理上不存在的设备叫虚拟设备
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);
}
// virtual debugging sensors are not added to mUserSensorList//虚拟调试传感器不被添加到mUserSensorList中
registerVirtualSensor( new CorrectedGyroSensor(list, count) );//修正陀螺传感器
registerVirtualSensor( new GyroDriftSensor() );//虚拟陀螺测漂传感器
}
// debugging sensor list
mUserSensorListDebug = mSensorList;
......
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];
mAckReceiver = new SensorEventAckReceiver(this);
mAckReceiver->run("SensorEventAckReceiver", PRIORITY_URGENT_DISPLAY);
mInitCheck = NO_ERROR;
run("SensorService", PRIORITY_URGENT_DISPLAY);//编号4.2开始运行SensorService线程，即启动SensorService::threadLoop()方法
}
}
}
Sensor SensorService::registerVirtualSensor(SensorInterface* s)
{
Sensor sensor = registerSensor(s);
mVirtualSensorList.add( s );//记录虚拟sensor
return sensor;
}
Sensor SensorService::registerSensor(SensorInterface* s)
{
sensors_event_t event;
memset(&event, 0, sizeof(event));
const Sensor sensor(s->getSensor());
//添加到Sensor列表，给客户端使用
// add to the sensor list (returned to clients)
mSensorList.add(sensor);
// 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;
}
4.1
SensorDevice.cpp
SensorDevice::SensorDevice()
: mSensorDevice(0),
mSensorModule(0)
{
status_t err = hw_get_module(SENSORS_HARDWARE_MODULE_ID,
(hw_module_t const**)&mSensorModule);//调用HAL层的hw_get_modele()方法，加载Sensor模块so文件
ALOGE_IF(err, "couldn't load %s module (%s)",
SENSORS_HARDWARE_MODULE_ID, strerror(-err));
if (mSensorModule) {
err = sensors_open_1(&mSensorModule->common, &mSensorDevice);//调用sensor.h的sensors_open方法打开设备
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);
mActivationCount.setCapacity(count);
Info model;
for (size_t i=0 ; i<size_t(count) ; i++) {
mActivationCount.add(list[i].handle, model);
mSensorDevice->activate(
reinterpret_cast<struct sensors_poll_device_t *>(mSensorDevice),//调用sensors_poll_device_t->activate()对Sensor模块使能
list[i].handle, 0);
}
}
}
}
4.2
SensorService.cpp
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);//轮询
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);
}
recordLastValueLocked(mSensorEventBuffer, count);
// handle virtual sensors
//从底层读上来的应该都是物理存在的sensor的信息，但上层使用的sensor有一部分是虚拟的（陀螺仪派生的），所以需要先处理一下
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]);
}
}
for (size_t i=0 ; i<size_t(count) && k<minBufferSize ; i++) {
for (size_t j=0 ; j<activeVirtualSensorCount ; j++) {
if (count + k >= minBufferSize) {
ALOGE("buffer too small to hold all events: "
"count=%zd, k=%zu, size=%zu",
count, k, minBufferSize);
break;
}
sensors_event_t out;
SensorInterface* si = mActiveVirtualSensors.valueAt(j);
if (si->process(&out, event[i])) {
mSensorEventBuffer[count + k] = out;
k++;
}
}
}
if (k) {
// record the last synthesized values
recordLastValueLocked(&mSensorEventBuffer[count], k);
count += k;
// sort the buffer by time-stamps
sortEventBuffer(mSensorEventBuffer, count);
}
}
}
// handle backward compatibility for RotationVector sensor
if (halVersion < SENSORS_DEVICE_API_VERSION_1_0) {
for (int i = 0; i < count; i++) {
if (mSensorEventBuffer[i].type == SENSOR_TYPE_ROTATION_VECTOR) {
// All the 4 components of the quaternion should be available
// No heading accuracy. Set it to -1
mSensorEventBuffer[i].data[4] = -1;
}
}
}
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();
}
}
}
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);//将数据写到管道中
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());
ALOGW("Exiting SensorService::threadLoop => aborting...");
abort();
return false;
}
4、消息传递
总结一下：
1、APP用registerListener注册回调
2、java层的客户端在SystemSensorManager.java
中的SystemSensorManager::SensorThreadRunnable::run()中
轮询服务端
3、服务端在
SensorService.cpp
中的bool SensorService::threadLoop()中
轮询HAL
4、服务端向客户端写数据是通过管道进行的，且使用的结构体如下
./hardware/libhardware/include/hardware/sensors.h
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;
/* time is in nanosecond */
int64_t timestamp;
union {
union {
float data[16];
/* acceleration values are in meter per second per second (m/s^2) */
sensors_vec_t acceleration;
/* magnetic vector values are in micro-Tesla (uT) */
sensors_vec_t magnetic;
/* orientation values are in degrees */
sensors_vec_t orientation;
/* gyroscope values are in rad/s */
sensors_vec_t gyro;
/* temperature is in degrees centigrade (Celsius) */
float temperature;
/* distance in centimeters */
float distance;
/* light in SI lux units */
float light;
/* pressure in hectopascal (hPa) */
float pressure;
/* relative humidity in percent */
float relative_humidity;
/* uncalibrated gyroscope values are in rad/s */
uncalibrated_event_t uncalibrated_gyro;
/* uncalibrated magnetometer values are in micro-Teslas */
uncalibrated_event_t uncalibrated_magnetic;
/* heart rate data containing value in bpm and status */
heart_rate_event_t heart_rate;
/* this is a special event. see SENSOR_TYPE_META_DATA above.
* sensors_meta_data_event_t events are all reported with a type of
* SENSOR_TYPE_META_DATA. The handle is ignored and must be zero.
*/
meta_data_event_t meta_data;
};
union {
uint64_t data[8];
/* step-counter */
uint64_t step_counter;
} u64;
};
/* Reserved flags for internal use. Set to zero. */
uint32_t flags;
uint32_t reserved1[3];
} sensors_event_t;
5、客户端从服务端读数据（通过android_hardware_SensorManager.cpp中的JNI接口sensors_data_poll）使用的结构体如下，可以看出和服务端使用的结构体基本一致，差异在联合体部分，且差异不会影响到联合体的大小
frameworks/native/include/android/sensor.h
/* NOTE: Must match hardware/sensors.h */
typedef struct ASensorEvent {
int32_t version; /* sizeof(struct ASensorEvent) */
int32_t sensor;
int32_t type;
int32_t reserved0;
int64_t timestamp;
union {
union {
float data[16];
ASensorVector vector;
ASensorVector acceleration;
ASensorVector magnetic;
float temperature;
float distance;
float light;
float pressure;
float relative_humidity;
AUncalibratedEvent uncalibrated_gyro;
AUncalibratedEvent uncalibrated_magnetic;
AMetaDataEvent meta_data;
AHeartRateEvent heart_rate;
};
union {
uint64_t data[8];
uint64_t step_counter;
} u64;
};
uint32_t flags;
int32_t reserved1[3];
} ASensorEvent;