探究一下Android的Sensor架构。主要目的是通过Sensor这个架构去初步了解Android系统是怎么的一个编程思想，整体架构和功能是怎么安排的。各个模块间是怎么进行通信和交互，最重要的了解一个整个数据流是怎么传送的。更要提高自己去大型源码的处理能力，这里以Gsensor为例
源码平台MTK Android 4.4.0源码。
日期：2015年3月22日
一. 在App的使用方法
| 1
2
3
4
5
6
7 | | SensorManager sensorManager = (SensorManager)getSystemService(Context.SENSOR_SERVICE);
Sensor accSensor = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
sensorManager.registerListener(this, accSensor, SensorManager.SENSOR_DELAY_NORMAL);
sensorManager.unregisterListener(this, accSensor);
//在Listener中实现数据的监听
public void onSensorChanged(SensorEvent event)
public void onAccuracyChanged(Sensor sensor, int accuracy) |
我现在要从SensorManager为入口去探究
二. SensorManager的初始化
SensorManager就是整个Sensor架构最开始的地方，所以它的初始化也是整个Sensor架构的初始化。
SensorManager在Frameworks中被继承为SystemSensorManager。
SystemSensorManager在两处被调用。
1. 在frameworks\base\core\java\android\appContextimpl.java中，供App用getSystemService()来获取服务。
| 1
2
3
4
5
6 | | registerService(SENSOR_SERVICE, new ServiceFetcher() {
public Object createService(ContextImpl ctx) {
return new SystemSensorManager(ctx.getOuterContext(),
ctx.mMainThread.getHandler().getLooper());
}
}); |
2. frameworks\base\services\java\com\android\server\power\PowerManagerService.java 在系统初始化时systemReady()中被调用
| 1 | | new SystemSensorManager(mContext, mHandler.getLooper()); |
SystemSensorManager构造函数
| 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20 | | public SystemSensorManager(Context context, Looper mainLooper) {
/* 在base/core/jni/android_hardware_SensorManager.cpp中
主要是找到Sensor类，并把类成员的jfieldID找到 */
nativeClassInit();
// initialize the sensor list
final ArrayList<Sensor> fullList = sFullSensorsList;
int i = 0;
do {
Sensor sensor = new Sensor();
/*初始化JNI的SensorManager
并通过SensorManager获取Sensor List，把List里的Sensor一个个传递上来*/
i = nativeGetNextSensor(sensor, i);
if (i >= 0) {
fullList.add(sensor);
sHandleToSensor.append(sensor.getHandle(), sensor);
}
} while (i > 0);
} |
nativeGetNextSensor函数
| 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16 | | static jint nativeGetNextSensor(JNIEnv *env, jclass clazz, jobject sensor, jint next){
//初始化SensorManager
SensorManager& mgr(SensorManager::getInstance());
Sensor const* const* sensorList;
//获取Sensor List
size_t count = mgr.getSensorList(&sensorList);
Sensor const* const list = sensorList[next];
const SensorOffsets& sensorOffsets(gSensorOffsets);
jstring name = env->NewStringUTF(list->getName().string());
jstring vendor = env->NewStringUTF(list->getVendor().string());
env->SetObjectField(sensor, sensorOffsets.name, name);
//...后面的就是设置Sensor类成员了
} |
native/libs/gui/SensorManager.cpp
| 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24 | | SensorManager::SensorManager()
assertStateLocked();
}
status_t SensorManager::assertStateLocked() const {
if (mSensorServer == NULL) {
// try for one second
const String16 name("sensorservice");
status_t err = getService(name, &mSensorServer);
//注册sensorservice服务死亡通知
mDeathObserver = new DeathObserver(*const_cast<SensorManager *>(this));
mSensorServer->asBinder()->linkToDeath(mDeathObserver);
//获取SensorList
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;
}
}
} |
native/services/sensorservice/SensorService.cpp
| 1
2
3
4 | | Vector<Sensor> SensorService::getSensorList() {
//......
return mUserSensorList;
} |
mUserSensorList在onFirstRef()函数里初始化
| 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24 | | void SensorService::onFirstRef() {
SensorDevice &dev(SensorDevice::getInstance());
if (dev.initCheck() == NO_ERROR) {
sensor_t const *list;
ssize_t count = dev.getSensorList(&list);
if (count > 0) {
ssize_t orientationIndex = -1;
bool hasGyro = false;
uint32_t virtualSensorsNeeds =
(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添加到SensorService的List中
registerSensor( new HardwareSensor(list[i]) );
//... 添加Sensor和Virtual Sensor
//启动子线程，主要用来捕获和分发数据。后面会讲到
run("SensorService", PRIORITY_URGENT_DISPLAY);
}
} |
上面的主要是SensorDevice和SensorDevice.getSensorList();
SensorDevice开始与Hardware层打交道
| 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26 | | SensorDevice::SensorDevice(){
/*获取hw模块，模块ID为SENSORS_HARDWARE_MODULE_ID*/
status_t err = hw_get_module(SENSORS_HARDWARE_MODULE_ID,
(hw_module_t const**)&mSensorModule);
if (mSensorModule) {
/*定义在hardware/sensors.h，主要是调用模块的open函数
module->methods->open(...);*/
err = sensors_open_1(&mSensorModule->common, &mSensorDevice);
if (mSensorDevice) {
sensor_t const* list;
//再次获取sensor 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);
//激活Sensor
mSensorDevice->activate(
reinterpret_cast<struct sensors_poll_device_t *>(mSensorDevice),
list[i].handle, 0);
}
}
}
} |
SENSORS_HARDWARE_MODULE_ID模块在hardware/sensor/Sensor.c中
sensors_open_1调用了此模块的open函数
| 1
2
3
4 | | static int open_sensors(const struct hw_module_t *module, const char *name,
struct hw_device_t **device) {
return init_nusensors(module, device);
} |
init_nusensors在hardware/sensor/Nusensors.cpp
| 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18 | | int init_nusensors(hw_module_t const *module, hw_device_t **device) {
sensors_poll_context_t *dev = new sensors_poll_context_t();
memset(&dev->device, 0, sizeof(sensors_poll_device_1));
//初始化hw_device_t
dev->device.common.tag = HARDWARE_DEVICE_TAG;
dev->device.common.version = 0;//SENSORS_DEVICE_API_VERSION_1_1;
dev->device.common.module = const_cast<hw_module_t *>(module);
dev->device.common.close = poll__close;
dev->device.activate = poll__activate;
dev->device.setDelay = poll__setDelay;
dev->device.poll = poll__poll;
dev->device.batch = poll__batch;
dev->device.flush = poll__flush;
*device = &dev->device.common;
status = 0;
return status;
} |
SensorDevice然后调用sensor.cpp里的get_sensors_list
| 1
2
3
4
5
6 | | static int sensors__get_sensors_list(struct sensors_module_t *module,
struct sensor_t const **list) {
//这个就是最低层的sensorlist
*list = sSensorList;
return ARRAY_SIZE(sSensorList);
} |
hardware\sensor\hwmsen_chip_info.c sSensorList里包含了所有的Sensor信息
| 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52 | | struct sensor_t sSensorList[MAX_NUM_SENSOR] =
{
#ifdef CUSTOM_KERNEL_ACCELEROMETER
{
.name = ACCELEROMETER,
.vendor = ACCELEROMETER_VENDER,
.version = 1,
.handle = ID_ACCELEROMETER,
.type = SENSOR_TYPE_ACCELEROMETER,
.maxRange = ACCELEROMETER_RANGE,//32.0f,
.resolution = ACCELEROMETER_RESOLUTION,//4.0f/1024.0f,
.power = ACCELEROMETER_POWER,//130.0f/1000.0f,
.reserved = {}
},
{
.name = ACCELEROMETER_1,
.vendor = ACCELEROMETER_VENDER,
.version = 1,
.handle = ID_ACCELEROMETER,
.type = SENSOR_TYPE_ACCELEROMETER,
.maxRange = ACCELEROMETER_RANGE,//32.0f,
.resolution = ACCELEROMETER_RESOLUTION,//4.0f/1024.0f,
.power = ACCELEROMETER_POWER,//130.0f/1000.0f,
.reserved = {}
},
{
.name = ACCELEROMETER_2,
.vendor = ACCELEROMETER_VENDER,
.version = 1,
.handle = ID_ACCELEROMETER,
.type = SENSOR_TYPE_ACCELEROMETER,
.maxRange = ACCELEROMETER_RANGE,//32.0f,
.resolution = ACCELEROMETER_RESOLUTION,//4.0f/1024.0f,
.power = ACCELEROMETER_POWER,//130.0f/1000.0f,
.reserved = {}
},
#endif
#ifdef CUSTOM_KERNEL_ALSPS
{
.name = PROXIMITY,
.vendor = PROXIMITY_VENDER,
.version = 1,
.handle = ID_PROXIMITY,
.type = SENSOR_TYPE_PROXIMITY,
.maxRange = PROXIMITY_RANGE,//1.00f,
.resolution = PROXIMITY_RESOLUTION,//1.0f,
.power = PROXIMITY_POWER,//0.13f,
.reserved = {}
},
//....
}; |
SensorDevice接着调用 mSensorDevice->activate();
在这里我们先理清楚一下mSensorDevice的类型转换问题
mSensorDevice的类型为sensors_poll_device_1_t，在最后的初始化为*device = &dev->device.common; common为hw_device_t类型。dev为sensors_poll_context_t类型。
再来看看这几个类型之间的关系
| 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39 | | struct sensors_poll_context_t {
struct sensors_poll_device_t device; // must be first
sensors_poll_context_t();
int activate(int handle, int enabled);
//...
};
struct sensors_poll_device_t {
struct hw_device_t common;
int (*activate)(struct sensors_poll_device_t *dev,
int (*setDelay)(struct sensors_poll_device_t *dev,
int (*poll)(struct sensors_poll_device_t *dev,
};
typedef struct sensors_poll_device_1 {
union {
struct sensors_poll_device_t v0;
struct {
struct hw_device_t common;
int (*activate)(struct sensors_poll_device_t *dev,
int (*setDelay)(struct sensors_poll_device_t *dev,
int (*poll)(struct sensors_poll_device_t *dev,
};
};
int (*batch)(struct sensors_poll_device_1* dev,
int (*flush)(struct sensors_poll_device_1* dev, int handle);
void (*reserved_procs[8])(void);
} sensors_poll_device_1_t;
|
sensors_poll_context_t的device和sensors_poll_device_t的common都在第一位，所以他们的指针地址都是一样的。
只要获取了首地址后，就可以通过类型的不同取到不同的值。
首先是mSensorDevice的sensors_poll_device_1_t，sensors_poll_device_1_t 的前半节成员位置分布是与 sensors_poll_context_t的一样的，所以mSensorDevice->activate调的就是初始化之后的poll__activate()。poll__activate的第一个参数又是mSensorDevice，poll__activate里又把它转换为sensors_poll_context_t，这样就可以调用sensors_poll_context_t里面的activate()函数。
sensors_poll_context_t的activate()：
其中的handle是sSensorList里的handle
| 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28 | | int sensors_poll_context_t::activate(int handle, int enabled) {
int index = handleToDriver(handle);
//使能Sensor
if(ID_ORIENTATION == handle) {
((AccelerationSensor*)(mSensors[accel]))->enableNoHALDataAcc(enabled);
((Hwmsen*)(mSensors[hwmsen]))->enableNoHALDataAcc(enabled);
}
if(NULL != mSensors[index] && index >0 ) {
ALOGD( "use new sensor index=%d, mSensors[index](%x)", index, mSensors[index]);
err = mSensors[index]->enable(handle, enabled);
}
if(err || index<0 ) {
ALOGD("use old sensor err(%d),index(%d) go to old hwmsen\n",err,index);
// notify to hwmsen sensor to support old architecture
err = mSensors[hwmsen]->enable(handle, enabled);
}
if (enabled && !err) {
//通过管道发送唤醒消息。这里有个疑问，一初始化就把所有的Sensor setenable和wake了，不会耗电吗？不是另有其用
const char wakeMessage(WAKE_MESSAGE);
int result = write(mWritePipeFd, &wakeMessage, 1);
ALOGE_IF(result<0, "error sending wake message (%s)", strerror(errno));
}
return err;
} |
其中的hwmsen是MTK提供的对所有的Sensor驱动进行统一管理的一个小架构。Hwmsen这个类会打开"/dev/hwmsensor"节点，访问hwmsen低层驱动，hwmsen集中了所有的sensor驱动，进行统一的管理。在sensors_poll_context_t()的构造函数中，把很多sensor类赋值给了mSensors，这里类继承了SensorBase。hardware层就是通过这些类去访问低层驱动。
三. Sensor数据的监听
这个要从App的registerListener说起。
App里getDefaultSensor根据Sensor Type从SensorList里获取出相应的Sensor传入到registerListener，先传入的是SensorManager.java的registerListener。
| 1
2
3
4
5
6
7
8
9 | | public boolean registerListener(SensorEventListener listener, Sensor sensor, int rateUs) {
return registerListener(listener, sensor, rateUs, null);
}
public boolean registerListener(SensorEventListener listener, Sensor sensor, int rateUs,
Handler handler) {
int delay = getDelay(rateUs);
return registerListenerImpl(listener, sensor, delay, handler, 0, 0);
} |
registerListenerImpl在SystemSensorManager.java里实现
| 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21 | | protected boolean registerListenerImpl(SensorEventListener listener, Sensor sensor,
int delayUs, Handler handler, int maxBatchReportLatencyUs, int reservedFlags) {
SensorEventQueue queue = mSensorListeners.get(listener);
//以前没有添加过的Listener，走这里
if (queue == null) {
//获取主线程的Looper
Looper looper = (handler != null) ? handler.getLooper() : mMainLooper;
//新建一个SensorEventQueue
queue = new SensorEventQueue(listener, looper, this);
//把Sensor添加进这个Queue
if (!queue.addSensor(sensor, delayUs, maxBatchReportLatencyUs, reservedFlags)) {
queue.dispose();
return false;
}
mSensorListeners.put(listener, queue);
return true;
} else {
return queue.addSensor(sensor, delayUs, maxBatchReportLatencyUs, reservedFlags);
}
} |
new SensorEventQueue()
| 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24 | | public SensorEventQueue(SensorEventListener listener, Looper looper,
SystemSensorManager manager) {
super(looper, manager);
}
BaseEventQueue(Looper looper, SystemSensorManager manager) {
//创建Native层的EventQueue
nSensorEventQueue = nativeInitBaseEventQueue(this, looper.getQueue(), mScratch);
}
/*
nativeInitBaseEventQueue在native层对应的是nativeInitSensorEventQueue
在Frameworks/base/core/jni/android_hardware_SensorManager.cpp
*/
static jint nativeInitSensorEventQueue(JNIEnv *env, jclass clazz, jobject eventQ, jobject msgQ, jfloatArray scratch) {
SensorManager& mgr(SensorManager::getInstance());
//真正创建SensorEventQueue
sp<SensorEventQueue> queue(mgr.createEventQueue());
sp<MessageQueue> messageQueue = android_os_MessageQueue_getMessageQueue(env, msgQ);
//Receiver继承LooperCallback，主要用于数据的Poll。
sp<Receiver> receiver = new Receiver(queue, messageQueue, eventQ, scratch);
} |
SensorManager.cpp
| 1
2
3
4
5
6
7
8
9
10
11 | | sp<SensorEventQueue> SensorManager::createEventQueue() {
sp<SensorEventQueue> queue;
//通过SensorServer创建一个Connection
sp<ISensorEventConnection> connection =
mSensorServer->createSensorEventConnection();
//通过这个Connection创建一个SensorEventQueue
queue = new SensorEventQueue(connection);
return queue;
} |
SensorService.cpp
| 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 | | 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){
const SensorDevice& device(SensorDevice::getInstance());
//这个VERSION在hardware/sensor/Sensor.c的sensor_module_t里
if (device.getHalDeviceVersion() >= SENSORS_DEVICE_API_VERSION_1_1) {
// Increase socket buffer size to 1MB for batching capabilities.
mChannel = new BitTube(service->mSocketBufferSize);
} else {
//代码里的VERSION是1.0
mChannel = new BitTube(SOCKET_BUFFER_SIZE_NON_BATCHED);
}
} |
native/libs.gui/BitTube.cpp
| 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25 | | BitTube::BitTube(size_t bufsize)
: mSendFd(-1), mReceiveFd(-1) {
init(bufsize, bufsize);
}
void BitTube::init(size_t rcvbuf, size_t sndbuf) {
int sockets[2];
if (socketpair(AF_UNIX, SOCK_SEQPACKET, 0, sockets) == 0) {
size_t size = DEFAULT_SOCKET_BUFFER_SIZE;
setsockopt(sockets[0], SOL_SOCKET, SO_RCVBUF, &rcvbuf, sizeof(rcvbuf));
setsockopt(sockets[1], SOL_SOCKET, SO_SNDBUF, &sndbuf, sizeof(sndbuf));
// sine we don't use the "return channel", we keep it small...
setsockopt(sockets[0], SOL_SOCKET, SO_SNDBUF, &size, sizeof(size));
setsockopt(sockets[1], SOL_SOCKET, SO_RCVBUF, &size, sizeof(size));
fcntl(sockets[0], F_SETFL, O_NONBLOCK);
fcntl(sockets[1], F_SETFL, O_NONBLOCK);
//这里主要是初始化mReceiveFd和mSendFd，用来后面的消息和数据的传递
mReceiveFd = sockets[0];
mSendFd = sockets[1];
} else {
mReceiveFd = -errno;
ALOGE("BitTube: pipe creation failed (%s)", strerror(-mReceiveFd));
}
} |
回到createEventQueue()，new SensorEventQueue(connection);
| 1
2
3
4 | | SensorEventQueue::SensorEventQueue(const sp<ISensorEventConnection>& connection)
: mSensorEventConnection(connection), mRecBuffer(NULL), mAvailable(0), mConsumed(0) {
mRecBuffer = new ASensorEvent[MAX_RECEIVE_BUFFER_EVENT_COUNT];
} |
这里android_hardware_SensorManager.cpp的nativeInitSensorEventQueue()，createEventQueue已经创建完。接下来创建了一个messageQueue。把SensorEventQueue和MessageQueue一起传给了Receiver，这个Receiver继承于LooperCallback。那这些类之间有什么联系呢。
写过APP的就都对Handler，Mesg和Looper有一些了解。而这些的底层实现就会刚才提到的这几个类有关，Android用此来实现进程间通信。这里简要说明：
MessageQueue是一个消息队列，用于存放消息。
Looper相当于一个消息管理者，它管理着队列里的消息进出，分发。它会把队列里的消息分发给相应的处理者。
整个进程间通信间通信用的是poll相关的FD来实现，此机制还提供了一个addFd接口。些接口传入了一个fd和一个LooperCallback，如果有消息过来，就会调用LooperCallback。
在Receiver的onFirstRef()
| 1
2
3
4
5
6
7 | | virtual void onFirstRef() {
LooperCallback::onFirstRef();
//mSensorQueue->getFd()，得到的是BitTube里的mReceiveFd。
//这里开始监听mReceiveFd。如果有消息过来则调用handleEvent
mMessageQueue->getLooper()->addFd(mSensorQueue->getFd(), 0,
ALOOPER_EVENT_INPUT, this, mSensorQueue.get());
} |
四. Sensor的使能
registerListenerImpl创建了一个queue后会把Sensor加入到queue里
| 1 | | queue.addSensor(sensor, delayUs, maxBatchReportLatencyUs, reservedFlags) |
这个函数主要是enableSensor，enableSensor可以追踪到SensorService的enable函数里。
SensorService的enable
| 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36 | | status_t SensorService::enable(const sp<SensorEventConnection>& connection,
int handle, nsecs_t samplingPeriodNs, nsecs_t maxBatchReportLatencyNs, int reservedFlags){
//mSensorMap在registerSensor里初始化。
//这个获取出来的sensor在registerSensor的时候就与SensorDevice绑定
//即调用这个sensor里的函数就相当于调用SensorDevice里的函数
SensorInterface* sensor = mSensorMap.valueFor(handle);
rec = new SensorRecord(connection);
//把相应的Sensor handle(即Sensor Type)加入到activesSensor
mActiveSensors.add(handle, rec);
//把handle与connection绑定
if (connection->addSensor(handle)) {
BatteryService::enableSensor(connection->getUid(), handle);
if (mActiveConnections.indexOf(connection) < 0) {
//并把connection加入到ActiveConnection的队列里
mActiveConnections.add(connection);
}
}
status_t err = sensor->batch(connection.get(), handle, reservedFlags, samplingPeriodNs,
maxBatchReportLatencyNs);
if (err == NO_ERROR) {
connection->setFirstFlushPending(handle, true);
status_t err_flush = sensor->flush(connection.get(), handle);
// Flush may return error if the sensor is not activated or the underlying h/w sensor does
// not support flush.
if (err_flush != NO_ERROR) {
connection->setFirstFlushPending(handle, false);
}
}
//真正启动Sensor
sensor->activate(connection.get(), true);
} |
SensorDevice在初始化的时候与ID为SENSORS_HARDWARE_MODULE_ID的hardware层的模块进行了绑定。
上面的activate相当于调用了nusensors.cpp的poll__activate函数，poll__activate 再调用当前文件的activate函数。此activate函数根据handle调用相应Sensor类。如这里调用 了hwmsen类，就相当于调用了hwmsen.cpp里的activate。这个Sensor类，就直接与驱动文件打交道了
五. 数据的获取
SensorService继承了Thread，其中的onFirstRef()调用了run()，线程跑了起来。
| 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28 | | bool SensorService::threadLoop(){
sensors_event_t buffer[minBufferSize];
do {
count = device.poll(buffer, numEventMax);
//我们现在的机器没有虚拟传感器，所以忽略了虚拟传感器部分。
//现在的版本为1.0，所以不会跑这里
if (halVersion < SENSORS_DEVICE_API_VERSION_1_0) { }
// send our events to clients...
const SortedVector< wp<SensorEventConnection> > activeConnections(
getActiveConnections());
size_t numConnections = activeConnections.size();
for (size_t i=0 ; i<numConnections ; i++) {
sp<SensorEventConnection> connection(
activeConnections[i].promote());
if (connection != 0) {
connection->sendEvents(buffer, count, scratch);
// Some sensors need to be auto disabled after the trigger
cleanupAutoDisabledSensor(connection, buffer, count);
}
}
// We have read the data, upper layers should hold the wakelock.
if (wakeLockAcquired) release_wake_lock(WAKE_LOCK_NAME);
} while (count >= 0 || Thread::exitPending());
} |
上面调用了SensorDevice的poll，由之前的逻辑可知。SensorDevice的poll最后会调用到nusensors.cpp的poll_poll，poll_poll调用了pollEvents()
| 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25 | | int sensors_poll_context_t::pollEvents(sensors_event_t* data, int count){
do {
// see if we have some leftover from the last poll()
for (int i=0 ; count && i<numSensorDrivers ; i++) {
SensorBase* const sensor(mSensors[i]);
if ((mPollFds[i].revents & POLLIN) || (sensor->hasPendingEvents())) {
//如果有数据就调用sensor的readEvents
int nb = sensor->readEvents(data, count);
if (nb < count) {
// no more data for this sensor
mPollFds[i].revents = 0;
}
count -= nb;
nbEvents += nb;
data += nb;
}
}
if (count) {
n = poll(mPollFds, numFds, nbEvents ? 0 : -1);
}
// if we have events and space, go read them
} while (n && count);
} |
以hwmsen的readEvents为例
| 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76 | | int Hwmsen::readEvents(sensors_event_t* data, int count){
//读取input数据
ssize_t n = mInputReader.fill(mdata_fd);
int numEventReceived = 0;
input_event const* event;
while (count && mInputReader.readEvent(&event)) {
int type = event->type;
if (type == EV_REL)
{
processEvent(event->code, event->value);
int64_t time = timevalToNano(event->time);
for (i=0 ; count && i<MAX_ANDROID_SENSOR_NUM ; i++)
{
if (mPendingMask & (1<<i))
{
mPendingMask &= ~(1<<i);
*data++ = mPendingEvents[i];
count--;
numEventReceived++;
}
}
}
mInputReader.next();
}
return numEventReceived;
}
void Hwmsen::processEvent(int code, int value)
{
hwm_trans_data sensors_data;
sensors_data.date_type = value;//set flag to read specified sensor
//真正获取Sensor Data
err = ioctl(dev_fd, HWM_IO_GET_SENSORS_DATA, &sensors_data);
for(i =0; i < MAX_ANDROID_SENSOR_NUM; i++) {
//根据不同的Snesor类型处理数据
switch (i) {
case ID_ORIENTATION:
break;
case ID_MAGNETIC:
break;
case ID_ACCELEROMETER:
mPendingMask |= 1<<Accelerometer;
mPendingEvents[Accelerometer].type = SENSOR_TYPE_ACCELEROMETER;
mPendingEvents[Accelerometer].sensor = sensors_data.data[ID_ACCELEROMETER].sensor;
mPendingEvents[Accelerometer].acceleration.status = sensors_data.data[ID_ACCELEROMETER].status;
mPendingEvents[Accelerometer].acceleration.v[0] = (float)sensors_data.data[ID_ACCELEROMETER].values[0];
mPendingEvents[Accelerometer].acceleration.v[1] = (float)sensors_data.data[ID_ACCELEROMETER].values[1];
mPendingEvents[Accelerometer].acceleration.v[2] = (float)sensors_data.data[ID_ACCELEROMETER].values[2];
mPendingEvents[Accelerometer].acceleration.v[0]/=sensors_data.data[ID_ACCELEROMETER].value_divide;
mPendingEvents[Accelerometer].acceleration.v[1]/=sensors_data.data[ID_ACCELEROMETER].value_divide;
mPendingEvents[Accelerometer].acceleration.v[2]/=sensors_data.data[ID_ACCELEROMETER].value_divide;
mPendingEvents[Accelerometer].timestamp = sensors_data.data[ID_ACCELEROMETER].time;
//ALOGE("[ID_ACCELEROMETER](%f,%f,%f) \r\n",mPendingEvents[Accelerometer].acceleration.v[0],mPendingEvents[Accelerometer].acceleration.v[1],mPendingEvents[Accelerometer].acceleration.v[2]);
break;
case ID_GYROSCOPE:
break;
case ID_PROXIMITY:
break;
case ID_LIGHT:
break;
}
}
} |
Input上来的是什么样的数据？！！数据类型是什么，后面的buffer[i].type == SENSOR_TYPE_STEP_COUNTER的type在哪里被初始化
SensorService的threadloop就这样把数据读出来。然后会把数据通过activeConnections队列，connection->sendEvents 把数据分发到所有的connection。
| 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48 | | status_t SensorService::SensorEventConnection::sendEvents(
sensors_event_t const* buffer, size_t numEvents,
sensors_event_t* scratch)
{
// filter out events not for this connection
size_t count = 0;
//这里传入的scratch为空
if (scratch) {
} else {
scratch = const_cast<sensors_event_t *>(buffer);
count = numEvents;
}
// Send pending flush events (if any) before sending events from the cache.
{
ASensorEvent flushCompleteEvent;
flushCompleteEvent.type = SENSOR_TYPE_META_DATA;
flushCompleteEvent.sensor = 0;
Mutex::Autolock _l(mConnectionLock);
// Loop through all the sensors for this connection and check if there are any pending
// flush complete events to be sent.
for (size_t i = 0; i < mSensorInfo.size(); ++i) {
FlushInfo& flushInfo = mSensorInfo.editValueAt(i);
while (flushInfo.mPendingFlushEventsToSend > 0) {
flushCompleteEvent.meta_data.sensor = mSensorInfo.keyAt(i);
ssize_t size = SensorEventQueue::write(mChannel, &flushCompleteEvent, 1);
if (size < 0) {
// ALOGW("dropping %d events on the floor", count);
countFlushCompleteEventsLocked(scratch, count);
return size;
}
ALOGD_IF(DEBUG_CONNECTIONS, "sent dropped flush complete event==%d ",
flushCompleteEvent.meta_data.sensor);
flushInfo.mPendingFlushEventsToSend--;
}
}
}
// Early return if there are no events for this connection.
if (count == 0) {
return status_t(NO_ERROR);
}
//把数据发送出去
// NOTE: ASensorEvent and sensors_event_t are the same type
ssize_t size = SensorEventQueue::write(mChannel,
reinterpret_cast<ASensorEvent const*>(scratch), count);
} |
在前面SensorEventQueue通过fd与Reciver绑定，上面的SensorEventQueue.write之后便触发了Reciver的回调函数handleEvent()。
| 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35 | | virtual int handleEvent(int fd, int events, void* data) {
JNIEnv* env = AndroidRuntime::getJNIEnv();
sp<SensorEventQueue> q = reinterpret_cast<SensorEventQueue *>(data);
ssize_t n;
ASensorEvent buffer[16];
while ((n = q->read(buffer, 16)) > 0) {
for (int i=0 ; i<n ; i++) {
if (buffer[i].type == SENSOR_TYPE_STEP_COUNTER) {
// step-counter returns a uint64, but the java API only deals with floats
float value = float(buffer[i].u64.step_counter);
env->SetFloatArrayRegion(mScratch, 0, 1, &value);
} else {
env->SetFloatArrayRegion(mScratch, 0, 16, buffer[i].data);
}
if (buffer[i].type == SENSOR_TYPE_META_DATA) {
// This is a flush complete sensor event. Call dispatchFlushCompleteEvent
// method.
env->CallVoidMethod(mReceiverObject,
gBaseEventQueueClassInfo.dispatchFlushCompleteEvent,
buffer[i].meta_data.sensor);
} else {
//调用了SystemSensorManager.ava的dispatchSensorEvent函数，
//dispatchSensorEvent又调用了Listener.onSensorChanged把数据传到App层
env->CallVoidMethod(mReceiverObject,
gBaseEventQueueClassInfo.dispatchSensorEvent,
buffer[i].sensor,
mScratch,
buffer[i].vector.status,
buffer[i].timestamp);
}
}
}
} |
扫一扫
6089
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
