Android 9.0 Framework系列--Sensor框架（一）
前言
研究代码永远是学习进入的最好方式，因为本人更多的工作内容还是在farmework层，这里把之前的一些研究也总结一下。所有的研究都是基于
Android 9.0。
一、Sensor框架概述
关于Sensor框架在网上描述的也挺多的，我也不做深入分析了，这里把自己的思考在这里做一下总结。
整个Android的思路都是server-client的思路，Sensor也不例外，Sensor框架也分为两部分，
1.1 client --SensorManager（frameworks\base\core\java\android\hardware）SensorManager类，它提供给客户实际操作。围绕SystemSensorManager，还有一系列相关类
1.1.1 java层
➢SensorManager.java --虚类
➢LegacySensorManager--9.0已废除
➢SensorListener.java --监听类
➢Sensor.java ---单个sensor的抽象，用户通过该类对Sensor进行具体实现
➢SystemSensorManager--SensorManager的实现类，实际上上层对Sensor的控制都在SystemSensorManager
1.1.2 jni层
android_hardware_SensorManager.cpp（frameworks\base\core\jni）
1.2 server--SensorService（frameworks\native\services\sensorservice）
SensorService及其一系列代码的主要功能是实现对hal层的的访问，实现虚拟传感器的的相关算法SensorService.cpp --传感器服务
SensorDevice.cpp-管理传感器
RotationVectorSensor.cpp-虚拟传感器
1.3 Hal层
hal层是由厂家自己实现的，它对上提供给SensorService访问，对下直接访问驱动，每一款不同的SOC写法不一样，但都遵照了相Android的相关规则。这里后续描述。
1.4 驱动层
驱动实现了sensor的具体的功能，比如加速度传感器主要是获得xyz的加速度等等。
二、启动
2.1 SensorService的启动
Android启动过程中，先启动SensorService，然后调用hal层进行相关初始化，并进入相关轮询状态。
2.1.1 startBootstrapServices() frameworks\base\services\java\com\android\server\SystemServer.java
/**
* Start the sensor service. This is a blocking call and can take time.
*/
private static native void startSensorService();
private void startBootstrapServices() {
.............................
// The sensor service needs access to package manager service, app ops
// service, and permissions service, therefore we start it after them.
// Start sensor service in a separate thread. Completion should be checked
// before using it.
mSensorServiceStart = SystemServerInitThreadPool.get().submit(() -> {
TimingsTraceLog traceLog = new TimingsTraceLog(
SYSTEM_SERVER_TIMING_ASYNC_TAG, Trace.TRACE_TAG_SYSTEM_SERVER);
traceLog.traceBegin(START_SENSOR_SERVICE);
//启动sensor，在jni中实现
startSensorService();
traceLog.traceEnd();
}, START_SENSOR_SERVICE);
}2.1.2 startSensorService()
frameworks\base\services\core\jni\com_android_server_SystemServer.cpp
startSensorService直接在jni中实现
/*
* JNI registration.
*/
static const JNINativeMethod gMethods[] = {
/* name, signature, funcPtr */
{ "startSensorService", "()V", (void*) android_server_SystemServer_startSensorService },
{ "startHidlServices", "()V", (void*) android_server_SystemServer_startHidlServices },
};
static void android_server_SystemServer_startSensorService(JNIEnv* /* env */, jobject /* clazz */) {
char propBuf[PROPERTY_VALUE_MAX];
property_get("system_init.startsensorservice", propBuf, "1");
if (strcmp(propBuf, "1") == 0) {
//直接调用SensorService::instantiate()
SensorService::instantiate();
}
}2.1.3 SensorService::instantiate()
SensorService继承自BinderService，SensorService::instantiate()会进一步执行BinderService::instantiate，在BinderService中会执行addService，然后将SensorService加入到ServiceManager中。
2.1.4 SensorService::onFirstRef()
SensorService还继承了RefBase，所以会在第一次调用时，调用onFirstRef，而SensorService的初始化就是在onFirstRef中完成。onFirstRef中，比较重要的初始化内容包括：
2.1.4.1.创建SensorDevice，SensorDevice是负责与Hal层连接的关键类
2.1.4.2.从SensorDevice获得当前的传感器列表，并判断当前系统存在哪些传感器，创建对应的相关类，
2.1.4.3 根据当前传感器，创建虚拟传感器类。
从代码上看，一些虚拟传感器的创建关系如下：
加速度/地磁/陀螺仪都有：
RotationVectorSensor
OrientationSensor
LinearAccelerationSensor
CorrectedGyroSensor
GyroDriftSensor
加速度/陀螺仪：
GameRotationVectorSensor
GravitySensor
加速度/地磁：
GeoMagRotationVectorSensor
void SensorService::onFirstRef() {
ALOGD("nuSensorService starting...");
//2.1.4.1===
SensorDevice& dev(SensorDevice::getInstance());
sHmacGlobalKeyIsValid = initializeHmacKey();
if (dev.initCheck() == NO_ERROR) {
sensor_t const* list;
//2.1.4.2===传感器创建
ssize_t count = dev.getSensorList(&list);
if (count > 0) {
ssize_t orientationIndex = -1;
bool hasGyro = false, hasAccel = false, hasMag = false;
uint32_t virtualSensorsNeeds =
(1< bool {
if (s.getFifoMaxEventCount() > 0) {
batchingSupported = true;
}
return !batchingSupported;
});
if (batchingSupported) {
// Increase socket buffer size to a max of 100 KB for batching capabilities.
mSocketBufferSize = MAX_SOCKET_BUFFER_SIZE_BATCHED;
} else {
mSocketBufferSize = SOCKET_BUFFER_SIZE_NON_BATCHED;
}
// Compare the socketBufferSize value against the system limits and limit
// it to maxSystemSocketBufferSize if necessary.
FILE *fp = fopen("/proc/sys/net/core/wmem_max", "r");
char line[128];
if (fp != NULL && fgets(line, sizeof(line), fp) != NULL) {
line[sizeof(line) - 1] = '\0';
size_t maxSystemSocketBufferSize;
sscanf(line, "%zu", &maxSystemSocketBufferSize);
if (mSocketBufferSize > maxSystemSocketBufferSize) {
mSocketBufferSize = maxSystemSocketBufferSize;
}
}
if (fp) {
fclose(fp);
}
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 wp [minBufferSize];
mCurrentOperatingMode = NORMAL;
mNextSensorRegIndex = 0;
for (int i = 0; i < SENSOR_REGISTRATIONS_BUF_SIZE; ++i) {
mLastNSensorRegistrations.push();
}
//2.1.4.4===运行
//会启动threadLoop
mInitCheck = NO_ERROR;
mAckReceiver = new SensorEventAckReceiver(this);
mAckReceiver->run("SensorEventAckReceiver", PRIORITY_URGENT_DISPLAY);
run("SensorService", PRIORITY_URGENT_DISPLAY);
// priority can only be changed after run
enableSchedFifoMode();
// Start watching UID changes to apply policy.
mUidPolicy->registerSelf();
}
}
} 2.1.5 SensorService::threadLoop()
SensorService::threadLoop()主要实现对sensor的poll，轮询sensor上报的相关事件
2.2 SensorService传感器的激活
SensorService除了了启动，还需要将已有的传感器进行activate，通常再底层驱动的实现过程中，只有activate后的传感器才会向上上报数据。
从代码跟踪上看Android启动过程中会向SystemSensorManager.注册registerListener，并进一步调用registerListenerImpl。
registerListenerImpl会获得SensorEventQueue ，并调用SensorEventQueue 的addSensor。
/** @hide */
@Override
protected boolean registerListenerImpl(SensorEventListener listener, Sensor sensor,
int delayUs, Handler handler, int maxBatchReportLatencyUs, int reservedFlags) {
................
// Invariants to preserve:
// - one Looper per SensorEventListener
// - one Looper per SensorEventQueue
// We map SensorEventListener to a SensorEventQueue, which holds the looper
synchronized (mSensorListeners) {
//获得SensorEventQueue
SensorEventQueue queue = mSensorListeners.get(listener);
if (queue == null) {
Looper looper = (handler != null) ? handler.getLooper() : mMainLooper;
final String fullClassName =
listener.getClass().getEnclosingClass() != null
? listener.getClass().getEnclosingClass().getName()
: listener.getClass().getName();
queue = new SensorEventQueue(listener, looper, this, fullClassName);
//向queue 中添加要监听的传感器
if (!queue.addSensor(sensor, delayUs, maxBatchReportLatencyUs)) {
queue.dispose();
return false;
}
mSensorListeners.put(listener, queue);
return true;
} else {
Log.e(TAG, "registerListenerImpl33333");
return queue.addSensor(sensor, delayUs, maxBatchReportLatencyUs);
}
}
}
SensorEventQueue是SystemSensorManager的内部类，具体实现类是InjectEventQueue。
SensorEventQueue中的addSensor，会将上层要监听的sensor加入到监听队列中，并调用enableSensor使能对应的传感器
public boolean addSensor(
Sensor sensor, int delayUs, int maxBatchReportLatencyUs) {
// Check if already present.
int handle = sensor.getHandle();
if (mActiveSensors.get(handle)) return false;
// Get ready to receive events before calling enable.
mActiveSensors.put(handle, true);
//添加监听队列
addSensorEvent(sensor);
//使能传感器
if (enableSensor(sensor, delayUs, maxBatchReportLatencyUs) != 0) {
// Try continuous mode if batching fails.
if (maxBatchReportLatencyUs == 0
|| maxBatchReportLatencyUs > 0 && enableSensor(sensor, delayUs, 0) != 0) {
removeSensor(sensor, false);
return false;
}
}
return true;
}
private int enableSensor(
Sensor sensor, int rateUs, int maxBatchReportLatencyUs) {
if (mNativeSensorEventQueue == 0) throw new NullPointerException();
if (sensor == null) throw new NullPointerException();
//调用android_hardware_SensorManager.cpp jni使能传感器
return nativeEnableSensor(mNativeSensorEventQueue, sensor.getHandle(), rateUs,
maxBatchReportLatencyUs);
}android_hardware_SensorManager.cpp jni使能传感器 开始调用SensorEventQueue
static jint nativeEnableSensor(JNIEnv *env, jclass clazz, jlong eventQ, jint handle, jint rate_us,
jint maxBatchReportLatency) {
sp receiver(reinterpret_cast(eventQ));
ALOGI("nativeEnableSensor");
return receiver->getSensorEventQueue()->enableSensor(handle, rate_us, maxBatchReportLatency,
0);
} SensorEventQueue会调用SensorEventConnection
status_t SensorEventQueue::enableSensor(Sensor const* sensor, int32_t samplingPeriodUs) const {
ALOGE("SensorEventQueue enableSensor");
return mSensorEventConnection->enableDisable(sensor->getHandle(), true,
us2ns(samplingPeriodUs), 0, 0);
}SensorEventConnection会调用SensorService进行传感器激活
status_t SensorService::SensorEventConnection::enableDisable(
int handle, bool enabled, nsecs_t samplingPeriodNs, nsecs_t maxBatchReportLatencyNs,
int reservedFlags)
{
status_t err;
if (enabled) {
ALOGE("SensorEventConnection::enableDisabl");
err = mService->enable(this, handle, samplingPeriodNs, maxBatchReportLatencyNs,
reservedFlags, mOpPackageName);
} else {
err = mService->disable(this, handle);
}
return err;
}
03-20 11:12:18.037 3509 3524 D SensorService: Calling batch handle==0 flags=0rate=66667000 timeout== 100000000
03-20 11:12:18.037 3509 3524 D SensorService: Calling batch handle==0 flags=0rate=66667000 timeout== 100000000
03-20 11:12:18.037 3509 3524 D SensorService: SensorDevice::batch: ident=0x9a4d1180, handle=0x00000000, flags=0, period_ns=66667000 timeout=100000000
03-20 11:12:18.037 3509 3524 D SensorService: >>> curr_period=9223372036854775807 min_period=66667000 curr_timeout=9223372036854775807 min_timeout=100000000
03-20 11:12:18.037 3509 3524 D SensorService: >>> actuating h/w BATCH 0x00000000 66667000 100000000
03-20 11:12:18.038 3509 3524 D SensorService: Calling activate on 0
03-20 11[ 26.291237@2] sensors 2-006b: sensor on: starting poll sensor data 64ms
:12:18.038 3509 3524 D SensorService: SensorDevice::activate: ident=0x9a4d1180, handle=0x00000000, enabled=1, count=1
03-20 11:12:18.038 3509 3524 D SensorService: enable index=0
03-20 11:12:18.038 3509 3524 D SensorService: >>> actuating h/w activate handle=0 enabled=1