ARTICLE · 1381382
Android源码第二十章:SensorService 与 ContextHub——数据从哪来?
在模拟器里转动手机,屏幕上的加速度分量跟着变。把采样周期设为 100 毫秒,Java 回调却未必每隔 100 毫秒来一次。有时几条回调挨得很近,里面的时间戳却间隔均匀。这两组时间各走了一段不同的路。
一次注册先通过 Binder 告诉系统「我要哪个传感器、多久采一份、最多等多久再报」。采样回来时,HAL 通过共享队列把事件交给 SensorService,服务再用本地 socket 把事件送到应用的 Looper。判断事件有没有成批到达,要同时看样本时间和应用收到样本的时间。如果需求是让一段小程序留在低功耗处理器上判断「有没有动」,再把结果告诉 Android,入口就要换到 ContextHub。

1. 先让应用收到一次加速度
前台应用在公开 SDK 中拿到 SensorManager,选默认加速度计,把监听器注册到 HandlerThread。标准加速度计三轴数值单位是 m/s²,包含重力的贡献,静止时三轴并不都为零。默认传感器的 wake-up 属性可用 isWakeUpSensor() 查询。下面的调用用普通应用权限即可尝试。ContextHub 的系统 API 与设备权限另在第 6 节说明。
这里的 listener 实现 SensorEventListener2,用于同时接收采样和 flush 完成通知。完整示例把注册、注销和回调都放在名为 sensor-demo 的线程。三个按钮分别触发开始、Flush 和停止。
SensorManager manager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);Sensor sensor = manager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);if (sensor != null) { boolean enabled = manager.registerListener( listener, sensor, 100_000, 0, workerHandler);}
100_000 微秒(100 毫秒)是请求的采样间隔,0 是请求尽快上报。 把 0 改成 2_000_000 后才是请求最多延迟 2 秒。前者影响多久取一个样本,后者决定已有样本可否先攒着。请求到达 HAL 后,设备能力和其他订阅也会影响实际表现。注册成功后,收到带数值的 onSensorChanged() 才算应用数据链路接通。
在 Android Studio 新建 Java 的 Empty Views Activity,包名填 com.example.sensorschapter,最低 API 设 23 或更高。把第 7.3 节的完整文件复制到 app/src/main/java/com/example/sensorschapter/MainActivity.java,沿用模板中已声明的 .MainActivity,选择有加速度计的 Android Emulator 并点击 Run。点「开始」后可在 Extended controls → Virtual sensors → Device Pose 中转动虚拟设备,观察三轴读数变化。日志标签是 Ch20Sensor,完整操作和日志判据见第 7.1 节。
2. 从两张总图找到每一站
2.1 整体架构

左侧是 Goldfish/Ranchu 加速度计,右侧是采用 Tinysys/SCP 的 ContextHub 实现,SCP 是这里承载 CHRE 的协处理器。两列是不同设备配置中的两条参考路径。 左边可用模拟器跟做,右边需要有匹配 HAL、驱动和 CHRE 固件的设备。先沿蓝线找到请求交给谁,再顺绿色回程找到数据经过的通道。两条链的应用回调方式不同,Sensors 侧是 BitTube fd 唤起 Looper,ContextHub 侧是 Binder 回调交给 Executor。
Goldfish 产品在启用 Sensors 时装入 AIDLandroid.hardware.sensors-service.multihal 和 2.1 子 HALandroid.hardware.sensors@2.1-impl.ranchu。子 HAL 名称里的 2.1 是它和 Multi-HAL 的接口形态,系统服务这一侧连接的是 AIDL HAL。设备执行结果仍应以实际镜像的服务和配置为准。 Goldfish 产品定义 · AIDL Multi-HAL 服务模块
2.2 全章时序

