夜雨聆风学习资料网

ARTICLE · 1381382

Android源码第二十章:SensorService 与 ContextHub——数据从哪来?

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 发给应用

通道
两端
传的内容
Binder
应用 ↔ SensorService,SensorService ↔ 供应商 HAL
注册、启停、flush、通道描述符及状态
Event FMQ
HAL → SensorService
批量写入的事件和 flush 完成元事件
BitTube
SensorService ↔ 应用
服务发筛选后的事件,应用回 wake-up 确认
Wake Lock FMQ
SensorService → HAL
服务接手的 wake-up 事件计数

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()
、register=、服务和 HAL 是否存在
区分设备未暴露资源、请求未获接受
注册成功,没有任何样本
界面保持前台,核对活跃订阅、模拟器姿态与回调线程
缩小到产数、过滤或 Looper 接收,还需下一层证据
连续样本挤在一起到达
两组时间差、FIFO 容量、设备 HAL 与调度
区分采样间隔和到达间隔,进一步调查是否 batch
Flush 受理但未完成
监听器类型、是否注销、HAL 元事件与服务映射
回调丢失与请求失败分别记录

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 文件

回首页,搜索你想要的文档

在首页搜索框输入关键词,快速定位资料

文库首页搜索指引 立即搜索

相关学习资料