【安卓Sensor框架-2】应用注册Sensor 流程
注册传感器的核心流程为如下：应用层调用 SensorManager注册传感器，framework层创建SensorEventQueue对象（事件队列），通过JNI调用Native方法nativeEnableSensor()；SensorService服务端createEventQueue()创建SensorEventConnection对象，然后enable使能sensor。
这里以监听光传感器的流程为例子。
/frameworks/base/services/core/java/com/android/server/display/DisplayPowerController2.java
// 这里设置lightsensor 使能：setLightSensorEnabled
652 private boolean setLightSensorEnabled(boolean enable) {
653 if (enable) {
654 if (!mLightSensorEnabled) {
655 mLightSensorEnabled = true;
656 mLightSensorEnableTime = mClock.uptimeMillis();
657 mCurrentLightSensorRate = mInitialLightSensorRate;
658 registerForegroundAppUpdater();
// mSensorManager是 SystemSensorManager 是powermanagerservice 设置的
// mLightSensor 是displaycontroller2 在构造的时候设置的
659 mSensorManager.registerListener(mLightSensorListener, mLightSensor,
660 mCurrentLightSensorRate * 1000, mHandler);
661 return true;
662 }
/frameworks/base/services/core/java/com/android/server/display/AutomaticBrightnessController.java
// mLightSensor 是displaycontroller2 在构造的时候设置的
// mSensorManager 是 SystemSensorManager ，继承了 SensorManager
659 mSensorManager.registerListener(mLightSensorListener, mLightSensor,
660 mCurrentLightSensorRate * 1000, mHandler);
/frameworks/base/core/java/android/hardware/SensorManager.java
852 public boolean registerListener(SensorEventListener listener, Sensor sensor,
853 int samplingPeriodUs, Handler handler) {
854 int delay = getDelay(samplingPeriodUs);
// 在子类中有实现registerListenerImpl
855 return registerListenerImpl(listener, sensor, delay, handler, 0, 0);
856 }
// 在子类中有实现registerListenerImpl
/frameworks/base/core/java/android/hardware/SystemSensorManager.java
240 @Override
241 protected boolean registerListenerImpl(SensorEventListener listener, Sensor sensor,
242 int delayUs, Handler handler, int maxBatchReportLatencyUs, int reservedFlags) {
243 if (listener == null || sensor == null) {
244 Log.e(TAG, "sensor or listener is null");
245 return false;
246 }
247 // Trigger Sensors should use the requestTriggerSensor call.
248 if (sensor.getReportingMode() == Sensor.REPORTING_MODE_ONE_SHOT) {
249 Log.e(TAG, "Trigger Sensors should use the requestTriggerSensor.");
250 return false;
251 }
252 if (maxBatchReportLatencyUs < 0 || delayUs < 0) {
253 Log.e(TAG, "maxBatchReportLatencyUs and delayUs should be non-negative");
254 return false;
255 }
// 最多观察者不能大于 128
256 if (mSensorListeners.size() >= MAX_LISTENER_COUNT) {
257 throw new IllegalStateException("register failed, "
258 + "the sensor listeners size has exceeded the maximum limit "
259 + MAX_LISTENER_COUNT);
260 }
261
262 // Invariants to preserve:
263 // - one Looper per SensorEventListener
264 // - one Looper per SensorEventQueue
265 // We map SensorEventListener to a SensorEventQueue, which holds the looper
266 synchronized (mSensorListeners) {
267 SensorEventQueue queue = mSensorListeners.get(listener);
// que 的值为 空
268 if (queue == null) {
269 Looper looper = (handler != null) ? handler.getLooper() : mMainLooper;
270 final String fullClassName =
271 listener.getClass().getEnclosingClass() != null
272 ? listener.getClass().getEnclosingClass().getName()
273 : listener.getClass().getName();
// 1）创建 SensorEventQueue 对象
274 queue = new SensorEventQueue(listener, looper, this, fullClassName);
// 2）调用 SensorEventQueue 的 addSensor 方法
275 if (!queue.addSensor(sensor, delayUs, maxBatchReportLatencyUs)) {
276 queue.dispose();
277 return false;
278 }
279 mSensorListeners.put(listener, queue);
280 return true;
281 } else {
282 return queue.addSensor(sensor, delayUs, maxBatchReportLatencyUs);
283 }
284 }
285 }
1）创建 SensorEventQueue 对象
940 static final class SensorEventQueue extends BaseEventQueue {
941 private final SensorEventListener mListener;
942 private final SparseArray<SensorEvent> mSensorsEvents = new SparseArray<SensorEvent>();
943
944 public SensorEventQueue(SensorEventListener listener, Looper looper,
945 SystemSensorManager manager, String packageName) {
// 调用父类的构造方法
946 super(looper, manager, OPERATING_MODE_NORMAL, packageName);
// 缓存了 mListener 监听回调
947 mListener = listener;
948 }
// 调用父类的构造方法
802 BaseEventQueue(Looper looper, SystemSensorManager manager, int mode, String packageName) {
803 if (packageName == null) packageName = "";
// mode为 OPERATING_MODE_NORMAL
804 mNativeSensorEventQueue = nativeInitBaseEventQueue(manager.mNativeInstance,
805 new WeakReference<>(this), looper.getQueue(),
806 packageName, mode, manager.mContext.getOpPackageName(),
807 manager.mContext.getAttributionTag());
808 mCloseGuard.open("BaseEventQueue.dispose");
809 mManager = manager;
810 }
// 初始化 eventqueue
457 static jlong nativeInitSensorEventQueue(JNIEnv *env, jclass clazz, jlong sensorManager,
458 jobject eventQWeak, jobject msgQ, jstring packageName,
459 jint mode, jstring opPackageName, jstring attributionTag) {
460 SensorManager* mgr = reinterpret_cast<SensorManager*>(sensorManager);
461 ScopedUtfChars packageUtf(env, packageName);
462 String8 clientName(packageUtf.c_str());
463
464 String16 attributionTagName("");
465 if (attributionTag != nullptr) {
466 ScopedUtfChars attrUtf(env, attributionTag);
467 attributionTagName = String16(attrUtf.c_str());
468 }
// 1-2）createEventQueue 创建 SensorEventQueue
469 sp<SensorEventQueue> queue(mgr->createEventQueue(clientName, mode, attributionTagName));
470
471 if (queue == NULL) {
472 jniThrowRuntimeException(env, "Cannot construct native SensorEventQueue.");
473 return 0;
474 }
475
476 sp<MessageQueue> messageQueue = android_os_MessageQueue_getMessageQueue(env, msgQ);
477 if (messageQueue == NULL) {
478 jniThrowRuntimeException(env, "MessageQueue is not initialized.");
479 return 0;
480 }
481
// 1-3）创建 Receiver 对象，传入了 SensorEventQueue 对象
482 sp<Receiver> receiver = new Receiver(queue, messageQueue, eventQWeak);
483 receiver->incStrong((void*)nativeInitSensorEventQueue);
484 return jlong(receiver.get());
485 }
// 1-2）createEventQueue 创建 SensorEventQueue
/frameworks/native/libs/sensor/SensorManager.cpp
286 sp<SensorEventQueue> SensorManager::createEventQueue(
287 String8 packageName, int mode, String16 attributionTag) {
288 sp<SensorEventQueue> queue;
289
290 Mutex::Autolock _l(mLock);
291 while (assertStateLocked() == NO_ERROR) {
// 1-2-1）createSensorEventConnection创建 ISensorEventConnection
292 sp<ISensorEventConnection> connection = mSensorServer->createSensorEventConnection(
293 packageName, mode, mOpPackageName, attributionTag);
294 if (connection == nullptr) {
295 // SensorService just died or the app doesn't have required permissions.
296 ALOGE("createEventQueue: connection is NULL.");
297 return nullptr;
298 }
// 1-2-2）创建 SensorEventQueue 对象
299 queue = new SensorEventQueue(connection);
300 break;
301 }
302 return queue;
303 }
// 1-2-1）createSensorEventConnection创建 ISensorEventConnection
// 与sensorservice binder通信设置与应用socket 通信
/frameworks/native/services/sensorservice/SensorService.cpp
1495 sp<ISensorEventConnection> SensorService::createSensorEventConnection(const String8& packageName,
1496 int requestedMode, const String16& opPackageName, const String16& attributionTag) {
1497 // Only 3 modes supported for a SensorEventConnection ... NORMAL, DATA_INJECTION and
1498 // REPLAY_DATA_INJECTION.
1499 if (requestedMode != NORMAL && requestedMode != DATA_INJECTION &&
1500 requestedMode != REPLAY_DATA_INJECTION) {
1501 return nullptr;
1502 }
1503 resetTargetSdkVersionCache(opPackageName);
1504
1505 Mutex::Autolock _l(mLock);
1506 // To create a client in DATA_INJECTION mode to inject data, SensorService should already be
1507 // operating in DI mode.
1508 if (requestedMode == DATA_INJECTION) {
1509 if (mCurrentOperatingMode != DATA_INJECTION) return nullptr;
1510 if (!isAllowListedPackage(packageName)) return nullptr;
1511 }
1512
1513 uid_t uid = IPCThreadState::self()->getCallingUid();
1514 pid_t pid = IPCThreadState::self()->getCallingPid();
1515
1516 String8 connPackageName =
1517 (packageName == "") ? String8::format("unknown_package_pid_%d", pid) : packageName;
1518 String16 connOpPackageName =
1519 (opPackageName == String16("")) ? String16(connPackageName) : opPackageName;
// 创建了 SensorEventConnection 对象，requestedMode 为normal
1520 sp<SensorEventConnection> result(new SensorEventConnection(this, uid, connPackageName,
1521 requestedMode == DATA_INJECTION || requestedMode == REPLAY_DATA_INJECTION,
1522 connOpPackageName, attributionTag));
1523 if (requestedMode == DATA_INJECTION || requestedMode == REPLAY_DATA_INJECTION) {
1524 mConnectionHolder.addEventConnectionIfNotPresent(result);
1525 // Add the associated file descriptor to the Looper for polling whenever there is data to
1526 // be injected.
1527 result->updateLooperRegistration(mLooper);
1528 }
1529 return result;
1530 }
// 创建了 SensorEventConnection 对象，
/frameworks/native/services/sensorservice/SensorEventConnection.cpp
40 SensorService::SensorEventConnection::SensorEventConnection(
41 const sp<SensorService>& service, uid_t uid, String8 packageName, bool isDataInjectionMode,
42 const String16& opPackageName, const String16& attributionTag)
43 : mService(service), mUid(uid), mWakeLockRefCount(0), mHasLooperCallbacks(false),
44 mDead(false), mDataInjectionMode(isDataInjectionMode), mEventCache(nullptr),
45 mCacheSize(0), mMaxCacheSize(0), mTimeOfLastEventDrop(0), mEventsDropped(0),
46 mPackageName(packageName), mOpPackageName(opPackageName), mAttributionTag(attributionTag),
47 mTargetSdk(kTargetSdkUnknown), mDestroyed(false) {
48 mUserId = multiuser_get_user_id(mUid);
// 创建了 BitTube，用于客户端与sensorservice 进程通信
49 mChannel = new BitTube(mService->mSocketBufferSize);
50 #if DEBUG_CONNECTIONS
51 mEventsReceived = mEventsSentFromCache = mEventsSent = 0;
52 mTotalAcksNeeded = mTotalAcksReceived = 0;
53 #endif
54 }
// 创建了 BitTube，用于客户端与sensorservice 进程通信
/frameworks/native/libs/sensor/BitTube.cpp
42 BitTube::BitTube(size_t bufsize)
43 : mSendFd(-1), mReceiveFd(-1)
44 {
45 init(bufsize, bufsize);
46 }
// 初始化，在系统进程 sensorservice 初始化 socket 通信
68 void BitTube::init(size_t rcvbuf, size_t sndbuf) {
69 int sockets[2];
70 if (socketpair(AF_UNIX, SOCK_SEQPACKET, 0, sockets) == 0) {
71 size_t size = DEFAULT_SOCKET_BUFFER_SIZE;
72 setsockopt(sockets[0], SOL_SOCKET, SO_RCVBUF, &rcvbuf, sizeof(rcvbuf));
73 setsockopt(sockets[1], SOL_SOCKET, SO_SNDBUF, &sndbuf, sizeof(sndbuf));
74 // sine we don't use the "return channel", we keep it small...
75 setsockopt(sockets[0], SOL_SOCKET, SO_SNDBUF, &size, sizeof(size));
76 setsockopt(sockets[1], SOL_SOCKET, SO_RCVBUF, &size, sizeof(size));
77 fcntl(sockets[0], F_SETFL, O_NONBLOCK);
78 fcntl(sockets[1], F_SETFL, O_NONBLOCK);
// 设置接收的fd，接收客户端信息
79 mReceiveFd = sockets[0];
// 设置发送的fd
80 mSendFd = sockets[1];
81 } else {
82 mReceiveFd = -errno;
83 ALOGE("BitTube: pipe creation failed (%s)", strerror(-mReceiveFd));
84 }
85 }
// 1-2-2）创建 SensorEventQueue 对象
/frameworks/native/libs/sensor/SensorEventQueue.cpp
// 缓存 mSensorEventConnection
40 SensorEventQueue::SensorEventQueue(const sp<ISensorEventConnection>& connection)
41 : mSensorEventConnection(connection), mRecBuffer(nullptr), mAvailable(0), mConsumed(0),
42 mNumAcksToSend(0) {
// mRecBuffer 用于保存sensor信息
43 mRecBuffer = new ASensorEvent[MAX_RECEIVE_BUFFER_EVENT_COUNT];
44 }50 void SensorEventQueue::onFirstRef()
51 {
// 获取socket通信创建的channel ，BitTube
52 mSensorChannel = mSensorEventConnection->getSensorChannel();
53 }
// 1-3）创建 Receiver 对象，传入了 SensorEventQueue 对象
// Receiver 继承了 LooperCallback
327 class Receiver : public LooperCallback {
328 sp<SensorEventQueue> mSensorQueue;
329 sp<MessageQueue> mMessageQueue;
330 jobject mReceiverWeakGlobal;
331 jfloatArray mFloatScratch;
332 jintArray mIntScratch;
333 public:
334 Receiver(const sp<SensorEventQueue>& sensorQueue,
335 const sp<MessageQueue>& messageQueue,
336 jobject receiverWeak) {
337 JNIEnv* env = AndroidRuntime::getJNIEnv();
// 缓存 SensorEventQueue 和 MessageQueue
338 mSensorQueue = sensorQueue;
339 mMessageQueue = messageQueue;
340 mReceiverWeakGlobal = env->NewGlobalRef(receiverWeak);
341
342 mIntScratch = (jintArray) env->NewGlobalRef(env->NewIntArray(16));
343 mFloatScratch = (jfloatArray) env->NewGlobalRef(env->NewFloatArray(16));
344 }
// 初始化方法
359 private:
360 virtual void onFirstRef() {
361 LooperCallback::onFirstRef();
// 从 BitTube获取到接收端的fd：mReceiveFd；当sensorservice 发送信息的时候，会触发回调 handleEvent
362 mMessageQueue->getLooper()->addFd(mSensorQueue->getFd(), 0,
363 ALOOPER_EVENT_INPUT, this, mSensorQueue.get());
364 }
2）调用 SensorEventQueue 的 addSensor 方法
/frameworks/base/core/java/android/hardware/SystemSensorManager.java
780 private abstract static class BaseEventQueue {
。。。
816 public boolean addSensor(
817 Sensor sensor, int delayUs, int maxBatchReportLatencyUs) {
818 // Check if already present.
819 int handle = sensor.getHandle();
// 将sensor使能，如果使能了，则返回为false
820 if (mActiveSensors.get(handle)) return false;
821
822 // Get ready to receive events before calling enable.
823 mActiveSensors.put(handle, true);
824 addSensorEvent(sensor);
// enableSensor 使能sensor
825 if (enableSensor(sensor, delayUs, maxBatchReportLatencyUs) != 0) {
826 // Try continuous mode if batching fails.
827 if (maxBatchReportLatencyUs == 0
828 || maxBatchReportLatencyUs > 0 && enableSensor(sensor, delayUs, 0) != 0) {
829 removeSensor(sensor, false);
830 return false;
831 }
832 }
833 return true;
834 }
// enableSensor 使能sensor
896 private int enableSensor(
897 Sensor sensor, int rateUs, int maxBatchReportLatencyUs) {
898 if (mNativeSensorEventQueue == 0) throw new NullPointerException();
899 if (sensor == null) throw new NullPointerException();
900 if (mManager.isSensorInCappedSet(sensor.getType())
901 && rateUs < CAPPED_SAMPLING_PERIOD_US
902 && mManager.mIsPackageDebuggable
903 && !mManager.hasHighSamplingRateSensorsPermission()
904 && Compatibility.isChangeEnabled(CHANGE_ID_SAMPLING_RATE_SENSORS_PERMISSION)) {
905 throw new SecurityException("To use the sampling rate of " + rateUs
906 + " microseconds, app needs to declare the normal permission"
907 + " HIGH_SAMPLING_RATE_SENSORS.");
908 }
// 调用native 层的方法
909 return nativeEnableSensor(mNativeSensorEventQueue, sensor.getHandle(), rateUs,
910 maxBatchReportLatencyUs);
911 }
/frameworks/base/core/jni/android_hardware_SensorManager.cpp
487 static jint nativeEnableSensor(JNIEnv *env, jclass clazz, jlong eventQ, jint handle, jint rate_us,
488 jint maxBatchReportLatency) {
489 sp<Receiver> receiver(reinterpret_cast<Receiver *>(eventQ));
// 通过 SensorEventQueue 去使能sensor
490 return receiver->getSensorEventQueue()->enableSensor(handle, rate_us, maxBatchReportLatency,
491 0);
492 }
// 通过 SensorEventQueue 去使能sensor
/frameworks/native/libs/sensor/SensorEventQueue.cpp
138 status_t SensorEventQueue::enableSensor(int32_t handle, int32_t samplingPeriodUs,
139 int64_t maxBatchReportLatencyUs, int reservedFlags) const {
140 return mSensorEventConnection->enableDisable(handle, true, us2ns(samplingPeriodUs),
141 us2ns(maxBatchReportLatencyUs), reservedFlags);
142 }
// mSensorEventConnection 是与sensorservice binder 通信的接口
/frameworks/native/services/sensorservice/SensorEventConnection.cpp
681 status_t SensorService::SensorEventConnection::enableDisable(
682 int handle, bool enabled, nsecs_t samplingPeriodNs, nsecs_t maxBatchReportLatencyNs,
683 int reservedFlags)
684 {
685 if (mDestroyed) {
686 android_errorWriteLog(0x534e4554, "168211968");
687 return DEAD_OBJECT;
688 }
689
690 status_t err;
691 if (enabled) {
692 nsecs_t requestedSamplingPeriodNs = samplingPeriodNs;
693 bool isSensorCapped = false;
694 std::shared_ptr<SensorInterface> si = mService->getSensorInterfaceFromHandle(handle);
695 if (si != nullptr) {
696 const Sensor& s = si->getSensor();
697 if (mService->isSensorInCappedSet(s.getType())) {
698 isSensorCapped = true;
699 }
700 }
701 if (isSensorCapped) {
702 err = mService->adjustSamplingPeriodBasedOnMicAndPermission(&samplingPeriodNs,
703 String16(mOpPackageName));
704 if (err != OK) {
705 return err;
706 }
707 }
// 如果enable为true，使能的话，则调用sensorservice 的enable方法
708 err = mService->enable(this, handle, samplingPeriodNs, maxBatchReportLatencyNs,
709 reservedFlags, mOpPackageName);
710 if (err == OK && isSensorCapped) {
711 if ((requestedSamplingPeriodNs >= SENSOR_SERVICE_CAPPED_SAMPLING_PERIOD_NS) ||
712 !isRateCappedBasedOnPermission()) {
713 mMicSamplingPeriodBackup[handle] = requestedSamplingPeriodNs;
714 } else {
715 mMicSamplingPeriodBackup[handle] = SENSOR_SERVICE_CAPPED_SAMPLING_PERIOD_NS;
716 }
717 }
718
719 } else {
// 不使能，则调用disable方法
720 err = mService->disable(this, handle);
721 mMicSamplingPeriodBackup.erase(handle);
722 }
723 return err;
724 }
// 如果enable为true，使能的话，则调用sensorservice 的anable方法
/frameworks/native/services/sensorservice/SensorService.cpp
1921 status_t SensorService::enable(const sp<SensorEventConnection>& connection,
1922 int handle, nsecs_t samplingPeriodNs, nsecs_t maxBatchReportLatencyNs, int reservedFlags,
1923 const String16& opPackageName) {
1924 if (mInitCheck != NO_ERROR)
1925 return mInitCheck;
1926
// 从sensorlist 中获取对应handle 传感器的接口
1927 std::shared_ptr<SensorInterface> sensor = getSensorInterfaceFromHandle(handle);
1928 if (sensor == nullptr ||
1929 !canAccessSensor(sensor->getSensor(), "Tried enabling", opPackageName)) {
1930 return BAD_VALUE;
1931 }
。。。
// 先调用了 batch 方法；大概率是设置了采样周期之类的
2018 status_t err = sensor->batch(connection.get(), handle, 0, samplingPeriodNs,
2019 maxBatchReportLatencyNs);
。。。。
2040 if (err == NO_ERROR) {
2041 ALOGD_IF(DEBUG_CONNECTIONS, "Calling activate on %d", handle);
// 调用 activate方法
2042 err = sensor->activate(connection.get(), true);
2043 }
// 对应的 SensorInterface 接口为如下：为 HardwareSensor
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();
343 if (registerSensor(std::move(s))) {
344 mProxSensorHandles.push_back(handle);
345 }
346 } else {
// 如下注册了对应的sensor，对应的 为 HardwareSensor
347 registerSensor(std::make_shared<HardwareSensor>(list[i]));
348 }
// 调用HardwareSensor的 activate方法
/frameworks/native/services/sensorservice/SensorInterface.cpp
// 通过 SensorDevice 去使能对应的sensor 的handle，找到对应的sensor
// ident为 SensorEventConnection
62 status_t HardwareSensor::activate(void* ident, bool enabled) {
63 return mSensorDevice.activate(ident, mSensor.getHandle(), enabled);
64 }
/frameworks/native/services/sensorservice/SensorDevice.cpp
437 status_t SensorDevice::activate(void* ident, int handle, int enabled) {
438 if (mHalWrapper == nullptr) return NO_INIT;
439
440 Mutex::Autolock _l(mLock);
441 return activateLocked(ident, handle, enabled);
442 }
444 status_t SensorDevice::activateLocked(void* ident, int handle, int enabled) {
445 bool activateHardware = false;
446
447 status_t err(NO_ERROR);
448
449 ssize_t activationIndex = mActivationCount.indexOfKey(handle);
450 if (activationIndex < 0) {
451 ALOGW("Handle %d cannot be found in activation record", handle);
452 return BAD_VALUE;
453 }
454 Info& info(mActivationCount.editValueAt(activationIndex));
455
456 ALOGD_IF(DEBUG_CONNECTIONS,
457 "SensorDevice::activate: ident=%p, handle=0x%08x, enabled=%d, count=%zu", ident,
458 handle, enabled, info.batchParams.size());
459
460 if (enabled) {
461 ALOGD_IF(DEBUG_CONNECTIONS, "enable index=%zd", info.batchParams.indexOfKey(ident));
462
463 if (isClientDisabledLocked(ident)) {
464 ALOGW("SensorDevice::activate, isClientDisabledLocked(%p):true, handle:%d", ident,
465 handle);
466 return NO_ERROR;
467 }
468
469 if (info.batchParams.indexOfKey(ident) >= 0) {
470 if (info.numActiveClients() > 0 && !info.isActive) {
471 activateHardware = true;
472 }
。。。。
509 if (activateHardware) {
510 err = doActivateHardwareLocked(handle, enabled);
526 status_t SensorDevice::doActivateHardwareLocked(int handle, bool enabled) {
527 ALOGD_IF(DEBUG_CONNECTIONS, "\t>>> actuating h/w activate handle=%d enabled=%d", handle,
528 enabled);
529 status_t err = mHalWrapper->activate(handle, enabled);
530 ALOGE_IF(err, "Error %s sensor %d (%s)", enabled ? "activating" : "disabling", handle,
531 strerror(-err));
532 return err;
533 }
/frameworks/native/services/sensorservice/AidlSensorHalWrapper.cpp
227 status_t AidlSensorHalWrapper::activate(int32_t sensorHandle, bool enabled) {
228 if (mSensors == nullptr) return NO_INIT;
// 调用aidl binder 通信去激活sensor
229 return convertToStatus(mSensors->activate(sensorHandle, enabled));
230 }
/hardware/interfaces/sensors/aidl/default/multihal/HalProxyAidl.cpp
122 ScopedAStatus HalProxyAidl::activate(int32_t in_sensorHandle, bool in_enabled) {
123 return resultToAStatus(HalProxy::activate(in_sensorHandle, in_enabled));
124 }
/hardware/interfaces/sensors/common/default/2.X/multihal/HalProxy.cpp
161 Return<Result> HalProxy::activate(int32_t sensorHandle, bool enabled) {
162 if (!isSubHalIndexValid(sensorHandle)) {
163 return Result::BAD_VALUE;
164 }
// 下列会通过hal层去设置使能传感器了
165 return getSubHalForSensorHandle(sensorHandle)
166 ->activate(clearSubHalIndex(sensorHandle), enabled);
167 }