1 /* 2 * Copyright (C) 2016 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 #define LOG_TAG "sensors_hidl_hal_test" 18 #include <VtsHalHidlTargetTestBase.h> 19 #include <android-base/logging.h> 20 #include <android/hardware/sensors/1.0/ISensors.h> 21 #include <android/hardware/sensors/1.0/types.h> 22 #include <cutils/ashmem.h> 23 #include <hardware/sensors.h> // for sensor type strings 24 #include <log/log.h> 25 #include <utils/SystemClock.h> 26 27 #include <algorithm> 28 #include <cinttypes> 29 #include <cmath> 30 #include <memory> 31 #include <mutex> 32 #include <thread> 33 #include <unordered_set> 34 #include <vector> 35 36 #include <sys/mman.h> 37 #include <unistd.h> 38 39 using ::android::hardware::Return; 40 using ::android::hardware::Void; 41 using ::android::hardware::hidl_string; 42 using ::android::sp; 43 using namespace ::android::hardware::sensors::V1_0; 44 45 // Test environment for sensors 46 class SensorsHidlTest; 47 class SensorsHidlEnvironment : public ::testing::Environment { 48 public: 49 // get the test environment singleton 50 static SensorsHidlEnvironment* Instance() { 51 static SensorsHidlEnvironment* instance = new SensorsHidlEnvironment; 52 return instance; 53 } 54 55 virtual void SetUp(); 56 virtual void TearDown(); 57 58 // Get and clear all events collected so far (like "cat" shell command). 59 // If output is nullptr, it clears all collected events. 60 void catEvents(std::vector<Event>* output); 61 62 // set sensor event collection status 63 void setCollection(bool enable); 64 65 private: 66 friend SensorsHidlTest; 67 // sensors hidl service 68 sp<ISensors> sensors; 69 70 SensorsHidlEnvironment() {} 71 72 void addEvent(const Event& ev); 73 void startPollingThread(); 74 void resetHal(); 75 static void pollingThread(SensorsHidlEnvironment* env, std::shared_ptr<bool> stop); 76 77 bool collectionEnabled; 78 std::shared_ptr<bool> stopThread; 79 std::thread pollThread; 80 std::vector<Event> events; 81 std::mutex events_mutex; 82 83 GTEST_DISALLOW_COPY_AND_ASSIGN_(SensorsHidlEnvironment); 84 }; 85 86 void SensorsHidlEnvironment::SetUp() { 87 resetHal(); 88 89 ASSERT_NE(sensors, nullptr) << "sensors is nullptr, cannot get hidl service"; 90 91 collectionEnabled = false; 92 startPollingThread(); 93 94 // In case framework just stopped for test and there is sensor events in the pipe, 95 // wait some time for those events to be cleared to avoid them messing up the test. 96 std::this_thread::sleep_for(std::chrono::seconds(3)); 97 } 98 99 void SensorsHidlEnvironment::TearDown() { 100 if (stopThread) { 101 *stopThread = true; 102 } 103 pollThread.detach(); 104 } 105 106 void SensorsHidlEnvironment::resetHal() { 107 // wait upto 100ms * 10 = 1s for hidl service. 108 constexpr auto RETRY_DELAY = std::chrono::milliseconds(100); 109 110 std::string step; 111 bool succeed = false; 112 for (size_t retry = 10; retry > 0; --retry) { 113 // this do ... while is for easy error handling 114 do { 115 step = "getService()"; 116 sensors = ISensors::getService(); 117 if (sensors == nullptr) { 118 break; 119 } 120 121 step = "poll() check"; 122 // Poke ISensor service. If it has lingering connection from previous generation of 123 // system server, it will kill itself. There is no intention to handle the poll result, 124 // which will be done since the size is 0. 125 if(!sensors->poll(0, [](auto, const auto &, const auto &) {}).isOk()) { 126 break; 127 } 128 129 step = "getSensorList"; 130 std::vector<SensorInfo> sensorList; 131 if (!sensors->getSensorsList( 132 [&] (const ::android::hardware::hidl_vec<SensorInfo> &list) { 133 sensorList.reserve(list.size()); 134 for (size_t i = 0; i < list.size(); ++i) { 135 sensorList.push_back(list[i]); 136 } 137 }).isOk()) { 138 break; 139 } 140 141 // stop each sensor individually 142 step = "stop each sensor"; 143 bool ok = true; 144 for (const auto &i : sensorList) { 145 if (!sensors->activate(i.sensorHandle, false).isOk()) { 146 ok = false; 147 break; 148 } 149 } 150 if (!ok) { 151 break; 152 } 153 154 // mark it done 155 step = "done"; 156 succeed = true; 157 } while(0); 158 159 if (succeed) { 160 return; 161 } 162 163 // Delay 100ms before retry, hidl service is expected to come up in short time after crash. 164 ALOGI("%s unsuccessful, try again soon (remaining retry %zu).", step.c_str(), retry - 1); 165 std::this_thread::sleep_for(RETRY_DELAY); 166 } 167 168 sensors = nullptr; 169 } 170 171 void SensorsHidlEnvironment::catEvents(std::vector<Event>* output) { 172 std::lock_guard<std::mutex> lock(events_mutex); 173 if (output) { 174 output->insert(output->end(), events.begin(), events.end()); 175 } 176 events.clear(); 177 } 178 179 void SensorsHidlEnvironment::setCollection(bool enable) { 180 std::lock_guard<std::mutex> lock(events_mutex); 181 collectionEnabled = enable; 182 } 183 184 void SensorsHidlEnvironment::addEvent(const Event& ev) { 185 std::lock_guard<std::mutex> lock(events_mutex); 186 if (collectionEnabled) { 187 events.push_back(ev); 188 } 189 } 190 191 void SensorsHidlEnvironment::startPollingThread() { 192 stopThread = std::shared_ptr<bool>(new bool(false)); 193 pollThread = std::thread(pollingThread, this, stopThread); 194 events.reserve(128); 195 } 196 197 void SensorsHidlEnvironment::pollingThread( 198 SensorsHidlEnvironment* env, std::shared_ptr<bool> stop) { 199 ALOGD("polling thread start"); 200 bool needExit = *stop; 201 202 while(!needExit) { 203 env->sensors->poll(64, [&](auto result, const auto& events, const auto& dynamicSensorsAdded) { 204 if (result != Result::OK 205 || (events.size() == 0 && dynamicSensorsAdded.size() == 0) 206 || *stop) { 207 needExit = true; 208 return; 209 } 210 211 for (const auto& e : events) { 212 env->addEvent(e); 213 } 214 }); 215 } 216 ALOGD("polling thread end"); 217 } 218 219 class SensorsTestSharedMemory { 220 public: 221 static SensorsTestSharedMemory* create(SharedMemType type, size_t size); 222 SharedMemInfo getSharedMemInfo() const; 223 char * getBuffer() const; 224 std::vector<Event> parseEvents(int64_t lastCounter = -1, size_t offset = 0) const; 225 virtual ~SensorsTestSharedMemory(); 226 private: 227 SensorsTestSharedMemory(SharedMemType type, size_t size); 228 229 SharedMemType mType; 230 native_handle_t* mNativeHandle; 231 size_t mSize; 232 char* mBuffer; 233 234 DISALLOW_COPY_AND_ASSIGN(SensorsTestSharedMemory); 235 }; 236 237 SharedMemInfo SensorsTestSharedMemory::getSharedMemInfo() const { 238 SharedMemInfo mem = { 239 .type = mType, 240 .format = SharedMemFormat::SENSORS_EVENT, 241 .size = static_cast<uint32_t>(mSize), 242 .memoryHandle = mNativeHandle 243 }; 244 return mem; 245 } 246 247 char * SensorsTestSharedMemory::getBuffer() const { 248 return mBuffer; 249 } 250 251 std::vector<Event> SensorsTestSharedMemory::parseEvents(int64_t lastCounter, size_t offset) const { 252 253 constexpr size_t kEventSize = static_cast<size_t>(SensorsEventFormatOffset::TOTAL_LENGTH); 254 constexpr size_t kOffsetSize = static_cast<size_t>(SensorsEventFormatOffset::SIZE_FIELD); 255 constexpr size_t kOffsetToken = static_cast<size_t>(SensorsEventFormatOffset::REPORT_TOKEN); 256 constexpr size_t kOffsetType = static_cast<size_t>(SensorsEventFormatOffset::SENSOR_TYPE); 257 constexpr size_t kOffsetAtomicCounter = 258 static_cast<size_t>(SensorsEventFormatOffset::ATOMIC_COUNTER); 259 constexpr size_t kOffsetTimestamp = static_cast<size_t>(SensorsEventFormatOffset::TIMESTAMP); 260 constexpr size_t kOffsetData = static_cast<size_t>(SensorsEventFormatOffset::DATA); 261 262 std::vector<Event> events; 263 std::vector<float> data(16); 264 265 while (offset + kEventSize <= mSize) { 266 int64_t atomicCounter = *reinterpret_cast<uint32_t *>(mBuffer + offset + kOffsetAtomicCounter); 267 if (atomicCounter <= lastCounter) { 268 break; 269 } 270 271 int32_t size = *reinterpret_cast<int32_t *>(mBuffer + offset + kOffsetSize); 272 if (size != kEventSize) { 273 // unknown error, events parsed may be wrong, remove all 274 events.clear(); 275 break; 276 } 277 278 int32_t token = *reinterpret_cast<int32_t *>(mBuffer + offset + kOffsetToken); 279 int32_t type = *reinterpret_cast<int32_t *>(mBuffer + offset + kOffsetType); 280 int64_t timestamp = *reinterpret_cast<int64_t *>(mBuffer + offset + kOffsetTimestamp); 281 282 ALOGV("offset = %zu, cnt %" PRId64 ", token %" PRId32 ", type %" PRId32 ", timestamp %" PRId64, 283 offset, atomicCounter, token, type, timestamp); 284 285 Event event = { 286 .timestamp = timestamp, 287 .sensorHandle = token, 288 .sensorType = static_cast<SensorType>(type), 289 }; 290 event.u.data = android::hardware::hidl_array<float, 16> 291 (reinterpret_cast<float*>(mBuffer + offset + kOffsetData)); 292 293 events.push_back(event); 294 295 lastCounter = atomicCounter; 296 offset += kEventSize; 297 } 298 299 return events; 300 } 301 302 SensorsTestSharedMemory::SensorsTestSharedMemory(SharedMemType type, size_t size) 303 : mType(type), mSize(0), mBuffer(nullptr) { 304 native_handle_t *handle = nullptr; 305 char *buffer = nullptr; 306 switch(type) { 307 case SharedMemType::ASHMEM: { 308 int fd; 309 handle = ::native_handle_create(1 /*nFds*/, 0/*nInts*/); 310 if (handle != nullptr) { 311 handle->data[0] = fd = ::ashmem_create_region("SensorsTestSharedMemory", size); 312 if (handle->data[0] > 0) { 313 // memory is pinned by default 314 buffer = static_cast<char *> 315 (::mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0)); 316 if (buffer != reinterpret_cast<char*>(MAP_FAILED)) { 317 break; 318 } 319 ::native_handle_close(handle); 320 } 321 ::native_handle_delete(handle); 322 handle = nullptr; 323 } 324 break; 325 } 326 case SharedMemType::GRALLOC: { 327 328 break; 329 } 330 default: 331 break; 332 } 333 334 if (buffer != nullptr) { 335 mNativeHandle = handle; 336 mSize = size; 337 mBuffer = buffer; 338 } 339 } 340 341 SensorsTestSharedMemory::~SensorsTestSharedMemory() { 342 switch(mType) { 343 case SharedMemType::ASHMEM: { 344 if (mSize != 0) { 345 ::munmap(mBuffer, mSize); 346 mBuffer = nullptr; 347 348 ::native_handle_close(mNativeHandle); 349 ::native_handle_delete(mNativeHandle); 350 351 mNativeHandle = nullptr; 352 mSize = 0; 353 } 354 break; 355 } 356 default: { 357 if (mNativeHandle != nullptr || mSize != 0 || mBuffer != nullptr) { 358 ALOGE("SensorsTestSharedMemory %p not properly destructed: " 359 "type %d, native handle %p, size %zu, buffer %p", 360 this, static_cast<int>(mType), mNativeHandle, mSize, mBuffer); 361 } 362 break; 363 } 364 } 365 } 366 367 SensorsTestSharedMemory* SensorsTestSharedMemory::create(SharedMemType type, size_t size) { 368 constexpr size_t kMaxSize = 128*1024*1024; // sensor test should not need more than 128M 369 if (size == 0 || size >= kMaxSize) { 370 return nullptr; 371 } 372 373 auto m = new SensorsTestSharedMemory(type, size); 374 if (m->mSize != size || m->mBuffer == nullptr) { 375 delete m; 376 m = nullptr; 377 } 378 return m; 379 } 380 381 class SensorEventsChecker { 382 public: 383 virtual bool check(const std::vector<Event> &events, std::string *out) const = 0; 384 virtual ~SensorEventsChecker() {} 385 }; 386 387 class NullChecker : public SensorEventsChecker { 388 public: 389 virtual bool check(const std::vector<Event> &, std::string *) const { 390 return true; 391 } 392 }; 393 394 class SensorEventPerEventChecker : public SensorEventsChecker { 395 public: 396 virtual bool checkEvent(const Event &event, std::string *out) const = 0; 397 virtual bool check(const std::vector<Event> &events, std::string *out) const { 398 for (const auto &e : events) { 399 if (!checkEvent(e, out)) { 400 return false; 401 } 402 } 403 return true; 404 } 405 }; 406 407 class Vec3NormChecker : public SensorEventPerEventChecker { 408 public: 409 Vec3NormChecker(float min, float max) : mRange(min, max) {} 410 static Vec3NormChecker byNominal(float nominal, float allowedError) { 411 return Vec3NormChecker(nominal - allowedError, nominal + allowedError); 412 } 413 414 virtual bool checkEvent(const Event &event, std::string *out) const { 415 Vec3 v = event.u.vec3; 416 float norm = std::sqrt(v.x * v.x + v.y * v.y + v.z * v.z); 417 if (norm < mRange.first || norm > mRange.second) { 418 if (out != nullptr) { 419 std::ostringstream ss; 420 ss << "Event @ " << event.timestamp << " (" << v.x << ", " << v.y << ", " << v.z << ")" 421 << " has norm " << norm << ", which is beyond range" 422 << " [" << mRange.first << ", " << mRange.second << "]"; 423 *out = ss.str(); 424 } 425 return false; 426 } 427 return true; 428 } 429 protected: 430 std::pair<float, float> mRange; 431 }; 432 433 // The main test class for SENSORS HIDL HAL. 434 class SensorsHidlTest : public ::testing::VtsHalHidlTargetTestBase { 435 public: 436 virtual void SetUp() override { 437 } 438 439 virtual void TearDown() override { 440 // stop all sensors 441 for (auto s : mSensorHandles) { 442 S()->activate(s, false); 443 } 444 mSensorHandles.clear(); 445 446 // stop all direct report and channels 447 for (auto c : mDirectChannelHandles) { 448 // disable all reports 449 S()->configDirectReport(-1, c, RateLevel::STOP, [] (auto, auto){}); 450 S()->unregisterDirectChannel(c); 451 } 452 mDirectChannelHandles.clear(); 453 } 454 455 protected: 456 SensorInfo defaultSensorByType(SensorType type); 457 std::vector<SensorInfo> getSensorsList(); 458 std::vector<Event> collectEvents(useconds_t timeLimitUs, size_t nEventLimit, 459 bool clearBeforeStart = true, bool changeCollection = true); 460 461 // implementation wrapper 462 Return<void> getSensorsList(ISensors::getSensorsList_cb _hidl_cb) { 463 return S()->getSensorsList(_hidl_cb); 464 } 465 466 Return<Result> activate( 467 int32_t sensorHandle, bool enabled); 468 469 Return<Result> batch( 470 int32_t sensorHandle, 471 int64_t samplingPeriodNs, 472 int64_t maxReportLatencyNs) { 473 return S()->batch(sensorHandle, samplingPeriodNs, maxReportLatencyNs); 474 } 475 476 Return<Result> flush(int32_t sensorHandle) { 477 return S()->flush(sensorHandle); 478 } 479 480 Return<Result> injectSensorData(const Event& event) { 481 return S()->injectSensorData(event); 482 } 483 484 Return<void> registerDirectChannel( 485 const SharedMemInfo& mem, ISensors::registerDirectChannel_cb _hidl_cb); 486 487 Return<Result> unregisterDirectChannel(int32_t channelHandle) { 488 return S()->unregisterDirectChannel(channelHandle); 489 } 490 491 Return<void> configDirectReport( 492 int32_t sensorHandle, int32_t channelHandle, RateLevel rate, 493 ISensors::configDirectReport_cb _hidl_cb) { 494 return S()->configDirectReport(sensorHandle, channelHandle, rate, _hidl_cb); 495 } 496 497 inline sp<ISensors>& S() { 498 return SensorsHidlEnvironment::Instance()->sensors; 499 } 500 501 inline static SensorFlagBits extractReportMode(uint64_t flag) { 502 return (SensorFlagBits) (flag 503 & ((uint64_t) SensorFlagBits::CONTINUOUS_MODE 504 | (uint64_t) SensorFlagBits::ON_CHANGE_MODE 505 | (uint64_t) SensorFlagBits::ONE_SHOT_MODE 506 | (uint64_t) SensorFlagBits::SPECIAL_REPORTING_MODE)); 507 } 508 509 inline static bool isMetaSensorType(SensorType type) { 510 return (type == SensorType::META_DATA 511 || type == SensorType::DYNAMIC_SENSOR_META 512 || type == SensorType::ADDITIONAL_INFO); 513 } 514 515 inline static bool isValidType(SensorType type) { 516 return (int32_t) type > 0; 517 } 518 519 void testStreamingOperation(SensorType type, 520 std::chrono::nanoseconds samplingPeriod, 521 std::chrono::seconds duration, 522 const SensorEventsChecker &checker); 523 void testSamplingRateHotSwitchOperation(SensorType type); 524 void testBatchingOperation(SensorType type); 525 void testDirectReportOperation( 526 SensorType type, SharedMemType memType, RateLevel rate, const SensorEventsChecker &checker); 527 528 static void assertTypeMatchStringType(SensorType type, const hidl_string& stringType); 529 static void assertTypeMatchReportMode(SensorType type, SensorFlagBits reportMode); 530 static void assertDelayMatchReportMode( 531 int32_t minDelay, int32_t maxDelay, SensorFlagBits reportMode); 532 static SensorFlagBits expectedReportModeForType(SensorType type); 533 static bool isDirectReportRateSupported(SensorInfo sensor, RateLevel rate); 534 static bool isDirectChannelTypeSupported(SensorInfo sensor, SharedMemType type); 535 536 // checkers 537 static const Vec3NormChecker sAccelNormChecker; 538 static const Vec3NormChecker sGyroNormChecker; 539 540 // all sensors and direct channnels used 541 std::unordered_set<int32_t> mSensorHandles; 542 std::unordered_set<int32_t> mDirectChannelHandles; 543 }; 544 545 const Vec3NormChecker SensorsHidlTest::sAccelNormChecker( 546 Vec3NormChecker::byNominal(GRAVITY_EARTH, 1.0f/*m/s^2*/)); 547 const Vec3NormChecker SensorsHidlTest::sGyroNormChecker( 548 Vec3NormChecker::byNominal(0.f, 0.1f/*rad/s*/)); 549 550 Return<Result> SensorsHidlTest::activate(int32_t sensorHandle, bool enabled) { 551 // If activating a sensor, add the handle in a set so that when test fails it can be turned off. 552 // The handle is not removed when it is deactivating on purpose so that it is not necessary to 553 // check the return value of deactivation. Deactivating a sensor more than once does not have 554 // negative effect. 555 if (enabled) { 556 mSensorHandles.insert(sensorHandle); 557 } 558 return S()->activate(sensorHandle, enabled); 559 } 560 561 Return<void> SensorsHidlTest::registerDirectChannel( 562 const SharedMemInfo& mem, ISensors::registerDirectChannel_cb cb) { 563 // If registeration of a channel succeeds, add the handle of channel to a set so that it can be 564 // unregistered when test fails. Unregister a channel does not remove the handle on purpose. 565 // Unregistering a channel more than once should not have negative effect. 566 S()->registerDirectChannel(mem, 567 [&] (auto result, auto channelHandle) { 568 if (result == Result::OK) { 569 mDirectChannelHandles.insert(channelHandle); 570 } 571 cb(result, channelHandle); 572 }); 573 return Void(); 574 } 575 576 std::vector<Event> SensorsHidlTest::collectEvents(useconds_t timeLimitUs, size_t nEventLimit, 577 bool clearBeforeStart, bool changeCollection) { 578 std::vector<Event> events; 579 constexpr useconds_t SLEEP_GRANULARITY = 100*1000; //granularity 100 ms 580 581 ALOGI("collect max of %zu events for %d us, clearBeforeStart %d", 582 nEventLimit, timeLimitUs, clearBeforeStart); 583 584 if (changeCollection) { 585 SensorsHidlEnvironment::Instance()->setCollection(true); 586 } 587 if (clearBeforeStart) { 588 SensorsHidlEnvironment::Instance()->catEvents(nullptr); 589 } 590 591 while (timeLimitUs > 0) { 592 useconds_t duration = std::min(SLEEP_GRANULARITY, timeLimitUs); 593 usleep(duration); 594 timeLimitUs -= duration; 595 596 SensorsHidlEnvironment::Instance()->catEvents(&events); 597 if (events.size() >= nEventLimit) { 598 break; 599 } 600 ALOGV("time to go = %d, events to go = %d", 601 (int)timeLimitUs, (int)(nEventLimit - events.size())); 602 } 603 604 if (changeCollection) { 605 SensorsHidlEnvironment::Instance()->setCollection(false); 606 } 607 return events; 608 } 609 610 void SensorsHidlTest::assertTypeMatchStringType(SensorType type, const hidl_string& stringType) { 611 612 if (type >= SensorType::DEVICE_PRIVATE_BASE) { 613 return; 614 } 615 616 switch (type) { 617 #define CHECK_TYPE_STRING_FOR_SENSOR_TYPE(type) \ 618 case SensorType::type: ASSERT_STREQ(SENSOR_STRING_TYPE_ ## type, stringType.c_str()); break; 619 CHECK_TYPE_STRING_FOR_SENSOR_TYPE(ACCELEROMETER); 620 CHECK_TYPE_STRING_FOR_SENSOR_TYPE(ACCELEROMETER_UNCALIBRATED); 621 CHECK_TYPE_STRING_FOR_SENSOR_TYPE(ADDITIONAL_INFO); 622 CHECK_TYPE_STRING_FOR_SENSOR_TYPE(AMBIENT_TEMPERATURE); 623 CHECK_TYPE_STRING_FOR_SENSOR_TYPE(DEVICE_ORIENTATION); 624 CHECK_TYPE_STRING_FOR_SENSOR_TYPE(DYNAMIC_SENSOR_META); 625 CHECK_TYPE_STRING_FOR_SENSOR_TYPE(GAME_ROTATION_VECTOR); 626 CHECK_TYPE_STRING_FOR_SENSOR_TYPE(GEOMAGNETIC_ROTATION_VECTOR); 627 CHECK_TYPE_STRING_FOR_SENSOR_TYPE(GLANCE_GESTURE); 628 CHECK_TYPE_STRING_FOR_SENSOR_TYPE(GRAVITY); 629 CHECK_TYPE_STRING_FOR_SENSOR_TYPE(GYROSCOPE); 630 CHECK_TYPE_STRING_FOR_SENSOR_TYPE(GYROSCOPE_UNCALIBRATED); 631 CHECK_TYPE_STRING_FOR_SENSOR_TYPE(HEART_BEAT); 632 CHECK_TYPE_STRING_FOR_SENSOR_TYPE(HEART_RATE); 633 CHECK_TYPE_STRING_FOR_SENSOR_TYPE(LIGHT); 634 CHECK_TYPE_STRING_FOR_SENSOR_TYPE(LINEAR_ACCELERATION); 635 CHECK_TYPE_STRING_FOR_SENSOR_TYPE(LOW_LATENCY_OFFBODY_DETECT); 636 CHECK_TYPE_STRING_FOR_SENSOR_TYPE(MAGNETIC_FIELD); 637 CHECK_TYPE_STRING_FOR_SENSOR_TYPE(MAGNETIC_FIELD_UNCALIBRATED); 638 CHECK_TYPE_STRING_FOR_SENSOR_TYPE(MOTION_DETECT); 639 CHECK_TYPE_STRING_FOR_SENSOR_TYPE(ORIENTATION); 640 CHECK_TYPE_STRING_FOR_SENSOR_TYPE(PICK_UP_GESTURE); 641 CHECK_TYPE_STRING_FOR_SENSOR_TYPE(POSE_6DOF); 642 CHECK_TYPE_STRING_FOR_SENSOR_TYPE(PRESSURE); 643 CHECK_TYPE_STRING_FOR_SENSOR_TYPE(PROXIMITY); 644 CHECK_TYPE_STRING_FOR_SENSOR_TYPE(RELATIVE_HUMIDITY); 645 CHECK_TYPE_STRING_FOR_SENSOR_TYPE(ROTATION_VECTOR); 646 CHECK_TYPE_STRING_FOR_SENSOR_TYPE(SIGNIFICANT_MOTION); 647 CHECK_TYPE_STRING_FOR_SENSOR_TYPE(STATIONARY_DETECT); 648 CHECK_TYPE_STRING_FOR_SENSOR_TYPE(STEP_COUNTER); 649 CHECK_TYPE_STRING_FOR_SENSOR_TYPE(STEP_DETECTOR); 650 CHECK_TYPE_STRING_FOR_SENSOR_TYPE(TEMPERATURE); 651 CHECK_TYPE_STRING_FOR_SENSOR_TYPE(TILT_DETECTOR); 652 CHECK_TYPE_STRING_FOR_SENSOR_TYPE(WAKE_GESTURE); 653 CHECK_TYPE_STRING_FOR_SENSOR_TYPE(WRIST_TILT_GESTURE); 654 default: 655 FAIL() << "Type " << static_cast<int>(type) << " in android defined range is not checked, " 656 << "stringType = " << stringType; 657 #undef CHECK_TYPE_STRING_FOR_SENSOR_TYPE 658 } 659 } 660 661 void SensorsHidlTest::assertTypeMatchReportMode(SensorType type, SensorFlagBits reportMode) { 662 if (type >= SensorType::DEVICE_PRIVATE_BASE) { 663 return; 664 } 665 666 SensorFlagBits expected = expectedReportModeForType(type); 667 668 ASSERT_TRUE(expected == (SensorFlagBits) -1 || expected == reportMode) 669 << "reportMode=" << static_cast<int>(reportMode) 670 << "expected=" << static_cast<int>(expected); 671 } 672 673 void SensorsHidlTest::assertDelayMatchReportMode( 674 int32_t minDelay, int32_t maxDelay, SensorFlagBits reportMode) { 675 switch(reportMode) { 676 case SensorFlagBits::CONTINUOUS_MODE: 677 ASSERT_LT(0, minDelay); 678 ASSERT_LE(0, maxDelay); 679 break; 680 case SensorFlagBits::ON_CHANGE_MODE: 681 ASSERT_LE(0, minDelay); 682 ASSERT_LE(0, maxDelay); 683 break; 684 case SensorFlagBits::ONE_SHOT_MODE: 685 ASSERT_EQ(-1, minDelay); 686 ASSERT_EQ(0, maxDelay); 687 break; 688 case SensorFlagBits::SPECIAL_REPORTING_MODE: 689 // do not enforce anything for special reporting mode 690 break; 691 default: 692 FAIL() << "Report mode " << static_cast<int>(reportMode) << " not checked"; 693 } 694 } 695 696 // return -1 means no expectation for this type 697 SensorFlagBits SensorsHidlTest::expectedReportModeForType(SensorType type) { 698 switch (type) { 699 case SensorType::ACCELEROMETER: 700 case SensorType::ACCELEROMETER_UNCALIBRATED: 701 case SensorType::GYROSCOPE: 702 case SensorType::MAGNETIC_FIELD: 703 case SensorType::ORIENTATION: 704 case SensorType::PRESSURE: 705 case SensorType::TEMPERATURE: 706 case SensorType::GRAVITY: 707 case SensorType::LINEAR_ACCELERATION: 708 case SensorType::ROTATION_VECTOR: 709 case SensorType::MAGNETIC_FIELD_UNCALIBRATED: 710 case SensorType::GAME_ROTATION_VECTOR: 711 case SensorType::GYROSCOPE_UNCALIBRATED: 712 case SensorType::GEOMAGNETIC_ROTATION_VECTOR: 713 case SensorType::POSE_6DOF: 714 case SensorType::HEART_BEAT: 715 return SensorFlagBits::CONTINUOUS_MODE; 716 717 case SensorType::LIGHT: 718 case SensorType::PROXIMITY: 719 case SensorType::RELATIVE_HUMIDITY: 720 case SensorType::AMBIENT_TEMPERATURE: 721 case SensorType::HEART_RATE: 722 case SensorType::DEVICE_ORIENTATION: 723 case SensorType::STEP_COUNTER: 724 case SensorType::LOW_LATENCY_OFFBODY_DETECT: 725 return SensorFlagBits::ON_CHANGE_MODE; 726 727 case SensorType::SIGNIFICANT_MOTION: 728 case SensorType::WAKE_GESTURE: 729 case SensorType::GLANCE_GESTURE: 730 case SensorType::PICK_UP_GESTURE: 731 case SensorType::MOTION_DETECT: 732 case SensorType::STATIONARY_DETECT: 733 return SensorFlagBits::ONE_SHOT_MODE; 734 735 case SensorType::STEP_DETECTOR: 736 case SensorType::TILT_DETECTOR: 737 case SensorType::WRIST_TILT_GESTURE: 738 case SensorType::DYNAMIC_SENSOR_META: 739 return SensorFlagBits::SPECIAL_REPORTING_MODE; 740 741 default: 742 ALOGW("Type %d is not implemented in expectedReportModeForType", (int)type); 743 return (SensorFlagBits)-1; 744 } 745 } 746 747 bool SensorsHidlTest::isDirectReportRateSupported(SensorInfo sensor, RateLevel rate) { 748 unsigned int r = 749 static_cast<unsigned int>(sensor.flags & SensorFlagBits::MASK_DIRECT_REPORT) 750 >> static_cast<unsigned int>(SensorFlagShift::DIRECT_REPORT); 751 return r >= static_cast<unsigned int>(rate); 752 } 753 754 bool SensorsHidlTest::isDirectChannelTypeSupported(SensorInfo sensor, SharedMemType type) { 755 switch (type) { 756 case SharedMemType::ASHMEM: 757 return (sensor.flags & SensorFlagBits::DIRECT_CHANNEL_ASHMEM) != 0; 758 case SharedMemType::GRALLOC: 759 return (sensor.flags & SensorFlagBits::DIRECT_CHANNEL_GRALLOC) != 0; 760 default: 761 return false; 762 } 763 } 764 765 SensorInfo SensorsHidlTest::defaultSensorByType(SensorType type) { 766 SensorInfo ret; 767 768 ret.type = (SensorType) -1; 769 S()->getSensorsList( 770 [&] (const auto &list) { 771 const size_t count = list.size(); 772 for (size_t i = 0; i < count; ++i) { 773 if (list[i].type == type) { 774 ret = list[i]; 775 return; 776 } 777 } 778 }); 779 780 return ret; 781 } 782 783 std::vector<SensorInfo> SensorsHidlTest::getSensorsList() { 784 std::vector<SensorInfo> ret; 785 786 S()->getSensorsList( 787 [&] (const auto &list) { 788 const size_t count = list.size(); 789 ret.reserve(list.size()); 790 for (size_t i = 0; i < count; ++i) { 791 ret.push_back(list[i]); 792 } 793 }); 794 795 return ret; 796 } 797 798 // Test if sensor list returned is valid 799 TEST_F(SensorsHidlTest, SensorListValid) { 800 S()->getSensorsList( 801 [&] (const auto &list) { 802 const size_t count = list.size(); 803 for (size_t i = 0; i < count; ++i) { 804 const auto &s = list[i]; 805 SCOPED_TRACE(::testing::Message() << i << "/" << count << ": " 806 << " handle=0x" << std::hex << std::setw(8) << std::setfill('0') 807 << s.sensorHandle << std::dec 808 << " type=" << static_cast<int>(s.type) 809 << " name=" << s.name); 810 811 // Test non-empty type string 812 EXPECT_FALSE(s.typeAsString.empty()); 813 814 // Test defined type matches defined string type 815 EXPECT_NO_FATAL_FAILURE(assertTypeMatchStringType(s.type, s.typeAsString)); 816 817 // Test if all sensor has name and vendor 818 EXPECT_FALSE(s.name.empty()); 819 EXPECT_FALSE(s.vendor.empty()); 820 821 // Test power > 0, maxRange > 0 822 EXPECT_LE(0, s.power); 823 EXPECT_LT(0, s.maxRange); 824 825 // Info type, should have no sensor 826 EXPECT_FALSE( 827 s.type == SensorType::ADDITIONAL_INFO 828 || s.type == SensorType::META_DATA); 829 830 // Test fifoMax >= fifoReserved 831 EXPECT_GE(s.fifoMaxEventCount, s.fifoReservedEventCount) 832 << "max=" << s.fifoMaxEventCount << " reserved=" << s.fifoReservedEventCount; 833 834 // Test Reporting mode valid 835 EXPECT_NO_FATAL_FAILURE(assertTypeMatchReportMode(s.type, extractReportMode(s.flags))); 836 837 // Test min max are in the right order 838 EXPECT_LE(s.minDelay, s.maxDelay); 839 // Test min/max delay matches reporting mode 840 EXPECT_NO_FATAL_FAILURE( 841 assertDelayMatchReportMode(s.minDelay, s.maxDelay, extractReportMode(s.flags))); 842 } 843 }); 844 } 845 846 // Test if sensor list returned is valid 847 TEST_F(SensorsHidlTest, SetOperationMode) { 848 std::vector<SensorInfo> sensorList = getSensorsList(); 849 850 bool needOperationModeSupport = 851 std::any_of(sensorList.begin(), sensorList.end(), 852 [] (const auto& s) { 853 return (s.flags & SensorFlagBits::DATA_INJECTION) != 0; 854 }); 855 if (!needOperationModeSupport) { 856 return; 857 } 858 859 ASSERT_EQ(Result::OK, S()->setOperationMode(OperationMode::NORMAL)); 860 ASSERT_EQ(Result::OK, S()->setOperationMode(OperationMode::DATA_INJECTION)); 861 ASSERT_EQ(Result::OK, S()->setOperationMode(OperationMode::NORMAL)); 862 } 863 864 // Test if sensor list returned is valid 865 TEST_F(SensorsHidlTest, InjectSensorEventData) { 866 std::vector<SensorInfo> sensorList = getSensorsList(); 867 std::vector<SensorInfo> sensorSupportInjection; 868 869 bool needOperationModeSupport = 870 std::any_of(sensorList.begin(), sensorList.end(), 871 [&sensorSupportInjection] (const auto& s) { 872 bool ret = (s.flags & SensorFlagBits::DATA_INJECTION) != 0; 873 if (ret) { 874 sensorSupportInjection.push_back(s); 875 } 876 return ret; 877 }); 878 if (!needOperationModeSupport) { 879 return; 880 } 881 882 ASSERT_EQ(Result::OK, S()->setOperationMode(OperationMode::NORMAL)); 883 ASSERT_EQ(Result::OK, S()->setOperationMode(OperationMode::DATA_INJECTION)); 884 885 for (const auto &s : sensorSupportInjection) { 886 switch (s.type) { 887 case SensorType::ACCELEROMETER: 888 case SensorType::GYROSCOPE: 889 case SensorType::MAGNETIC_FIELD: { 890 usleep(100000); // sleep 100ms 891 892 Event dummy; 893 dummy.timestamp = android::elapsedRealtimeNano(); 894 dummy.sensorType = s.type; 895 dummy.sensorHandle = s.sensorHandle; 896 Vec3 v = {1, 2, 3, SensorStatus::ACCURACY_HIGH}; 897 dummy.u.vec3 = v; 898 899 EXPECT_EQ(Result::OK, S()->injectSensorData(dummy)); 900 break; 901 } 902 default: 903 break; 904 } 905 } 906 ASSERT_EQ(Result::OK, S()->setOperationMode(OperationMode::NORMAL)); 907 } 908 909 void SensorsHidlTest::testStreamingOperation(SensorType type, 910 std::chrono::nanoseconds samplingPeriod, 911 std::chrono::seconds duration, 912 const SensorEventsChecker &checker) { 913 std::vector<Event> events; 914 915 const int64_t samplingPeriodInNs = samplingPeriod.count(); 916 const int64_t batchingPeriodInNs = 0; // no batching 917 const useconds_t minTimeUs = std::chrono::microseconds(duration).count(); 918 const size_t minNEvent = duration / samplingPeriod; 919 920 SensorInfo sensor = defaultSensorByType(type); 921 922 if (!isValidType(sensor.type)) { 923 // no default sensor of this type 924 return; 925 } 926 927 if (std::chrono::microseconds(sensor.minDelay) > samplingPeriod) { 928 // rate not supported 929 return; 930 } 931 932 int32_t handle = sensor.sensorHandle; 933 934 ASSERT_EQ(batch(handle, samplingPeriodInNs, batchingPeriodInNs), Result::OK); 935 ASSERT_EQ(activate(handle, 1), Result::OK); 936 events = collectEvents(minTimeUs, minNEvent, true /*clearBeforeStart*/); 937 ASSERT_EQ(activate(handle, 0), Result::OK); 938 939 ALOGI("Collected %zu samples", events.size()); 940 941 ASSERT_GT(events.size(), 0u); 942 943 size_t nRealEvent = 0; 944 bool handleMismatchReported = false; 945 bool metaSensorTypeErrorReported = false; 946 for (auto & e : events) { 947 if (e.sensorType == type) { 948 // avoid generating hundreds of error 949 if (!handleMismatchReported) { 950 EXPECT_EQ(e.sensorHandle, handle) 951 << (handleMismatchReported = true, 952 "Event of the same type must come from the sensor registered"); 953 } 954 ++ nRealEvent; 955 } else { 956 // avoid generating hundreds of error 957 if (!metaSensorTypeErrorReported) { 958 EXPECT_TRUE(isMetaSensorType(e.sensorType)) 959 << (metaSensorTypeErrorReported = true, 960 "Only meta types are allowed besides the type registered"); 961 } 962 } 963 } 964 965 std::string s; 966 EXPECT_TRUE(checker.check(events, &s)) << s; 967 968 EXPECT_GE(nRealEvent, minNEvent / 2); // make sure returned events are not all meta 969 } 970 971 // Test if sensor hal can do UI speed accelerometer streaming properly 972 TEST_F(SensorsHidlTest, AccelerometerStreamingOperationSlow) { 973 testStreamingOperation(SensorType::ACCELEROMETER, 974 std::chrono::milliseconds(200), 975 std::chrono::seconds(5), 976 sAccelNormChecker); 977 } 978 979 // Test if sensor hal can do normal speed accelerometer streaming properly 980 TEST_F(SensorsHidlTest, AccelerometerStreamingOperationNormal) { 981 testStreamingOperation(SensorType::ACCELEROMETER, 982 std::chrono::milliseconds(20), 983 std::chrono::seconds(5), 984 sAccelNormChecker); 985 } 986 987 // Test if sensor hal can do game speed accelerometer streaming properly 988 TEST_F(SensorsHidlTest, AccelerometerStreamingOperationFast) { 989 testStreamingOperation(SensorType::ACCELEROMETER, 990 std::chrono::milliseconds(5), 991 std::chrono::seconds(5), 992 sAccelNormChecker); 993 } 994 995 // Test if sensor hal can do UI speed gyroscope streaming properly 996 TEST_F(SensorsHidlTest, GyroscopeStreamingOperationSlow) { 997 testStreamingOperation(SensorType::GYROSCOPE, 998 std::chrono::milliseconds(200), 999 std::chrono::seconds(5), 1000 sGyroNormChecker); 1001 } 1002 1003 // Test if sensor hal can do normal speed gyroscope streaming properly 1004 TEST_F(SensorsHidlTest, GyroscopeStreamingOperationNormal) { 1005 testStreamingOperation(SensorType::GYROSCOPE, 1006 std::chrono::milliseconds(20), 1007 std::chrono::seconds(5), 1008 sGyroNormChecker); 1009 } 1010 1011 // Test if sensor hal can do game speed gyroscope streaming properly 1012 TEST_F(SensorsHidlTest, GyroscopeStreamingOperationFast) { 1013 testStreamingOperation(SensorType::GYROSCOPE, 1014 std::chrono::milliseconds(5), 1015 std::chrono::seconds(5), 1016 sGyroNormChecker); 1017 } 1018 1019 // Test if sensor hal can do UI speed magnetometer streaming properly 1020 TEST_F(SensorsHidlTest, MagnetometerStreamingOperationSlow) { 1021 testStreamingOperation(SensorType::MAGNETIC_FIELD, 1022 std::chrono::milliseconds(200), 1023 std::chrono::seconds(5), 1024 NullChecker()); 1025 } 1026 1027 // Test if sensor hal can do normal speed magnetometer streaming properly 1028 TEST_F(SensorsHidlTest, MagnetometerStreamingOperationNormal) { 1029 testStreamingOperation(SensorType::MAGNETIC_FIELD, 1030 std::chrono::milliseconds(20), 1031 std::chrono::seconds(5), 1032 NullChecker()); 1033 } 1034 1035 // Test if sensor hal can do game speed magnetometer streaming properly 1036 TEST_F(SensorsHidlTest, MagnetometerStreamingOperationFast) { 1037 testStreamingOperation(SensorType::MAGNETIC_FIELD, 1038 std::chrono::milliseconds(5), 1039 std::chrono::seconds(5), 1040 NullChecker()); 1041 } 1042 1043 void SensorsHidlTest::testSamplingRateHotSwitchOperation(SensorType type) { 1044 std::vector<Event> events1, events2; 1045 1046 constexpr int64_t batchingPeriodInNs = 0; // no batching 1047 constexpr size_t minNEvent = 50; 1048 1049 SensorInfo sensor = defaultSensorByType(type); 1050 1051 if (!isValidType(sensor.type)) { 1052 // no default sensor of this type 1053 return; 1054 } 1055 1056 int32_t handle = sensor.sensorHandle; 1057 int64_t minSamplingPeriodInNs = sensor.minDelay * 1000ll; 1058 int64_t maxSamplingPeriodInNs = sensor.maxDelay * 1000ll; 1059 1060 if (minSamplingPeriodInNs == maxSamplingPeriodInNs) { 1061 // only support single rate 1062 return; 1063 } 1064 1065 ASSERT_EQ(batch(handle, minSamplingPeriodInNs, batchingPeriodInNs), Result::OK); 1066 ASSERT_EQ(activate(handle, 1), Result::OK); 1067 1068 usleep(500000); // sleep 0.5 sec to wait for change rate to happen 1069 events1 = collectEvents(sensor.minDelay * minNEvent, minNEvent, true /*clearBeforeStart*/); 1070 1071 ASSERT_EQ(batch(handle, maxSamplingPeriodInNs, batchingPeriodInNs), Result::OK); 1072 1073 usleep(500000); // sleep 0.5 sec to wait for change rate to happen 1074 events2 = collectEvents(sensor.maxDelay * minNEvent, minNEvent, true /*clearBeforeStart*/); 1075 1076 ASSERT_EQ(activate(handle, 0), Result::OK); 1077 1078 ALOGI("Collected %zu fast samples and %zu slow samples", events1.size(), events2.size()); 1079 1080 ASSERT_GT(events1.size(), 0u); 1081 ASSERT_GT(events2.size(), 0u); 1082 1083 int64_t minDelayAverageInterval, maxDelayAverageInterval; 1084 1085 size_t nEvent = 0; 1086 int64_t prevTimestamp = -1; 1087 int64_t timestampInterval = 0; 1088 for (auto & e : events1) { 1089 if (e.sensorType == type) { 1090 ASSERT_EQ(e.sensorHandle, handle); 1091 if (prevTimestamp > 0) { 1092 timestampInterval += e.timestamp - prevTimestamp; 1093 } 1094 prevTimestamp = e.timestamp; 1095 ++ nEvent; 1096 } 1097 } 1098 ASSERT_GT(nEvent, 2u); 1099 minDelayAverageInterval = timestampInterval / (nEvent - 1); 1100 1101 nEvent = 0; 1102 prevTimestamp = -1; 1103 timestampInterval = 0; 1104 for (auto & e : events2) { 1105 if (e.sensorType == type) { 1106 ASSERT_EQ(e.sensorHandle, handle); 1107 if (prevTimestamp > 0) { 1108 timestampInterval += e.timestamp - prevTimestamp; 1109 } 1110 prevTimestamp = e.timestamp; 1111 ++ nEvent; 1112 } 1113 } 1114 ASSERT_GT(nEvent, 2u); 1115 maxDelayAverageInterval = timestampInterval / (nEvent - 1); 1116 1117 // change of rate is significant. 1118 EXPECT_GT((maxDelayAverageInterval - minDelayAverageInterval), minDelayAverageInterval / 10); 1119 1120 // fastest rate sampling time is close to spec 1121 ALOGI("minDelayAverageInterval = %" PRId64, minDelayAverageInterval); 1122 EXPECT_LT(std::abs(minDelayAverageInterval - minSamplingPeriodInNs), 1123 minSamplingPeriodInNs / 10); 1124 } 1125 1126 // Test if sensor hal can do accelerometer sampling rate switch properly when sensor is active 1127 TEST_F(SensorsHidlTest, AccelerometerSamplingPeriodHotSwitchOperation) { 1128 testSamplingRateHotSwitchOperation(SensorType::ACCELEROMETER); 1129 } 1130 1131 // Test if sensor hal can do gyroscope sampling rate switch properly when sensor is active 1132 TEST_F(SensorsHidlTest, GyroscopeSamplingPeriodHotSwitchOperation) { 1133 testSamplingRateHotSwitchOperation(SensorType::GYROSCOPE); 1134 } 1135 1136 // Test if sensor hal can do magnetometer sampling rate switch properly when sensor is active 1137 TEST_F(SensorsHidlTest, MagnetometerSamplingPeriodHotSwitchOperation) { 1138 testSamplingRateHotSwitchOperation(SensorType::MAGNETIC_FIELD); 1139 } 1140 1141 void SensorsHidlTest::testBatchingOperation(SensorType type) { 1142 std::vector<Event> events; 1143 1144 constexpr int64_t maxBatchingTestTimeNs = 30ull * 1000 * 1000 * 1000; 1145 constexpr int64_t oneSecondInNs = 1ull * 1000 * 1000 * 1000; 1146 1147 SensorInfo sensor = defaultSensorByType(type); 1148 1149 if (!isValidType(sensor.type)) { 1150 // no default sensor of this type 1151 return; 1152 } 1153 1154 int32_t handle = sensor.sensorHandle; 1155 int64_t minSamplingPeriodInNs = sensor.minDelay * 1000ll; 1156 uint32_t minFifoCount = sensor.fifoReservedEventCount; 1157 int64_t batchingPeriodInNs = minFifoCount * minSamplingPeriodInNs; 1158 1159 if (batchingPeriodInNs < oneSecondInNs) { 1160 // batching size too small to test reliably 1161 return; 1162 } 1163 1164 batchingPeriodInNs = std::min(batchingPeriodInNs, maxBatchingTestTimeNs); 1165 1166 ALOGI("Test batching for %d ms", (int)(batchingPeriodInNs / 1000 / 1000)); 1167 1168 int64_t allowedBatchDeliverTimeNs = 1169 std::max(oneSecondInNs, batchingPeriodInNs / 10); 1170 1171 ASSERT_EQ(batch(handle, minSamplingPeriodInNs, INT64_MAX), Result::OK); 1172 ASSERT_EQ(activate(handle, 1), Result::OK); 1173 1174 usleep(500000); // sleep 0.5 sec to wait for initialization 1175 ASSERT_EQ(flush(handle), Result::OK); 1176 1177 // wait for 80% of the reserved batching period 1178 // there should not be any significant amount of events 1179 // since collection is not enabled all events will go down the drain 1180 usleep(batchingPeriodInNs / 1000 * 8 / 10); 1181 1182 SensorsHidlEnvironment::Instance()->setCollection(true); 1183 // clean existing collections 1184 collectEvents(0 /*timeLimitUs*/, 0/*nEventLimit*/, 1185 true /*clearBeforeStart*/, false /*change collection*/); 1186 1187 // 0.8 + 0.2 times the batching period 1188 usleep(batchingPeriodInNs / 1000 * 8 / 10); 1189 ASSERT_EQ(flush(handle), Result::OK); 1190 1191 // plus some time for the event to deliver 1192 events = collectEvents(allowedBatchDeliverTimeNs / 1000, 1193 minFifoCount, false /*clearBeforeStart*/, false /*change collection*/); 1194 1195 SensorsHidlEnvironment::Instance()->setCollection(false); 1196 ASSERT_EQ(activate(handle, 0), Result::OK); 1197 1198 size_t nEvent = 0; 1199 for (auto & e : events) { 1200 if (e.sensorType == type && e.sensorHandle == handle) { 1201 ++ nEvent; 1202 } 1203 } 1204 1205 // at least reach 90% of advertised capacity 1206 ASSERT_GT(nEvent, (size_t)(minFifoCount * 9 / 10)); 1207 } 1208 1209 // Test if sensor hal can do accelerometer batching properly 1210 TEST_F(SensorsHidlTest, AccelerometerBatchingOperation) { 1211 testBatchingOperation(SensorType::ACCELEROMETER); 1212 } 1213 1214 // Test if sensor hal can do gyroscope batching properly 1215 TEST_F(SensorsHidlTest, GyroscopeBatchingOperation) { 1216 testBatchingOperation(SensorType::GYROSCOPE); 1217 } 1218 1219 // Test if sensor hal can do magnetometer batching properly 1220 TEST_F(SensorsHidlTest, MagnetometerBatchingOperation) { 1221 testBatchingOperation(SensorType::MAGNETIC_FIELD); 1222 } 1223 1224 void SensorsHidlTest::testDirectReportOperation( 1225 SensorType type, SharedMemType memType, RateLevel rate, const SensorEventsChecker &checker) { 1226 constexpr size_t kEventSize = static_cast<size_t>(SensorsEventFormatOffset::TOTAL_LENGTH); 1227 constexpr size_t kNEvent = 4096; 1228 constexpr size_t kMemSize = kEventSize * kNEvent; 1229 1230 constexpr float kNormalNominal = 50; 1231 constexpr float kFastNominal = 200; 1232 constexpr float kVeryFastNominal = 800; 1233 1234 constexpr float kNominalTestTimeSec = 1.f; 1235 constexpr float kMaxTestTimeSec = kNominalTestTimeSec + 0.5f; // 0.5 second for initialization 1236 1237 SensorInfo sensor = defaultSensorByType(type); 1238 1239 if (!isValidType(sensor.type)) { 1240 // no default sensor of this type 1241 return; 1242 } 1243 1244 if (!isDirectReportRateSupported(sensor, rate)) { 1245 return; 1246 } 1247 1248 if (!isDirectChannelTypeSupported(sensor, memType)) { 1249 return; 1250 } 1251 1252 std::unique_ptr<SensorsTestSharedMemory> 1253 mem(SensorsTestSharedMemory::create(memType, kMemSize)); 1254 ASSERT_NE(mem, nullptr); 1255 1256 char* buffer = mem->getBuffer(); 1257 // fill memory with data 1258 for (size_t i = 0; i < kMemSize; ++i) { 1259 buffer[i] = '\xcc'; 1260 } 1261 1262 int32_t channelHandle; 1263 registerDirectChannel(mem->getSharedMemInfo(), 1264 [&channelHandle] (auto result, auto channelHandle_) { 1265 ASSERT_EQ(result, Result::OK); 1266 channelHandle = channelHandle_; 1267 }); 1268 1269 // check memory is zeroed 1270 for (size_t i = 0; i < kMemSize; ++i) { 1271 ASSERT_EQ(buffer[i], '\0'); 1272 } 1273 1274 int32_t eventToken; 1275 configDirectReport(sensor.sensorHandle, channelHandle, rate, 1276 [&eventToken] (auto result, auto token) { 1277 ASSERT_EQ(result, Result::OK); 1278 eventToken = token; 1279 }); 1280 1281 usleep(static_cast<useconds_t>(kMaxTestTimeSec * 1e6f)); 1282 auto events = mem->parseEvents(); 1283 1284 // find norminal rate 1285 float nominalFreq = 0.f; 1286 switch (rate) { 1287 case RateLevel::NORMAL: 1288 nominalFreq = kNormalNominal; 1289 break; 1290 case RateLevel::FAST: 1291 nominalFreq = kFastNominal; 1292 break; 1293 case RateLevel::VERY_FAST: 1294 nominalFreq = kVeryFastNominal; 1295 break; 1296 case RateLevel::STOP: 1297 FAIL(); 1298 } 1299 1300 // allowed to be between 55% and 220% of nominal freq 1301 ASSERT_GT(events.size(), static_cast<size_t>(nominalFreq * 0.55f * kNominalTestTimeSec)); 1302 ASSERT_LT(events.size(), static_cast<size_t>(nominalFreq * 2.2f * kMaxTestTimeSec)); 1303 1304 int64_t lastTimestamp = 0; 1305 bool typeErrorReported = false; 1306 bool tokenErrorReported = false; 1307 bool timestampErrorReported = false; 1308 for (auto &e : events) { 1309 if (!typeErrorReported) { 1310 EXPECT_EQ(type, e.sensorType) 1311 << (typeErrorReported = true, "Type in event does not match type of sensor registered."); 1312 } 1313 if (!tokenErrorReported) { 1314 EXPECT_EQ(eventToken, e.sensorHandle) 1315 << (tokenErrorReported = true, 1316 "Event token does not match that retured from configDirectReport"); 1317 } 1318 if (!timestampErrorReported) { 1319 EXPECT_GT(e.timestamp, lastTimestamp) 1320 << (timestampErrorReported = true, "Timestamp not monotonically increasing"); 1321 } 1322 lastTimestamp = e.timestamp; 1323 } 1324 1325 std::string s; 1326 EXPECT_TRUE(checker.check(events, &s)) << s; 1327 1328 // stop sensor and unregister channel 1329 configDirectReport(sensor.sensorHandle, channelHandle, RateLevel::STOP, 1330 [](auto result, auto) { EXPECT_EQ(result, Result::OK); }); 1331 EXPECT_EQ(unregisterDirectChannel(channelHandle), Result::OK); 1332 } 1333 1334 // Test sensor event direct report with ashmem for accel sensor at normal rate 1335 TEST_F(SensorsHidlTest, AccelerometerAshmemDirectReportOperationNormal) { 1336 testDirectReportOperation(SensorType::ACCELEROMETER, SharedMemType::ASHMEM, RateLevel::NORMAL, 1337 sAccelNormChecker); 1338 } 1339 1340 // Test sensor event direct report with ashmem for accel sensor at fast rate 1341 TEST_F(SensorsHidlTest, AccelerometerAshmemDirectReportOperationFast) { 1342 testDirectReportOperation(SensorType::ACCELEROMETER, SharedMemType::ASHMEM, RateLevel::FAST, 1343 sAccelNormChecker); 1344 } 1345 1346 // Test sensor event direct report with ashmem for accel sensor at very fast rate 1347 TEST_F(SensorsHidlTest, AccelerometerAshmemDirectReportOperationVeryFast) { 1348 testDirectReportOperation(SensorType::ACCELEROMETER, SharedMemType::ASHMEM, RateLevel::VERY_FAST, 1349 sAccelNormChecker); 1350 } 1351 1352 // Test sensor event direct report with ashmem for gyro sensor at normal rate 1353 TEST_F(SensorsHidlTest, GyroscopeAshmemDirectReportOperationNormal) { 1354 testDirectReportOperation(SensorType::GYROSCOPE, SharedMemType::ASHMEM, RateLevel::NORMAL, 1355 sGyroNormChecker); 1356 } 1357 1358 // Test sensor event direct report with ashmem for gyro sensor at fast rate 1359 TEST_F(SensorsHidlTest, GyroscopeAshmemDirectReportOperationFast) { 1360 testDirectReportOperation(SensorType::GYROSCOPE, SharedMemType::ASHMEM, RateLevel::FAST, 1361 sGyroNormChecker); 1362 } 1363 1364 // Test sensor event direct report with ashmem for gyro sensor at very fast rate 1365 TEST_F(SensorsHidlTest, GyroscopeAshmemDirectReportOperationVeryFast) { 1366 testDirectReportOperation(SensorType::GYROSCOPE, SharedMemType::ASHMEM, RateLevel::VERY_FAST, 1367 sGyroNormChecker); 1368 } 1369 1370 // Test sensor event direct report with ashmem for mag sensor at normal rate 1371 TEST_F(SensorsHidlTest, MagnetometerAshmemDirectReportOperationNormal) { 1372 testDirectReportOperation(SensorType::MAGNETIC_FIELD, SharedMemType::ASHMEM, RateLevel::NORMAL, 1373 NullChecker()); 1374 } 1375 1376 // Test sensor event direct report with ashmem for mag sensor at fast rate 1377 TEST_F(SensorsHidlTest, MagnetometerAshmemDirectReportOperationFast) { 1378 testDirectReportOperation(SensorType::MAGNETIC_FIELD, SharedMemType::ASHMEM, RateLevel::FAST, 1379 NullChecker()); 1380 } 1381 1382 // Test sensor event direct report with ashmem for mag sensor at very fast rate 1383 TEST_F(SensorsHidlTest, MagnetometerAshmemDirectReportOperationVeryFast) { 1384 testDirectReportOperation( 1385 SensorType::MAGNETIC_FIELD, SharedMemType::ASHMEM, RateLevel::VERY_FAST, NullChecker()); 1386 } 1387 1388 int main(int argc, char **argv) { 1389 ::testing::AddGlobalTestEnvironment(SensorsHidlEnvironment::Instance()); 1390 ::testing::InitGoogleTest(&argc, argv); 1391 int status = RUN_ALL_TESTS(); 1392 ALOGI("Test result = %d", status); 1393 return status; 1394 } 1395 // vim: set ts=2 sw=2 1396