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 <android-base/logging.h>
  19 #include <android/hardware/sensors/1.0/ISensors.h>
  20 #include <android/hardware/sensors/1.0/types.h>
  21 #include <android/log.h>
  22 #include <cutils/ashmem.h>
  23 #include <VtsHalHidlTargetBaseTest.h>
  24 #include <hardware/sensors.h>       // for sensor type strings
  25
  26 #include <algorithm>
  27 #include <cinttypes>
  28 #include <cmath>
  29 #include <memory>
  30 #include <mutex>
  31 #include <thread>
  32 #include <unordered_set>
  33 #include <vector>
  34
  35 #include <sys/mman.h>
  36 #include <unistd.h>
  37
  38 using ::android::hardware::Return;
  39 using ::android::hardware::Void;
  40 using ::android::hardware::hidl_string;
  41 using ::android::sp;
  42 using namespace ::android::hardware::sensors::V1_0;
  43
  44 // Test environment for sensors
  45 class SensorsHidlEnvironment : public ::testing::Environment {
  46  public:
  47   // get the test environment singleton
  48   static SensorsHidlEnvironment* Instance() {
  49     static SensorsHidlEnvironment* instance = new SensorsHidlEnvironment;
  50     return instance;
  51   }
  52
  53   // sensors hidl service
  54   sp<ISensors> sensors;
  55
  56   virtual void SetUp();
  57   virtual void TearDown();
  58
  59   // Get and clear all events collected so far (like "cat" shell command).
  60   // If output is nullptr, it clears all collected events.
  61   void catEvents(std::vector<Event>* output);
  62
  63   // set sensor event collection status
  64   void setCollection(bool enable);
  65
  66  private:
  67   SensorsHidlEnvironment() {}
  68
  69   void addEvent(const Event& ev);
  70   void startPollingThread();
  71   static void pollingThread(SensorsHidlEnvironment* env, std::shared_ptr<bool> stop);
  72
  73   bool collectionEnabled;
  74   std::shared_ptr<bool> stopThread;
  75   std::thread pollThread;
  76   std::vector<Event> events;
  77   std::mutex events_mutex;
  78
  79   GTEST_DISALLOW_COPY_AND_ASSIGN_(SensorsHidlEnvironment);
  80 };
  81
  82 void SensorsHidlEnvironment::SetUp() {
  83   sensors = ::testing::VtsHalHidlTargetBaseTest::getService<ISensors>();
  84   ALOGI_IF(sensors, "sensors is not nullptr, %p", sensors.get());
  85   ASSERT_NE(sensors, nullptr);
  86
  87   collectionEnabled = false;
  88   startPollingThread();
  89
  90   // In case framework just stopped for test and there is sensor events in the pipe,
  91   // wait some time for those events to be cleared to avoid them messing up the test.
  92   std::this_thread::sleep_for(std::chrono::seconds(3));
  93 }
  94
  95 void SensorsHidlEnvironment::TearDown() {
  96   ALOGI("TearDown SensorsHidlEnvironement");
  97
  98   if (stopThread) {
  99     *stopThread = true;
 100   }
 101   pollThread.detach();
 102 }
 103
 104 void SensorsHidlEnvironment::catEvents(std::vector<Event>* output) {
 105   std::lock_guard<std::mutex> lock(events_mutex);
 106   if (output) {
 107     output->insert(output->end(), events.begin(), events.end());
 108   }
 109   events.clear();
 110 }
 111
 112 void SensorsHidlEnvironment::setCollection(bool enable) {
 113   std::lock_guard<std::mutex> lock(events_mutex);
 114   collectionEnabled = enable;
 115 }
 116
 117 void SensorsHidlEnvironment::addEvent(const Event& ev) {
 118   std::lock_guard<std::mutex> lock(events_mutex);
 119   if (collectionEnabled) {
 120     events.push_back(ev);
 121   }
 122 }
 123
 124 void SensorsHidlEnvironment::startPollingThread() {
 125   stopThread = std::shared_ptr<bool>(new bool(false));
 126   pollThread = std::thread(pollingThread, this, stopThread);
 127   events.reserve(128);
 128 }
 129
 130 void SensorsHidlEnvironment::pollingThread(
 131     SensorsHidlEnvironment* env, std::shared_ptr<bool> stop) {
 132   ALOGD("polling thread start");
 133   bool needExit = *stop;
 134
 135   while(!needExit) {
 136     env->sensors->poll(1,
 137         [&](auto result, const auto &events, const auto &dynamicSensorsAdded) {
 138           if (result != Result::OK
 139               || (events.size() == 0 && dynamicSensorsAdded.size() == 0)
 140               || *stop) {
 141             needExit = true;
 142             return;
 143           }
 144
 145           if (events.size() > 0) {
 146             env->addEvent(events[0]);
 147           }
 148         });
 149   }
 150   ALOGD("polling thread end");
 151 }
 152
 153 class SensorsTestSharedMemory {
 154  public:
 155   static SensorsTestSharedMemory* create(SharedMemType type, size_t size);
 156   SharedMemInfo getSharedMemInfo() const;
 157   char * getBuffer() const;
 158   std::vector<Event> parseEvents(int64_t lastCounter = -1, size_t offset = 0) const;
 159   virtual ~SensorsTestSharedMemory();
 160  private:
 161   SensorsTestSharedMemory(SharedMemType type, size_t size);
 162
 163   SharedMemType mType;
 164   native_handle_t* mNativeHandle;
 165   size_t mSize;
 166   char* mBuffer;
 167
 168   DISALLOW_COPY_AND_ASSIGN(SensorsTestSharedMemory);
 169 };
 170
 171 SharedMemInfo SensorsTestSharedMemory::getSharedMemInfo() const {
 172   SharedMemInfo mem = {
 173     .type = mType,
 174     .format = SharedMemFormat::SENSORS_EVENT,
 175     .size = static_cast<uint32_t>(mSize),
 176     .memoryHandle = mNativeHandle
 177   };
 178   return mem;
 179 }
 180
 181 char * SensorsTestSharedMemory::getBuffer() const {
 182   return mBuffer;
 183 }
 184
 185 std::vector<Event> SensorsTestSharedMemory::parseEvents(int64_t lastCounter, size_t offset) const {
 186
 187   constexpr size_t kEventSize = static_cast<size_t>(SensorsEventFormatOffset::TOTAL_LENGTH);
 188   constexpr size_t kOffsetSize = static_cast<size_t>(SensorsEventFormatOffset::SIZE_FIELD);
 189   constexpr size_t kOffsetToken = static_cast<size_t>(SensorsEventFormatOffset::REPORT_TOKEN);
 190   constexpr size_t kOffsetType = static_cast<size_t>(SensorsEventFormatOffset::SENSOR_TYPE);
 191   constexpr size_t kOffsetAtomicCounter =
 192       static_cast<size_t>(SensorsEventFormatOffset::ATOMIC_COUNTER);
 193   constexpr size_t kOffsetTimestamp = static_cast<size_t>(SensorsEventFormatOffset::TIMESTAMP);
 194   constexpr size_t kOffsetData = static_cast<size_t>(SensorsEventFormatOffset::DATA);
 195
 196   std::vector<Event> events;
 197   std::vector<float> data(16);
 198
 199   while (offset + kEventSize <= mSize) {
 200     int64_t atomicCounter = *reinterpret_cast<uint32_t *>(mBuffer + offset + kOffsetAtomicCounter);
 201     if (atomicCounter <= lastCounter) {
 202       break;
 203     }
 204
 205     int32_t size = *reinterpret_cast<int32_t *>(mBuffer + offset + kOffsetSize);
 206     if (size != kEventSize) {
 207       // unknown error, events parsed may be wrong, remove all
 208       events.clear();
 209       break;
 210     }
 211
 212     int32_t token = *reinterpret_cast<int32_t *>(mBuffer + offset + kOffsetToken);
 213     int32_t type = *reinterpret_cast<int32_t *>(mBuffer + offset + kOffsetType);
 214     int64_t timestamp = *reinterpret_cast<int64_t *>(mBuffer + offset + kOffsetTimestamp);
 215
 216     ALOGV("offset = %zu, cnt %" PRId64 ", token %" PRId32 ", type %" PRId32 ", timestamp %" PRId64,
 217         offset, atomicCounter, token, type, timestamp);
 218
 219     Event event = {
 220       .timestamp = timestamp,
 221       .sensorHandle = token,
 222       .sensorType = static_cast<SensorType>(type),
 223     };
 224     event.u.data = android::hardware::hidl_array<float, 16>
 225         (reinterpret_cast<float*>(mBuffer + offset + kOffsetData));
 226
 227     events.push_back(event);
 228
 229     lastCounter = atomicCounter;
 230     offset += kEventSize;
 231   }
 232
 233   return events;
 234 }
 235
 236 SensorsTestSharedMemory::SensorsTestSharedMemory(SharedMemType type, size_t size)
 237     : mType(type), mSize(0), mBuffer(nullptr) {
 238   native_handle_t *handle = nullptr;
 239   char *buffer = nullptr;
 240   switch(type) {
 241     case SharedMemType::ASHMEM: {
 242       int fd;
 243       handle = ::native_handle_create(1 /*nFds*/, 0/*nInts*/);
 244       if (handle != nullptr) {
 245         handle->data[0] = fd = ::ashmem_create_region("SensorsTestSharedMemory", size);
 246         if (handle->data[0] > 0) {
 247           // memory is pinned by default
 248           buffer = static_cast<char *>
 249               (::mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0));
 250           if (buffer != reinterpret_cast<char*>(MAP_FAILED)) {
 251             break;
 252           }
 253           ::native_handle_close(handle);
 254         }
 255         ::native_handle_delete(handle);
 256         handle = nullptr;
 257       }
 258       break;
 259     }
 260     default:
 261       break;
 262   }
 263
 264   if (buffer != nullptr) {
 265     mNativeHandle = handle;
 266     mSize = size;
 267     mBuffer = buffer;
 268   }
 269 }
 270
 271 SensorsTestSharedMemory::~SensorsTestSharedMemory() {
 272   switch(mType) {
 273     case SharedMemType::ASHMEM: {
 274       if (mSize != 0) {
 275         ::munmap(mBuffer, mSize);
 276         mBuffer = nullptr;
 277
 278         ::native_handle_close(mNativeHandle);
 279         ::native_handle_delete(mNativeHandle);
 280
 281         mNativeHandle = nullptr;
 282         mSize = 0;
 283       }
 284       break;
 285     }
 286     default: {
 287       if (mNativeHandle != nullptr || mSize != 0 || mBuffer != nullptr) {
 288         ALOGE("SensorsTestSharedMemory %p not properly destructed: "
 289             "type %d, native handle %p, size %zu, buffer %p",
 290             this, static_cast<int>(mType), mNativeHandle, mSize, mBuffer);
 291       }
 292       break;
 293     }
 294   }
 295 }
 296
 297 SensorsTestSharedMemory* SensorsTestSharedMemory::create(SharedMemType type, size_t size) {
 298   constexpr size_t kMaxSize = 128*1024*1024; // sensor test should not need more than 128M
 299   if (size == 0 || size >= kMaxSize) {
 300     return nullptr;
 301   }
 302
 303   auto m = new SensorsTestSharedMemory(type, size);
 304   if (m->mSize != size || m->mBuffer == nullptr) {
 305     delete m;
 306     m = nullptr;
 307   }
 308   return m;
 309 }
 310
 311 // The main test class for SENSORS HIDL HAL.
 312 class SensorsHidlTest : public ::testing::VtsHalHidlTargetBaseTest {
 313  public:
 314   virtual void SetUp() override {
 315   }
 316
 317   virtual void TearDown() override {
 318     // stop all sensors
 319     for (auto s : mSensorHandles) {
 320       S()->activate(s, false);
 321     }
 322     mSensorHandles.clear();
 323
 324     // stop all direct report and channels
 325     for (auto c : mDirectChannelHandles) {
 326       // disable all reports
 327       S()->configDirectReport(-1, c, RateLevel::STOP, [] (auto, auto){});
 328       S()->unregisterDirectChannel(c);
 329     }
 330     mDirectChannelHandles.clear();
 331   }
 332
 333  protected:
 334   SensorInfo defaultSensorByType(SensorType type);
 335   std::vector<Event> collectEvents(useconds_t timeLimitUs, size_t nEventLimit,
 336         bool clearBeforeStart = true, bool changeCollection = true);
 337
 338   // implementation wrapper
 339   Return<void> getSensorsList(ISensors::getSensorsList_cb _hidl_cb) {
 340     return S()->getSensorsList(_hidl_cb);
 341   }
 342
 343   Return<Result> activate(
 344           int32_t sensorHandle, bool enabled);
 345
 346   Return<Result> batch(
 347           int32_t sensorHandle,
 348           int64_t samplingPeriodNs,
 349           int64_t maxReportLatencyNs) {
 350     return S()->batch(sensorHandle, samplingPeriodNs, maxReportLatencyNs);
 351   }
 352
 353   Return<Result> flush(int32_t sensorHandle) {
 354     return S()->flush(sensorHandle);
 355   }
 356
 357   Return<Result> injectSensorData(const Event& event) {
 358     return S()->injectSensorData(event);
 359   }
 360
 361   Return<void> registerDirectChannel(
 362           const SharedMemInfo& mem, ISensors::registerDirectChannel_cb _hidl_cb);
 363
 364   Return<Result> unregisterDirectChannel(int32_t channelHandle) {
 365     return S()->unregisterDirectChannel(channelHandle);
 366   }
 367
 368   Return<void> configDirectReport(
 369           int32_t sensorHandle, int32_t channelHandle, RateLevel rate,
 370           ISensors::configDirectReport_cb _hidl_cb) {
 371     return S()->configDirectReport(sensorHandle, channelHandle, rate, _hidl_cb);
 372   }
 373
 374   inline sp<ISensors>& S() {
 375     return SensorsHidlEnvironment::Instance()->sensors;
 376   }
 377
 378   inline static SensorFlagBits extractReportMode(uint64_t flag) {
 379     return (SensorFlagBits) (flag
 380         & ((uint64_t) SensorFlagBits::CONTINUOUS_MODE
 381           | (uint64_t) SensorFlagBits::ON_CHANGE_MODE
 382           | (uint64_t) SensorFlagBits::ONE_SHOT_MODE
 383           | (uint64_t) SensorFlagBits::SPECIAL_REPORTING_MODE));
 384   }
 385
 386   inline static bool isMetaSensorType(SensorType type) {
 387     return (type == SensorType::META_DATA
 388             || type == SensorType::DYNAMIC_SENSOR_META
 389             || type == SensorType::ADDITIONAL_INFO);
 390   }
 391
 392   inline static bool isValidType(SensorType type) {
 393     return (int32_t) type > 0;
 394   }
 395
 396   static bool typeMatchStringType(SensorType type, const hidl_string& stringType);
 397   static bool typeMatchReportMode(SensorType type, SensorFlagBits reportMode);
 398   static bool delayMatchReportMode(int32_t minDelay, int32_t maxDelay, SensorFlagBits reportMode);
 399   static SensorFlagBits expectedReportModeForType(SensorType type);
 400
 401   // all sensors and direct channnels used
 402   std::unordered_set<int32_t> mSensorHandles;
 403   std::unordered_set<int32_t> mDirectChannelHandles;
 404 };
 405
 406
 407 Return<Result> SensorsHidlTest::activate(int32_t sensorHandle, bool enabled) {
 408   // If activating a sensor, add the handle in a set so that when test fails it can be turned off.
 409   // The handle is not removed when it is deactivating on purpose so that it is not necessary to
 410   // check the return value of deactivation. Deactivating a sensor more than once does not have
 411   // negative effect.
 412   if (enabled) {
 413     mSensorHandles.insert(sensorHandle);
 414   }
 415   return S()->activate(sensorHandle, enabled);
 416 }
 417
 418 Return<void> SensorsHidlTest::registerDirectChannel(
 419     const SharedMemInfo& mem, ISensors::registerDirectChannel_cb cb) {
 420   // If registeration of a channel succeeds, add the handle of channel to a set so that it can be
 421   // unregistered when test fails. Unregister a channel does not remove the handle on purpose.
 422   // Unregistering a channel more than once should not have negative effect.
 423   S()->registerDirectChannel(mem,
 424       [&] (auto result, auto channelHandle) {
 425         if (result == Result::OK) {
 426           mDirectChannelHandles.insert(channelHandle);
 427         }
 428         cb(result, channelHandle);
 429       });
 430   return Void();
 431 }
 432
 433 std::vector<Event> SensorsHidlTest::collectEvents(useconds_t timeLimitUs, size_t nEventLimit,
 434       bool clearBeforeStart, bool changeCollection) {
 435   std::vector<Event> events;
 436   constexpr useconds_t SLEEP_GRANULARITY = 100*1000; //gradularity 100 ms
 437
 438   ALOGI("collect max of %zu events for %d us, clearBeforeStart %d",
 439         nEventLimit, timeLimitUs, clearBeforeStart);
 440
 441   if (changeCollection) {
 442     SensorsHidlEnvironment::Instance()->setCollection(true);
 443   }
 444   if (clearBeforeStart) {
 445     SensorsHidlEnvironment::Instance()->catEvents(nullptr);
 446   }
 447
 448   while (timeLimitUs > 0) {
 449     useconds_t duration = std::min(SLEEP_GRANULARITY, timeLimitUs);
 450     usleep(duration);
 451     timeLimitUs -= duration;
 452
 453     SensorsHidlEnvironment::Instance()->catEvents(&events);
 454     if (events.size() >= nEventLimit) {
 455       break;
 456     }
 457     ALOGV("time to go = %d, events to go = %d",
 458           (int)timeLimitUs, (int)(nEventLimit - events.size()));
 459   }
 460
 461   if (changeCollection) {
 462     SensorsHidlEnvironment::Instance()->setCollection(false);
 463   }
 464   return events;
 465 }
 466
 467 bool SensorsHidlTest::typeMatchStringType(SensorType type, const hidl_string& stringType) {
 468
 469   if (type >= SensorType::DEVICE_PRIVATE_BASE) {
 470     return true;
 471   }
 472
 473   bool res = true;
 474   switch (type) {
 475 #define CHECK_TYPE_STRING_FOR_SENSOR_TYPE(type) \
 476     case SensorType::type: res = stringType == SENSOR_STRING_TYPE_ ## type;\
 477       break;\
 478
 479     CHECK_TYPE_STRING_FOR_SENSOR_TYPE(ACCELEROMETER);
 480     CHECK_TYPE_STRING_FOR_SENSOR_TYPE(MAGNETIC_FIELD);
 481     CHECK_TYPE_STRING_FOR_SENSOR_TYPE(ORIENTATION);
 482     CHECK_TYPE_STRING_FOR_SENSOR_TYPE(GYROSCOPE);
 483     CHECK_TYPE_STRING_FOR_SENSOR_TYPE(LIGHT);
 484     CHECK_TYPE_STRING_FOR_SENSOR_TYPE(PRESSURE);
 485     CHECK_TYPE_STRING_FOR_SENSOR_TYPE(TEMPERATURE);
 486     CHECK_TYPE_STRING_FOR_SENSOR_TYPE(PROXIMITY);
 487     CHECK_TYPE_STRING_FOR_SENSOR_TYPE(GRAVITY);
 488     CHECK_TYPE_STRING_FOR_SENSOR_TYPE(LINEAR_ACCELERATION);
 489     CHECK_TYPE_STRING_FOR_SENSOR_TYPE(ROTATION_VECTOR);
 490     CHECK_TYPE_STRING_FOR_SENSOR_TYPE(RELATIVE_HUMIDITY);
 491     CHECK_TYPE_STRING_FOR_SENSOR_TYPE(AMBIENT_TEMPERATURE);
 492     CHECK_TYPE_STRING_FOR_SENSOR_TYPE(MAGNETIC_FIELD_UNCALIBRATED);
 493     CHECK_TYPE_STRING_FOR_SENSOR_TYPE(GAME_ROTATION_VECTOR);
 494     CHECK_TYPE_STRING_FOR_SENSOR_TYPE(GYROSCOPE_UNCALIBRATED);
 495     CHECK_TYPE_STRING_FOR_SENSOR_TYPE(SIGNIFICANT_MOTION);
 496     CHECK_TYPE_STRING_FOR_SENSOR_TYPE(STEP_DETECTOR);
 497     CHECK_TYPE_STRING_FOR_SENSOR_TYPE(STEP_COUNTER);
 498     CHECK_TYPE_STRING_FOR_SENSOR_TYPE(GEOMAGNETIC_ROTATION_VECTOR);
 499     CHECK_TYPE_STRING_FOR_SENSOR_TYPE(HEART_RATE);
 500     CHECK_TYPE_STRING_FOR_SENSOR_TYPE(TILT_DETECTOR);
 501     CHECK_TYPE_STRING_FOR_SENSOR_TYPE(WAKE_GESTURE);
 502     CHECK_TYPE_STRING_FOR_SENSOR_TYPE(GLANCE_GESTURE);
 503     CHECK_TYPE_STRING_FOR_SENSOR_TYPE(PICK_UP_GESTURE);
 504     CHECK_TYPE_STRING_FOR_SENSOR_TYPE(WRIST_TILT_GESTURE);
 505     CHECK_TYPE_STRING_FOR_SENSOR_TYPE(DEVICE_ORIENTATION);
 506     CHECK_TYPE_STRING_FOR_SENSOR_TYPE(POSE_6DOF);
 507     CHECK_TYPE_STRING_FOR_SENSOR_TYPE(STATIONARY_DETECT);
 508     CHECK_TYPE_STRING_FOR_SENSOR_TYPE(MOTION_DETECT);
 509     CHECK_TYPE_STRING_FOR_SENSOR_TYPE(HEART_BEAT);
 510     CHECK_TYPE_STRING_FOR_SENSOR_TYPE(DYNAMIC_SENSOR_META);
 511     CHECK_TYPE_STRING_FOR_SENSOR_TYPE(ADDITIONAL_INFO);
 512     CHECK_TYPE_STRING_FOR_SENSOR_TYPE(LOW_LATENCY_OFFBODY_DETECT);
 513     default:
 514       ALOGW("Type %d is not checked, stringType = %s", (int)type, stringType.c_str());
 515 #undef CHECK_TYPE_STRING_FOR_SENSOR_TYPE
 516   }
 517   return res;
 518 }
 519
 520 bool SensorsHidlTest::typeMatchReportMode(SensorType type, SensorFlagBits reportMode) {
 521   if (type >= SensorType::DEVICE_PRIVATE_BASE) {
 522     return true;
 523   }
 524
 525   SensorFlagBits expected = expectedReportModeForType(type);
 526
 527   return expected == (SensorFlagBits)-1 || expected == reportMode;
 528 }
 529
 530 bool SensorsHidlTest::delayMatchReportMode(
 531     int32_t minDelay, int32_t maxDelay, SensorFlagBits reportMode) {
 532   bool res = true;
 533   switch(reportMode) {
 534     case SensorFlagBits::CONTINUOUS_MODE:
 535       res = (minDelay > 0) && (maxDelay >= 0);
 536       break;
 537     case SensorFlagBits::ON_CHANGE_MODE:
 538       //TODO: current implementation does not satisfy minDelay == 0 on Proximity
 539       res = (minDelay >= 0) && (maxDelay >= 0);
 540       //res = (minDelay == 0) && (maxDelay >= 0);
 541       break;
 542     case SensorFlagBits::ONE_SHOT_MODE:
 543       res = (minDelay == -1) && (maxDelay == 0);
 544       break;
 545     case SensorFlagBits::SPECIAL_REPORTING_MODE:
 546       res = (minDelay == 0) && (maxDelay == 0);
 547       break;
 548     default:
 549       res = false;
 550   }
 551
 552   return res;
 553 }
 554
 555 SensorFlagBits SensorsHidlTest::expectedReportModeForType(SensorType type) {
 556   switch (type) {
 557     case SensorType::ACCELEROMETER:
 558     case SensorType::GYROSCOPE:
 559     case SensorType::MAGNETIC_FIELD:
 560     case SensorType::ORIENTATION:
 561     case SensorType::PRESSURE:
 562     case SensorType::TEMPERATURE:
 563     case SensorType::GRAVITY:
 564     case SensorType::LINEAR_ACCELERATION:
 565     case SensorType::ROTATION_VECTOR:
 566     case SensorType::MAGNETIC_FIELD_UNCALIBRATED:
 567     case SensorType::GAME_ROTATION_VECTOR:
 568     case SensorType::GYROSCOPE_UNCALIBRATED:
 569     case SensorType::GEOMAGNETIC_ROTATION_VECTOR:
 570     case SensorType::POSE_6DOF:
 571     case SensorType::HEART_BEAT:
 572       return SensorFlagBits::CONTINUOUS_MODE;
 573
 574     case SensorType::LIGHT:
 575     case SensorType::PROXIMITY:
 576     case SensorType::RELATIVE_HUMIDITY:
 577     case SensorType::AMBIENT_TEMPERATURE:
 578     case SensorType::HEART_RATE:
 579     case SensorType::DEVICE_ORIENTATION:
 580     case SensorType::MOTION_DETECT:
 581     case SensorType::STEP_COUNTER:
 582       return SensorFlagBits::ON_CHANGE_MODE;
 583
 584     case SensorType::SIGNIFICANT_MOTION:
 585     case SensorType::WAKE_GESTURE:
 586     case SensorType::GLANCE_GESTURE:
 587     case SensorType::PICK_UP_GESTURE:
 588       return SensorFlagBits::ONE_SHOT_MODE;
 589
 590     case SensorType::STEP_DETECTOR:
 591     case SensorType::TILT_DETECTOR:
 592     case SensorType::WRIST_TILT_GESTURE:
 593     case SensorType::DYNAMIC_SENSOR_META:
 594       return SensorFlagBits::SPECIAL_REPORTING_MODE;
 595
 596     default:
 597       ALOGW("Type %d is not implemented in expectedReportModeForType", (int)type);
 598       return (SensorFlagBits)-1;
 599   }
 600 }
 601
 602 SensorInfo SensorsHidlTest::defaultSensorByType(SensorType type) {
 603   SensorInfo ret;
 604
 605   ret.type = (SensorType) -1;
 606   S()->getSensorsList(
 607       [&] (const auto &list) {
 608         const size_t count = list.size();
 609         for (size_t i = 0; i < count; ++i) {
 610           if (list[i].type == type) {
 611             ret = list[i];
 612             return;
 613           }
 614         }
 615       });
 616
 617   return ret;
 618 }
 619
 620 // Test if sensor list returned is valid
 621 TEST_F(SensorsHidlTest, SensorListValid) {
 622   S()->getSensorsList(
 623       [&] (const auto &list) {
 624         const size_t count = list.size();
 625         for (size_t i = 0; i < count; ++i) {
 626           auto &s = list[i];
 627           ALOGV("\t%zu: handle=%#08x type=%d name=%s",
 628                 i, s.sensorHandle, (int)s.type, s.name.c_str());
 629
 630           // Test non-empty type string
 631           ASSERT_FALSE(s.typeAsString.empty());
 632
 633           // Test defined type matches defined string type
 634           ASSERT_TRUE(typeMatchStringType(s.type, s.typeAsString));
 635
 636           // Test if all sensor has name and vendor
 637           ASSERT_FALSE(s.name.empty());
 638           ASSERT_FALSE(s.vendor.empty());
 639
 640           // Test power > 0, maxRange > 0
 641           ASSERT_GE(s.power, 0);
 642           ASSERT_GT(s.maxRange, 0);
 643
 644           // Info type, should have no sensor
 645           ASSERT_FALSE(
 646               s.type == SensorType::ADDITIONAL_INFO
 647               || s.type == SensorType::META_DATA);
 648
 649           // Test fifoMax >= fifoReserved
 650           ALOGV("max reserve = %d, %d", s.fifoMaxEventCount, s.fifoReservedEventCount);
 651           ASSERT_GE(s.fifoMaxEventCount, s.fifoReservedEventCount);
 652
 653           // Test Reporting mode valid
 654           ASSERT_TRUE(typeMatchReportMode(s.type, extractReportMode(s.flags)));
 655
 656           // Test min max are in the right order
 657           ASSERT_LE(s.minDelay, s.maxDelay);
 658           // Test min/max delay matches reporting mode
 659           ASSERT_TRUE(delayMatchReportMode(s.minDelay, s.maxDelay, extractReportMode(s.flags)));
 660         }
 661       });
 662 }
 663
 664 // Test if sensor hal can do normal accelerometer streaming properly
 665 TEST_F(SensorsHidlTest, NormalAccelerometerStreamingOperation) {
 666
 667   std::vector<Event> events;
 668
 669   constexpr int64_t samplingPeriodInNs = 20ull*1000*1000; // 20ms
 670   constexpr int64_t batchingPeriodInNs = 0; // no batching
 671   constexpr useconds_t minTimeUs = 5*1000*1000;  // 5 s
 672   constexpr size_t minNEvent = 100;  // at lease 100 events
 673   constexpr SensorType type = SensorType::ACCELEROMETER;
 674
 675   SensorInfo sensor = defaultSensorByType(type);
 676
 677   if (!isValidType(sensor.type)) {
 678     // no default sensor of this type
 679     return;
 680   }
 681
 682   int32_t handle = sensor.sensorHandle;
 683
 684   ASSERT_EQ(batch(handle, samplingPeriodInNs, batchingPeriodInNs), Result::OK);
 685   ASSERT_EQ(activate(handle, 1), Result::OK);
 686   events = collectEvents(minTimeUs, minNEvent, true /*clearBeforeStart*/);
 687   ASSERT_EQ(activate(handle, 0), Result::OK);
 688
 689   ALOGI("Collected %zu samples", events.size());
 690
 691   ASSERT_GT(events.size(), 0u);
 692
 693   size_t nRealEvent = 0;
 694   for (auto & e : events) {
 695     if (e.sensorType == type) {
 696
 697       ASSERT_EQ(e.sensorHandle, handle);
 698
 699       Vec3 acc = e.u.vec3;
 700
 701       double gravityNorm = std::sqrt(acc.x * acc.x + acc.y * acc.y + acc.z * acc.z);
 702       ALOGV("Norm = %f", gravityNorm);
 703
 704       // assert this is earth gravity
 705       ASSERT_TRUE(std::fabs(gravityNorm - GRAVITY_EARTH) < 1);
 706
 707       ++ nRealEvent;
 708     } else {
 709       ALOGI("Event type %d, handle %d", (int) e.sensorType, (int) e.sensorHandle);
 710       // Only meta types are allowed besides the subscribed sensor
 711       ASSERT_TRUE(isMetaSensorType(e.sensorType));
 712     }
 713   }
 714
 715   ASSERT_GE(nRealEvent, minNEvent / 2); // make sure returned events are not all meta
 716 }
 717
 718 // Test if sensor hal can do gyroscope streaming properly
 719 TEST_F(SensorsHidlTest, NormalGyroscopeStreamingOperation) {
 720   std::vector<Event> events;
 721
 722   constexpr int64_t samplingPeriodInNs = 10ull*1000*1000; // 10ms
 723   constexpr int64_t batchingPeriodInNs = 0; // no batching
 724   constexpr useconds_t minTimeUs = 5*1000*1000;  // 5 s
 725   constexpr size_t minNEvent = 200;
 726   constexpr SensorType type = SensorType::GYROSCOPE;
 727
 728   SensorInfo sensor = defaultSensorByType(type);
 729
 730   if (!isValidType(sensor.type)) {
 731     // no default sensor of this type
 732     return;
 733   }
 734
 735   int32_t handle = sensor.sensorHandle;
 736
 737   ASSERT_EQ(batch(handle, samplingPeriodInNs, batchingPeriodInNs), Result::OK);
 738   ASSERT_EQ(activate(handle, 1), Result::OK);
 739   events = collectEvents(minTimeUs, minNEvent, true /*clearBeforeStart*/);
 740   ASSERT_EQ(activate(handle, 0), Result::OK);
 741
 742   ALOGI("Collected %zu samples", events.size());
 743
 744   ASSERT_GT(events.size(), 0u);
 745
 746   size_t nRealEvent = 0;
 747   for (auto & e : events) {
 748     if (e.sensorType == type) {
 749
 750       ASSERT_EQ(e.sensorHandle, handle);
 751
 752       Vec3 gyro = e.u.vec3;
 753
 754       double gyroNorm = std::sqrt(gyro.x * gyro.x + gyro.y * gyro.y + gyro.z * gyro.z);
 755       ALOGV("Gyro Norm = %f", gyroNorm);
 756
 757       // assert not drifting
 758       ASSERT_TRUE(gyroNorm < 0.1);  // < ~5 degree/s
 759
 760       ++ nRealEvent;
 761     } else {
 762       ALOGI("Event type %d, handle %d", (int) e.sensorType, (int) e.sensorHandle);
 763       // Only meta types are allowed besides the subscribed sensor
 764       ASSERT_TRUE(isMetaSensorType(e.sensorType));
 765     }
 766   }
 767
 768   ASSERT_GE(nRealEvent, minNEvent / 2); // make sure returned events are not all meta
 769 }
 770
 771 // Test if sensor hal can do accelerometer sampling rate switch properly when sensor is active
 772 TEST_F(SensorsHidlTest, AccelerometerSamplingPeriodHotSwitchOperation) {
 773   std::vector<Event> events1, events2;
 774
 775   constexpr int64_t batchingPeriodInNs = 0; // no batching
 776   constexpr size_t minNEvent = 50;
 777   constexpr SensorType type = SensorType::ACCELEROMETER;
 778
 779   SensorInfo sensor = defaultSensorByType(type);
 780
 781   if (!isValidType(sensor.type)) {
 782     // no default sensor of this type
 783     return;
 784   }
 785
 786   int32_t handle = sensor.sensorHandle;
 787   int64_t minSamplingPeriodInNs = sensor.minDelay * 1000ll;
 788   int64_t maxSamplingPeriodInNs = sensor.maxDelay * 1000ll;
 789
 790   if (minSamplingPeriodInNs == maxSamplingPeriodInNs) {
 791     // only support single rate
 792     return;
 793   }
 794
 795   ASSERT_EQ(batch(handle, minSamplingPeriodInNs, batchingPeriodInNs), Result::OK);
 796   ASSERT_EQ(activate(handle, 1), Result::OK);
 797
 798   usleep(500000); // sleep 0.5 sec to wait for change rate to happen
 799   events1 = collectEvents(sensor.minDelay * minNEvent, minNEvent, true /*clearBeforeStart*/);
 800
 801   ASSERT_EQ(batch(handle, maxSamplingPeriodInNs, batchingPeriodInNs), Result::OK);
 802
 803   usleep(500000); // sleep 0.5 sec to wait for change rate to happen
 804   events2 = collectEvents(sensor.maxDelay * minNEvent, minNEvent, true /*clearBeforeStart*/);
 805
 806   ASSERT_EQ(activate(handle, 0), Result::OK);
 807
 808   ALOGI("Collected %zu fast samples and %zu slow samples", events1.size(), events2.size());
 809
 810   ASSERT_GT(events1.size(), 0u);
 811   ASSERT_GT(events2.size(), 0u);
 812
 813   int64_t minDelayAverageInterval, maxDelayAverageInterval;
 814
 815   size_t nEvent = 0;
 816   int64_t prevTimestamp = -1;
 817   int64_t timestampInterval = 0;
 818   for (auto & e : events1) {
 819     if (e.sensorType == type) {
 820       ASSERT_EQ(e.sensorHandle, handle);
 821       if (prevTimestamp > 0) {
 822         timestampInterval += e.timestamp - prevTimestamp;
 823       }
 824       prevTimestamp = e.timestamp;
 825       ++ nEvent;
 826     }
 827   }
 828   ASSERT_GT(nEvent, 2u);
 829   minDelayAverageInterval = timestampInterval / (nEvent - 1);
 830
 831   nEvent = 0;
 832   prevTimestamp = -1;
 833   timestampInterval = 0;
 834   for (auto & e : events2) {
 835     if (e.sensorType == type) {
 836       ASSERT_EQ(e.sensorHandle, handle);
 837       if (prevTimestamp > 0) {
 838         timestampInterval += e.timestamp - prevTimestamp;
 839       }
 840       prevTimestamp = e.timestamp;
 841       ++ nEvent;
 842     }
 843   }
 844   ASSERT_GT(nEvent, 2u);
 845   maxDelayAverageInterval = timestampInterval / (nEvent - 1);
 846
 847   // change of rate is significant.
 848   ASSERT_GT((maxDelayAverageInterval - minDelayAverageInterval), minDelayAverageInterval / 10);
 849
 850   // fastest rate sampling time is close to spec
 851   ALOGI("minDelayAverageInterval = %" PRId64, minDelayAverageInterval);
 852   ASSERT_LT(std::abs(minDelayAverageInterval - minSamplingPeriodInNs),
 853       minSamplingPeriodInNs / 10);
 854 }
 855
 856 // Test if sensor hal can do normal accelerometer batching properly
 857 TEST_F(SensorsHidlTest, AccelerometerBatchingOperation) {
 858   std::vector<Event> events;
 859
 860   constexpr int64_t oneSecondInNs = 1ull * 1000 * 1000 * 1000;
 861   constexpr SensorType type = SensorType::ACCELEROMETER;
 862   constexpr int64_t maxBatchingTestTimeNs = 30ull * 1000 * 1000 * 1000;
 863
 864   SensorInfo sensor = defaultSensorByType(type);
 865
 866   if (!isValidType(sensor.type)) {
 867     // no default sensor of this type
 868     return;
 869   }
 870
 871   int32_t handle = sensor.sensorHandle;
 872   int64_t minSamplingPeriodInNs = sensor.minDelay * 1000ll;
 873   uint32_t minFifoCount = sensor.fifoReservedEventCount;
 874   int64_t batchingPeriodInNs = minFifoCount * minSamplingPeriodInNs;
 875
 876   if (batchingPeriodInNs < oneSecondInNs) {
 877     // batching size too small to test reliably
 878     return;
 879   }
 880
 881   batchingPeriodInNs = std::min(batchingPeriodInNs, maxBatchingTestTimeNs);
 882
 883   ALOGI("Test batching for %d ms", (int)(batchingPeriodInNs / 1000 / 1000));
 884
 885   int64_t allowedBatchDeliverTimeNs =
 886       std::max(oneSecondInNs, batchingPeriodInNs / 10);
 887
 888   ASSERT_EQ(batch(handle, minSamplingPeriodInNs, INT64_MAX), Result::OK);
 889   ASSERT_EQ(activate(handle, 1), Result::OK);
 890
 891   usleep(500000); // sleep 0.5 sec to wait for initialization
 892   ASSERT_EQ(flush(handle), Result::OK);
 893
 894   // wait for 80% of the reserved batching period
 895   // there should not be any significant amount of events
 896   // since collection is not enabled all events will go down the drain
 897   usleep(batchingPeriodInNs / 1000 * 8 / 10);
 898
 899   SensorsHidlEnvironment::Instance()->setCollection(true);
 900   // 0.8 + 0.3 times the batching period
 901   // plus some time for the event to deliver
 902   events = collectEvents(
 903       batchingPeriodInNs / 1000 * 3 / 10,
 904         minFifoCount, true /*clearBeforeStart*/, false /*change collection*/);
 905
 906   ASSERT_EQ(flush(handle), Result::OK);
 907
 908   events = collectEvents(allowedBatchDeliverTimeNs / 1000,
 909         minFifoCount, true /*clearBeforeStart*/, false /*change collection*/);
 910
 911   SensorsHidlEnvironment::Instance()->setCollection(false);
 912   ASSERT_EQ(activate(handle, 0), Result::OK);
 913
 914   size_t nEvent = 0;
 915   for (auto & e : events) {
 916     if (e.sensorType == type && e.sensorHandle == handle) {
 917       ++ nEvent;
 918     }
 919   }
 920
 921   // at least reach 90% of advertised capacity
 922   ASSERT_GT(nEvent, (size_t)(batchingPeriodInNs / minSamplingPeriodInNs * 9 / 10));
 923 }
 924
 925 // Test sensor event direct report with ashmem for gyro sensor
 926 TEST_F(SensorsHidlTest, GyroscopeAshmemDirectReport) {
 927
 928   constexpr SensorType type = SensorType::GYROSCOPE;
 929   constexpr size_t kEventSize = 104;
 930   constexpr size_t kNEvent = 500;
 931   constexpr size_t kMemSize = kEventSize * kNEvent;
 932
 933   SensorInfo sensor = defaultSensorByType(type);
 934
 935   if (!(sensor.flags | SensorFlagBits::MASK_DIRECT_REPORT)
 936       || !(sensor.flags | SensorFlagBits::DIRECT_CHANNEL_ASHMEM)) {
 937     // does not declare support
 938     return;
 939   }
 940
 941   std::unique_ptr<SensorsTestSharedMemory>
 942       mem(SensorsTestSharedMemory::create(SharedMemType::ASHMEM, kMemSize));
 943   ASSERT_NE(mem, nullptr);
 944
 945   char* buffer = mem->getBuffer();
 946   // fill memory with data
 947   for (size_t i = 0; i < kMemSize; ++i) {
 948     buffer[i] = '\xcc';
 949   }
 950
 951   int32_t channelHandle;
 952   registerDirectChannel(mem->getSharedMemInfo(),
 953       [&channelHandle] (auto result, auto channelHandle_) {
 954           ASSERT_EQ(result, Result::OK);
 955           channelHandle = channelHandle_;
 956       });
 957
 958   // check memory is zeroed
 959   for (size_t i = 0; i < kMemSize; ++i) {
 960     ASSERT_EQ(buffer[i], '\0');
 961   }
 962
 963   int32_t eventToken;
 964   configDirectReport(sensor.sensorHandle, channelHandle, RateLevel::NORMAL,
 965       [&eventToken] (auto result, auto token) {
 966           ASSERT_EQ(result, Result::OK);
 967           eventToken = token;
 968       });
 969
 970   usleep(1500000); // sleep 1 sec for data, plus 0.5 sec for initialization
 971   auto events = mem->parseEvents();
 972
 973   // allowed to be 55% of nominal freq (50Hz)
 974   ASSERT_GT(events.size(), 50u / 2u);
 975   ASSERT_LT(events.size(), static_cast<size_t>(110*1.5));
 976
 977   int64_t lastTimestamp = 0;
 978   for (auto &e : events) {
 979     ASSERT_EQ(e.sensorType, type);
 980     ASSERT_EQ(e.sensorHandle, eventToken);
 981     ASSERT_GT(e.timestamp, lastTimestamp);
 982
 983     Vec3 gyro = e.u.vec3;
 984     double gyroNorm = std::sqrt(gyro.x * gyro.x + gyro.y * gyro.y + gyro.z * gyro.z);
 985     // assert not drifting
 986     ASSERT_TRUE(gyroNorm < 0.1);  // < ~5 degree/sa
 987
 988     lastTimestamp = e.timestamp;
 989   }
 990
 991   // stop sensor and unregister channel
 992   configDirectReport(sensor.sensorHandle, channelHandle, RateLevel::STOP,
 993         [&eventToken] (auto result, auto) {
 994             ASSERT_EQ(result, Result::OK);
 995         });
 996   ASSERT_EQ(unregisterDirectChannel(channelHandle), Result::OK);
 997 }
 998
 999 int main(int argc, char **argv) {
1000   ::testing::AddGlobalTestEnvironment(SensorsHidlEnvironment::Instance());
1001   ::testing::InitGoogleTest(&argc, argv);
1002   int status = RUN_ALL_TESTS();
1003   ALOGI("Test result = %d", status);
1004   return status;
1005 }
1006 // vim: set ts=2 sw=2