加速度计链路见第 3~5 节。先跟同一个 handle,它像设备名册上的编号,把应用注册、服务订阅与采样回调连起来。ContextHub 链路见第 6 节。nanoapp ID 找到要执行的微型程序,host endpoint 是此次连接在 Android 侧的收件地址,payload 则装着实际消息。给每次请求放一个临时编号(nonce),回包里带回同一个编号,就能认出这次请求的结果。
API 返回值回答请求是否受理,样本或回包由后续通道交付。这两件事可以由不同线程观察到,日志的打印先后不能替代对业务结果的判断。
3. 注册如何从 Java 到 Sensors HAL
3.1 第一次注册先创建队列,再启用当前传感器
SystemSensorManager 把监听器对象作为键。一位监听器可挂多个传感器,但它第一次注册时选定的 Looper 会随队列保留。换一个 Handler 再复用同一监听器,不会替旧队列切换线程。要换线程,先移除这个监听器的全部注册,或改用另一个监听器。 SystemSensorManager.registerListenerImpl
队列创建和启用传感器是两步。 下面是 registerListenerImpl 的核心分支,省略了参数检查和类名计算。
SensorEventQueue queue = mSensorListeners.get(listener);if (queue == null) { Looper looper = (handler != null) ? handler.getLooper() : mMainLooper; // 省略 fullClassName 的计算。 queue = new SensorEventQueue(listener, looper, this, fullClassName); if (!queue.addSensor(sensor, delayUs, maxBatchReportLatencyUs)) { queue.dispose(); return false; } mSensorListeners.put(listener, queue); return true;} else { return queue.addSensor(sensor, delayUs, maxBatchReportLatencyUs);}
父类 BaseEventQueue 把 Java 队列的弱引用和 looper.getQueue() 传给 JNI。Native SensorManager::createEventQueue() 通过 ISensorServer 向名为 sensorservice 的服务创建连接。常规系统启动时,这个 Native SensorService 由 system_server 内的 Sensors 启动代码创建并注册。Native SensorEventQueue 构造器从 Binder 连接取 getSensorChannel(),拿到的是 BitTube 的应用端 fd。BitTube 在服务端连接构造期间创建,底层为 socketpair(AF_UNIX, SOCK_SEQPACKET, …),fd 经 Parcel 交给应用,创建连接只发生在这条控制面。 BaseEventQueue · SensorService 启动 · 创建 Native 队列 · 创建服务连接 · Binder 传递通道 · BitTube
Java 的 long 保存的是应用进程里的 JNI Receiver 地址。 JNI 先创建 Native 队列,再用它和对应 Native MessageQueue 创建 Receiver。显式引用维持其生命周期。第一次取得强引用时,Receiver 把 BitTube fd 注册到指定 Looper。
// 摘自 nativeInitSensorEventQueue,省略参数解析与错误分支。sp<SensorEventQueue> queue(mgr->createEventQueue(clientName, mode, attributionTagName));sp<MessageQueue> messageQueue = android_os_MessageQueue_getMessageQueue(env, msgQ);sp<Receiver> receiver = new Receiver(queue, messageQueue, eventQWeak);receiver->incStrong((void*)nativeInitSensorEventQueue);return jlong(receiver.get());
同一个 Receiver 稍后也处理启用、禁用和读事件。它注册 fd 的那一步把「指定一个 Handler」变成了「由这个线程的 Looper 监听一个真实文件描述符」。 JNI 创建 Receiver · JNI 监听 fd
3.2 SensorService 合并请求,然后配置 HAL
Java 的 addSensor() 先准备 active handle 与可复用的事件对象,再调用 JNI。启用失败时,如果原来请求了非零 batch 延迟,Java 会用 0 重试一次。两次都失败就移除刚才准备的状态。这个重试说明 true 也可能来自退回实时模式。 SystemSensorManager.addSensor
JNI 找到 Receiver 持有的 Native 队列,下面的重载把微秒转为纳秒,再经 ISensorEventConnection::enableDisable() 进入服务。
status_t SensorEventQueue::enableSensor(int32_t handle, int32_t samplingPeriodUs, int64_t maxBatchReportLatencyUs, int reservedFlags) const { return mSensorEventConnection->enableDisable(handle, true, us2ns(samplingPeriodUs), us2ns(maxBatchReportLatencyUs), reservedFlags);}
服务先 batch,再 activate。 服务会检查权限和访问策略、校正周期范围,再把请求挂到对应连接和 handle。连续型传感器如果已经有其他连接,服务还可能先发一次内部 flush,用首个完成标记划出新连接的起点。下面仅保留本章第一次注册的主路径。
// SensorService::enable,保留第一次注册的主要交接。status_t err = sensor->batch(connection.get(), handle, 0, samplingPeriodNs, maxBatchReportLatencyNs);if (err == NO_ERROR) { err = sensor->activate(connection.get(), true);}
一个物理传感器通常同时服务多个连接。对本文加速度计,HardwareSensor 把 batch/activate 转给 SensorDevice。它用连接标识存住每份 batch 请求,对有效连接取最短采样周期,并取最紧的有效批次约束。合并中每个连接参与计算的批次约束为 max(其最大延迟, 其采样周期),合并后的约束短于或等于选定采样周期时才归零;不能把它简化成每个应用都有自己的硬件 FIFO。请求变化且有效配置变化时才需要重设 HAL。第一次启用和最后一个有效连接退出时才涉及共享传感器的开关。 Native 微秒转换 · SensorService.enable · HardwareSensor · 合并参数 · SensorDevice 激活
在这个镜像组合里,AidlSensorHalWrapper 将参数经 AIDL ISensors 交给供应商 HAL 进程。HalProxyAidl 把 batch 和 activate 交给 HalProxy,后者将聚合 handle 对应到子 HAL 的本地 handle,再以进程内接口调用 ranchu 子 HAL。两层之间没有第二次 HIDL 跨进程事务。 选择 HAL · AIDL 控制调用 · HalProxyAidl · HalProxy 路由
4. 同一个样本怎样回到 Java
4.1 模拟器把主机轴值送进 Guest HAL
ranchu 的 QemudSensorsTransport 打开 qemud 的 sensors 通道。当前固定 gfxstream 源码对它这类非图形通道尝试 socket(AF_VSOCK, SOCK_STREAM, 0) → connect(VMADDR_CID_HOST, 5000)。连接成功后写入以 NUL 结尾的 pipe:qemud:sensors,在该连接里用带长度头的 qemud 消息交互。这个版本给图形通道用的 /dev/goldfish_pipe_dprctd 路径不适用于这里。 ranchu 传输对象 · qemud 帧格式 · gfxstream vsock 分支
Guest 内核的 AF_VSOCK 层负责 socket 连接和收发。在使用 virtio-vsock 的 Guest 配置中,virtio_transport_rx_work() 从接收 virtqueue 取包并调用 virtio_transport_recv_pkt(),后者按地址和连接状态分发。已连接的读写数据进入对应 socket 的接收队列并通知可读,HAL 的 epoll 线程才有机会读取。这里的设备边界是虚拟机 transport。换到实体手机,可能沿 I²C/SPI 传感器、IRQ/FIFO、IIO 缓冲或厂商 sensor hub 走,确切节点、驱动和唤醒源应沿该设备 HAL 和 kernel 源继续定位。 AF_VSOCK · virtio-vsock 接收队列 · 数据包入 socket · ranchu epoll
子 HAL 的 batch() 可能通过这条连接发送 set-delay:<ms>,更新主机上报间隔;连续型传感器的 activate() 主要在 Guest 中安排定时发样和维护 active mask。ranchu 在通道初始化时已向主机开启支持的轴值上报,应用每次注册不等于主机重新启用加速度计。
HAL 解析主机的 acceleration:x:y:z,把三个值放进 Event 并记到对应传感器的状态。主机更新读数和子 HAL 定时上报是两件事。 对连续型传感器,定时线程取已缓存的值,使用计划发样时刻给 Event 填时间戳,然后提交给 Multi-HAL。这也解释了为什么改变姿态可以验证三轴数据的传递,但不能据样本时间戳反推出主机每一次更新的时间。 解析轴值 · 缓存与 PostEvents · 子 HAL 定时发样
// MultihalSensors::batchThread,节选已到发样时刻且有数据的分支。batchInfo.event.timestamp = evRef.timestamp;const SensorInfo* sensor = getSensorInfoByHandle(sensorHandle);doPostSensorEventLocked(*sensor, batchInfo.event);
4.2 HAL 写 FMQ,服务用 BitTube 发给应用

FMQ(Fast Message Queue)是共享内存队列。AIDL wrapper 初始化时分配 Event FMQ 和 Wake Lock FMQ,把描述符传给 HAL。ranchu 子 HAL 提交 postEvents(),Multi-HAL 做格式与 handle 转换,写 Event FMQ 后用 EventFlag 的 READ_AND_PROCESS 通知服务。EventFlag 传的是「队列可处理」信号,样本留在队列里。队列空间不足时,Multi-HAL 还有暂存和待写线程。 两条 FMQ 初始化 · Multi-HAL 写 Event FMQ
// HalProxy::postEventsToMessageQueue,节选可立即写入的一批。numToWrite = std::min(events.size(), mEventQueue->availableToWrite());if (numToWrite > 0 && mEventQueue->write(events.data(), numToWrite)) { mEventQueueFlag->wake(static_cast<uint32_t>(EventQueueFlagBits::READ_AND_PROCESS));}
上段把两层 if 合并为同一条件,省略返回与统计逻辑。接力点是 mEventQueue->write 和 READ_AND_PROCESS。 SensorService 自己的事件线程在 threadLoop() 内调用 SensorDevice::poll(),AIDL wrapper 从 FMQ 读取,通知 HAL EVENTS_READ 可腾出写入空间,再把读出的事件转为 sensors_event_t。这个通知与 wake-up 事件计数是两次不同的交接。服务按订阅、访问条件与 flush 归属分发。每个连接的 sendEvents() 写该连接自己的 BitTube,应用读慢时可进连接的事件缓存,缓存的有限容量也意味着过载时不能保证事件无限保留。 AIDL 读 Event FMQ · 服务事件线程 · 连接发送与缓存
4.3 Looper 读到 fd,JNI 才调用监听器
回到应用进程,Native Looper 等的 fd 就是注册时接到的那个 BitTube。可读通知让 Receiver::handleEvent() 尝试读取,JNI 把样本的值、时间戳和 handle 交还 Java SensorEventQueue,接着才是应用的 onSensorChanged()。
// SystemSensorManager.SensorEventQueue.dispatchSensorEvent,省略查表与准确度处理。System.arraycopy(values, 0, t.values, 0, t.values.length);t.timestamp = timestamp;t.accuracy = inAccuracy;t.sensor = sensor;// 省略 onAccuracyChanged 与特定传感器的连续性处理。mListener.onSensorChanged(t);
Binder 线程受理服务请求,SensorService 事件线程收 HAL 数据,应用自己的 Looper 线程执行回调。 Handler 在本例用来选择 Looper,普通样本无需由 Binder 逐条回调,也不必额外发一条 Java Handler 消息。Java 队列在回调时复用 SensorEvent 与数组;如果打算交给另一个线程长期使用,先复制时间戳与所需的值。注销后查不到活动事件对象时,Java 会跳过队列里迟来的样本。 JNI Receiver.handleEvent · Java dispatchSensorEvent
5. 用 batch、flush 和注销区分三件事
5.1 何时采一份,何时交一批
假设 AP 保持清醒,传感器有可用硬件 FIFO,每 100 毫秒采一份,允许最多延迟 2 秒。如果 FIFO 撑不到 2 秒、需要 flush 或其他订阅要求更早交付,事件会提前上报。应用连续读到几条样本时,可能看到后两份样本各相隔约 100 毫秒,应用却只隔 1~2 毫秒收到它们。这里的数字用于说明 sampleGapMs 与 arrivalGapMs 的差别。这是观察到的交付模式,若要确认是硬件 batch,还要和 FIFO 能力、HAL 配置及线程调度证据对照。 Sensors 批处理契约 · SensorManager.registerListener
Goldfish 的这份子 HAL 忽略 maxReportLatencyNs。batch() 保存采样周期,但用 (void)maxReportLatencyNs 丢弃这个延迟。代码里的 batchThread 负责定时向上发样。用有 FIFO 的真机另做两组对照,才有条件验证物理批量上报。启动后 fifoMax=0 就先把预期放在取样与回调上。 ranchu batch
5.2 flush 完成从事件通道回来

点 Flush 后,manager.flush(listener) 先找 Java 队列,经 JNI 和 Binder 向 SensorService::flushSensor() 请求该连接的活动传感器刷新。对于本文选择的硬件接口,服务持有 mLock,调用 HAL flush 并在成功后登记待完成连接。事件线程也要取得这把锁才会匹配元事件,因此即使 HAL 很快写出完成标记,这个线程也不能越过登记。HAL 将对应 META_DATA_FLUSH_COMPLETE 作为事件交回,服务用每个传感器的待完成队列把它对给发起连接。JNI 解开元事件,Java 只在监听器实现 SensorEventListener2 时调用 onFlushCompleted()。 服务端 flush · ranchu flush · Java flush 回调
// MultihalSensors::flush,节选传感器仍处于活动状态的分支。Event event;event.sensorHandle = sensorHandle;event.sensorType = SensorType::META_DATA;event.u.meta.what = MetaDataEventType::META_DATA_FLUSH_COMPLETE;doPostSensorEventLocked(*sensor, event);
flush() == true 表示请求受理,onFlushCompleted() 才是应用端完成标记。 样本持续产生,完成标记之后仍可能收到新样本。Ranchu 会直接补发完成标记,拿它能验证回执链;要证明真实 FIFO 被清空,还得在支持批处理的硬件上看 flush 前后的数据和 HAL 证据。
5.3 退出一个监听器,底层可能还在为别人采样
显式调用 unregisterListener(listener, sensor) 时,Java 移除 handle,经 Native 队列调用服务禁用本连接的传感器。服务撤销该连接的记录,重新评估剩余订阅。移除监听器的最后一个 handle 时,Java 释放队列,JNI 从 Looper 移除 fd 并释放 Receiver 的持有关系。应用进程异常结束时,Binder 连接生命周期也会使服务端连接析构清理订阅。 Java 注销 · JNI 销毁 Receiver · 服务端禁用 · 连接析构
wake-up 传感器还涉及两段确认。当事件写入 Event FMQ,HAL 有责任保护到 Framework 接手;SensorService 读到 wake-up 事件,持自己的 wake lock,再往 Wake Lock FMQ 报告计数。服务往客户端 BitTube 发送带 ACK 标记的事件后,应用 JNI 在一批分发后回 ACK;服务连接侧扣减引用,并在没有待确认连接时释放。丢失客户端或超时也有清理路径。左边报的是 HAL 到 Framework 的交接,右边报的是 Framework 到客户端的交接,两种计数不能互换。实验的默认加速度计以 wakeUp 日志为准,据普通回调无法推断系统是否从 suspend 恢复。 AIDL HAL 唤醒契约 · Framework 接手唤醒事件 · 应用发 ACK · 连接收 ACK
6. ContextHub 如何把纳米应用的结果送回 Android
只在界面上画三轴数值,SensorManager 足够。若想把简单检测放到低功耗处理器上持续运行,例如采样后确认是否出现了特定动作,系统集成方可以在 CHRE 上运行 nanoapp。ContextHub 是 Android 侧的管理和消息入口。CHRE(Context Hub Runtime Environment)是低功耗处理器上的运行时,nanoapp 是其中被调度的小程序。 这里把运行 Android 的应用处理器称为 AP。 nanoapp 还可以按平台能力使用 CHRE 自己的传感器 API,不必把每个原始样本送回 Android。 CHRE 系统结构 · CHRE sensor_world
6.1 先确认设备和 nanoapp,再建立一个端点
ContextHubManager 这组入口是受限系统 API,需要设备支持和 ACCESS_CONTEXT_HUB,该权限是 signature|privileged。普通应用仅在 Manifest 里声明拿不到这个权限。安装了 ContextHub HAL 名称的模拟器也未必能跑 nanoapp,例如 AOSP 的示例 HAL 默认不枚举真实 hub。下面按 AIDL ContextHub + Tinysys/SCP + 已有回显 nanoapp 追踪普通消息路径。 权限声明 · 示例 HAL · Tinysys HAL 实现
集成侧先通过 getContextHubs() 找 hub,再用 queryNanoApps(hub) 的完成响应确认 nanoapp 已存在。若由集成工具加载,loadNanoApp(hub, binary) 先建立带回调的 ContextHubTransaction。系统服务把加载事务加进队列,HAL 后续以事务 ID 报告结果。预装的 nanoapp 则由固件/产品配置提供,设备重启、hub 重置后的可用性应重新查询。这里加载二进制指给已有运行时增加 nanoapp,更新处理器固件是另一件事。 ContextHubManager 的加载与查询 · 服务安排加载事务 · 事务匹配与超时
宿主代码在已确认的 hub 上创建回调客户端。下面是系统客户端的接口骨架,nanoAppId、消息类型与 nonce 的编码需和实际回显 nanoapp 约定一致。接收、超时和资源释放属于调用方调度,所以这里将客户端留给后续处理而没有立即关闭。
ContextHubClient client = manager.createClient(hub, callback, executor);NanoAppMessage ping = NanoAppMessage.createMessageToNanoApp( nanoAppId, pingType, nonceBytes);int accepted = client.sendMessageToNanoApp(ping);// 在 callback 中按 nanoAppId、回包类型和 nonce 匹配本次请求。// 等到回包、超时或任务取消后,通过 client.close() 释放端点。
ContextHubManager.createClient() 先在应用内创建 ContextHubClient 和 Binder 回调 Stub。系统服务校验权限、hub ID 和回调后,ContextHubClientManager 分配 hostEndPointId,创建 ContextHubClientBroker,放进端点表,并把服务端 Binder 代理交回应用。发送时 Java 客户端用这个代理,回包时服务用端点表找原来那个 broker。hub ID 选运行环境,nanoapp ID 选低功耗程序,host endpoint 标识 Android 侧的接收者。 应用创建客户端 · 系统服务 createClient · 分配端点与注册 broker
6.2 发出普通消息,返回成功只说明 HAL 接收了请求
应用调用 ContextHubClient.sendMessageToNanoApp(),经 IContextHubClient Binder 到 broker。broker 检查调用权限、客户端是否还在注册和 nanoapp 授权状态,再把 host endpoint、hub ID、消息交给 AIDL wrapper。wrapper 组装 ContextHubMessage 并调用 IContextHub.sendMessageToHub(),这段采用 Java 生成的 AIDL 客户端,无需另走应用的传感器 JNI 或 BitTube。 客户端发送 · broker 权限与发送 · AIDL wrapper
// IContextHubWrapper 的 AIDL 发送分支,省略异常映射。var msg = ContextHubServiceUtil.createAidlContextHubMessage(hostEndpointId, message);hub.sendMessageToHub(contextHubId, msg);return ContextHubTransaction.RESULT_SUCCESS;
Tinysys HAL 选用 TinysysChreConnection。AIDL HAL 验证 hub 和 CHRE 状态,把 nanoappId、messageType、hostEndpoint、payload 编成 FlatBuffers,必要时转换 endpoint 以区分 HAL 客户端。在这个实现里,成功只表示请求进入 HAL 发送队列。 HAL 的独立发送线程从队列取出数据后,对打开的 /dev/scp_chre_manager 执行 write(),监听线程从相同设备接口读取反向消息。HAL 进程外的 Linux vendor 驱动源码未在当前树定位,设备文件、读写点和 SCP 端协议是本章能对齐的边界。 HAL 组包 · 设备节点定义 · HAL 读写线程与发送队列
// TinysysChreConnection::sendMessage,保留长度保护与入队。if (length <= 0 || length > kMaxSendingPayloadBytes) { // 省略日志。 return false;}return mSendingQueue.emplace(data, length);
这个 I/O 边界和前面的虚拟加速度计完全不同。Tinysys 固件侧 chreIpiHandler() 处理 AP 与 SCP 的处理器间中断(IPI),验证消息头并从对应共享区取 payload。取得的 FlatBuffers 消息经 HostMessageHandlers 进入 HostCommsManager。它按 nanoapp ID 找事件循环和运行实例,复制消息内容并投递,随后在目标循环分发 CHRE_EVENT_MESSAGE_FROM_HOST。消息在分发后释放,nanoapp 如需在回调外使用入站数据,应按 API 生命周期复制。 SCP 入站 IPI · SCP 把协议消息交给运行时 · CHRE 查找和投递 · CHRE 事件分发
// HostCommsManager,节选找到 nanoapp 且应该分发的分支。eventLoop->distributeEventSync(CHRE_EVENT_MESSAGE_FROM_HOST, &craftedMessage->fromHostData, targetInstanceId);error = CHRE_ERROR_NONE;
6.3 回包按 endpoint 找回客户端,唤醒与确认各有边界
nanoapp 接到请求,按协议处理后,取入站消息的 endpoint,用 chreSendMessageToHostEndpoint() 发回匹配 nonce 的应答。CHRE 把出站消息交给 HostLink 队列,Tinysys 后台任务将数据写入 SCP→AP 的共享区,用 IPI 通知 AP。IPI 确认是处理器间传输环节的一次交接。随后 HAL 读取设备节点,还原客户端 endpoint,并通过已注册的 AIDL HAL callback 把消息交给 Framework。 CHRE 消息及所有权 API · SCP 出站共享区与 IPI · HAL 恢复 endpoint 并回调
Framework 的 AIDL wrapper 先把回调投递给自己的 Handler,再由服务查 endpoint 表。找到 broker 且权限、AppOps 检查通过后,服务用 oneway 的 IContextHubClientCallback 发给应用。应用 Stub 将业务回调交给此前传入的 Executor,线程由 Executor 决定,内联执行的 Executor 可能不再切线程。业务成功以应用收到约定回包为准。 close 或客户端死亡后,服务注销端点并通知 HAL;只有先通过应用协议匹配的结果才属于当前请求,超时之后的迟到回包应丢弃。关闭端点不会卸载共享 nanoapp。 HAL callback 进 Framework Handler · 服务接收普通消息 · 按端点分发 · broker 接收权限 · 应用 Binder 回调 · Executor 分发 · 端点清理
// ContextHubManager.createClientCallback,保留普通消息的路径。executor.execute(() -> { callback.onMessageFromNanoApp(client, message); client.callbackFinished();});
callbackFinished() 是当前应用回调完成后的框架通知。可靠消息有独立的序列号、交付状态和事务处理,应用层协议仍应自行说明何为业务完成。
CHRE 能在 AP 休眠时继续运行。端点发消息的 API 可以唤醒休眠的 AP,实际中断、唤醒源和恢复时刻取决于设备实现。CHRE 的 wokeHost 字段依据它看到的主机状态与统计归因,主机状态通知可能滞后,不能据这个字段断言发生了一次硬件深睡唤醒。Tinysys HAL 在收到数据后还会尝试持 partial wake lock 保护 AP 侧处理,这属于收到之后保持清醒的环节。 CHRE 主机休眠 API · CHRE wokeHost 归因 · HAL 接收唤醒锁
7. 用两组日志复核,再决定去哪里查
7.1 在模拟器验证回调和 flush
Android Studio 用第 1 节的配置运行后,在 开发机终端选择目标设备。下列 emulator-5554 是 adb 序列号示例,替换为实际值。日志命令持续输出,按 Ctrl+C 停止采集。
adb devices -lSERIAL=emulator-5554adb -s "$SERIAL" logcat -s Ch20Sensor:I
在界面依次做四件事。
1. 不选 batch,点「开始」。预期日志首先出现 register=true,随后是带 eventNs、arrivalNs 和 thread=sensor-demo 的样本。转动虚拟设备后对照三轴值。
2. 点 Flush。示例串行处理按钮与回调,避免把同一传感器的多次 flush 混在一起。预期先有 flushAccepted=true,再有 flushComplete。如果没有完成标记,先确认监听器仍注册,超时就记为「本轮未观察到完成」,停止监听。若要做可独立判定的重复试验,先重启测试模拟器清掉上一轮在途元事件,再重新注册。服务回执按 handle 匹配待完成队列,旧事件没有应用侧的试验编号。
3. 点「停止」。预期出现 unregistered count=…,同一次注册不再记录采样。返回桌面也会触发注销。
4. 勾选 batch,再点「开始」。对比两轮 sampleGapMs 和 arrivalGapMs,同时看 fifoMax。首条两项记录为 0 仅用于初始化。Goldfish 上按该子 HAL 的实现,不能把选项开启当成硬件 FIFO 已使用。
在另一个终端,以同一序列号查看当前服务订阅和活动状态。可分别在按钮开始与停止后执行命令,记录应用名称和加速度计名称对应条目。不同版本的输出字段会变化。
SERIAL=emulator-5554adb -s "$SERIAL" shell getprop ro.build.fingerprintadb -s "$SERIAL" shell service list | grep -Ei 'sensor|contexthub'adb -s "$SERIAL" shell dumpsys sensorservice
如需进一步核对内核运输方式,使用与本章相配套的 userdebug 镜像、其内核配置和 HAL 进程权限,先对照 AIDL 服务、Goldfish 传输库和 Guest vsock 驱动。固定 Goldfish x86_64 配置默认选择 6.12,并在相应配置中列出 vmw_vsock_virtio_transport.ko;这份构建证据不能代替拿到当前客户端 fd 或 transport 的运行记录。 x86_64 内核产品配置
| getDefaultSensor() | ||
7.2 在匹配设备上验证一次 CHRE 消息往返
这是系统集成侧的实验。先确认设备的 contexthub 服务、AIDL HAL 实例、固件与 nanoapp ID,再使用已获授权的系统测试客户端执行「查询 → 创建端点 → 发出 ping → 等待回显 → 关闭」。日志最少记录 hub ID、nanoapp ID、消息类型、nonce、接受状态与回包结果。只有回包的 nonce 和类型匹配才记为通过。AOSP 给了可对照的成对实现。回显 nanoapp 沿原 host endpoint 发回相同消息类型与 payload,Android 测试客户端用 echo_message.napp 验证发送和响应。跟做选用这对实现时,预期回包类型就是原请求类型;测试程序的构建与安装依目标设备配置。 CHRE 回显 nanoapp · Android 回显测试客户端
关注低功耗时,单独做设备已进入 suspend 的用例,把恢复原因、AP 电源状态和 CHRE 回包记录放在同一时间线上。只拿到消息或服务进程日志,还不足以判断设备是否经过 suspend。这篇的应用示例核对 SDK 和源码,设备运行、实体 FIFO 与 Tinysys 固件实测均留待匹配设备验证。
7.3 完整示例
package com.example.sensorschapter;import android.app.Activity;import android.content.Context;import android.hardware.Sensor;import android.hardware.SensorEvent;import android.hardware.SensorEventListener2;import android.hardware.SensorManager;import android.os.Bundle;import android.os.Handler;import android.os.HandlerThread;import android.os.SystemClock;import android.util.Log;import android.widget.Button;import android.widget.CheckBox;import android.widget.LinearLayout;import android.widget.TextView;import java.util.Locale;public final class MainActivity extends Activity implements SensorEventListener2 { private static final String TAG = "Ch20Sensor"; private static final int SAMPLE_US = 100_000; private static final int BATCH_US = 2_000_000; private SensorManager manager; private Sensor accelerometer; private HandlerThread worker; private Handler handler; private TextView status; // These fields are used only on the sensor worker thread. private boolean registered; private long previousEventNs; private long previousArrivalNs; private boolean flushPending; private int count; @Override protected void onCreate(Bundle state) { super.onCreate(state); manager = (SensorManager) getSystemService(Context.SENSOR_SERVICE); accelerometer = manager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER); worker = new HandlerThread("sensor-demo"); worker.start(); handler = new Handler(worker.getLooper()); LinearLayout panel = new LinearLayout(this); panel.setOrientation(LinearLayout.VERTICAL); int pad = (int) (16 * getResources().getDisplayMetrics().density); panel.setPadding(pad, pad, pad, pad); CheckBox batch = new CheckBox(this); batch.setText("请求最多 2 秒批量延迟(重新开始后生效)"); panel.addView(batch); addButton(panel, "开始", () -> { int latencyUs = batch.isChecked() ? BATCH_US : 0; handler.post(() -> start(latencyUs)); }); addButton(panel, "Flush", () -> handler.post(this::requestFlush)); addButton(panel, "停止", () -> handler.post(this::stop)); status = new TextView(this); status.setText("等待开始"); panel.addView(status); setContentView(panel); } private void addButton(LinearLayout panel, String label, Runnable action) { Button button = new Button(this); button.setText(label); button.setOnClickListener(v -> action.run()); panel.addView(button); } private void start(int latencyUs) { if (registered) { report("已注册,先停止再更改参数"); return; } if (accelerometer == null) { report("没有 TYPE_ACCELEROMETER"); return; } count = 0; previousEventNs = 0; previousArrivalNs = 0; flushPending = false; registered = manager.registerListener(this, accelerometer, SAMPLE_US, latencyUs, handler); report("register=" + registered + " sensor=" + accelerometer.getName() + " requestedLatencyUs=" + latencyUs + " fifoMax=" + accelerometer.getFifoMaxEventCount() + " wakeUp=" + accelerometer.isWakeUpSensor()); } private void requestFlush() { if (!registered || flushPending) { report(registered ? "等待上一轮 flush 的完成回调" : "尚未注册"); return; } flushPending = manager.flush(this); report("flushAccepted=" + flushPending); } private void stop() { if (!registered) { return; } manager.unregisterListener(this, accelerometer); registered = false; flushPending = false; report("unregistered count=" + count); } @Override public void onSensorChanged(SensorEvent event) { if (!registered) { return; } long nowNs = SystemClock.elapsedRealtimeNanos(); double sampleGapMs = gapMs(event.timestamp, previousEventNs); double arrivalGapMs = gapMs(nowNs, previousArrivalNs); previousEventNs = event.timestamp; previousArrivalNs = nowNs; count++; String line = String.format(Locale.ROOT, "#%d eventNs=%d arrivalNs=%d sampleGapMs=%.1f arrivalGapMs=%.1f " + "xyz=(%.2f, %.2f, %.2f) thread=%s", count, event.timestamp, nowNs, sampleGapMs, arrivalGapMs, event.values[0], event.values[1], event.values[2], Thread.currentThread().getName()); Log.i(TAG, line); if (count == 1 || count % 10 == 0) { show(line); } } private static double gapMs(long now, long previous) { return previous == 0 ? 0 : (now - previous) / 1_000_000.0; } @Override public void onAccuracyChanged(Sensor sensor, int accuracy) { Log.i(TAG, "accuracy=" + accuracy + " sensor=" + sensor.getName()); } @Override public void onFlushCompleted(Sensor sensor) { if (registered && sensor == accelerometer && flushPending) { flushPending = false; report("flushComplete sensor=" + sensor.getName() + " afterCount=" + count + " thread=" + Thread.currentThread().getName()); } } private void report(String line) { Log.i(TAG, line); show(line); } private void show(String line) { runOnUiThread(() -> { if (!isDestroyed()) { status.setText(line); } }); } @Override protected void onPause() { handler.post(this::stop); super.onPause(); } @Override protected void onDestroy() { handler.post(() -> { stop(); worker.quitSafely(); }); super.onDestroy(); }}
8. 复盘
再转一次虚拟手机,日志里的两组时间就有了各自的来处。样本时间跟着 HAL 的事件走,应用到达时间取自执行回调的线程。要追一条 SensorEvent,先用 handle 串起注册和数据,再分开看 HAL 的 FMQ 和应用的 BitTube。回调挨在一起时,先比两组时间,再去看 FIFO 与线程。要追 ContextHub 的结果,就用 nanoapp ID 找执行者、用端点找回接收者、用消息协议认出本次回包。两条路径的共同点是请求答复和异步结果各有证据。先确认自己等的是哪个结果,才知道该查哪条线程和哪一段通道。
参考资料
• Sensors AIDL HAL
• Sensors 批处理、FIFO 与上报延迟
• Android Emulator 控制台与传感器
• SensorManager API
• CHRE 运行环境与 HAL
• Goldfish 产品源码 · Linux virtio-vsock 接收
• 本章完整 Java 文件















































































