sensors/1.0/vts/functional/VtsHalSensorsV1_0TargetTest.cpp

   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, 0.5f/*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 = 500;
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 (!isDirectReportRateSupported(sensor, rate)) {
1240     return;
1241   }
1242
1243   if (!isDirectChannelTypeSupported(sensor, memType)) {
1244     return;
1245   }
1246
1247   std::unique_ptr<SensorsTestSharedMemory>
1248       mem(SensorsTestSharedMemory::create(memType, kMemSize));
1249   ASSERT_NE(mem, nullptr);
1250
1251   char* buffer = mem->getBuffer();
1252   // fill memory with data
1253   for (size_t i = 0; i < kMemSize; ++i) {
1254     buffer[i] = '\xcc';
1255   }
1256
1257   int32_t channelHandle;
1258   registerDirectChannel(mem->getSharedMemInfo(),
1259       [&channelHandle] (auto result, auto channelHandle_) {
1260           ASSERT_EQ(result, Result::OK);
1261           channelHandle = channelHandle_;
1262       });
1263
1264   // check memory is zeroed
1265   for (size_t i = 0; i < kMemSize; ++i) {
1266     ASSERT_EQ(buffer[i], '\0');
1267   }
1268
1269   int32_t eventToken;
1270   configDirectReport(sensor.sensorHandle, channelHandle, rate,
1271       [&eventToken] (auto result, auto token) {
1272           ASSERT_EQ(result, Result::OK);
1273           eventToken = token;
1274       });
1275
1276   usleep(static_cast<useconds_t>(kMaxTestTimeSec * 1e6f));
1277   auto events = mem->parseEvents();
1278
1279   // find norminal rate
1280   float nominalFreq = 0.f;
1281   switch (rate) {
1282       case RateLevel::NORMAL:
1283           nominalFreq = kNormalNominal;
1284           break;
1285       case RateLevel::FAST:
1286           nominalFreq = kFastNominal;
1287           break;
1288       case RateLevel::VERY_FAST:
1289           nominalFreq = kVeryFastNominal;
1290           break;
1291       case RateLevel::STOP:
1292           FAIL();
1293   }
1294
1295   // allowed to be between 55% and 220% of nominal freq
1296   ASSERT_GT(events.size(), static_cast<size_t>(nominalFreq * 0.55f * kNominalTestTimeSec));
1297   ASSERT_LT(events.size(), static_cast<size_t>(nominalFreq * 2.2f * kMaxTestTimeSec));
1298
1299   int64_t lastTimestamp = 0;
1300   bool typeErrorReported = false;
1301   bool tokenErrorReported = false;
1302   bool timestampErrorReported = false;
1303   for (auto &e : events) {
1304     if (!typeErrorReported) {
1305       EXPECT_EQ(type, e.sensorType)
1306           << (typeErrorReported = true, "Type in event does not match type of sensor registered.");
1307     }
1308     if (!tokenErrorReported) {
1309       EXPECT_EQ(eventToken, e.sensorHandle)
1310           << (tokenErrorReported = true,
1311             "Event token does not match that retured from configDirectReport");
1312     }
1313     if (!timestampErrorReported) {
1314       EXPECT_GT(e.timestamp, lastTimestamp)
1315           << (timestampErrorReported = true, "Timestamp not monotonically increasing");
1316     }
1317     lastTimestamp = e.timestamp;
1318   }
1319
1320   std::string s;
1321   EXPECT_TRUE(checker.check(events, &s)) << s;
1322
1323   // stop sensor and unregister channel
1324   configDirectReport(sensor.sensorHandle, channelHandle, RateLevel::STOP,
1325         [&eventToken] (auto result, auto) {
1326             EXPECT_EQ(result, Result::OK);
1327         });
1328   EXPECT_EQ(unregisterDirectChannel(channelHandle), Result::OK);
1329 }
1330
1331 // Test sensor event direct report with ashmem for accel sensor at normal rate
1332 TEST_F(SensorsHidlTest, AccelerometerAshmemDirectReportOperationNormal) {
1333   testDirectReportOperation(SensorType::ACCELEROMETER, SharedMemType::ASHMEM, RateLevel::NORMAL,
1334                             sAccelNormChecker);
1335 }
1336
1337 // Test sensor event direct report with ashmem for accel sensor at fast rate
1338 TEST_F(SensorsHidlTest, AccelerometerAshmemDirectReportOperationFast) {
1339   testDirectReportOperation(SensorType::ACCELEROMETER, SharedMemType::ASHMEM, RateLevel::FAST,
1340                             sAccelNormChecker);
1341 }
1342
1343 // Test sensor event direct report with ashmem for accel sensor at very fast rate
1344 TEST_F(SensorsHidlTest, AccelerometerAshmemDirectReportOperationVeryFast) {
1345   testDirectReportOperation(SensorType::ACCELEROMETER, SharedMemType::ASHMEM, RateLevel::VERY_FAST,
1346                             sAccelNormChecker);
1347 }
1348
1349 // Test sensor event direct report with ashmem for gyro sensor at normal rate
1350 TEST_F(SensorsHidlTest, GyroscopeAshmemDirectReportOperationNormal) {
1351   testDirectReportOperation(SensorType::GYROSCOPE, SharedMemType::ASHMEM, RateLevel::NORMAL,
1352                             sGyroNormChecker);
1353 }
1354
1355 // Test sensor event direct report with ashmem for gyro sensor at fast rate
1356 TEST_F(SensorsHidlTest, GyroscopeAshmemDirectReportOperationFast) {
1357   testDirectReportOperation(SensorType::GYROSCOPE, SharedMemType::ASHMEM, RateLevel::FAST,
1358                             sGyroNormChecker);
1359 }
1360
1361 // Test sensor event direct report with ashmem for gyro sensor at very fast rate
1362 TEST_F(SensorsHidlTest, GyroscopeAshmemDirectReportOperationVeryFast) {
1363   testDirectReportOperation(SensorType::GYROSCOPE, SharedMemType::ASHMEM, RateLevel::VERY_FAST,
1364                             sGyroNormChecker);
1365 }
1366
1367 // Test sensor event direct report with ashmem for mag sensor at normal rate
1368 TEST_F(SensorsHidlTest, MagnetometerAshmemDirectReportOperationNormal) {
1369   testDirectReportOperation(SensorType::MAGNETIC_FIELD, SharedMemType::ASHMEM, RateLevel::NORMAL,
1370                             NullChecker());
1371 }
1372
1373 // Test sensor event direct report with ashmem for mag sensor at fast rate
1374 TEST_F(SensorsHidlTest, MagnetometerAshmemDirectReportOperationFast) {
1375   testDirectReportOperation(SensorType::MAGNETIC_FIELD, SharedMemType::ASHMEM, RateLevel::FAST,
1376                             NullChecker());
1377 }
1378
1379 // Test sensor event direct report with ashmem for mag sensor at very fast rate
1380 TEST_F(SensorsHidlTest, MagnetometerAshmemDirectReportOperationVeryFast) {
1381   testDirectReportOperation(
1382       SensorType::MAGNETIC_FIELD, SharedMemType::ASHMEM, RateLevel::VERY_FAST, NullChecker());
1383 }
1384
1385 int main(int argc, char **argv) {
1386   ::testing::AddGlobalTestEnvironment(SensorsHidlEnvironment::Instance());
1387   ::testing::InitGoogleTest(&argc, argv);
1388   int status = RUN_ALL_TESTS();
1389   ALOGI("Test result = %d", status);
1390   return status;
1391 }
1392 // vim: set ts=2 sw=2