内核启动后，首个用户空间进程init（pid=1）解析init.rc配置文件，启动关键服务（如Zygote和ServiceManager）。
Zygote服务配置为/system/bin/app_process --zygote --start-system-server，后续用于孵化Java进程。Zygote进程通过fork()生成SystemServer进程，并执行com.android.server.SystemServer的main()方法
SystemServer作为Java框架层核心，负责启动所有系统服务，这些服务就包含有SensorService
所以，SensorService的是跑在系统进程中。整个android sensor模块的核心是SensorService，应用通过SensorManager与其交互，SensorService管理着sensor的所有行为，包括开关sensor【注册传感器】，上报sensor数据给到应用。
接下来，看下sensorservice 的启动流程
/android-14.0.0_r21/xref/frameworks/base/services/java/com/android/server/SystemServer.java
1351 t.traceBegin("StartSensorService");
// 启动 SensorService
1352 mSystemServiceManager.startService(SensorService.class);
1353 t.traceEnd();
1354 t.traceEnd(); // startBootstrapServices
1355 }
SystemServiceManager 会通过反射的方法去创建 SensorService 对象，然后回调 onStart 方法
frameworks/base/services/core/java/com/android/server/SystemServiceManager.java
public <T extends SystemService> T startService(Class<T> serviceClass) {try {final String name = serviceClass.getName();Slog.i(TAG, "Starting " + name);Trace.traceBegin(Trace.TRACE_TAG_SYSTEM_SERVER, "StartService " + name);// Create the service.if (!SystemService.class.isAssignableFrom(serviceClass)) {throw new RuntimeException("Failed to create " + name+ ": service must extend " + SystemService.class.getName());}final T service;try {Constructor<T> constructor = serviceClass.getConstructor(Context.class);// 创建 SensorService 对象service = constructor.newInstance(mContext);} catch (InstantiationException ex) {throw new RuntimeException("Failed to create service " + name+ ": service could not be instantiated", ex);} catch (IllegalAccessException ex) {throw new RuntimeException("Failed to create service " + name+ ": service must have a public constructor with a Context argument", ex);} catch (NoSuchMethodException ex) {throw new RuntimeException("Failed to create service " + name+ ": service must have a public constructor with a Context argument", ex);} catch (InvocationTargetException ex) {throw new RuntimeException("Failed to create service " + name+ ": service constructor threw an exception", ex);}startService(service);return service;} finally {Trace.traceEnd(Trace.TRACE_TAG_SYSTEM_SERVER);}}@android.ravenwood.annotation.RavenwoodKeeppublic void startService(@NonNull final SystemService service) {// Check if already startedString className = service.getClass().getName();if (mServiceClassnames.contains(className)) {Slog.i(TAG, "Not starting an already started service " + className);return;}mServiceClassnames.add(className);// Register it.mServices.add(service);// Start it.long time = SystemClock.elapsedRealtime();try {// 执行SensorService 的onstart 方法service.onStart();} catch (RuntimeException ex) {throw new RuntimeException("Failed to start service " + service.getClass().getName()+ ": onStart threw an exception", ex);}warnIfTooLong(SystemClock.elapsedRealtime() - time, service, "onStart");}
创建 SensorService 对象
/frameworks/base/services/core/java/com/android/server/sensors/SensorService.java
66 public SensorService(Context ctx) {
67 super(ctx);
68 synchronized (mLock) {
69 mSensorServiceStart = SystemServerInitThreadPool.submit(() -> {
70 TimingsTraceAndSlog traceLog = TimingsTraceAndSlog.newAsyncLog();
71 traceLog.traceBegin(START_NATIVE_SENSOR_SERVICE);
// 调用native层的方法：startSensorServiceNative
72 long ptr = startSensorServiceNative(new ProximityListenerDelegate());
73 synchronized (mLock) {
74 mPtr = ptr;
75 }
76 traceLog.traceEnd();
77 }, START_NATIVE_SENSOR_SERVICE);
78 }
79 }
80 // onstart 方法，将其publish 到servicemanager，系统进程可以通过 SensorManagerInternal.class 获取到
81 @Override
82 public void onStart() {
83 LocalServices.addService(SensorManagerInternal.class, new LocalService());
84 }
// 调用native层的方法：startSensorServiceNative
/frameworks/base/services/core/jni/com_android_server_sensor_SensorService.cpp
294 static jlong startSensorServiceNative(JNIEnv* env, jclass, jobject listener) {
// 创建 NativeSensorService 对象
295 NativeSensorService* service = new NativeSensorService(env, listener);
296 return reinterpret_cast<jlong>(service);
297 }
// 创建 NativeSensorService 对象
95 NativeSensorService::NativeSensorService(JNIEnv* env, jobject listener)
96 : mProximityActiveListenerDelegate(new ProximityActiveListenerDelegate(env, listener)) {
97 if (base::GetBoolProperty("system_init.startsensorservice", true)) {
98 sp<IServiceManager> sm(defaultServiceManager());
// 创建native 层的 SensorService 对象
99 mService = new SensorService();
// 将其增加到 servicemanager 中
100 sm->addService(String16(SensorService::getServiceName()), mService,
101 false /* allowIsolated */, IServiceManager::DUMP_FLAG_PRIORITY_CRITICAL);
102 }
103 }
// SensorService 构造方法
/frameworks/native/services/sensorservice/SensorService.cpp
161 SensorService::SensorService()
// 设置 mSocketBufferSize socket 通信的buffer 的大小
162 : mInitCheck(NO_INIT), mSocketBufferSize(SOCKET_BUFFER_SIZE_NON_BATCHED),
163 mWakeLockAcquired(false), mLastReportedProxIsActive(false) {
164 mUidPolicy = new UidPolicy(this);
165 mSensorPrivacyPolicy = new SensorPrivacyPolicy(this);
166 mMicSensorPrivacyPolicy = new MicrophonePrivacyPolicy(this);
167 }
// 接着走onfirstref 方法
286 void SensorService::onFirstRef() {
287 ALOGD("nuSensorService starting...");
// 1） SensorDevice构造函数SensorDevice::getInstance()
288 SensorDevice& dev(SensorDevice::getInstance());
289
290 sHmacGlobalKeyIsValid = initializeHmacKey();
291
292 if (dev.initCheck() == NO_ERROR) {
293 sensor_t const* list;
294 ssize_t count = dev.getSensorList(&list);
...
306 for (ssize_t i=0 ; i<count ; i++) {
307 bool useThisSensor = true;
308
309 switch (list[i].type) {
310 case SENSOR_TYPE_ACCELEROMETER:
311 hasAccel = true;
312 break;
。。。。
339 if (useThisSensor) {
340 if (list[i].type == SENSOR_TYPE_PROXIMITY) {
341 auto s = std::make_shared<ProximitySensor>(list[i], *this);
342 const int handle = s->getSensor().getHandle();
// 获取到hal 层的sensor，这里去注册sensor
343 if (registerSensor(std::move(s))) {
344 mProxSensorHandles.push_back(handle);
345 }
346 } else {
347 registerSensor(std::make_shared<HardwareSensor>(list[i]));
348 }
349 }
。。。。。
469 mInitCheck = NO_ERROR;
470 mAckReceiver = new SensorEventAckReceiver(this);
471 mAckReceiver->run("SensorEventAckReceiver", PRIORITY_URGENT_DISPLAY);
// 2）执行 SensorService 的线程方法
472 run("SensorService", PRIORITY_URGENT_DISPLAY);
// SensorDevice构造函数SensorDevice::getInstance()
/frameworks/native/services/sensorservice/SensorDevice.cpp
68 SensorDevice::SensorDevice() {
// 1-1）首先去连接hal service
69 if (!connectHalService()) {
70 return;
71 }
72
// 1-2）初始化sensor列表:initializeSensorList
73 initializeSensorList();
74
75 mIsDirectReportSupported = (mHalWrapper->unregisterDirectChannel(-1) != INVALID_OPERATION);
76 }
1-1）首先去连接hal service
138 bool SensorDevice::connectHalService() {
// 创建 AidlSensorHalWrapper 对象
139 std::unique_ptr<ISensorHalWrapper> aidl_wrapper = std::make_unique<AidlSensorHalWrapper>();
// AidlSensorHalWrapper 去连接底层的service
140 if (aidl_wrapper->connect(this)) {
141 mHalWrapper = std::move(aidl_wrapper);
142 return true;
143 }
144
145 std::unique_ptr<ISensorHalWrapper> hidl_wrapper = std::make_unique<HidlSensorHalWrapper>();
146 if (hidl_wrapper->connect(this)) {
147 mHalWrapper = std::move(hidl_wrapper);
148 return true;
149 }
150
151 // TODO: check aidl connection;
152 return false;
153 }
// AidlSensorHalWrapper 去连接底层的service，调用 AidlSensorHalWrapper的connect 方法
/frameworks/native/services/sensorservice/AidlSensorHalWrapper.cpp
105 bool AidlSensorHalWrapper::connect(SensorDeviceCallback *callback) {
// allback回调就是 SensorDevice
106 mSensorDeviceCallback = callback;
107 mSensors = nullptr;
108
// 获取到aidl 的hal层的sensor 进程service 的名字
109 auto aidlServiceName = std::string() + ISensors::descriptor + "/default";
110 if (AServiceManager_isDeclared(aidlServiceName.c_str())) {
111 if (mSensors != nullptr) {
112 AIBinder_unlinkToDeath(mSensors->asBinder().get(), mDeathRecipient.get(), this);
113 }
114
// 获取到对应的binder 客户端对象
115 ndk::SpAIBinder binder(AServiceManager_waitForService(aidlServiceName.c_str()));
116 if (binder.get() != nullptr) {
117 mSensors = ISensors::fromBinder(binder);
// 创建了 mEventQueue ，与系统进程通信
118 mEventQueue = std::make_unique<AidlMessageQueue<
119 Event, SynchronizedReadWrite>>(MAX_RECEIVE_BUFFER_EVENT_COUNT,
120 /*configureEventFlagWord=*/true);
121
122 mWakeLockQueue = std::make_unique<AidlMessageQueue<
123 int32_t, SynchronizedReadWrite>>(MAX_RECEIVE_BUFFER_EVENT_COUNT,
124 /*configureEventFlagWord=*/true);
125 if (mEventQueueFlag != nullptr) {
126 EventFlag::deleteEventFlag(&mEventQueueFlag);
127 }
128 EventFlag::createEventFlag(mEventQueue->getEventFlagWord(), &mEventQueueFlag);
129 if (mWakeLockQueueFlag != nullptr) {
130 EventFlag::deleteEventFlag(&mWakeLockQueueFlag);
131 }
132 EventFlag::createEventFlag(mWakeLockQueue->getEventFlagWord(), &mWakeLockQueueFlag);
133
134 CHECK(mEventQueue != nullptr && mEventQueueFlag != nullptr &&
135 mWakeLockQueue != nullptr && mWakeLockQueueFlag != nullptr);
136
// 创建callback，mSensorDeviceCallback为 SensorDevice
137 mCallback = ndk::SharedRefBase::make<AidlSensorsCallback>(mSensorDeviceCallback);
// binder 通信去初始化，并设置会回调 SensorDevice；这里把 mEventQueue 的 dupeDesc给到了服务器端
138 mSensors->initialize(mEventQueue->dupeDesc(), mWakeLockQueue->dupeDesc(), mCallback);
139
140 AIBinder_linkToDeath(mSensors->asBinder().get(), mDeathRecipient.get(), this);
141 } else {
142 ALOGE("Could not connect to declared sensors AIDL HAL");
143 }
144 }
145
146 return mSensors != nullptr;
147 }
// binder 通信去初始化，并设置会回调 SensorDevice
对应服务器端为如下， 在init 进程的时候会去创建hal service：
/hardware/interfaces/sensors/aidl/multihal/service.cpp
24 int main() {
25 ABinderProcess_setThreadPoolMaxThreadCount(0);
26
27 // Make a default multihal sensors service
// 创建了 HalProxyAidl 对象
28 auto halProxy = ndk::SharedRefBase::make<HalProxyAidl>main();
29 const std::string halProxyName = std::string() + HalProxyAidl::descriptor + "/default";
// 并将其保存到了 servicemanager
30 binder_status_t status =
31 AServiceManager_addService(halProxy->asBinder().get(), halProxyName.c_str());
32 CHECK_EQ(status, STATUS_OK);
33
34 ABinderProcess_joinThreadPool();
35 return EXIT_FAILURE; // should not reach
36 }
// 创建了 HalProxyAidl 对象，主要调用父类的构造函数：
/hardware/interfaces/sensors/common/default/2.X/multihal/HalProxy.cpp
84 HalProxy::HalProxy() {
85 static const std::string kMultiHalConfigFiles[] = {"/vendor/etc/sensors/hals.conf",
86 "/odm/etc/sensors/hals.conf"};
87 for (const std::string& configFile : kMultiHalConfigFiles) {
// 执行方法 initializeSubHalListFromConfigFile
88 initializeSubHalListFromConfigFile(configFile.c_str());
89 }
90 init();
91 }
// 执行方法 initializeSubHalListFromConfigFile
438 void HalProxy::initializeSubHalListFromConfigFile(const char* configFileName) {
439 std::ifstream subHalConfigStream(configFileName);
440 if (!subHalConfigStream) {
441 ALOGE("Failed to load subHal config file: %s", configFileName);
442 } else {
443 std::string subHalLibraryFile;
444 while (subHalConfigStream >> subHalLibraryFile) {
// 打开so 库：getHandleForSubHalSharedObject
445 void* handle = getHandleForSubHalSharedObject(subHalLibraryFile);
。。。。
463 } else {
// 找到 so的 对应的sensorsHalGetSubHal_2_1方法【这里能找到】
464 SensorsHalGetSubHalV2_1Func* getSubHalV2_1Ptr =
465 (SensorsHalGetSubHalV2_1Func*)dlsym(handle, "sensorsHalGetSubHal_2_1");
466
467 if (getSubHalV2_1Ptr == nullptr) {
468 ALOGE("Failed to locate sensorsHalGetSubHal function for library: %s",
469 subHalLibraryFile.c_str());
470 } else {
471 std::function<SensorsHalGetSubHalV2_1Func> sensorsHalGetSubHal_2_1 =
472 *getSubHalV2_1Ptr;
473 uint32_t version;
// 调用 sensorsHalGetSubHal_2_1 方法，返回hal层接口
474 ISensorsSubHalV2_1* subHal = sensorsHalGetSubHal_2_1(&version);
475 if (version != SUB_HAL_2_1_VERSION) {
476 ALOGE("SubHal version was not 2.1 for library: %s",
477 subHalLibraryFile.c_str());
478 } else {
479 ALOGV("Loaded SubHal from library: %s", subHalLibraryFile.c_str());
// j将hal层接口保存到 mSubHalList
480 mSubHalList.push_back(std::make_unique<SubHalWrapperV2_1>(subHal));
481 }
482 }
483 }
// 打开so 库：getHandleForSubHalSharedObject
510 void* HalProxy::getHandleForSubHalSharedObject(const std::string& filename) {
511 static const std::string kSubHalShareObjectLocations[] = {
512 "", // Default locations will be searched
513 #ifdef __LP64__
514 "/vendor/lib64/hw/", "/odm/lib64/hw/"
515 #else
516 "/vendor/lib/hw/", "/odm/lib/hw/"
517 #endif
518 };
519
520 for (const std::string& dir : kSubHalShareObjectLocations) {
521 void* handle = dlopen((dir + filename).c_str(), RTLD_NOW);
522 if (handle != nullptr) {
523 return handle;
524 }
525 }
526 return nullptr;
527 }
// 接着执行init 方法，获取到sensors
529 void HalProxy::init() {
530 initializeSensorList();
531 }
489 void HalProxy::initializeSensorList() {
490 for (size_t subHalIndex = 0; subHalIndex < mSubHalList.size(); subHalIndex++) {
// 下列方法会调用到 hal 层去获取到 sensors
491 auto result = mSubHalList[subHalIndex]->getSensorsList([&](const auto& list) {
492 for (SensorInfo sensor : list) {
493 if (!subHalIndexIsClear(sensor.sensorHandle)) {
494 ALOGE("SubHal sensorHandle's first byte was not 0");
495 } else {
496 ALOGV("Loaded sensor: %s", sensor.name.c_str());
497 sensor.sensorHandle = setSubHalIndex(sensor.sensorHandle, subHalIndex);
498 setDirectChannelFlags(&sensor, mSubHalList[subHalIndex]);
499 mSensors[sensor.sensorHandle] = sensor;
500 }
501 }
502 });
=======
// 调用 initialize 方法
/hardware/interfaces/sensors/aidl/default/multihal/HalProxyAidl.cpp
162 ScopedAStatus HalProxyAidl::initialize(
163 const MQDescriptor<::aidl::android::hardware::sensors::Event,
164 SynchronizedReadWrite> &in_eventQueueDescriptor,
165 const MQDescriptor<int32_t, SynchronizedReadWrite> &in_wakeLockDescriptor,
166 const std::shared_ptr<ISensorsCallback> &in_sensorsCallback) {
167 ::android::sp<::android::hardware::sensors::V2_1::implementation::
168 ISensorsCallbackWrapperBase>
// 依据callback 创建了 ISensorsCallbackWrapperAidl
169 dynamicCallback = new ISensorsCallbackWrapperAidl(in_sensorsCallback);
170
// 通过客户端给到的 in_eventQueueDescriptor，创建 aidlEventQueue
171 auto aidlEventQueue = std::make_unique<::android::AidlMessageQueue<
172 ::aidl::android::hardware::sensors::Event, SynchronizedReadWrite>>(
173 in_eventQueueDescriptor, true /* resetPointers */);
// 同样创建 eventQueue
174 std::unique_ptr<::android::hardware::sensors::V2_1::implementation::
175 EventMessageQueueWrapperBase>
176 eventQueue =
177 std::make_unique<EventMessageQueueWrapperAidl>(aidlEventQueue);
178
179 auto aidlWakeLockQueue = std::make_unique<
180 ::android::AidlMessageQueue<int32_t, SynchronizedReadWrite>>(
181 in_wakeLockDescriptor, true /* resetPointers */);
182 std::unique_ptr<::android::hardware::sensors::V2_1::implementation::
183 WakeLockMessageQueueWrapperBase>
184 wakeLockQueue =
185 std::make_unique<WakeLockMessageQueueWrapperAidl>(aidlWakeLockQueue);
186
// 调用父类的 initializeCommon 方法
187 return resultToAStatus(
188 initializeCommon(eventQueue, wakeLockQueue, dynamicCallback));
189 }
// 调用父类的 initializeCommon 方法
/hardware/interfaces/sensors/common/default/2.X/multihal/HalProxy.cpp
213 Return<Result> HalProxy::initializeCommon(
214 std::unique_ptr<EventMessageQueueWrapperBase>& eventQueue,
215 std::unique_ptr<WakeLockMessageQueueWrapperBase>& wakeLockQueue,
216 const sp<ISensorsCallbackWrapperBase>& sensorsCallback) {
217 Result result = Result::OK;
218
219 stopThreads();
220 resetSharedWakelock();
221
222 // So that the pending write events queue can be cleared safely and when we start threads
223 // again we do not get new events until after initialize resets the subhals.
224 disableAllSensors();
225
226 // Clears the queue if any events were pending write before.
227 mPendingWriteEventsQueue = std::queue<std::pair<std::vector<V2_1::Event>, size_t>>();
228 mSizePendingWriteEventsQueue = 0;
229
230 // Clears previously connected dynamic sensors
231 mDynamicSensors.clear();
232
233 mDynamicSensorsCallback = sensorsCallback;
234
。。。。
260 mPendingWritesThread = std::thread(startPendingWritesThread, this);
261 mWakelockThread = std::thread(startWakelockThread, this);
262
// 下列流程也会去初始化 hal层，mSubHalList 是在构造方法中设置了
263 for (size_t i = 0; i < mSubHalList.size(); i++) {
264 Result currRes = mSubHalList[i]->initialize(this, this, i);
265 if (currRes != Result::OK) {
266 result = currRes;
267 ALOGE("Subhal '%s' failed to initialize with reason %" PRId32 ".",
268 mSubHalList[i]->getName().c_str(), static_cast<int32_t>(currRes));
269 }
270 }
271
272 mCurrentOperationMode = OperationMode::NORMAL;
273
274 return result;
275 }
// 1-2）初始化sensor列表:initializeSensorList
/frameworks/native/services/sensorservice/SensorDevice.cpp
78 void SensorDevice::initializeSensorList() {
79 if (mHalWrapper == nullptr) {
80 return;
81 }
82
// hal 层获取到sensors
83 auto list = mHalWrapper->getSensorsList();
84 const size_t count = list.size();
85
86 mActivationCount.setCapacity(count);
87 Info model;
88 for (size_t i = 0; i < count; i++) {
89 sensor_t sensor = list[i];
// 将其保存到 mSensorList
124 mSensorList.push_back(sensor);
2）执行 SensorService 的线程方法
1040 bool SensorService::threadLoop() {
1041 ALOGD("nuSensorService thread starting...");
1042
1043 // each virtual sensor could generate an event per "real" event, that's why we need to size
1044 // numEventMax much smaller than MAX_RECEIVE_BUFFER_EVENT_COUNT. in practice, this is too
1045 // aggressive, but guaranteed to be enough.
1046 const size_t vcount = mSensors.getVirtualSensors().size();
1047 const size_t minBufferSize = SensorEventQueue::MAX_RECEIVE_BUFFER_EVENT_COUNT;
1048 const size_t numEventMax = minBufferSize / (1 + vcount);
1049
1050 SensorDevice& device(SensorDevice::getInstance());
1051
1052 const int halVersion = device.getHalDeviceVersion();
1053 do {
// 调用 SensorDevice 监听 sensor数据
1054 ssize_t count = device.poll(mSensorEventBuffer, numEventMax);
1055 if (count < 0) {
1056 if(count == DEAD_OBJECT && device.isReconnecting()) {
。。。
1172 const std::vector<sp<SensorEventConnection>> activeConnections = connLock.getActiveConnections();
。。。
// 遍历所有的connection，去通知到应用客户端
1235 for (const sp<SensorEventConnection>& connection : activeConnections) {
1236 connection->sendEvents(mSensorEventBuffer, count, mSensorEventScratch,
1237 mMapFlushEventsToConnections);
1238 needsWakeLock |= connection->needsWakeLock();
// 调用 SensorDevice 监听 sensor数据
/frameworks/native/services/sensorservice/SensorDevice.cpp
351 ssize_t SensorDevice::poll(sensors_event_t* buffer, size_t count) {
352 if (mHalWrapper == nullptr) return NO_INIT;
353
354 ssize_t eventsRead = 0;
// aidlhal 是为true 的
355 if (mHalWrapper->supportsMessageQueues()) {
// 调用 的pollFmq
356 eventsRead = mHalWrapper->pollFmq(buffer, count);
357 } else if (mHalWrapper->supportsPolling()) {
358 eventsRead = mHalWrapper->poll(buffer, count);
359 } else {
360 ALOGE("Must support polling or FMQ");
361 eventsRead = -1;
362 }
363
364 if (eventsRead > 0) {
/frameworks/native/services/sensorservice/AidlSensorHalWrapper.cpp
160 ssize_t AidlSensorHalWrapper::pollFmq(sensors_event_t *buffer, size_t maxNumEventsToRead) {
161 ssize_t eventsRead = 0;
162 size_t availableEvents = mEventQueue->availableToRead();
163
164 if (availableEvents == 0) {
165 uint32_t eventFlagState = 0;
166
167 // Wait for events to become available. This is necessary so that the Event FMQ's read() is
168 // able to be called with the correct number of events to read. If the specified number of
169 // events is not available, then read() would return no events, possibly introducing
170 // additional latency in delivering events to applications.
// 等待数据通过 mEventQueueFlag
171 if (mEventQueueFlag != nullptr) {
172 mEventQueueFlag->wait(asBaseType(ISensors::EVENT_QUEUE_FLAG_BITS_READ_AND_PROCESS) |
173 asBaseType(INTERNAL_WAKE),
174 &eventFlagState);
175 }
176 availableEvents = mEventQueue->availableToRead();
// 对应的 是在connect 方法中，去连接hal 层，也给到了对应的服务器端：
EventFlag::createEventFlag(mEventQueue->getEventFlagWord(), &mEventQueueFlag);
所以服务器端触发响应的流程为：
/hardware/interfaces/sensors/common/default/2.X/multihal/HalProxy.cpp
661 void HalProxy::postEventsToMessageQueue(const std::vector<Event>& events, size_t numWakeupEvents,
662 V2_0::implementation::ScopedWakelock wakelock) {
663 size_t numToWrite = 0;
664 std::lock_guard<std::mutex> lock(mEventQueueWriteMutex);
665 if (wakelock.isLocked()) {
666 incrementRefCountAndMaybeAcquireWakelock(numWakeupEvents);
667 }
668 if (mPendingWriteEventsQueue.empty()) {
669 numToWrite = std::min(events.size(), mEventQueue->availableToWrite());
670 if (numToWrite > 0) {
// 这里去写入参数，并唤醒
671 if (mEventQueue->write(events.data(), numToWrite)) {
672 // TODO(b/143302327): While loop if mEventQueue->avaiableToWrite > 0 to possibly fit
673 // in more writes immediately
674 mEventQueueFlag->wake(static_cast<uint32_t>(EventQueueFlagBits::READ_AND_PROCESS));
675 } else {
676 numToWrite = 0;
677 }
678 }
679 }
680 size_t numLeft = events.size() - numToWrite;
681 if (numToWrite < events.size() &&
682 mSizePendingWriteEventsQueue + numLeft <= kMaxSizePendingWriteEventsQueue) {
683 std::vector<Event> eventsLeft(events.begin() + numToWrite, events.end());
684 mPendingWriteEventsQueue.push({eventsLeft, numWakeupEvents});
685 mSizePendingWriteEventsQueue += numLeft;
686 mMostEventsObservedPendingWriteEventsQueue =
687 std::max(mMostEventsObservedPendingWriteEventsQueue, mSizePendingWriteEventsQueue);
688 mEventQueueWriteCV.notify_one();
689 }
690 }
=设置callback 的流程=
/hardware/interfaces/sensors/common/default/2.X/multihal/HalProxy.cpp
438 void HalProxy::initializeSubHalListFromConfigFile(const char* configFileName) {
。。。
478 } else {
479 ALOGV("Loaded SubHal from library: %s", subHalLibraryFile.c_str());
// // 创建了 SubHalWrapperV2_1 做为代理类
480 mSubHalList.push_back(std::make_unique<SubHalWrapperV2_1>(subHal));
// 然后再调用 initializeCommon去初始化 initialize
213 Return<Result> HalProxy::initializeCommon(
214 std::unique_ptr<EventMessageQueueWrapperBase>& eventQueue,
215 std::unique_ptr<WakeLockMessageQueueWrapperBase>& wakeLockQueue,
216 const sp<ISensorsCallbackWrapperBase>& sensorsCallback) {
。。。
263 for (size_t i = 0; i < mSubHalList.size(); i++) {
// 回调为this
264 Result currRes = mSubHalList[i]->initialize(this, this, i);
// SubHalWrapperV2_1 的初始化
/hardware/interfaces/sensors/common/default/2.X/multihal/include/SubHalWrapper.h
// 继承了 SubHalWrapperBase 的方法
161 class SubHalWrapperV2_1 : public SubHalWrapperBase<V2_1::implementation::ISensorsSubHal> {
162 public:
163 SubHalWrapperV2_1(V2_1::implementation::ISensorsSubHal* subHal) : SubHalWrapperBase(subHal) {}
175
176 Return<Result> initialize(V2_0::implementation::ISubHalCallback* callback,
177 V2_0::implementation::IScopedWakelockRefCounter* refCounter,
178 int32_t subHalIndex) override {
// callback为 HalProxy
179 return mSubHal->initialize(
180 new V2_0::implementation::HalProxyCallbackV2_1(callback, refCounter, subHalIndex));
181 }
182 };
// 由于 继承了 SubHalWrapperBase 的方法，所以会调用到 HalProxy::postEventsToMessageQueue 方法
/hardware/interfaces/sensors/common/default/2.X/multihal/HalProxyCallback.cpp
41 void HalProxyCallbackBase::postEvents(const std::vector<V2_1::Event>& events,
42 ScopedWakelock wakelock) {
43 if (events.empty() || !mCallback->areThreadsRunning()) return;
44 size_t numWakeupEvents;
45 std::vector<V2_1::Event> processedEvents = processEvents(events, &numWakeupEvents);
46 if (numWakeupEvents > 0) {
47 ALOG_ASSERT(wakelock.isLocked(),
48 "Wakeup events posted while wakelock unlocked for subhal"
49 " w/ index %" PRId32 ".",
50 mSubHalIndex);
51 } else {
52 ALOG_ASSERT(!wakelock.isLocked(),
53 "No Wakeup events posted but wakelock locked for subhal"
54 " w/ index %" PRId32 ".",
55 mSubHalIndex);
56 }
57 mCallback->postEventsToMessageQueue(processedEvents, numWakeupEvents, std::move(wakelock));
58 }
callback 的流程是hal层的传感器参数回调给系统进程中，在后文的博文 【sensor 事件上报流程】中有解析。
 数据库操作SQLAlchemy)
