/*
* Copyright (C) 2018 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "SensorsHidlTestBase.h"
#include "sensors-vts-utils/GrallocWrapper.h"
#include "sensors-vts-utils/SensorsTestSharedMemory.h"
#include <hardware/sensors.h> // for sensor type strings
#include <log/log.h>
#include <utils/SystemClock.h>
#include <cinttypes>
using ::android::sp;
using ::android::hardware::hidl_string;
using ::android::hardware::Return;
using ::android::hardware::Void;
using ::android::hardware::sensors::V1_0::SensorFlagShift;
using ::android::hardware::sensors::V1_0::SensorsEventFormatOffset;
const Vec3NormChecker SensorsHidlTestBase::sAccelNormChecker(
Vec3NormChecker::byNominal(GRAVITY_EARTH, 1.0f /*m/s^2*/));
const Vec3NormChecker SensorsHidlTestBase::sGyroNormChecker(
Vec3NormChecker::byNominal(0.f, 0.1f /*rad/s*/));
std::vector<Event> SensorsHidlTestBase::collectEvents(useconds_t timeLimitUs, size_t nEventLimit,
bool clearBeforeStart,
bool changeCollection) {
return collectEvents(timeLimitUs, nEventLimit, getEnvironment(), clearBeforeStart,
changeCollection);
}
std::vector<Event> SensorsHidlTestBase::collectEvents(useconds_t timeLimitUs, size_t nEventLimit,
SensorsHidlEnvironmentBase* environment,
bool clearBeforeStart,
bool changeCollection) {
std::vector<Event> events;
constexpr useconds_t SLEEP_GRANULARITY = 100 * 1000; // granularity 100 ms
ALOGI("collect max of %zu events for %d us, clearBeforeStart %d", nEventLimit, timeLimitUs,
clearBeforeStart);
if (changeCollection) {
environment->setCollection(true);
}
if (clearBeforeStart) {
environment->catEvents(nullptr);
}
while (timeLimitUs > 0) {
useconds_t duration = std::min(SLEEP_GRANULARITY, timeLimitUs);
usleep(duration);
timeLimitUs -= duration;
environment->catEvents(&events);
if (events.size() >= nEventLimit) {
break;
}
ALOGV("time to go = %d, events to go = %d", (int)timeLimitUs,
(int)(nEventLimit - events.size()));
}
if (changeCollection) {
environment->setCollection(false);
}
return events;
}
void SensorsHidlTestBase::assertTypeMatchStringType(SensorType type,
const hidl_string& stringType) {
if (type >= SensorType::DEVICE_PRIVATE_BASE) {
return;
}
switch (type) {
#define CHECK_TYPE_STRING_FOR_SENSOR_TYPE(type) \
case SensorType::type: \
ASSERT_STREQ(SENSOR_STRING_TYPE_##type, stringType.c_str()); \
break;
CHECK_TYPE_STRING_FOR_SENSOR_TYPE(ACCELEROMETER);
CHECK_TYPE_STRING_FOR_SENSOR_TYPE(ACCELEROMETER_UNCALIBRATED);
CHECK_TYPE_STRING_FOR_SENSOR_TYPE(ADDITIONAL_INFO);
CHECK_TYPE_STRING_FOR_SENSOR_TYPE(AMBIENT_TEMPERATURE);
CHECK_TYPE_STRING_FOR_SENSOR_TYPE(DEVICE_ORIENTATION);
CHECK_TYPE_STRING_FOR_SENSOR_TYPE(DYNAMIC_SENSOR_META);
CHECK_TYPE_STRING_FOR_SENSOR_TYPE(GAME_ROTATION_VECTOR);
CHECK_TYPE_STRING_FOR_SENSOR_TYPE(GEOMAGNETIC_ROTATION_VECTOR);
CHECK_TYPE_STRING_FOR_SENSOR_TYPE(GLANCE_GESTURE);
CHECK_TYPE_STRING_FOR_SENSOR_TYPE(GRAVITY);
CHECK_TYPE_STRING_FOR_SENSOR_TYPE(GYROSCOPE);
CHECK_TYPE_STRING_FOR_SENSOR_TYPE(GYROSCOPE_UNCALIBRATED);
CHECK_TYPE_STRING_FOR_SENSOR_TYPE(HEART_BEAT);
CHECK_TYPE_STRING_FOR_SENSOR_TYPE(HEART_RATE);
CHECK_TYPE_STRING_FOR_SENSOR_TYPE(LIGHT);
CHECK_TYPE_STRING_FOR_SENSOR_TYPE(LINEAR_ACCELERATION);
CHECK_TYPE_STRING_FOR_SENSOR_TYPE(LOW_LATENCY_OFFBODY_DETECT);
CHECK_TYPE_STRING_FOR_SENSOR_TYPE(MAGNETIC_FIELD);
CHECK_TYPE_STRING_FOR_SENSOR_TYPE(MAGNETIC_FIELD_UNCALIBRATED);
CHECK_TYPE_STRING_FOR_SENSOR_TYPE(MOTION_DETECT);
CHECK_TYPE_STRING_FOR_SENSOR_TYPE(ORIENTATION);
CHECK_TYPE_STRING_FOR_SENSOR_TYPE(PICK_UP_GESTURE);
CHECK_TYPE_STRING_FOR_SENSOR_TYPE(POSE_6DOF);
CHECK_TYPE_STRING_FOR_SENSOR_TYPE(PRESSURE);
CHECK_TYPE_STRING_FOR_SENSOR_TYPE(PROXIMITY);
CHECK_TYPE_STRING_FOR_SENSOR_TYPE(RELATIVE_HUMIDITY);
CHECK_TYPE_STRING_FOR_SENSOR_TYPE(ROTATION_VECTOR);
CHECK_TYPE_STRING_FOR_SENSOR_TYPE(SIGNIFICANT_MOTION);
CHECK_TYPE_STRING_FOR_SENSOR_TYPE(STATIONARY_DETECT);
CHECK_TYPE_STRING_FOR_SENSOR_TYPE(STEP_COUNTER);
CHECK_TYPE_STRING_FOR_SENSOR_TYPE(STEP_DETECTOR);
CHECK_TYPE_STRING_FOR_SENSOR_TYPE(TEMPERATURE);
CHECK_TYPE_STRING_FOR_SENSOR_TYPE(TILT_DETECTOR);
CHECK_TYPE_STRING_FOR_SENSOR_TYPE(WAKE_GESTURE);
CHECK_TYPE_STRING_FOR_SENSOR_TYPE(WRIST_TILT_GESTURE);
default:
FAIL() << "Type " << static_cast<int>(type)
<< " in android defined range is not checked, "
<< "stringType = " << stringType;
#undef CHECK_TYPE_STRING_FOR_SENSOR_TYPE
}
}
void SensorsHidlTestBase::assertTypeMatchReportMode(SensorType type, SensorFlagBits reportMode) {
if (type >= SensorType::DEVICE_PRIVATE_BASE) {
return;
}
SensorFlagBits expected = expectedReportModeForType(type);
ASSERT_TRUE(expected == (SensorFlagBits)-1 || expected == reportMode)
<< "reportMode=" << static_cast<int>(reportMode)
<< "expected=" << static_cast<int>(expected);
}
void SensorsHidlTestBase::assertDelayMatchReportMode(int32_t minDelay, int32_t maxDelay,
SensorFlagBits reportMode) {
switch (reportMode) {
case SensorFlagBits::CONTINUOUS_MODE:
ASSERT_LT(0, minDelay);
ASSERT_LE(0, maxDelay);
break;
case SensorFlagBits::ON_CHANGE_MODE:
ASSERT_LE(0, minDelay);
ASSERT_LE(0, maxDelay);
break;
case SensorFlagBits::ONE_SHOT_MODE:
ASSERT_EQ(-1, minDelay);
ASSERT_EQ(0, maxDelay);
break;
case SensorFlagBits::SPECIAL_REPORTING_MODE:
// do not enforce anything for special reporting mode
break;
default:
FAIL() << "Report mode " << static_cast<int>(reportMode) << " not checked";
}
}
// return -1 means no expectation for this type
SensorFlagBits SensorsHidlTestBase::expectedReportModeForType(SensorType type) {
switch (type) {
case SensorType::ACCELEROMETER:
case SensorType::ACCELEROMETER_UNCALIBRATED:
case SensorType::GYROSCOPE:
case SensorType::MAGNETIC_FIELD:
case SensorType::ORIENTATION:
case SensorType::PRESSURE:
case SensorType::TEMPERATURE:
case SensorType::GRAVITY:
case SensorType::LINEAR_ACCELERATION:
case SensorType::ROTATION_VECTOR:
case SensorType::MAGNETIC_FIELD_UNCALIBRATED:
case SensorType::GAME_ROTATION_VECTOR:
case SensorType::GYROSCOPE_UNCALIBRATED:
case SensorType::GEOMAGNETIC_ROTATION_VECTOR:
case SensorType::POSE_6DOF:
case SensorType::HEART_BEAT:
return SensorFlagBits::CONTINUOUS_MODE;
case SensorType::LIGHT:
case SensorType::PROXIMITY:
case SensorType::RELATIVE_HUMIDITY:
case SensorType::AMBIENT_TEMPERATURE:
case SensorType::HEART_RATE:
case SensorType::DEVICE_ORIENTATION:
case SensorType::STEP_COUNTER:
case SensorType::LOW_LATENCY_OFFBODY_DETECT:
return SensorFlagBits::ON_CHANGE_MODE;
case SensorType::SIGNIFICANT_MOTION:
case SensorType::WAKE_GESTURE:
case SensorType::GLANCE_GESTURE:
case SensorType::PICK_UP_GESTURE:
case SensorType::MOTION_DETECT:
case SensorType::STATIONARY_DETECT:
return SensorFlagBits::ONE_SHOT_MODE;
case SensorType::STEP_DETECTOR:
case SensorType::TILT_DETECTOR:
case SensorType::WRIST_TILT_GESTURE:
case SensorType::DYNAMIC_SENSOR_META:
return SensorFlagBits::SPECIAL_REPORTING_MODE;
default:
ALOGW("Type %d is not implemented in expectedReportModeForType", (int)type);
return (SensorFlagBits)-1;
}
}
bool SensorsHidlTestBase::isDirectReportRateSupported(SensorInfo sensor, RateLevel rate) {
unsigned int r = static_cast<unsigned int>(sensor.flags & SensorFlagBits::MASK_DIRECT_REPORT) >>
static_cast<unsigned int>(SensorFlagShift::DIRECT_REPORT);
return r >= static_cast<unsigned int>(rate);
}
bool SensorsHidlTestBase::isDirectChannelTypeSupported(SensorInfo sensor, SharedMemType type) {
switch (type) {
case SharedMemType::ASHMEM:
return (sensor.flags & SensorFlagBits::DIRECT_CHANNEL_ASHMEM) != 0;
case SharedMemType::GRALLOC:
return (sensor.flags & SensorFlagBits::DIRECT_CHANNEL_GRALLOC) != 0;
default:
return false;
}
}
void SensorsHidlTestBase::testDirectReportOperation(SensorType type, SharedMemType memType,
RateLevel rate,
const SensorEventsChecker& checker) {
constexpr size_t kEventSize = static_cast<size_t>(SensorsEventFormatOffset::TOTAL_LENGTH);
constexpr size_t kNEvent = 4096;
constexpr size_t kMemSize = kEventSize * kNEvent;
constexpr float kNormalNominal = 50;
constexpr float kFastNominal = 200;
constexpr float kVeryFastNominal = 800;
constexpr float kNominalTestTimeSec = 1.f;
constexpr float kMaxTestTimeSec = kNominalTestTimeSec + 0.5f; // 0.5 second for initialization
SensorInfo sensor = defaultSensorByType(type);
if (!isValidType(sensor.type)) {
// no default sensor of this type
return;
}
if (!isDirectReportRateSupported(sensor, rate)) {
return;
}
if (!isDirectChannelTypeSupported(sensor, memType)) {
return;
}
std::unique_ptr<SensorsTestSharedMemory> mem(
SensorsTestSharedMemory::create(memType, kMemSize));
ASSERT_NE(mem, nullptr);
char* buffer = mem->getBuffer();
// fill memory with data
for (size_t i = 0; i < kMemSize; ++i) {
buffer[i] = '\xcc';
}
int32_t channelHandle;
registerDirectChannel(mem->getSharedMemInfo(),
[&channelHandle](auto result, auto channelHandle_) {
ASSERT_EQ(result, Result::OK);
channelHandle = channelHandle_;
});
// check memory is zeroed
for (size_t i = 0; i < kMemSize; ++i) {
ASSERT_EQ(buffer[i], '\0');
}
int32_t eventToken;
configDirectReport(sensor.sensorHandle, channelHandle, rate,
[&eventToken](auto result, auto token) {
ASSERT_EQ(result, Result::OK);
eventToken = token;
});
usleep(static_cast<useconds_t>(kMaxTestTimeSec * 1e6f));
auto events = mem->parseEvents();
// find norminal rate
float nominalFreq = 0.f;
switch (rate) {
case RateLevel::NORMAL:
nominalFreq = kNormalNominal;
break;
case RateLevel::FAST:
nominalFreq = kFastNominal;
break;
case RateLevel::VERY_FAST:
nominalFreq = kVeryFastNominal;
break;
case RateLevel::STOP:
FAIL();
}
// allowed to be between 55% and 220% of nominal freq
ASSERT_GT(events.size(), static_cast<size_t>(nominalFreq * 0.55f * kNominalTestTimeSec));
ASSERT_LT(events.size(), static_cast<size_t>(nominalFreq * 2.2f * kMaxTestTimeSec));
int64_t lastTimestamp = 0;
bool typeErrorReported = false;
bool tokenErrorReported = false;
bool timestampErrorReported = false;
std::vector<Event> sensorEvents;
for (auto& e : events) {
if (!tokenErrorReported) {
EXPECT_EQ(eventToken, e.sensorHandle)
<< (tokenErrorReported = true,
"Event token does not match that retured from configDirectReport");
}
if (isMetaSensorType(e.sensorType)) {
continue;
}
sensorEvents.push_back(e);
if (!typeErrorReported) {
EXPECT_EQ(type, e.sensorType)
<< (typeErrorReported = true,
"Type in event does not match type of sensor registered.");
}
if (!timestampErrorReported) {
EXPECT_GT(e.timestamp, lastTimestamp)
<< (timestampErrorReported = true, "Timestamp not monotonically increasing");
}
lastTimestamp = e.timestamp;
}
std::string s;
EXPECT_TRUE(checker.check(sensorEvents, &s)) << s;
// stop sensor and unregister channel
configDirectReport(sensor.sensorHandle, channelHandle, RateLevel::STOP,
[](auto result, auto) { EXPECT_EQ(result, Result::OK); });
EXPECT_EQ(unregisterDirectChannel(channelHandle), Result::OK);
}
void SensorsHidlTestBase::testStreamingOperation(SensorType type,
std::chrono::nanoseconds samplingPeriod,
std::chrono::seconds duration,
const SensorEventsChecker& checker) {
std::vector<Event> events;
std::vector<Event> sensorEvents;
const int64_t samplingPeriodInNs = samplingPeriod.count();
const int64_t batchingPeriodInNs = 0; // no batching
const useconds_t minTimeUs = std::chrono::microseconds(duration).count();
const size_t minNEvent = duration / samplingPeriod;
SensorInfo sensor = defaultSensorByType(type);
if (!isValidType(sensor.type)) {
// no default sensor of this type
return;
}
if (std::chrono::microseconds(sensor.minDelay) > samplingPeriod) {
// rate not supported
return;
}
int32_t handle = sensor.sensorHandle;
ASSERT_EQ(batch(handle, samplingPeriodInNs, batchingPeriodInNs), Result::OK);
ASSERT_EQ(activate(handle, 1), Result::OK);
events = collectEvents(minTimeUs, minNEvent, true /*clearBeforeStart*/);
ASSERT_EQ(activate(handle, 0), Result::OK);
ALOGI("Collected %zu samples", events.size());
ASSERT_GT(events.size(), 0u);
bool handleMismatchReported = false;
bool metaSensorTypeErrorReported = false;
for (auto& e : events) {
if (e.sensorType == type) {
// avoid generating hundreds of error
if (!handleMismatchReported) {
EXPECT_EQ(e.sensorHandle, handle)
<< (handleMismatchReported = true,
"Event of the same type must come from the sensor registered");
}
sensorEvents.push_back(e);
} else {
// avoid generating hundreds of error
if (!metaSensorTypeErrorReported) {
EXPECT_TRUE(isMetaSensorType(e.sensorType))
<< (metaSensorTypeErrorReported = true,
"Only meta types are allowed besides the type registered");
}
}
}
std::string s;
EXPECT_TRUE(checker.check(sensorEvents, &s)) << s;
EXPECT_GE(sensorEvents.size(),
minNEvent / 2); // make sure returned events are not all meta
}
void SensorsHidlTestBase::testSamplingRateHotSwitchOperation(SensorType type, bool fastToSlow) {
std::vector<Event> events1, events2;
constexpr int64_t batchingPeriodInNs = 0; // no batching
constexpr int64_t collectionTimeoutUs = 60000000; // 60s
constexpr size_t minNEvent = 50;
SensorInfo sensor = defaultSensorByType(type);
if (!isValidType(sensor.type)) {
// no default sensor of this type
return;
}
int32_t handle = sensor.sensorHandle;
int64_t minSamplingPeriodInNs = sensor.minDelay * 1000ll;
int64_t maxSamplingPeriodInNs = sensor.maxDelay * 1000ll;
if (minSamplingPeriodInNs == maxSamplingPeriodInNs) {
// only support single rate
return;
}
int64_t firstCollectionPeriod = fastToSlow ? minSamplingPeriodInNs : maxSamplingPeriodInNs;
int64_t secondCollectionPeriod = !fastToSlow ? minSamplingPeriodInNs : maxSamplingPeriodInNs;
// first collection
ASSERT_EQ(batch(handle, firstCollectionPeriod, batchingPeriodInNs), Result::OK);
ASSERT_EQ(activate(handle, 1), Result::OK);
usleep(500000); // sleep 0.5 sec to wait for change rate to happen
events1 = collectEvents(collectionTimeoutUs, minNEvent);
// second collection, without stop sensor
ASSERT_EQ(batch(handle, secondCollectionPeriod, batchingPeriodInNs), Result::OK);
usleep(500000); // sleep 0.5 sec to wait for change rate to happen
events2 = collectEvents(collectionTimeoutUs, minNEvent);
// end of collection, stop sensor
ASSERT_EQ(activate(handle, 0), Result::OK);
ALOGI("Collected %zu fast samples and %zu slow samples", events1.size(), events2.size());
ASSERT_GT(events1.size(), 0u);
ASSERT_GT(events2.size(), 0u);
int64_t minDelayAverageInterval, maxDelayAverageInterval;
std::vector<Event>& minDelayEvents(fastToSlow ? events1 : events2);
std::vector<Event>& maxDelayEvents(fastToSlow ? events2 : events1);
size_t nEvent = 0;
int64_t prevTimestamp = -1;
int64_t timestampInterval = 0;
for (auto& e : minDelayEvents) {
if (e.sensorType == type) {
ASSERT_EQ(e.sensorHandle, handle);
if (prevTimestamp > 0) {
timestampInterval += e.timestamp - prevTimestamp;
}
prevTimestamp = e.timestamp;
++nEvent;
}
}
ASSERT_GT(nEvent, 2u);
minDelayAverageInterval = timestampInterval / (nEvent - 1);
nEvent = 0;
prevTimestamp = -1;
timestampInterval = 0;
for (auto& e : maxDelayEvents) {
if (e.sensorType == type) {
ASSERT_EQ(e.sensorHandle, handle);
if (prevTimestamp > 0) {
timestampInterval += e.timestamp - prevTimestamp;
}
prevTimestamp = e.timestamp;
++nEvent;
}
}
ASSERT_GT(nEvent, 2u);
maxDelayAverageInterval = timestampInterval / (nEvent - 1);
// change of rate is significant.
ALOGI("min/maxDelayAverageInterval = %" PRId64 " %" PRId64, minDelayAverageInterval,
maxDelayAverageInterval);
EXPECT_GT((maxDelayAverageInterval - minDelayAverageInterval), minDelayAverageInterval / 10);
// fastest rate sampling time is close to spec
EXPECT_LT(std::abs(minDelayAverageInterval - minSamplingPeriodInNs),
minSamplingPeriodInNs / 10);
// slowest rate sampling time is close to spec
EXPECT_LT(std::abs(maxDelayAverageInterval - maxSamplingPeriodInNs),
maxSamplingPeriodInNs / 10);
}
void SensorsHidlTestBase::testBatchingOperation(SensorType type) {
std::vector<Event> events;
constexpr int64_t maxBatchingTestTimeNs = 30ull * 1000 * 1000 * 1000;
constexpr int64_t oneSecondInNs = 1ull * 1000 * 1000 * 1000;
SensorInfo sensor = defaultSensorByType(type);
if (!isValidType(sensor.type)) {
// no default sensor of this type
return;
}
int32_t handle = sensor.sensorHandle;
int64_t minSamplingPeriodInNs = sensor.minDelay * 1000ll;
uint32_t minFifoCount = sensor.fifoReservedEventCount;
int64_t batchingPeriodInNs = minFifoCount * minSamplingPeriodInNs;
if (batchingPeriodInNs < oneSecondInNs) {
// batching size too small to test reliably
return;
}
batchingPeriodInNs = std::min(batchingPeriodInNs, maxBatchingTestTimeNs);
ALOGI("Test batching for %d ms", (int)(batchingPeriodInNs / 1000 / 1000));
int64_t allowedBatchDeliverTimeNs = std::max(oneSecondInNs, batchingPeriodInNs / 10);
ASSERT_EQ(batch(handle, minSamplingPeriodInNs, INT64_MAX), Result::OK);
ASSERT_EQ(activate(handle, 1), Result::OK);
usleep(500000); // sleep 0.5 sec to wait for initialization
ASSERT_EQ(flush(handle), Result::OK);
// wait for 80% of the reserved batching period
// there should not be any significant amount of events
// since collection is not enabled all events will go down the drain
usleep(batchingPeriodInNs / 1000 * 8 / 10);
getEnvironment()->setCollection(true);
// clean existing collections
collectEvents(0 /*timeLimitUs*/, 0 /*nEventLimit*/, true /*clearBeforeStart*/,
false /*change collection*/);
// 0.8 + 0.2 times the batching period
usleep(batchingPeriodInNs / 1000 * 8 / 10);
ASSERT_EQ(flush(handle), Result::OK);
// plus some time for the event to deliver
events = collectEvents(allowedBatchDeliverTimeNs / 1000, minFifoCount,
false /*clearBeforeStart*/, false /*change collection*/);
getEnvironment()->setCollection(false);
ASSERT_EQ(activate(handle, 0), Result::OK);
size_t nEvent = 0;
for (auto& e : events) {
if (e.sensorType == type && e.sensorHandle == handle) {
++nEvent;
}
}
// at least reach 90% of advertised capacity
ASSERT_GT(nEvent, (size_t)(minFifoCount * 9 / 10));
}