blob: 7c526616019da1e565673d5e1a27ef0fd0d7caa7 [file] [log] [blame]
Stan Rokita2e37ec442019-07-30 11:35:48 -04001/*
2 * Copyright (C) 2019 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#include "HalProxy.h"
18
19#include "SubHal.h"
20
21#include <android/hardware/sensors/2.0/types.h>
22
23#include <android-base/file.h>
24#include "hardware_legacy/power.h"
25
26#include <dlfcn.h>
27
28#include <cinttypes>
29#include <cmath>
30#include <fstream>
31#include <functional>
32#include <thread>
33
34namespace android {
35namespace hardware {
36namespace sensors {
37namespace V2_0 {
38namespace implementation {
39
40using ::android::hardware::sensors::V2_0::EventQueueFlagBits;
41using ::android::hardware::sensors::V2_0::WakeLockQueueFlagBits;
42using ::android::hardware::sensors::V2_0::implementation::getTimeNow;
43using ::android::hardware::sensors::V2_0::implementation::kWakelockTimeoutNs;
44
45typedef ISensorsSubHal*(SensorsHalGetSubHalFunc)(uint32_t*);
46
47static constexpr int32_t kBitsAfterSubHalIndex = 24;
48
49/**
50 * Set the subhal index as first byte of sensor handle and return this modified version.
51 *
52 * @param sensorHandle The sensor handle to modify.
53 * @param subHalIndex The index in the hal proxy of the sub hal this sensor belongs to.
54 *
55 * @return The modified sensor handle.
56 */
57int32_t setSubHalIndex(int32_t sensorHandle, size_t subHalIndex) {
58 return sensorHandle | (static_cast<int32_t>(subHalIndex) << kBitsAfterSubHalIndex);
59}
60
61/**
62 * Extract the subHalIndex from sensorHandle.
63 *
64 * @param sensorHandle The sensorHandle to extract from.
65 *
66 * @return The subhal index.
67 */
68size_t extractSubHalIndex(int32_t sensorHandle) {
69 return static_cast<size_t>(sensorHandle >> kBitsAfterSubHalIndex);
70}
71
72/**
73 * Convert nanoseconds to milliseconds.
74 *
75 * @param nanos The nanoseconds input.
76 *
77 * @return The milliseconds count.
78 */
79int64_t msFromNs(int64_t nanos) {
80 constexpr int64_t nanosecondsInAMillsecond = 1000000;
81 return nanos / nanosecondsInAMillsecond;
82}
83
84HalProxy::HalProxy() {
85 const char* kMultiHalConfigFile = "/vendor/etc/sensors/hals.conf";
86 initializeSubHalListFromConfigFile(kMultiHalConfigFile);
87 init();
88}
89
90HalProxy::HalProxy(std::vector<ISensorsSubHal*>& subHalList) : mSubHalList(subHalList) {
91 init();
92}
93
94HalProxy::~HalProxy() {
95 stopThreads();
96}
97
98Return<void> HalProxy::getSensorsList(getSensorsList_cb _hidl_cb) {
99 std::vector<SensorInfo> sensors;
100 for (const auto& iter : mSensors) {
101 sensors.push_back(iter.second);
102 }
103 _hidl_cb(sensors);
104 return Void();
105}
106
107Return<Result> HalProxy::setOperationMode(OperationMode mode) {
108 Result result = Result::OK;
109 size_t subHalIndex;
110 for (subHalIndex = 0; subHalIndex < mSubHalList.size(); subHalIndex++) {
111 ISensorsSubHal* subHal = mSubHalList[subHalIndex];
112 result = subHal->setOperationMode(mode);
113 if (result != Result::OK) {
114 ALOGE("setOperationMode failed for SubHal: %s", subHal->getName().c_str());
115 break;
116 }
117 }
118 if (result != Result::OK) {
119 // Reset the subhal operation modes that have been flipped
120 for (size_t i = 0; i < subHalIndex; i++) {
121 ISensorsSubHal* subHal = mSubHalList[i];
122 subHal->setOperationMode(mCurrentOperationMode);
123 }
124 } else {
125 mCurrentOperationMode = mode;
126 }
127 return result;
128}
129
130Return<Result> HalProxy::activate(int32_t sensorHandle, bool enabled) {
131 if (!isSubHalIndexValid(sensorHandle)) {
132 return Result::BAD_VALUE;
133 }
134 return getSubHalForSensorHandle(sensorHandle)
135 ->activate(clearSubHalIndex(sensorHandle), enabled);
136}
137
138Return<Result> HalProxy::initialize(
139 const ::android::hardware::MQDescriptorSync<Event>& eventQueueDescriptor,
140 const ::android::hardware::MQDescriptorSync<uint32_t>& wakeLockDescriptor,
141 const sp<ISensorsCallback>& sensorsCallback) {
142 Result result = Result::OK;
143
144 stopThreads();
145 resetSharedWakelock();
146
147 // So that the pending write events queue can be cleared safely and when we start threads
148 // again we do not get new events until after initialize resets the subhals.
149 disableAllSensors();
150
151 // Clears the queue if any events were pending write before.
152 mPendingWriteEventsQueue = std::queue<std::pair<std::vector<Event>, size_t>>();
Stan Rokita5098f0a2019-11-04 13:36:54 -0800153 mSizePendingWriteEventsQueue = 0;
Stan Rokita2e37ec442019-07-30 11:35:48 -0400154
155 // Clears previously connected dynamic sensors
156 mDynamicSensors.clear();
157
158 mDynamicSensorsCallback = sensorsCallback;
159
160 // Create the Event FMQ from the eventQueueDescriptor. Reset the read/write positions.
161 mEventQueue =
162 std::make_unique<EventMessageQueue>(eventQueueDescriptor, true /* resetPointers */);
163
164 // Create the Wake Lock FMQ that is used by the framework to communicate whenever WAKE_UP
165 // events have been successfully read and handled by the framework.
166 mWakeLockQueue =
167 std::make_unique<WakeLockMessageQueue>(wakeLockDescriptor, true /* resetPointers */);
168
169 if (mEventQueueFlag != nullptr) {
170 EventFlag::deleteEventFlag(&mEventQueueFlag);
171 }
172 if (mWakelockQueueFlag != nullptr) {
173 EventFlag::deleteEventFlag(&mWakelockQueueFlag);
174 }
175 if (EventFlag::createEventFlag(mEventQueue->getEventFlagWord(), &mEventQueueFlag) != OK) {
176 result = Result::BAD_VALUE;
177 }
178 if (EventFlag::createEventFlag(mWakeLockQueue->getEventFlagWord(), &mWakelockQueueFlag) != OK) {
179 result = Result::BAD_VALUE;
180 }
181 if (!mDynamicSensorsCallback || !mEventQueue || !mWakeLockQueue || mEventQueueFlag == nullptr) {
182 result = Result::BAD_VALUE;
183 }
184
185 mThreadsRun.store(true);
186
187 mPendingWritesThread = std::thread(startPendingWritesThread, this);
188 mWakelockThread = std::thread(startWakelockThread, this);
189
190 for (size_t i = 0; i < mSubHalList.size(); i++) {
191 auto subHal = mSubHalList[i];
192 const auto& subHalCallback = mSubHalCallbacks[i];
193 Result currRes = subHal->initialize(subHalCallback);
194 if (currRes != Result::OK) {
195 result = currRes;
196 ALOGE("Subhal '%s' failed to initialize.", subHal->getName().c_str());
197 break;
198 }
199 }
200
201 mCurrentOperationMode = OperationMode::NORMAL;
202
203 return result;
204}
205
206Return<Result> HalProxy::batch(int32_t sensorHandle, int64_t samplingPeriodNs,
207 int64_t maxReportLatencyNs) {
208 if (!isSubHalIndexValid(sensorHandle)) {
209 return Result::BAD_VALUE;
210 }
211 return getSubHalForSensorHandle(sensorHandle)
212 ->batch(clearSubHalIndex(sensorHandle), samplingPeriodNs, maxReportLatencyNs);
213}
214
215Return<Result> HalProxy::flush(int32_t sensorHandle) {
216 if (!isSubHalIndexValid(sensorHandle)) {
217 return Result::BAD_VALUE;
218 }
219 return getSubHalForSensorHandle(sensorHandle)->flush(clearSubHalIndex(sensorHandle));
220}
221
222Return<Result> HalProxy::injectSensorData(const Event& event) {
223 Result result = Result::OK;
224 if (mCurrentOperationMode == OperationMode::NORMAL &&
225 event.sensorType != V1_0::SensorType::ADDITIONAL_INFO) {
226 ALOGE("An event with type != ADDITIONAL_INFO passed to injectSensorData while operation"
227 " mode was NORMAL.");
228 result = Result::BAD_VALUE;
229 }
230 if (result == Result::OK) {
231 Event subHalEvent = event;
232 if (!isSubHalIndexValid(event.sensorHandle)) {
233 return Result::BAD_VALUE;
234 }
235 subHalEvent.sensorHandle = clearSubHalIndex(event.sensorHandle);
236 result = getSubHalForSensorHandle(event.sensorHandle)->injectSensorData(subHalEvent);
237 }
238 return result;
239}
240
241Return<void> HalProxy::registerDirectChannel(const SharedMemInfo& mem,
242 registerDirectChannel_cb _hidl_cb) {
243 if (mDirectChannelSubHal == nullptr) {
244 _hidl_cb(Result::INVALID_OPERATION, -1 /* channelHandle */);
245 } else {
246 mDirectChannelSubHal->registerDirectChannel(mem, _hidl_cb);
247 }
248 return Return<void>();
249}
250
251Return<Result> HalProxy::unregisterDirectChannel(int32_t channelHandle) {
252 Result result;
253 if (mDirectChannelSubHal == nullptr) {
254 result = Result::INVALID_OPERATION;
255 } else {
256 result = mDirectChannelSubHal->unregisterDirectChannel(channelHandle);
257 }
258 return result;
259}
260
261Return<void> HalProxy::configDirectReport(int32_t sensorHandle, int32_t channelHandle,
262 RateLevel rate, configDirectReport_cb _hidl_cb) {
263 if (mDirectChannelSubHal == nullptr) {
264 _hidl_cb(Result::INVALID_OPERATION, -1 /* reportToken */);
265 } else {
266 mDirectChannelSubHal->configDirectReport(clearSubHalIndex(sensorHandle), channelHandle,
267 rate, _hidl_cb);
268 }
269 return Return<void>();
270}
271
272Return<void> HalProxy::debug(const hidl_handle& fd, const hidl_vec<hidl_string>& /*args*/) {
273 if (fd.getNativeHandle() == nullptr || fd->numFds < 1) {
274 ALOGE("%s: missing fd for writing", __FUNCTION__);
275 return Void();
276 }
277
278 android::base::borrowed_fd writeFd = dup(fd->data[0]);
279
280 std::ostringstream stream;
281 stream << "===HalProxy===" << std::endl;
282 stream << "Internal values:" << std::endl;
283 stream << " Threads are running: " << (mThreadsRun.load() ? "true" : "false") << std::endl;
284 int64_t now = getTimeNow();
285 stream << " Wakelock timeout start time: " << msFromNs(now - mWakelockTimeoutStartTime)
286 << " ms ago" << std::endl;
287 stream << " Wakelock timeout reset time: " << msFromNs(now - mWakelockTimeoutResetTime)
288 << " ms ago" << std::endl;
289 // TODO(b/142969448): Add logging for history of wakelock acquisition per subhal.
290 stream << " Wakelock ref count: " << mWakelockRefCount << std::endl;
Stan Rokita5098f0a2019-11-04 13:36:54 -0800291 stream << " # of events on pending write writes queue: " << mSizePendingWriteEventsQueue
Stan Rokita2e37ec442019-07-30 11:35:48 -0400292 << std::endl;
293 if (!mPendingWriteEventsQueue.empty()) {
294 stream << " Size of events list on front of pending writes queue: "
295 << mPendingWriteEventsQueue.front().first.size() << std::endl;
296 }
297 stream << " # of non-dynamic sensors across all subhals: " << mSensors.size() << std::endl;
298 stream << " # of dynamic sensors across all subhals: " << mDynamicSensors.size() << std::endl;
299 stream << "SubHals (" << mSubHalList.size() << "):" << std::endl;
300 for (ISensorsSubHal* subHal : mSubHalList) {
301 stream << " Name: " << subHal->getName() << std::endl;
302 stream << " Debug dump: " << std::endl;
303 android::base::WriteStringToFd(stream.str(), writeFd);
304 subHal->debug(fd, {});
305 stream.str("");
306 stream << std::endl;
307 }
308 android::base::WriteStringToFd(stream.str(), writeFd);
309 return Return<void>();
310}
311
312Return<void> HalProxy::onDynamicSensorsConnected(const hidl_vec<SensorInfo>& dynamicSensorsAdded,
313 int32_t subHalIndex) {
314 std::vector<SensorInfo> sensors;
315 {
316 std::lock_guard<std::mutex> lock(mDynamicSensorsMutex);
317 for (SensorInfo sensor : dynamicSensorsAdded) {
318 if (!subHalIndexIsClear(sensor.sensorHandle)) {
319 ALOGE("Dynamic sensor added %s had sensorHandle with first byte not 0.",
320 sensor.name.c_str());
321 } else {
322 sensor.sensorHandle = setSubHalIndex(sensor.sensorHandle, subHalIndex);
323 mDynamicSensors[sensor.sensorHandle] = sensor;
324 sensors.push_back(sensor);
325 }
326 }
327 }
328 mDynamicSensorsCallback->onDynamicSensorsConnected(sensors);
329 return Return<void>();
330}
331
332Return<void> HalProxy::onDynamicSensorsDisconnected(
333 const hidl_vec<int32_t>& dynamicSensorHandlesRemoved, int32_t subHalIndex) {
334 // TODO(b/143302327): Block this call until all pending events are flushed from queue
335 std::vector<int32_t> sensorHandles;
336 {
337 std::lock_guard<std::mutex> lock(mDynamicSensorsMutex);
338 for (int32_t sensorHandle : dynamicSensorHandlesRemoved) {
339 if (!subHalIndexIsClear(sensorHandle)) {
340 ALOGE("Dynamic sensorHandle removed had first byte not 0.");
341 } else {
342 sensorHandle = setSubHalIndex(sensorHandle, subHalIndex);
343 if (mDynamicSensors.find(sensorHandle) != mDynamicSensors.end()) {
344 mDynamicSensors.erase(sensorHandle);
345 sensorHandles.push_back(sensorHandle);
346 }
347 }
348 }
349 }
350 mDynamicSensorsCallback->onDynamicSensorsDisconnected(sensorHandles);
351 return Return<void>();
352}
353
354void HalProxy::initializeSubHalListFromConfigFile(const char* configFileName) {
355 std::ifstream subHalConfigStream(configFileName);
356 if (!subHalConfigStream) {
357 ALOGE("Failed to load subHal config file: %s", configFileName);
358 } else {
359 std::string subHalLibraryFile;
360 while (subHalConfigStream >> subHalLibraryFile) {
361 void* handle = dlopen(subHalLibraryFile.c_str(), RTLD_NOW);
362 if (handle == nullptr) {
363 ALOGE("dlopen failed for library: %s", subHalLibraryFile.c_str());
364 } else {
365 SensorsHalGetSubHalFunc* sensorsHalGetSubHalPtr =
366 (SensorsHalGetSubHalFunc*)dlsym(handle, "sensorsHalGetSubHal");
367 if (sensorsHalGetSubHalPtr == nullptr) {
368 ALOGE("Failed to locate sensorsHalGetSubHal function for library: %s",
369 subHalLibraryFile.c_str());
370 } else {
371 std::function<SensorsHalGetSubHalFunc> sensorsHalGetSubHal =
372 *sensorsHalGetSubHalPtr;
373 uint32_t version;
374 ISensorsSubHal* subHal = sensorsHalGetSubHal(&version);
375 if (version != SUB_HAL_2_0_VERSION) {
376 ALOGE("SubHal version was not 2.0 for library: %s",
377 subHalLibraryFile.c_str());
378 } else {
379 ALOGV("Loaded SubHal from library: %s", subHalLibraryFile.c_str());
380 mSubHalList.push_back(subHal);
381 }
382 }
383 }
384 }
385 }
386}
387
388void HalProxy::initializeSubHalCallbacks() {
389 for (size_t subHalIndex = 0; subHalIndex < mSubHalList.size(); subHalIndex++) {
390 sp<IHalProxyCallback> callback = new HalProxyCallback(this, subHalIndex);
391 mSubHalCallbacks.push_back(callback);
392 }
393}
394
395void HalProxy::initializeSensorList() {
396 for (size_t subHalIndex = 0; subHalIndex < mSubHalList.size(); subHalIndex++) {
397 ISensorsSubHal* subHal = mSubHalList[subHalIndex];
398 auto result = subHal->getSensorsList([&](const auto& list) {
399 for (SensorInfo sensor : list) {
400 if (!subHalIndexIsClear(sensor.sensorHandle)) {
401 ALOGE("SubHal sensorHandle's first byte was not 0");
402 } else {
403 ALOGV("Loaded sensor: %s", sensor.name.c_str());
404 sensor.sensorHandle = setSubHalIndex(sensor.sensorHandle, subHalIndex);
405 setDirectChannelFlags(&sensor, subHal);
406 mSensors[sensor.sensorHandle] = sensor;
407 }
408 }
409 });
410 if (!result.isOk()) {
411 ALOGE("getSensorsList call failed for SubHal: %s", subHal->getName().c_str());
412 }
413 }
414}
415
416void HalProxy::init() {
417 initializeSubHalCallbacks();
418 initializeSensorList();
419}
420
421void HalProxy::stopThreads() {
422 mThreadsRun.store(false);
423 if (mEventQueueFlag != nullptr && mEventQueue != nullptr) {
424 size_t numToRead = mEventQueue->availableToRead();
425 std::vector<Event> events(numToRead);
426 mEventQueue->read(events.data(), numToRead);
427 mEventQueueFlag->wake(static_cast<uint32_t>(EventQueueFlagBits::EVENTS_READ));
428 }
429 if (mWakelockQueueFlag != nullptr && mWakeLockQueue != nullptr) {
430 uint32_t kZero = 0;
431 mWakeLockQueue->write(&kZero);
432 mWakelockQueueFlag->wake(static_cast<uint32_t>(WakeLockQueueFlagBits::DATA_WRITTEN));
433 }
434 mWakelockCV.notify_one();
435 mEventQueueWriteCV.notify_one();
436 if (mPendingWritesThread.joinable()) {
437 mPendingWritesThread.join();
438 }
439 if (mWakelockThread.joinable()) {
440 mWakelockThread.join();
441 }
442}
443
444void HalProxy::disableAllSensors() {
445 for (const auto& sensorEntry : mSensors) {
446 int32_t sensorHandle = sensorEntry.first;
447 activate(sensorHandle, false /* enabled */);
448 }
449 std::lock_guard<std::mutex> dynamicSensorsLock(mDynamicSensorsMutex);
450 for (const auto& sensorEntry : mDynamicSensors) {
451 int32_t sensorHandle = sensorEntry.first;
452 activate(sensorHandle, false /* enabled */);
453 }
454}
455
456void HalProxy::startPendingWritesThread(HalProxy* halProxy) {
457 halProxy->handlePendingWrites();
458}
459
460void HalProxy::handlePendingWrites() {
461 // TODO(b/143302327): Find a way to optimize locking strategy maybe using two mutexes instead of
462 // one.
463 std::unique_lock<std::mutex> lock(mEventQueueWriteMutex);
464 while (mThreadsRun.load()) {
465 mEventQueueWriteCV.wait(
466 lock, [&] { return !mPendingWriteEventsQueue.empty() || !mThreadsRun.load(); });
467 if (mThreadsRun.load()) {
468 std::vector<Event>& pendingWriteEvents = mPendingWriteEventsQueue.front().first;
469 size_t numWakeupEvents = mPendingWriteEventsQueue.front().second;
470 size_t eventQueueSize = mEventQueue->getQuantumCount();
471 size_t numToWrite = std::min(pendingWriteEvents.size(), eventQueueSize);
472 lock.unlock();
473 if (!mEventQueue->writeBlocking(
474 pendingWriteEvents.data(), numToWrite,
475 static_cast<uint32_t>(EventQueueFlagBits::EVENTS_READ),
476 static_cast<uint32_t>(EventQueueFlagBits::READ_AND_PROCESS),
477 kPendingWriteTimeoutNs, mEventQueueFlag)) {
478 ALOGE("Dropping %zu events after blockingWrite failed.", numToWrite);
479 if (numWakeupEvents > 0) {
480 if (pendingWriteEvents.size() > eventQueueSize) {
481 decrementRefCountAndMaybeReleaseWakelock(
482 countNumWakeupEvents(pendingWriteEvents, eventQueueSize));
483 } else {
484 decrementRefCountAndMaybeReleaseWakelock(numWakeupEvents);
485 }
486 }
487 }
488 lock.lock();
Stan Rokitabc0b20a2020-01-15 08:12:45 -0800489 mSizePendingWriteEventsQueue -= numToWrite;
Stan Rokita2e37ec442019-07-30 11:35:48 -0400490 if (pendingWriteEvents.size() > eventQueueSize) {
491 // TODO(b/143302327): Check if this erase operation is too inefficient. It will copy
492 // all the events ahead of it down to fill gap off array at front after the erase.
493 pendingWriteEvents.erase(pendingWriteEvents.begin(),
494 pendingWriteEvents.begin() + eventQueueSize);
495 } else {
496 mPendingWriteEventsQueue.pop();
497 }
498 }
499 }
500}
501
502void HalProxy::startWakelockThread(HalProxy* halProxy) {
503 halProxy->handleWakelocks();
504}
505
506void HalProxy::handleWakelocks() {
507 std::unique_lock<std::recursive_mutex> lock(mWakelockMutex);
508 while (mThreadsRun.load()) {
509 mWakelockCV.wait(lock, [&] { return mWakelockRefCount > 0 || !mThreadsRun.load(); });
510 if (mThreadsRun.load()) {
511 int64_t timeLeft;
512 if (sharedWakelockDidTimeout(&timeLeft)) {
513 resetSharedWakelock();
514 } else {
515 uint32_t numWakeLocksProcessed;
516 lock.unlock();
517 bool success = mWakeLockQueue->readBlocking(
518 &numWakeLocksProcessed, 1, 0,
519 static_cast<uint32_t>(WakeLockQueueFlagBits::DATA_WRITTEN), timeLeft);
520 lock.lock();
521 if (success) {
522 decrementRefCountAndMaybeReleaseWakelock(
523 static_cast<size_t>(numWakeLocksProcessed));
524 }
525 }
526 }
527 }
528 resetSharedWakelock();
529}
530
531bool HalProxy::sharedWakelockDidTimeout(int64_t* timeLeft) {
532 bool didTimeout;
533 int64_t duration = getTimeNow() - mWakelockTimeoutStartTime;
534 if (duration > kWakelockTimeoutNs) {
535 didTimeout = true;
536 } else {
537 didTimeout = false;
538 *timeLeft = kWakelockTimeoutNs - duration;
539 }
540 return didTimeout;
541}
542
543void HalProxy::resetSharedWakelock() {
544 std::lock_guard<std::recursive_mutex> lockGuard(mWakelockMutex);
545 decrementRefCountAndMaybeReleaseWakelock(mWakelockRefCount);
546 mWakelockTimeoutResetTime = getTimeNow();
547}
548
549void HalProxy::postEventsToMessageQueue(const std::vector<Event>& events, size_t numWakeupEvents,
550 ScopedWakelock wakelock) {
551 size_t numToWrite = 0;
552 std::lock_guard<std::mutex> lock(mEventQueueWriteMutex);
553 if (wakelock.isLocked()) {
554 incrementRefCountAndMaybeAcquireWakelock(numWakeupEvents);
555 }
556 if (mPendingWriteEventsQueue.empty()) {
557 numToWrite = std::min(events.size(), mEventQueue->availableToWrite());
558 if (numToWrite > 0) {
559 if (mEventQueue->write(events.data(), numToWrite)) {
560 // TODO(b/143302327): While loop if mEventQueue->avaiableToWrite > 0 to possibly fit
561 // in more writes immediately
562 mEventQueueFlag->wake(static_cast<uint32_t>(EventQueueFlagBits::READ_AND_PROCESS));
563 } else {
564 numToWrite = 0;
565 }
566 }
567 }
Stan Rokita5098f0a2019-11-04 13:36:54 -0800568 size_t numLeft = events.size() - numToWrite;
569 if (numToWrite < events.size() &&
570 mSizePendingWriteEventsQueue + numLeft <= kMaxSizePendingWriteEventsQueue) {
Stan Rokita2e37ec442019-07-30 11:35:48 -0400571 std::vector<Event> eventsLeft(events.begin() + numToWrite, events.end());
572 mPendingWriteEventsQueue.push({eventsLeft, numWakeupEvents});
Stan Rokita5098f0a2019-11-04 13:36:54 -0800573 mSizePendingWriteEventsQueue += numLeft;
Stan Rokita2e37ec442019-07-30 11:35:48 -0400574 mEventQueueWriteCV.notify_one();
575 }
576}
577
578bool HalProxy::incrementRefCountAndMaybeAcquireWakelock(size_t delta,
579 int64_t* timeoutStart /* = nullptr */) {
580 if (!mThreadsRun.load()) return false;
581 std::lock_guard<std::recursive_mutex> lockGuard(mWakelockMutex);
582 if (mWakelockRefCount == 0) {
583 acquire_wake_lock(PARTIAL_WAKE_LOCK, kWakelockName);
584 mWakelockCV.notify_one();
585 }
586 mWakelockTimeoutStartTime = getTimeNow();
587 mWakelockRefCount += delta;
588 if (timeoutStart != nullptr) {
589 *timeoutStart = mWakelockTimeoutStartTime;
590 }
591 return true;
592}
593
594void HalProxy::decrementRefCountAndMaybeReleaseWakelock(size_t delta,
595 int64_t timeoutStart /* = -1 */) {
596 if (!mThreadsRun.load()) return;
597 std::lock_guard<std::recursive_mutex> lockGuard(mWakelockMutex);
598 if (timeoutStart == -1) timeoutStart = mWakelockTimeoutResetTime;
599 if (mWakelockRefCount == 0 || timeoutStart < mWakelockTimeoutResetTime) return;
600 mWakelockRefCount -= std::min(mWakelockRefCount, delta);
601 if (mWakelockRefCount == 0) {
602 release_wake_lock(kWakelockName);
603 }
604}
605
606void HalProxy::setDirectChannelFlags(SensorInfo* sensorInfo, ISensorsSubHal* subHal) {
607 bool sensorSupportsDirectChannel =
608 (sensorInfo->flags & (V1_0::SensorFlagBits::MASK_DIRECT_REPORT |
609 V1_0::SensorFlagBits::MASK_DIRECT_CHANNEL)) != 0;
610 if (mDirectChannelSubHal == nullptr && sensorSupportsDirectChannel) {
611 mDirectChannelSubHal = subHal;
612 } else if (mDirectChannelSubHal != nullptr && subHal != mDirectChannelSubHal) {
613 // disable direct channel capability for sensors in subHals that are not
614 // the only one we will enable
615 sensorInfo->flags &= ~(V1_0::SensorFlagBits::MASK_DIRECT_REPORT |
616 V1_0::SensorFlagBits::MASK_DIRECT_CHANNEL);
617 }
618}
619
620ISensorsSubHal* HalProxy::getSubHalForSensorHandle(int32_t sensorHandle) {
621 return mSubHalList[extractSubHalIndex(sensorHandle)];
622}
623
624bool HalProxy::isSubHalIndexValid(int32_t sensorHandle) {
625 return extractSubHalIndex(sensorHandle) < mSubHalList.size();
626}
627
628size_t HalProxy::countNumWakeupEvents(const std::vector<Event>& events, size_t n) {
629 size_t numWakeupEvents = 0;
630 for (size_t i = 0; i < n; i++) {
631 int32_t sensorHandle = events[i].sensorHandle;
632 if (mSensors[sensorHandle].flags & static_cast<uint32_t>(V1_0::SensorFlagBits::WAKE_UP)) {
633 numWakeupEvents++;
634 }
635 }
636 return numWakeupEvents;
637}
638
639int32_t HalProxy::clearSubHalIndex(int32_t sensorHandle) {
640 return sensorHandle & (~kSensorHandleSubHalIndexMask);
641}
642
643bool HalProxy::subHalIndexIsClear(int32_t sensorHandle) {
644 return (sensorHandle & kSensorHandleSubHalIndexMask) == 0;
645}
646
647void HalProxyCallback::postEvents(const std::vector<Event>& events, ScopedWakelock wakelock) {
648 if (events.empty() || !mHalProxy->areThreadsRunning()) return;
649 size_t numWakeupEvents;
650 std::vector<Event> processedEvents = processEvents(events, &numWakeupEvents);
651 if (numWakeupEvents > 0) {
652 ALOG_ASSERT(wakelock.isLocked(),
653 "Wakeup events posted while wakelock unlocked for subhal"
Stan Rokita010c36d2020-01-21 15:29:51 -0800654 " w/ index %" PRId32 ".",
Stan Rokita2e37ec442019-07-30 11:35:48 -0400655 mSubHalIndex);
656 } else {
657 ALOG_ASSERT(!wakelock.isLocked(),
658 "No Wakeup events posted but wakelock locked for subhal"
Stan Rokita010c36d2020-01-21 15:29:51 -0800659 " w/ index %" PRId32 ".",
Stan Rokita2e37ec442019-07-30 11:35:48 -0400660 mSubHalIndex);
661 }
662 mHalProxy->postEventsToMessageQueue(processedEvents, numWakeupEvents, std::move(wakelock));
663}
664
665ScopedWakelock HalProxyCallback::createScopedWakelock(bool lock) {
666 ScopedWakelock wakelock(mHalProxy, lock);
667 return wakelock;
668}
669
670std::vector<Event> HalProxyCallback::processEvents(const std::vector<Event>& events,
671 size_t* numWakeupEvents) const {
672 *numWakeupEvents = 0;
673 std::vector<Event> eventsOut;
674 for (Event event : events) {
675 event.sensorHandle = setSubHalIndex(event.sensorHandle, mSubHalIndex);
676 eventsOut.push_back(event);
677 const SensorInfo& sensor = mHalProxy->getSensorInfo(event.sensorHandle);
678 if ((sensor.flags & V1_0::SensorFlagBits::WAKE_UP) != 0) {
679 (*numWakeupEvents)++;
680 }
681 }
682 return eventsOut;
683}
684
685} // namespace implementation
686} // namespace V2_0
687} // namespace sensors
688} // namespace hardware
689} // namespace android