From 0c102a998f8c2b51668de7b0f6c32e71a6da2b63 Mon Sep 17 00:00:00 2001 From: Brian Stack Date: Tue, 25 Sep 2018 14:42:57 -0700 Subject: Refactor SensorsTestSharedMemory Extracts SensorsTestSharedMemory so that it can be used by other versions of the sensors tests. Bug: 111070257 Test: Build Change-Id: I03df7462302d4ab0ea647e0d7688a46bf0e06dc1 --- .../common/vts/utils/SensorsTestSharedMemory.cpp | 206 +++++++++++++++++++++ 1 file changed, 206 insertions(+) create mode 100644 sensors/common/vts/utils/SensorsTestSharedMemory.cpp (limited to 'sensors/common/vts/utils/SensorsTestSharedMemory.cpp') diff --git a/sensors/common/vts/utils/SensorsTestSharedMemory.cpp b/sensors/common/vts/utils/SensorsTestSharedMemory.cpp new file mode 100644 index 0000000000..50964983e7 --- /dev/null +++ b/sensors/common/vts/utils/SensorsTestSharedMemory.cpp @@ -0,0 +1,206 @@ +/* + * 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 "SensorsTestSharedMemory.h" + +#include + +#include +#include + +using namespace ::android::hardware::sensors::V1_0; + +SharedMemInfo SensorsTestSharedMemory::getSharedMemInfo() const { + SharedMemInfo mem = {.type = mType, + .format = SharedMemFormat::SENSORS_EVENT, + .size = static_cast(mSize), + .memoryHandle = mNativeHandle}; + return mem; +} + +char* SensorsTestSharedMemory::getBuffer() const { + return mBuffer; +} + +std::vector SensorsTestSharedMemory::parseEvents(int64_t lastCounter, size_t offset) const { + constexpr size_t kEventSize = static_cast(SensorsEventFormatOffset::TOTAL_LENGTH); + constexpr size_t kOffsetSize = static_cast(SensorsEventFormatOffset::SIZE_FIELD); + constexpr size_t kOffsetToken = static_cast(SensorsEventFormatOffset::REPORT_TOKEN); + constexpr size_t kOffsetType = static_cast(SensorsEventFormatOffset::SENSOR_TYPE); + constexpr size_t kOffsetAtomicCounter = + static_cast(SensorsEventFormatOffset::ATOMIC_COUNTER); + constexpr size_t kOffsetTimestamp = static_cast(SensorsEventFormatOffset::TIMESTAMP); + constexpr size_t kOffsetData = static_cast(SensorsEventFormatOffset::DATA); + + std::vector events; + std::vector data(16); + + while (offset + kEventSize <= mSize) { + int64_t atomicCounter = + *reinterpret_cast(mBuffer + offset + kOffsetAtomicCounter); + if (atomicCounter <= lastCounter) { + ALOGV("atomicCounter = %" PRId64 ", lastCounter = %" PRId64, atomicCounter, + lastCounter); + break; + } + + int32_t size = *reinterpret_cast(mBuffer + offset + kOffsetSize); + if (size != kEventSize) { + // unknown error, events parsed may be wrong, remove all + events.clear(); + break; + } + + int32_t token = *reinterpret_cast(mBuffer + offset + kOffsetToken); + int32_t type = *reinterpret_cast(mBuffer + offset + kOffsetType); + int64_t timestamp = *reinterpret_cast(mBuffer + offset + kOffsetTimestamp); + + ALOGV("offset = %zu, cnt %" PRId64 ", token %" PRId32 ", type %" PRId32 + ", timestamp %" PRId64, + offset, atomicCounter, token, type, timestamp); + + Event event = { + .timestamp = timestamp, + .sensorHandle = token, + .sensorType = static_cast(type), + }; + event.u.data = android::hardware::hidl_array( + reinterpret_cast(mBuffer + offset + kOffsetData)); + + events.push_back(event); + + lastCounter = atomicCounter; + offset += kEventSize; + } + + return events; +} + +SensorsTestSharedMemory::SensorsTestSharedMemory(SharedMemType type, size_t size) + : mType(type), mSize(0), mBuffer(nullptr) { + native_handle_t* handle = nullptr; + char* buffer = nullptr; + switch (type) { + case SharedMemType::ASHMEM: { + int fd; + handle = ::native_handle_create(1 /*nFds*/, 0 /*nInts*/); + if (handle != nullptr) { + handle->data[0] = fd = ::ashmem_create_region("SensorsTestSharedMemory", size); + if (handle->data[0] > 0) { + // memory is pinned by default + buffer = static_cast( + ::mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0)); + if (buffer != reinterpret_cast(MAP_FAILED)) { + break; + } + ::native_handle_close(handle); + } + ::native_handle_delete(handle); + handle = nullptr; + } + break; + } + case SharedMemType::GRALLOC: { + mGrallocWrapper = std::make_unique<::android::GrallocWrapper>(); + if (mGrallocWrapper->getAllocator() == nullptr || + mGrallocWrapper->getMapper() == nullptr) { + break; + } + using android::hardware::graphics::common::V1_0::BufferUsage; + using android::hardware::graphics::common::V1_0::PixelFormat; + mapper2::IMapper::BufferDescriptorInfo buf_desc_info = { + .width = static_cast(size), + .height = 1, + .layerCount = 1, + .usage = static_cast(BufferUsage::SENSOR_DIRECT_DATA | + BufferUsage::CPU_READ_OFTEN), + .format = PixelFormat::BLOB}; + + handle = const_cast(mGrallocWrapper->allocate(buf_desc_info)); + if (handle != nullptr) { + mapper2::IMapper::Rect region{0, 0, static_cast(buf_desc_info.width), + static_cast(buf_desc_info.height)}; + buffer = static_cast( + mGrallocWrapper->lock(handle, buf_desc_info.usage, region, /*fence=*/-1)); + if (buffer != nullptr) { + break; + } + mGrallocWrapper->freeBuffer(handle); + handle = nullptr; + } + break; + } + default: + break; + } + + if (buffer != nullptr) { + mNativeHandle = handle; + mSize = size; + mBuffer = buffer; + } +} + +SensorsTestSharedMemory::~SensorsTestSharedMemory() { + switch (mType) { + case SharedMemType::ASHMEM: { + if (mSize != 0) { + ::munmap(mBuffer, mSize); + mBuffer = nullptr; + + ::native_handle_close(mNativeHandle); + ::native_handle_delete(mNativeHandle); + + mNativeHandle = nullptr; + mSize = 0; + } + break; + } + case SharedMemType::GRALLOC: { + if (mSize != 0) { + mGrallocWrapper->unlock(mNativeHandle); + mGrallocWrapper->freeBuffer(mNativeHandle); + + mNativeHandle = nullptr; + mSize = 0; + } + break; + } + default: { + if (mNativeHandle != nullptr || mSize != 0 || mBuffer != nullptr) { + ALOGE( + "SensorsTestSharedMemory %p not properly destructed: " + "type %d, native handle %p, size %zu, buffer %p", + this, static_cast(mType), mNativeHandle, mSize, mBuffer); + } + break; + } + } +} + +SensorsTestSharedMemory* SensorsTestSharedMemory::create(SharedMemType type, size_t size) { + constexpr size_t kMaxSize = 128 * 1024 * 1024; // sensor test should not need more than 128M + if (size == 0 || size >= kMaxSize) { + return nullptr; + } + + auto m = new SensorsTestSharedMemory(type, size); + if (m->mSize != size || m->mBuffer == nullptr) { + delete m; + m = nullptr; + } + return m; +} -- cgit v1.2.3 From 56358cae58cdd0540920f2011b87d7888b74999f Mon Sep 17 00:00:00 2001 From: Brian Stack Date: Mon, 29 Oct 2018 17:20:43 -0700 Subject: Implement Direct Channel Tests Implements Direct Channel tests for Sensors HAL 2.0. The tests verify that the interface has been implemented correctly and that expected values are returned. These tests are not intended to verify that the rate at which sensor events are generated is correct. Also, correctly return -1 as the channel handle if direct report is not supported. Bug: 115969174 Test: Tests pass against default implementation Change-Id: I31b3211268701665757b03d5ee4ba2316f461282 --- sensors/common/vts/utils/SensorsTestSharedMemory.cpp | 4 ++++ 1 file changed, 4 insertions(+) (limited to 'sensors/common/vts/utils/SensorsTestSharedMemory.cpp') diff --git a/sensors/common/vts/utils/SensorsTestSharedMemory.cpp b/sensors/common/vts/utils/SensorsTestSharedMemory.cpp index 50964983e7..819e2974f7 100644 --- a/sensors/common/vts/utils/SensorsTestSharedMemory.cpp +++ b/sensors/common/vts/utils/SensorsTestSharedMemory.cpp @@ -35,6 +35,10 @@ char* SensorsTestSharedMemory::getBuffer() const { return mBuffer; } +size_t SensorsTestSharedMemory::getSize() const { + return mSize; +} + std::vector SensorsTestSharedMemory::parseEvents(int64_t lastCounter, size_t offset) const { constexpr size_t kEventSize = static_cast(SensorsEventFormatOffset::TOTAL_LENGTH); constexpr size_t kOffsetSize = static_cast(SensorsEventFormatOffset::SIZE_FIELD); -- cgit v1.2.3