Merge changes from topic 'display-p3'
* changes:
Add Display P3 DATASPACE enums
Remove TODO
diff --git a/broadcastradio/1.0/ITuner.hal b/broadcastradio/1.0/ITuner.hal
index 5e2bffe..ae4b284 100644
--- a/broadcastradio/1.0/ITuner.hal
+++ b/broadcastradio/1.0/ITuner.hal
@@ -103,11 +103,9 @@
/*
* Retrieve current station information.
- * @param withMetadata True if Metadata should be returned, false otherwise.
* @return result OK if scan successfully started
* NOT_INITIALIZED if another error occurs
* @return info Current program information.
*/
- getProgramInformation(bool withMetadata)
- generates(Result result, ProgramInfo info);
+ getProgramInformation() generates(Result result, ProgramInfo info);
};
diff --git a/broadcastradio/1.0/default/Tuner.cpp b/broadcastradio/1.0/default/Tuner.cpp
index 27b298b..de63127 100644
--- a/broadcastradio/1.0/default/Tuner.cpp
+++ b/broadcastradio/1.0/default/Tuner.cpp
@@ -46,7 +46,7 @@
mCallback->antennaStateChange(halEvent->on);
break;
case RADIO_EVENT_TUNED:
- Utils::convertProgramInfoFromHal(&info, &halEvent->info, true);
+ Utils::convertProgramInfoFromHal(&info, &halEvent->info);
mCallback->tuneComplete(Utils::convertHalResult(halEvent->status), info);
break;
case RADIO_EVENT_METADATA: {
@@ -61,7 +61,7 @@
mCallback->trafficAnnouncement(halEvent->on);
break;
case RADIO_EVENT_AF_SWITCH:
- Utils::convertProgramInfoFromHal(&info, &halEvent->info, true);
+ Utils::convertProgramInfoFromHal(&info, &halEvent->info);
mCallback->afSwitch(info);
break;
case RADIO_EVENT_EA:
@@ -164,7 +164,7 @@
return Utils::convertHalResult(rc);
}
-Return<void> Tuner::getProgramInformation(bool withMetadata, getProgramInformation_cb _hidl_cb) {
+Return<void> Tuner::getProgramInformation(getProgramInformation_cb _hidl_cb) {
int rc;
radio_program_info_t halInfo;
ProgramInfo info;
@@ -174,18 +174,13 @@
rc = -ENODEV;
goto exit;
}
- if (withMetadata) {
- radio_metadata_allocate(&halInfo.metadata, 0, 0);
- } else {
- halInfo.metadata = NULL;
- }
+
+ radio_metadata_allocate(&halInfo.metadata, 0, 0);
rc = mHalTuner->get_program_information(mHalTuner, &halInfo);
if (rc == 0) {
- Utils::convertProgramInfoFromHal(&info, &halInfo, withMetadata);
+ Utils::convertProgramInfoFromHal(&info, &halInfo);
}
- if (withMetadata) {
- radio_metadata_deallocate(halInfo.metadata);
- }
+ radio_metadata_deallocate(halInfo.metadata);
exit:
_hidl_cb(Utils::convertHalResult(rc), info);
diff --git a/broadcastradio/1.0/default/Tuner.h b/broadcastradio/1.0/default/Tuner.h
index a621d97..bfdd4f4 100644
--- a/broadcastradio/1.0/default/Tuner.h
+++ b/broadcastradio/1.0/default/Tuner.h
@@ -40,8 +40,7 @@
Return<Result> step(Direction direction, bool skipSubChannel) override;
Return<Result> tune(uint32_t channel, uint32_t subChannel) override;
Return<Result> cancel() override;
- Return<void> getProgramInformation(bool withMetadata,
- getProgramInformation_cb _hidl_cb) override;
+ Return<void> getProgramInformation(getProgramInformation_cb _hidl_cb) override;
static void callback(radio_hal_event_t *halEvent, void *cookie);
void onCallback(radio_hal_event_t *halEvent);
diff --git a/broadcastradio/1.0/default/Utils.cpp b/broadcastradio/1.0/default/Utils.cpp
index c2c2ff3..aefeeb1 100644
--- a/broadcastradio/1.0/default/Utils.cpp
+++ b/broadcastradio/1.0/default/Utils.cpp
@@ -222,8 +222,7 @@
//static
void Utils::convertProgramInfoFromHal(ProgramInfo *info,
- radio_program_info_t *halInfo,
- bool withMetadata)
+ radio_program_info_t *halInfo)
{
info->channel = halInfo->channel;
info->subChannel = halInfo->sub_channel;
@@ -231,9 +230,7 @@
info->stereo = halInfo->stereo;
info->digital = halInfo->digital;
info->signalStrength = halInfo->signal_strength;
- if (withMetadata && halInfo->metadata != NULL) {
- convertMetaDataFromHal(info->metadata, halInfo->metadata);
- }
+ convertMetaDataFromHal(info->metadata, halInfo->metadata);
}
//static
@@ -241,6 +238,7 @@
radio_metadata_t *halMetadata)
{
if (halMetadata == NULL) {
+ ALOGE("Invalid argument: halMetadata is NULL");
return 0;
}
diff --git a/broadcastradio/1.0/default/Utils.h b/broadcastradio/1.0/default/Utils.h
index 25eb6ee..4ef22a5 100644
--- a/broadcastradio/1.0/default/Utils.h
+++ b/broadcastradio/1.0/default/Utils.h
@@ -36,8 +36,7 @@
static void convertBandConfigToHal(radio_hal_band_config_t *halConfig,
const BandConfig *config);
static void convertProgramInfoFromHal(ProgramInfo *info,
- radio_program_info_t *halInfo,
- bool withMetadata);
+ radio_program_info_t *halInfo);
static int convertMetaDataFromHal(hidl_vec<MetaData>& metadata,
radio_metadata_t *halMetadata);
private:
diff --git a/broadcastradio/1.0/vts/functional/broadcastradio_hidl_hal_test.cpp b/broadcastradio/1.0/vts/functional/broadcastradio_hidl_hal_test.cpp
index 12bbb6b..bcbfbb7 100644
--- a/broadcastradio/1.0/vts/functional/broadcastradio_hidl_hal_test.cpp
+++ b/broadcastradio/1.0/vts/functional/broadcastradio_hidl_hal_test.cpp
@@ -434,11 +434,11 @@
ProgramInfo halInfo;
Result halResult = Result::NOT_INITIALIZED;
Return<void> hidlReturn = mTuner->getProgramInformation(
- false, [&](Result result, const ProgramInfo& info) {
- halResult = result;
- if (result == Result::OK) {
- halInfo = info;
- }
+ [&](Result result, const ProgramInfo& info) {
+ halResult = result;
+ if (result == Result::OK) {
+ halInfo = info;
+ }
});
EXPECT_TRUE(hidlReturn.isOk());
EXPECT_EQ(Result::OK, halResult);
diff --git a/contexthub/1.0/types.hal b/contexthub/1.0/types.hal
index 043bb39..c8ea623 100644
--- a/contexthub/1.0/types.hal
+++ b/contexthub/1.0/types.hal
@@ -20,12 +20,11 @@
OK, // Success
UNKNOWN_FAILURE, // Failure, unknown reason
BAD_PARAMS, // Parameters not sane
- NOT_INIT, // not initialized
- TRANSACTION_FAILED, // transaction failed
+ NOT_INIT, // Not initialized
+ TRANSACTION_FAILED, // Transaction failed
TRANSACTION_PENDING, // Pending transaction, cannot accept a new request
};
-
enum NanoAppFlags : uint32_t {
SIGNED = (1<<0), // Signed nanoapp
ENCRYPTED = (1<<1),// Encrypted nanoapp
@@ -34,11 +33,12 @@
struct NanoAppBinary {
uint32_t headerVersion; // 0x1 for this version
uint32_t magic; // "NANO"
- uint64_t appId; // App Id contains vendor id
+ uint64_t appId; // App ID (contains vendor ID in most significant
+ // 5 bytes)
uint32_t appVersion; // Version of the app
- uint32_t flags; // mask of NanoAppFlags
- uint64_t hwHubType; // which hub type is this compiled for
- // a unique UUID for each h/w + toolchain
+ uint32_t flags; // Mask of NanoAppFlags
+ uint64_t hwHubType; // Which hub type is this app is compiled for. A
+ // unique ID for each h/w + toolchain
// combination.
vec<uint8_t> customBinary; // start of custom binary data
};
@@ -82,38 +82,38 @@
// definition may be different from say the
// number advertised in the sensors HAL
// which allows for batching in a hub.
- uint32_t fifoMaxCount; // maximum number of batchable events.
- uint64_t minDelayMs; // in milliseconds, corresponding to highest
+ uint32_t fifoMaxCount; // Maximum number of batchable events.
+ uint64_t minDelayMs; // In milliseconds, corresponding to highest
// sampling freq.
- uint64_t maxDelayMs; // in milliseconds, corresponds to minimum
+ uint64_t maxDelayMs; // In milliseconds, corresponds to minimum
// sampling frequency
float peakPowerMw; // At max frequency & no batching, power
// in milliwatts
};
struct ContextHub {
- string name; // descriptive name eg: "Awesome Hub #1"
- string vendor; // hub hardware vendor eg: "Qualcomm"
- string toolchain; // toolchain to make binaries eg: "gcc ARM"
+ string name; // Descriptive name eg: "Awesome Hub #1"
+ string vendor; // Hub hardware vendor eg: "Qualcomm"
+ string toolchain; // Toolchain to make binaries eg: "gcc ARM"
uint32_t platformVersion; // Version of the hardware : eg 0x20
uint32_t toolchainVersion; // Version of the toolchain : eg: 0x484
- uint32_t hubId; // a device unique id for this hub
+ uint32_t hubId; // A device unique ID for this hub
float peakMips; // Peak MIPS platform can deliver
- float stoppedPowerDrawMw; // if stopped, retention power, milliwatts
- float sleepPowerDrawMw; // if sleeping, retention power, milliwatts
- float peakPowerDrawMw; // for a busy CPUm power in milliwatts
+ float stoppedPowerDrawMw; // If stopped, retention power, milliwatts
+ float sleepPowerDrawMw; // If sleeping, retention power, milliwatts
+ float peakPowerDrawMw; // For a busy CPU, power in milliwatts
- vec<PhysicalSensor> connectedSensors; // array of connected sensors
+ vec<PhysicalSensor> connectedSensors; // Array of connected sensors
uint32_t maxSupportedMsgLen;// This is the maximum size of the message that can
// be sent to the hub in one chunk (in bytes)
};
struct ContextHubMsg {
- uint64_t appName; // intended recipient
- uint32_t msgType; // identifier for message
- vec<uint8_t> msg; // message body
+ uint64_t appName; // Intended recipient (appId)
+ uint32_t msgType; // Identifier for message
+ vec<uint8_t> msg; // Message body
};
enum HubMemoryType : uint32_t {
@@ -129,24 +129,26 @@
};
struct MemRange {
- uint32_t totalBytes; // total capacity in bytes
- uint32_t freeBytes; // free capacity in bytes
- HubMemoryType type; // type of memory, see HubMemoryType
- uint32_t flags; // mask of HubMemoryFlag
+ uint32_t totalBytes; // Total capacity in bytes
+ uint32_t freeBytes; // Free capacity in bytes
+ HubMemoryType type; // Type of memory, see HubMemoryType
+ uint32_t flags; // Mask of HubMemoryFlag
};
enum AsyncEventType : uint32_t {
- RESTARTED = 1, // Hub restarted unexpectedly
+ RESTARTED = 1, // Hub restarted unexpectedly
};
enum TransactionResult : int32_t {
- SUCCESS, // successful completion of transaction
- FAILURE, // failed transaction
+ SUCCESS, // Successful completion of transaction
+ FAILURE, // Failed transaction
};
struct HubAppInfo {
uint64_t appId; // Identifier of the app
- uint32_t version; // version of the app
+ uint32_t version; // Version of the app
vec<MemRange> memUsage; // Memory used by this app
+ bool enabled; // true if the app is currently enabled and running,
+ // or false if in the loaded but disabled state
};
diff --git a/graphics/allocator/2.0/default/Android.bp b/graphics/allocator/2.0/default/Android.bp
index 994feb3..f0c736c 100644
--- a/graphics/allocator/2.0/default/Android.bp
+++ b/graphics/allocator/2.0/default/Android.bp
@@ -34,7 +34,7 @@
cc_library_static {
name: "libgralloc1-adapter",
- srcs: ["gralloc1-adapter.c"],
+ srcs: ["gralloc1-adapter.cpp", "Gralloc1On0Adapter.cpp"],
include_dirs: ["system/core/libsync/include"],
cflags: ["-Wall", "-Wextra", "-Wno-unused-parameter"],
export_include_dirs: ["."],
diff --git a/graphics/allocator/2.0/default/Gralloc1On0Adapter.cpp b/graphics/allocator/2.0/default/Gralloc1On0Adapter.cpp
new file mode 100644
index 0000000..4b9c9e1
--- /dev/null
+++ b/graphics/allocator/2.0/default/Gralloc1On0Adapter.cpp
@@ -0,0 +1,560 @@
+/*
+ * Copyright 2016 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.
+ */
+
+#undef LOG_TAG
+#define LOG_TAG "Gralloc1On0Adapter"
+//#define LOG_NDEBUG 0
+
+#include "Gralloc1On0Adapter.h"
+#include "gralloc1-adapter.h"
+
+#include <hardware/gralloc.h>
+
+#include <utils/Log.h>
+#include <sync/sync.h>
+
+#include <inttypes.h>
+
+template <typename PFN, typename T>
+static gralloc1_function_pointer_t asFP(T function)
+{
+ static_assert(std::is_same<PFN, T>::value, "Incompatible function pointer");
+ return reinterpret_cast<gralloc1_function_pointer_t>(function);
+}
+
+namespace android {
+namespace hardware {
+
+Gralloc1On0Adapter::Gralloc1On0Adapter(const hw_module_t* module)
+ : gralloc1_device_t(),
+ mModule(reinterpret_cast<const gralloc_module_t*>(module)),
+ mDevice(nullptr)
+{
+ ALOGV("Constructing");
+
+ int minor = 0;
+ mModule->perform(mModule,
+ GRALLOC1_ADAPTER_PERFORM_GET_REAL_MODULE_API_VERSION_MINOR,
+ &minor);
+ mMinorVersion = minor;
+
+ common.tag = HARDWARE_DEVICE_TAG,
+ common.version = HARDWARE_DEVICE_API_VERSION(0, 0),
+ common.module = const_cast<struct hw_module_t*>(module),
+ common.close = closeHook,
+
+ getCapabilities = getCapabilitiesHook;
+ getFunction = getFunctionHook;
+ int error = ::gralloc_open(&(mModule->common), &mDevice);
+ if (error) {
+ ALOGE("Failed to open gralloc0 module: %d", error);
+ }
+ ALOGV("Opened gralloc0 device %p", mDevice);
+}
+
+Gralloc1On0Adapter::~Gralloc1On0Adapter()
+{
+ ALOGV("Destructing");
+ if (mDevice) {
+ ALOGV("Closing gralloc0 device %p", mDevice);
+ ::gralloc_close(mDevice);
+ }
+}
+
+void Gralloc1On0Adapter::doGetCapabilities(uint32_t* outCount,
+ int32_t* outCapabilities)
+{
+ *outCount = 0;
+}
+
+gralloc1_function_pointer_t Gralloc1On0Adapter::doGetFunction(
+ int32_t intDescriptor)
+{
+ constexpr auto lastDescriptor =
+ static_cast<int32_t>(GRALLOC1_LAST_FUNCTION);
+ if (intDescriptor < 0 || intDescriptor > lastDescriptor) {
+ ALOGE("Invalid function descriptor");
+ return nullptr;
+ }
+
+ auto descriptor =
+ static_cast<gralloc1_function_descriptor_t>(intDescriptor);
+ switch (descriptor) {
+ case GRALLOC1_FUNCTION_DUMP:
+ return asFP<GRALLOC1_PFN_DUMP>(dumpHook);
+ case GRALLOC1_FUNCTION_CREATE_DESCRIPTOR:
+ return asFP<GRALLOC1_PFN_CREATE_DESCRIPTOR>(createDescriptorHook);
+ case GRALLOC1_FUNCTION_DESTROY_DESCRIPTOR:
+ return asFP<GRALLOC1_PFN_DESTROY_DESCRIPTOR>(destroyDescriptorHook);
+ case GRALLOC1_FUNCTION_SET_CONSUMER_USAGE:
+ return asFP<GRALLOC1_PFN_SET_CONSUMER_USAGE>(setConsumerUsageHook);
+ case GRALLOC1_FUNCTION_SET_DIMENSIONS:
+ return asFP<GRALLOC1_PFN_SET_DIMENSIONS>(setDimensionsHook);
+ case GRALLOC1_FUNCTION_SET_FORMAT:
+ return asFP<GRALLOC1_PFN_SET_FORMAT>(setFormatHook);
+ case GRALLOC1_FUNCTION_SET_LAYER_COUNT:
+ return asFP<GRALLOC1_PFN_SET_LAYER_COUNT>(setLayerCountHook);
+ case GRALLOC1_FUNCTION_SET_PRODUCER_USAGE:
+ return asFP<GRALLOC1_PFN_SET_PRODUCER_USAGE>(setProducerUsageHook);
+ case GRALLOC1_FUNCTION_GET_BACKING_STORE:
+ return asFP<GRALLOC1_PFN_GET_BACKING_STORE>(
+ bufferHook<decltype(&Buffer::getBackingStore),
+ &Buffer::getBackingStore, gralloc1_backing_store_t*>);
+ case GRALLOC1_FUNCTION_GET_CONSUMER_USAGE:
+ return asFP<GRALLOC1_PFN_GET_CONSUMER_USAGE>(getConsumerUsageHook);
+ case GRALLOC1_FUNCTION_GET_DIMENSIONS:
+ return asFP<GRALLOC1_PFN_GET_DIMENSIONS>(
+ bufferHook<decltype(&Buffer::getDimensions),
+ &Buffer::getDimensions, uint32_t*, uint32_t*>);
+ case GRALLOC1_FUNCTION_GET_FORMAT:
+ return asFP<GRALLOC1_PFN_GET_FORMAT>(
+ bufferHook<decltype(&Buffer::getFormat),
+ &Buffer::getFormat, int32_t*>);
+ case GRALLOC1_FUNCTION_GET_LAYER_COUNT:
+ return asFP<GRALLOC1_PFN_GET_LAYER_COUNT>(
+ bufferHook<decltype(&Buffer::getLayerCount),
+ &Buffer::getLayerCount, uint32_t*>);
+ case GRALLOC1_FUNCTION_GET_PRODUCER_USAGE:
+ return asFP<GRALLOC1_PFN_GET_PRODUCER_USAGE>(getProducerUsageHook);
+ case GRALLOC1_FUNCTION_GET_STRIDE:
+ return asFP<GRALLOC1_PFN_GET_STRIDE>(
+ bufferHook<decltype(&Buffer::getStride),
+ &Buffer::getStride, uint32_t*>);
+ case GRALLOC1_FUNCTION_ALLOCATE:
+ if (mDevice != nullptr) {
+ return asFP<GRALLOC1_PFN_ALLOCATE>(allocateHook);
+ } else {
+ return nullptr;
+ }
+ case GRALLOC1_FUNCTION_RETAIN:
+ return asFP<GRALLOC1_PFN_RETAIN>(retainHook);
+ case GRALLOC1_FUNCTION_RELEASE:
+ return asFP<GRALLOC1_PFN_RELEASE>(releaseHook);
+ case GRALLOC1_FUNCTION_GET_NUM_FLEX_PLANES:
+ return asFP<GRALLOC1_PFN_GET_NUM_FLEX_PLANES>(
+ bufferHook<decltype(&Buffer::getNumFlexPlanes),
+ &Buffer::getNumFlexPlanes, uint32_t*>);
+ case GRALLOC1_FUNCTION_LOCK:
+ return asFP<GRALLOC1_PFN_LOCK>(
+ lockHook<void*, &Gralloc1On0Adapter::lock>);
+ case GRALLOC1_FUNCTION_LOCK_FLEX:
+ return asFP<GRALLOC1_PFN_LOCK_FLEX>(
+ lockHook<struct android_flex_layout,
+ &Gralloc1On0Adapter::lockFlex>);
+ case GRALLOC1_FUNCTION_UNLOCK:
+ return asFP<GRALLOC1_PFN_UNLOCK>(unlockHook);
+ case GRALLOC1_FUNCTION_INVALID:
+ ALOGE("Invalid function descriptor");
+ return nullptr;
+ }
+
+ ALOGE("Unknown function descriptor: %d", intDescriptor);
+ return nullptr;
+}
+
+void Gralloc1On0Adapter::dump(uint32_t* outSize, char* outBuffer)
+{
+ ALOGV("dump(%u (%p), %p", outSize ? *outSize : 0, outSize, outBuffer);
+
+ if (!mDevice->dump) {
+ // dump is optional on gralloc0 implementations
+ *outSize = 0;
+ return;
+ }
+
+ if (!outBuffer) {
+ constexpr int32_t BUFFER_LENGTH = 4096;
+ char buffer[BUFFER_LENGTH] = {};
+ mDevice->dump(mDevice, buffer, BUFFER_LENGTH);
+ buffer[BUFFER_LENGTH - 1] = 0; // Ensure the buffer is null-terminated
+ size_t actualLength = std::strlen(buffer);
+ mCachedDump.resize(actualLength);
+ std::copy_n(buffer, actualLength, mCachedDump.begin());
+ *outSize = static_cast<uint32_t>(actualLength);
+ } else {
+ *outSize = std::min(*outSize,
+ static_cast<uint32_t>(mCachedDump.size()));
+ outBuffer = std::copy_n(mCachedDump.cbegin(), *outSize, outBuffer);
+ }
+}
+
+gralloc1_error_t Gralloc1On0Adapter::createDescriptor(
+ gralloc1_buffer_descriptor_t* outDescriptor)
+{
+ auto descriptorId = sNextBufferDescriptorId++;
+ std::lock_guard<std::mutex> lock(mDescriptorMutex);
+ mDescriptors.emplace(descriptorId, std::make_shared<Descriptor>());
+
+ ALOGV("Created descriptor %" PRIu64, descriptorId);
+
+ *outDescriptor = descriptorId;
+ return GRALLOC1_ERROR_NONE;
+}
+
+gralloc1_error_t Gralloc1On0Adapter::destroyDescriptor(
+ gralloc1_buffer_descriptor_t descriptor)
+{
+ ALOGV("Destroying descriptor %" PRIu64, descriptor);
+
+ std::lock_guard<std::mutex> lock(mDescriptorMutex);
+ if (mDescriptors.count(descriptor) == 0) {
+ return GRALLOC1_ERROR_BAD_DESCRIPTOR;
+ }
+
+ mDescriptors.erase(descriptor);
+ return GRALLOC1_ERROR_NONE;
+}
+
+Gralloc1On0Adapter::Buffer::Buffer(buffer_handle_t handle,
+ gralloc1_backing_store_t store, const Descriptor& descriptor,
+ uint32_t stride, uint32_t numFlexPlanes, bool wasAllocated)
+ : mHandle(handle),
+ mReferenceCount(1),
+ mStore(store),
+ mDescriptor(descriptor),
+ mStride(stride),
+ mNumFlexPlanes(numFlexPlanes),
+ mWasAllocated(wasAllocated) {}
+
+gralloc1_error_t Gralloc1On0Adapter::allocate(
+ gralloc1_buffer_descriptor_t id,
+ const std::shared_ptr<Descriptor>& descriptor,
+ buffer_handle_t* outBufferHandle)
+{
+ ALOGV("allocate(%" PRIu64 ")", id);
+
+ // If this function is being called, it's because we handed out its function
+ // pointer, which only occurs when mDevice has been loaded successfully and
+ // we are permitted to allocate
+
+ int usage = static_cast<int>(descriptor->producerUsage) |
+ static_cast<int>(descriptor->consumerUsage);
+ buffer_handle_t handle = nullptr;
+ int stride = 0;
+ ALOGV("Calling alloc(%p, %u, %u, %i, %u)", mDevice, descriptor->width,
+ descriptor->height, descriptor->format, usage);
+ auto error = mDevice->alloc(mDevice,
+ static_cast<int>(descriptor->width),
+ static_cast<int>(descriptor->height), descriptor->format,
+ usage, &handle, &stride);
+ if (error != 0) {
+ ALOGE("gralloc0 allocation failed: %d (%s)", error,
+ strerror(-error));
+ return GRALLOC1_ERROR_NO_RESOURCES;
+ }
+
+ mModule->perform(mModule, GRALLOC1_ADAPTER_PERFORM_SET_USAGES,
+ handle,
+ static_cast<int>(descriptor->producerUsage),
+ static_cast<int>(descriptor->consumerUsage));
+
+ uint64_t backingStore = 0;
+ mModule->perform(mModule, GRALLOC1_ADAPTER_PERFORM_GET_BACKING_STORE,
+ handle, &backingStore);
+ int numFlexPlanes = 0;
+ mModule->perform(mModule, GRALLOC1_ADAPTER_PERFORM_GET_NUM_FLEX_PLANES,
+ handle, &numFlexPlanes);
+
+ *outBufferHandle = handle;
+ auto buffer = std::make_shared<Buffer>(handle, backingStore,
+ *descriptor, stride, numFlexPlanes, true);
+
+ std::lock_guard<std::mutex> lock(mBufferMutex);
+ mBuffers.emplace(handle, std::move(buffer));
+
+ return GRALLOC1_ERROR_NONE;
+}
+
+int32_t Gralloc1On0Adapter::allocateHook(gralloc1_device* device,
+ uint32_t numDescriptors,
+ const gralloc1_buffer_descriptor_t* descriptors,
+ buffer_handle_t* outBuffers)
+{
+ if (!outBuffers) {
+ return GRALLOC1_ERROR_UNDEFINED;
+ }
+
+ auto adapter = getAdapter(device);
+
+ gralloc1_error_t error = GRALLOC1_ERROR_NONE;
+ uint32_t i;
+ for (i = 0; i < numDescriptors; i++) {
+ auto descriptor = adapter->getDescriptor(descriptors[i]);
+ if (!descriptor) {
+ error = GRALLOC1_ERROR_BAD_DESCRIPTOR;
+ break;
+ }
+
+ buffer_handle_t bufferHandle = nullptr;
+ error = adapter->allocate(descriptors[i], descriptor, &bufferHandle);
+ if (error != GRALLOC1_ERROR_NONE) {
+ break;
+ }
+
+ outBuffers[i] = bufferHandle;
+ }
+
+ if (error == GRALLOC1_ERROR_NONE) {
+ if (numDescriptors > 1) {
+ error = GRALLOC1_ERROR_NOT_SHARED;
+ }
+ } else {
+ for (uint32_t j = 0; j < i; j++) {
+ adapter->release(adapter->getBuffer(outBuffers[j]));
+ outBuffers[j] = nullptr;
+ }
+ }
+
+ return error;
+}
+
+gralloc1_error_t Gralloc1On0Adapter::retain(
+ const std::shared_ptr<Buffer>& buffer)
+{
+ std::lock_guard<std::mutex> lock(mBufferMutex);
+ buffer->retain();
+ return GRALLOC1_ERROR_NONE;
+}
+
+gralloc1_error_t Gralloc1On0Adapter::release(
+ const std::shared_ptr<Buffer>& buffer)
+{
+ std::lock_guard<std::mutex> lock(mBufferMutex);
+ if (!buffer->release()) {
+ return GRALLOC1_ERROR_NONE;
+ }
+
+ buffer_handle_t handle = buffer->getHandle();
+ if (buffer->wasAllocated()) {
+ ALOGV("Calling free(%p)", handle);
+ int result = mDevice->free(mDevice, handle);
+ if (result != 0) {
+ ALOGE("gralloc0 free failed: %d", result);
+ }
+ } else {
+ ALOGV("Calling unregisterBuffer(%p)", handle);
+ int result = mModule->unregisterBuffer(mModule, handle);
+ if (result != 0) {
+ ALOGE("gralloc0 unregister failed: %d", result);
+ }
+ }
+
+ mBuffers.erase(handle);
+ return GRALLOC1_ERROR_NONE;
+}
+
+gralloc1_error_t Gralloc1On0Adapter::retain(buffer_handle_t bufferHandle)
+{
+ ALOGV("retain(%p)", bufferHandle);
+
+ std::lock_guard<std::mutex> lock(mBufferMutex);
+
+ if (mBuffers.count(bufferHandle) != 0) {
+ mBuffers[bufferHandle]->retain();
+ return GRALLOC1_ERROR_NONE;
+ }
+
+ ALOGV("Calling registerBuffer(%p)", bufferHandle);
+ int result = mModule->registerBuffer(mModule, bufferHandle);
+ if (result != 0) {
+ ALOGE("gralloc0 register failed: %d", result);
+ return GRALLOC1_ERROR_NO_RESOURCES;
+ }
+
+ uint64_t backingStore = 0;
+ mModule->perform(mModule, GRALLOC1_ADAPTER_PERFORM_GET_BACKING_STORE,
+ bufferHandle, &backingStore);
+
+ int numFlexPlanes = 0;
+ mModule->perform(mModule, GRALLOC1_ADAPTER_PERFORM_GET_NUM_FLEX_PLANES,
+ bufferHandle, &numFlexPlanes);
+
+ int stride = 0;
+ mModule->perform(mModule, GRALLOC1_ADAPTER_PERFORM_GET_STRIDE,
+ bufferHandle, &stride);
+
+ int width = 0;
+ int height = 0;
+ int format = HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED;
+ int producerUsage = 0;
+ int consumerUsage = 0;
+ mModule->perform(mModule, GRALLOC1_ADAPTER_PERFORM_GET_DIMENSIONS,
+ bufferHandle, &width, &height);
+ mModule->perform(mModule, GRALLOC1_ADAPTER_PERFORM_GET_FORMAT,
+ bufferHandle, &format);
+ mModule->perform(mModule, GRALLOC1_ADAPTER_PERFORM_GET_PRODUCER_USAGE,
+ bufferHandle, &producerUsage);
+ mModule->perform(mModule, GRALLOC1_ADAPTER_PERFORM_GET_CONSUMER_USAGE,
+ bufferHandle, &consumerUsage);
+
+ Descriptor descriptor;
+ descriptor.setDimensions(width, height);
+ descriptor.setFormat(format);
+ descriptor.setProducerUsage(
+ static_cast<gralloc1_producer_usage_t>(producerUsage));
+ descriptor.setConsumerUsage(
+ static_cast<gralloc1_consumer_usage_t>(consumerUsage));
+
+ auto buffer = std::make_shared<Buffer>(bufferHandle, backingStore,
+ descriptor, stride, numFlexPlanes, false);
+ mBuffers.emplace(bufferHandle, std::move(buffer));
+ return GRALLOC1_ERROR_NONE;
+}
+
+static void syncWaitForever(int fd, const char* logname)
+{
+ if (fd < 0) {
+ return;
+ }
+
+ const int warningTimeout = 3500;
+ const int error = sync_wait(fd, warningTimeout);
+ if (error < 0 && errno == ETIME) {
+ ALOGE("%s: fence %d didn't signal in %u ms", logname, fd,
+ warningTimeout);
+ sync_wait(fd, -1);
+ }
+}
+
+gralloc1_error_t Gralloc1On0Adapter::lock(
+ const std::shared_ptr<Buffer>& buffer,
+ gralloc1_producer_usage_t producerUsage,
+ gralloc1_consumer_usage_t consumerUsage,
+ const gralloc1_rect_t& accessRegion, void** outData,
+ int acquireFence)
+{
+ if (mMinorVersion >= 3) {
+ int result = mModule->lockAsync(mModule, buffer->getHandle(),
+ static_cast<int32_t>(producerUsage | consumerUsage),
+ accessRegion.left, accessRegion.top, accessRegion.width,
+ accessRegion.height, outData, acquireFence);
+ if (result != 0) {
+ return GRALLOC1_ERROR_UNSUPPORTED;
+ }
+ } else {
+ syncWaitForever(acquireFence, "Gralloc1On0Adapter::lock");
+
+ int result = mModule->lock(mModule, buffer->getHandle(),
+ static_cast<int32_t>(producerUsage | consumerUsage),
+ accessRegion.left, accessRegion.top, accessRegion.width,
+ accessRegion.height, outData);
+ ALOGV("gralloc0 lock returned %d", result);
+ if (result != 0) {
+ return GRALLOC1_ERROR_UNSUPPORTED;
+ } else if (acquireFence >= 0) {
+ close(acquireFence);
+ }
+ }
+ return GRALLOC1_ERROR_NONE;
+}
+
+gralloc1_error_t Gralloc1On0Adapter::lockFlex(
+ const std::shared_ptr<Buffer>& buffer,
+ gralloc1_producer_usage_t producerUsage,
+ gralloc1_consumer_usage_t consumerUsage,
+ const gralloc1_rect_t& accessRegion,
+ struct android_flex_layout* outFlex,
+ int acquireFence)
+{
+ if (mMinorVersion >= 3) {
+ int result = mModule->perform(mModule,
+ GRALLOC1_ADAPTER_PERFORM_LOCK_FLEX,
+ buffer->getHandle(),
+ static_cast<int>(producerUsage),
+ static_cast<int>(consumerUsage),
+ accessRegion.left,
+ accessRegion.top,
+ accessRegion.width,
+ accessRegion.height,
+ outFlex, acquireFence);
+ if (result != 0) {
+ return GRALLOC1_ERROR_UNSUPPORTED;
+ }
+ } else {
+ syncWaitForever(acquireFence, "Gralloc1On0Adapter::lockFlex");
+
+ int result = mModule->perform(mModule,
+ GRALLOC1_ADAPTER_PERFORM_LOCK_FLEX,
+ buffer->getHandle(),
+ static_cast<int>(producerUsage),
+ static_cast<int>(consumerUsage),
+ accessRegion.left,
+ accessRegion.top,
+ accessRegion.width,
+ accessRegion.height,
+ outFlex, -1);
+ if (result != 0) {
+ return GRALLOC1_ERROR_UNSUPPORTED;
+ } else if (acquireFence >= 0) {
+ close(acquireFence);
+ }
+ }
+
+ return GRALLOC1_ERROR_NONE;
+}
+
+gralloc1_error_t Gralloc1On0Adapter::unlock(
+ const std::shared_ptr<Buffer>& buffer,
+ int* outReleaseFence)
+{
+ if (mMinorVersion >= 3) {
+ int fenceFd = -1;
+ int result = mModule->unlockAsync(mModule, buffer->getHandle(),
+ &fenceFd);
+ if (result != 0) {
+ close(fenceFd);
+ ALOGE("gralloc0 unlockAsync failed: %d", result);
+ } else {
+ *outReleaseFence = fenceFd;
+ }
+ } else {
+ int result = mModule->unlock(mModule, buffer->getHandle());
+ if (result != 0) {
+ ALOGE("gralloc0 unlock failed: %d", result);
+ } else {
+ *outReleaseFence = -1;
+ }
+ }
+ return GRALLOC1_ERROR_NONE;
+}
+
+std::shared_ptr<Gralloc1On0Adapter::Descriptor>
+Gralloc1On0Adapter::getDescriptor(gralloc1_buffer_descriptor_t descriptorId)
+{
+ std::lock_guard<std::mutex> lock(mDescriptorMutex);
+ if (mDescriptors.count(descriptorId) == 0) {
+ return nullptr;
+ }
+
+ return mDescriptors[descriptorId];
+}
+
+std::shared_ptr<Gralloc1On0Adapter::Buffer> Gralloc1On0Adapter::getBuffer(
+ buffer_handle_t bufferHandle)
+{
+ std::lock_guard<std::mutex> lock(mBufferMutex);
+ if (mBuffers.count(bufferHandle) == 0) {
+ return nullptr;
+ }
+
+ return mBuffers[bufferHandle];
+}
+
+std::atomic<gralloc1_buffer_descriptor_t>
+ Gralloc1On0Adapter::sNextBufferDescriptorId(1);
+
+} // namespace hardware
+} // namespace android
diff --git a/graphics/allocator/2.0/default/Gralloc1On0Adapter.h b/graphics/allocator/2.0/default/Gralloc1On0Adapter.h
new file mode 100644
index 0000000..180015d
--- /dev/null
+++ b/graphics/allocator/2.0/default/Gralloc1On0Adapter.h
@@ -0,0 +1,458 @@
+/*
+ * Copyright 2016 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.
+ */
+
+#ifndef ANDROID_HARDWARE_GRALLOC_1_ON_0_ADAPTER_H
+#define ANDROID_HARDWARE_GRALLOC_1_ON_0_ADAPTER_H
+
+#include <hardware/gralloc1.h>
+#include <log/log.h>
+
+#include <atomic>
+#include <memory>
+#include <mutex>
+#include <string>
+#include <unordered_map>
+#include <utility>
+
+struct gralloc_module_t;
+struct alloc_device_t;
+
+namespace android {
+namespace hardware {
+
+class Gralloc1On0Adapter : public gralloc1_device_t
+{
+public:
+ Gralloc1On0Adapter(const hw_module_t* module);
+ ~Gralloc1On0Adapter();
+
+ gralloc1_device_t* getDevice() {
+ return static_cast<gralloc1_device_t*>(this);
+ }
+
+private:
+ static inline Gralloc1On0Adapter* getAdapter(gralloc1_device_t* device) {
+ return static_cast<Gralloc1On0Adapter*>(device);
+ }
+
+ static int closeHook(struct hw_device_t* device) {
+ delete getAdapter(reinterpret_cast<gralloc1_device_t*>(device));
+ return 0;
+ }
+
+ // getCapabilities
+
+ void doGetCapabilities(uint32_t* outCount,
+ int32_t* /*gralloc1_capability_t*/ outCapabilities);
+ static void getCapabilitiesHook(gralloc1_device_t* device,
+ uint32_t* outCount,
+ int32_t* /*gralloc1_capability_t*/ outCapabilities) {
+ getAdapter(device)->doGetCapabilities(outCount, outCapabilities);
+ }
+
+ // getFunction
+
+ gralloc1_function_pointer_t doGetFunction(
+ int32_t /*gralloc1_function_descriptor_t*/ descriptor);
+ static gralloc1_function_pointer_t getFunctionHook(
+ gralloc1_device_t* device,
+ int32_t /*gralloc1_function_descriptor_t*/ descriptor) {
+ return getAdapter(device)->doGetFunction(descriptor);
+ }
+
+ // dump
+
+ void dump(uint32_t* outSize, char* outBuffer);
+ static void dumpHook(gralloc1_device_t* device, uint32_t* outSize,
+ char* outBuffer) {
+ return getAdapter(device)->dump(outSize, outBuffer);
+ }
+ std::string mCachedDump;
+
+ // Buffer descriptor lifecycle functions
+
+ struct Descriptor;
+
+ gralloc1_error_t createDescriptor(
+ gralloc1_buffer_descriptor_t* outDescriptor);
+ static int32_t createDescriptorHook(gralloc1_device_t* device,
+ gralloc1_buffer_descriptor_t* outDescriptor) {
+ auto error = getAdapter(device)->createDescriptor(outDescriptor);
+ return static_cast<int32_t>(error);
+ }
+
+ gralloc1_error_t destroyDescriptor(gralloc1_buffer_descriptor_t descriptor);
+ static int32_t destroyDescriptorHook(gralloc1_device_t* device,
+ gralloc1_buffer_descriptor_t descriptor) {
+ auto error = getAdapter(device)->destroyDescriptor(descriptor);
+ return static_cast<int32_t>(error);
+ }
+
+ // Buffer descriptor modification functions
+
+ struct Descriptor : public std::enable_shared_from_this<Descriptor> {
+ Descriptor()
+ : width(0),
+ height(0),
+ format(HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED),
+ layerCount(1),
+ producerUsage(GRALLOC1_PRODUCER_USAGE_NONE),
+ consumerUsage(GRALLOC1_CONSUMER_USAGE_NONE) {}
+
+ gralloc1_error_t setDimensions(uint32_t w, uint32_t h) {
+ width = w;
+ height = h;
+ return GRALLOC1_ERROR_NONE;
+ }
+
+ gralloc1_error_t setFormat(int32_t f) {
+ format = f;
+ return GRALLOC1_ERROR_NONE;
+ }
+
+ gralloc1_error_t setLayerCount(uint32_t lc) {
+ layerCount = lc;
+ return GRALLOC1_ERROR_NONE;
+ }
+
+ gralloc1_error_t setProducerUsage(gralloc1_producer_usage_t usage) {
+ producerUsage = usage;
+ return GRALLOC1_ERROR_NONE;
+ }
+
+ gralloc1_error_t setConsumerUsage(gralloc1_consumer_usage_t usage) {
+ consumerUsage = usage;
+ return GRALLOC1_ERROR_NONE;
+ }
+
+ uint32_t width;
+ uint32_t height;
+ int32_t format;
+ uint32_t layerCount;
+ gralloc1_producer_usage_t producerUsage;
+ gralloc1_consumer_usage_t consumerUsage;
+ };
+
+ template <typename ...Args>
+ static int32_t callDescriptorFunction(gralloc1_device_t* device,
+ gralloc1_buffer_descriptor_t descriptorId,
+ gralloc1_error_t (Descriptor::*member)(Args...), Args... args) {
+ auto descriptor = getAdapter(device)->getDescriptor(descriptorId);
+ if (!descriptor) {
+ return static_cast<int32_t>(GRALLOC1_ERROR_BAD_DESCRIPTOR);
+ }
+ auto error = ((*descriptor).*member)(std::forward<Args>(args)...);
+ return static_cast<int32_t>(error);
+ }
+
+ static int32_t setConsumerUsageHook(gralloc1_device_t* device,
+ gralloc1_buffer_descriptor_t descriptorId, uint64_t intUsage) {
+ auto usage = static_cast<gralloc1_consumer_usage_t>(intUsage);
+ return callDescriptorFunction(device, descriptorId,
+ &Descriptor::setConsumerUsage, usage);
+ }
+
+ static int32_t setDimensionsHook(gralloc1_device_t* device,
+ gralloc1_buffer_descriptor_t descriptorId, uint32_t width,
+ uint32_t height) {
+ return callDescriptorFunction(device, descriptorId,
+ &Descriptor::setDimensions, width, height);
+ }
+
+ static int32_t setFormatHook(gralloc1_device_t* device,
+ gralloc1_buffer_descriptor_t descriptorId, int32_t format) {
+ return callDescriptorFunction(device, descriptorId,
+ &Descriptor::setFormat, format);
+ }
+
+ static int32_t setLayerCountHook(gralloc1_device_t* device,
+ gralloc1_buffer_descriptor_t descriptorId, uint32_t layerCount) {
+ return callDescriptorFunction(device, descriptorId,
+ &Descriptor::setLayerCount, layerCount);
+ }
+
+ static int32_t setProducerUsageHook(gralloc1_device_t* device,
+ gralloc1_buffer_descriptor_t descriptorId, uint64_t intUsage) {
+ auto usage = static_cast<gralloc1_producer_usage_t>(intUsage);
+ return callDescriptorFunction(device, descriptorId,
+ &Descriptor::setProducerUsage, usage);
+ }
+
+ // Buffer handle query functions
+
+ class Buffer {
+ public:
+ Buffer(buffer_handle_t handle, gralloc1_backing_store_t store,
+ const Descriptor& descriptor, uint32_t stride,
+ uint32_t numFlexPlanes, bool wasAllocated);
+
+ buffer_handle_t getHandle() const { return mHandle; }
+
+ void retain() { ++mReferenceCount; }
+
+ // Returns true if the reference count has dropped to 0, indicating that
+ // the buffer needs to be released
+ bool release() { return --mReferenceCount == 0; }
+
+ bool wasAllocated() const { return mWasAllocated; }
+
+ gralloc1_error_t getBackingStore(
+ gralloc1_backing_store_t* outStore) const {
+ *outStore = mStore;
+ return GRALLOC1_ERROR_NONE;
+ }
+
+ gralloc1_error_t getConsumerUsage(
+ gralloc1_consumer_usage_t* outUsage) const {
+ *outUsage = mDescriptor.consumerUsage;
+ return GRALLOC1_ERROR_NONE;
+ }
+
+ gralloc1_error_t getDimensions(uint32_t* outWidth,
+ uint32_t* outHeight) const {
+ *outWidth = mDescriptor.width;
+ *outHeight = mDescriptor.height;
+ return GRALLOC1_ERROR_NONE;
+ }
+
+ gralloc1_error_t getFormat(int32_t* outFormat) const {
+ *outFormat = mDescriptor.format;
+ return GRALLOC1_ERROR_NONE;
+ }
+
+ gralloc1_error_t getLayerCount(uint32_t* outLayerCount) const {
+ *outLayerCount = mDescriptor.layerCount;
+ return GRALLOC1_ERROR_NONE;
+ }
+
+ gralloc1_error_t getNumFlexPlanes(uint32_t* outNumPlanes) const {
+ *outNumPlanes = mNumFlexPlanes;
+ return GRALLOC1_ERROR_NONE;
+ }
+
+ gralloc1_error_t getProducerUsage(
+ gralloc1_producer_usage_t* outUsage) const {
+ *outUsage = mDescriptor.producerUsage;
+ return GRALLOC1_ERROR_NONE;
+ }
+
+ gralloc1_error_t getStride(uint32_t* outStride) const {
+ *outStride = mStride;
+ return GRALLOC1_ERROR_NONE;
+ }
+
+ private:
+
+ const buffer_handle_t mHandle;
+ size_t mReferenceCount;
+
+ const gralloc1_backing_store_t mStore;
+ const Descriptor mDescriptor;
+ const uint32_t mStride;
+ const uint32_t mNumFlexPlanes;
+
+ // Whether this buffer allocated in this process (as opposed to just
+ // being retained here), which determines whether to free or unregister
+ // the buffer when this Buffer is released
+ const bool mWasAllocated;
+ };
+
+ template <typename ...Args>
+ static int32_t callBufferFunction(gralloc1_device_t* device,
+ buffer_handle_t bufferHandle,
+ gralloc1_error_t (Buffer::*member)(Args...) const, Args... args) {
+ auto buffer = getAdapter(device)->getBuffer(bufferHandle);
+ if (!buffer) {
+ return static_cast<int32_t>(GRALLOC1_ERROR_BAD_HANDLE);
+ }
+ auto error = ((*buffer).*member)(std::forward<Args>(args)...);
+ return static_cast<int32_t>(error);
+ }
+
+ template <typename MF, MF memFunc, typename ...Args>
+ static int32_t bufferHook(gralloc1_device_t* device,
+ buffer_handle_t bufferHandle, Args... args) {
+ return Gralloc1On0Adapter::callBufferFunction(device, bufferHandle,
+ memFunc, std::forward<Args>(args)...);
+ }
+
+ static int32_t getConsumerUsageHook(gralloc1_device_t* device,
+ buffer_handle_t bufferHandle, uint64_t* outUsage) {
+ auto usage = GRALLOC1_CONSUMER_USAGE_NONE;
+ auto error = callBufferFunction(device, bufferHandle,
+ &Buffer::getConsumerUsage, &usage);
+ if (error == GRALLOC1_ERROR_NONE) {
+ *outUsage = static_cast<uint64_t>(usage);
+ }
+ return error;
+ }
+
+ static int32_t getProducerUsageHook(gralloc1_device_t* device,
+ buffer_handle_t bufferHandle, uint64_t* outUsage) {
+ auto usage = GRALLOC1_PRODUCER_USAGE_NONE;
+ auto error = callBufferFunction(device, bufferHandle,
+ &Buffer::getProducerUsage, &usage);
+ if (error == GRALLOC1_ERROR_NONE) {
+ *outUsage = static_cast<uint64_t>(usage);
+ }
+ return error;
+ }
+
+ // Buffer management functions
+
+ gralloc1_error_t allocate(
+ gralloc1_buffer_descriptor_t id,
+ const std::shared_ptr<Descriptor>& descriptor,
+ buffer_handle_t* outBufferHandle);
+ static int32_t allocateHook(gralloc1_device* device,
+ uint32_t numDescriptors,
+ const gralloc1_buffer_descriptor_t* descriptors,
+ buffer_handle_t* outBuffers);
+
+ gralloc1_error_t retain(const std::shared_ptr<Buffer>& buffer);
+ gralloc1_error_t retain(buffer_handle_t bufferHandle);
+ static int32_t retainHook(gralloc1_device_t* device,
+ buffer_handle_t bufferHandle)
+ {
+ auto adapter = getAdapter(device);
+ return adapter->retain(bufferHandle);
+ }
+
+ gralloc1_error_t release(const std::shared_ptr<Buffer>& buffer);
+ static int32_t releaseHook(gralloc1_device_t* device,
+ buffer_handle_t bufferHandle) {
+ auto adapter = getAdapter(device);
+
+ auto buffer = adapter->getBuffer(bufferHandle);
+ if (!buffer) {
+ return static_cast<int32_t>(GRALLOC1_ERROR_BAD_HANDLE);
+ }
+
+ auto error = adapter->release(buffer);
+ return static_cast<int32_t>(error);
+ }
+
+ // Buffer access functions
+
+ gralloc1_error_t lock(const std::shared_ptr<Buffer>& buffer,
+ gralloc1_producer_usage_t producerUsage,
+ gralloc1_consumer_usage_t consumerUsage,
+ const gralloc1_rect_t& accessRegion, void** outData,
+ int acquireFence);
+ gralloc1_error_t lockFlex(const std::shared_ptr<Buffer>& buffer,
+ gralloc1_producer_usage_t producerUsage,
+ gralloc1_consumer_usage_t consumerUsage,
+ const gralloc1_rect_t& accessRegion,
+ struct android_flex_layout* outFlex,
+ int acquireFence);
+
+ template <typename OUT, gralloc1_error_t (Gralloc1On0Adapter::*member)(
+ const std::shared_ptr<Buffer>&, gralloc1_producer_usage_t,
+ gralloc1_consumer_usage_t, const gralloc1_rect_t&, OUT*,
+ int)>
+ static int32_t lockHook(gralloc1_device_t* device,
+ buffer_handle_t bufferHandle,
+ uint64_t /*gralloc1_producer_usage_t*/ uintProducerUsage,
+ uint64_t /*gralloc1_consumer_usage_t*/ uintConsumerUsage,
+ const gralloc1_rect_t* accessRegion, OUT* outData,
+ int32_t acquireFenceFd) {
+ auto adapter = getAdapter(device);
+
+ // Exactly one of producer and consumer usage must be *_USAGE_NONE,
+ // but we can't check this until the upper levels of the framework
+ // correctly distinguish between producer and consumer usage
+ /*
+ bool hasProducerUsage =
+ uintProducerUsage != GRALLOC1_PRODUCER_USAGE_NONE;
+ bool hasConsumerUsage =
+ uintConsumerUsage != GRALLOC1_CONSUMER_USAGE_NONE;
+ if (hasProducerUsage && hasConsumerUsage ||
+ !hasProducerUsage && !hasConsumerUsage) {
+ return static_cast<int32_t>(GRALLOC1_ERROR_BAD_VALUE);
+ }
+ */
+
+ auto producerUsage =
+ static_cast<gralloc1_producer_usage_t>(uintProducerUsage);
+ auto consumerUsage =
+ static_cast<gralloc1_consumer_usage_t>(uintConsumerUsage);
+
+ if (!outData) {
+ const auto producerCpuUsage = GRALLOC1_PRODUCER_USAGE_CPU_READ |
+ GRALLOC1_PRODUCER_USAGE_CPU_WRITE;
+ if ((producerUsage & producerCpuUsage) != 0) {
+ return static_cast<int32_t>(GRALLOC1_ERROR_BAD_VALUE);
+ }
+ if ((consumerUsage & GRALLOC1_CONSUMER_USAGE_CPU_READ) != 0) {
+ return static_cast<int32_t>(GRALLOC1_ERROR_BAD_VALUE);
+ }
+ }
+
+ auto buffer = adapter->getBuffer(bufferHandle);
+ if (!buffer) {
+ return static_cast<int32_t>(GRALLOC1_ERROR_BAD_HANDLE);
+ }
+
+ if (!accessRegion) {
+ ALOGE("accessRegion is null");
+ return static_cast<int32_t>(GRALLOC1_ERROR_BAD_VALUE);
+ }
+
+ auto error = ((*adapter).*member)(buffer, producerUsage, consumerUsage,
+ *accessRegion, outData, acquireFenceFd);
+ return static_cast<int32_t>(error);
+ }
+
+ gralloc1_error_t unlock(const std::shared_ptr<Buffer>& buffer,
+ int* outReleaseFence);
+ static int32_t unlockHook(gralloc1_device_t* device,
+ buffer_handle_t bufferHandle, int32_t* outReleaseFenceFd) {
+ auto adapter = getAdapter(device);
+
+ auto buffer = adapter->getBuffer(bufferHandle);
+ if (!buffer) {
+ return static_cast<int32_t>(GRALLOC1_ERROR_BAD_HANDLE);
+ }
+
+ int releaseFence = -1;
+ auto error = adapter->unlock(buffer, &releaseFence);
+ if (error == GRALLOC1_ERROR_NONE) {
+ *outReleaseFenceFd = releaseFence;
+ }
+ return static_cast<int32_t>(error);
+ }
+
+ // Adapter internals
+ const gralloc_module_t* mModule;
+ uint8_t mMinorVersion;
+ alloc_device_t* mDevice;
+
+ std::shared_ptr<Descriptor> getDescriptor(
+ gralloc1_buffer_descriptor_t descriptorId);
+ std::shared_ptr<Buffer> getBuffer(buffer_handle_t bufferHandle);
+
+ static std::atomic<gralloc1_buffer_descriptor_t> sNextBufferDescriptorId;
+ std::mutex mDescriptorMutex;
+ std::unordered_map<gralloc1_buffer_descriptor_t,
+ std::shared_ptr<Descriptor>> mDescriptors;
+ std::mutex mBufferMutex;
+ std::unordered_map<buffer_handle_t, std::shared_ptr<Buffer>> mBuffers;
+};
+
+} // namespace hardware
+} // namespace android
+
+#endif // ANDROID_HARDWARE_GRALLOC_1_ON_0_ADAPTER_H
diff --git a/graphics/allocator/2.0/default/gralloc1-adapter.c b/graphics/allocator/2.0/default/gralloc1-adapter.c
deleted file mode 100644
index 724cd47..0000000
--- a/graphics/allocator/2.0/default/gralloc1-adapter.c
+++ /dev/null
@@ -1,660 +0,0 @@
-/*
- * Copyright 2016 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.
- */
-
-#define LOG_TAG "Gralloc1Adapter"
-
-#include <stdatomic.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include <pthread.h>
-
-#include <cutils/native_handle.h>
-#include <hardware/gralloc1.h>
-#include <sync/sync.h>
-#include <log/log.h>
-
-#include "gralloc1-adapter.h"
-
-struct gralloc1_adapter_module {
- struct gralloc_module_t base;
- struct gralloc1_adapter adapter;
-};
-
-struct gralloc1_adapter_device {
- struct gralloc1_device base;
-
- struct alloc_device_t* alloc_dev;
-
- /* fixed size for thread safety */
- char saved_dump[4096];
- size_t saved_dump_size;
-};
-
-/* additional data associated with registered buffer_handle_t */
-struct gralloc1_adapter_buffer_data {
- struct gralloc1_adapter_buffer_info info;
-
- atomic_int refcount;
- bool owned;
-};
-
-struct gralloc1_adapter_buffer_descriptor {
- int width;
- int height;
- int format;
- int producer_usage;
- int consumer_usage;
-};
-
-static const struct gralloc1_adapter_module* gralloc1_adapter_module(
- struct gralloc1_device* dev)
-{
- return (const struct gralloc1_adapter_module*) dev->common.module;
-}
-
-static struct gralloc1_adapter_device* gralloc1_adapter_device(
- struct gralloc1_device* dev)
-{
- return (struct gralloc1_adapter_device*) dev;
-}
-
-static struct gralloc1_adapter_buffer_data* lookup_buffer_data(
- struct gralloc1_device* dev, buffer_handle_t buffer)
-{
- const struct gralloc1_adapter_module* mod = gralloc1_adapter_module(dev);
- if (!mod->adapter.is_registered(&mod->base, buffer))
- return NULL;
-
- return mod->adapter.get_data(&mod->base, buffer);
-}
-
-static struct gralloc1_adapter_buffer_descriptor* lookup_buffer_descriptor(
- struct gralloc1_device* dev, gralloc1_buffer_descriptor_t id)
-{
- /* do we want to validate? */
- return (struct gralloc1_adapter_buffer_descriptor*) ((uintptr_t) id);
-}
-
-static void device_dump(struct gralloc1_device* device,
- uint32_t* outSize, char* outBuffer)
-{
- struct gralloc1_adapter_device* dev = gralloc1_adapter_device(device);
-
- if (outBuffer) {
- uint32_t copy = (uint32_t) dev->saved_dump_size;
- if (*outSize < copy) {
- copy = *outSize;
- } else {
- *outSize = copy;
- }
-
- memcpy(outBuffer, dev->saved_dump, copy);
- } else {
- /* dump is optional and may not null-terminate */
- if (dev->alloc_dev->dump) {
- dev->alloc_dev->dump(dev->alloc_dev, dev->saved_dump,
- sizeof(dev->saved_dump) - 1);
- dev->saved_dump_size = strlen(dev->saved_dump);
- }
-
- *outSize = (uint32_t) dev->saved_dump_size;
- }
-}
-
-static int32_t device_create_descriptor(struct gralloc1_device* device,
- gralloc1_buffer_descriptor_t* outDescriptor)
-{
- struct gralloc1_adapter_buffer_descriptor* desc;
-
- desc = calloc(1, sizeof(*desc));
- if (!desc) {
- return GRALLOC1_ERROR_NO_RESOURCES;
- }
-
- *outDescriptor = (gralloc1_buffer_descriptor_t) (uintptr_t) desc;
-
- return GRALLOC1_ERROR_NONE;
-}
-
-static int32_t device_destroy_descriptor(struct gralloc1_device* device,
- gralloc1_buffer_descriptor_t descriptor)
-{
- struct gralloc1_adapter_buffer_descriptor* desc =
- lookup_buffer_descriptor(device, descriptor);
- if (!desc) {
- return GRALLOC1_ERROR_BAD_DESCRIPTOR;
- }
-
- free(desc);
-
- return GRALLOC1_ERROR_NONE;
-}
-
-static int32_t device_set_consumer_usage(struct gralloc1_device* device,
- gralloc1_buffer_descriptor_t descriptor, uint64_t usage)
-{
- struct gralloc1_adapter_buffer_descriptor* desc =
- lookup_buffer_descriptor(device, descriptor);
- if (!desc) {
- return GRALLOC1_ERROR_BAD_DESCRIPTOR;
- }
-
- desc->consumer_usage = (int) usage;
-
- return GRALLOC1_ERROR_NONE;
-}
-
-static int32_t device_set_dimensions(struct gralloc1_device* device,
- gralloc1_buffer_descriptor_t descriptor,
- uint32_t width, uint32_t height)
-{
- struct gralloc1_adapter_buffer_descriptor* desc =
- lookup_buffer_descriptor(device, descriptor);
- if (!desc) {
- return GRALLOC1_ERROR_BAD_DESCRIPTOR;
- }
-
- desc->width = (int) width;
- desc->height = (int) height;
-
- return GRALLOC1_ERROR_NONE;
-}
-
-static int32_t device_set_format(struct gralloc1_device* device,
- gralloc1_buffer_descriptor_t descriptor, int32_t format)
-{
- struct gralloc1_adapter_buffer_descriptor* desc =
- lookup_buffer_descriptor(device, descriptor);
- if (!desc) {
- return GRALLOC1_ERROR_BAD_DESCRIPTOR;
- }
-
- desc->format = format;
-
- return GRALLOC1_ERROR_NONE;
-}
-
-static int32_t device_set_producer_usage(struct gralloc1_device* device,
- gralloc1_buffer_descriptor_t descriptor, uint64_t usage)
-{
- struct gralloc1_adapter_buffer_descriptor* desc =
- lookup_buffer_descriptor(device, descriptor);
- if (!desc) {
- return GRALLOC1_ERROR_BAD_DESCRIPTOR;
- }
-
- desc->producer_usage = (int) usage;
-
- return GRALLOC1_ERROR_NONE;
-}
-
-static int32_t device_get_backing_store(struct gralloc1_device* device,
- buffer_handle_t buffer, gralloc1_backing_store_t* outStore)
-{
- /* we never share backing store */
- *outStore = (gralloc1_backing_store_t) (uintptr_t) buffer;
-
- return GRALLOC1_ERROR_NONE;
-}
-
-static int32_t device_get_consumer_usage(struct gralloc1_device* device,
- buffer_handle_t buffer, uint64_t* outUsage)
-{
- const struct gralloc1_adapter_buffer_data* data =
- lookup_buffer_data(device, buffer);
- if (!data) {
- return GRALLOC1_ERROR_BAD_HANDLE;
- }
-
- *outUsage = data->info.usage;
-
- return GRALLOC1_ERROR_NONE;
-}
-
-static int32_t device_get_dimensions(struct gralloc1_device* device,
- buffer_handle_t buffer, uint32_t* outWidth, uint32_t* outHeight)
-{
- const struct gralloc1_adapter_buffer_data* data =
- lookup_buffer_data(device, buffer);
- if (!data) {
- return GRALLOC1_ERROR_BAD_HANDLE;
- }
-
- *outWidth = data->info.width;
- *outHeight = data->info.height;
-
- return GRALLOC1_ERROR_NONE;
-}
-
-static int32_t device_get_format(struct gralloc1_device* device,
- buffer_handle_t buffer, int32_t* outFormat)
-{
- const struct gralloc1_adapter_buffer_data* data =
- lookup_buffer_data(device, buffer);
- if (!data) {
- return GRALLOC1_ERROR_BAD_HANDLE;
- }
-
- *outFormat = data->info.format;
-
- return GRALLOC1_ERROR_NONE;
-}
-
-static int32_t device_get_producer_usage(struct gralloc1_device* device,
- buffer_handle_t buffer, uint64_t* outUsage)
-{
- const struct gralloc1_adapter_buffer_data* data =
- lookup_buffer_data(device, buffer);
- if (!data) {
- return GRALLOC1_ERROR_BAD_HANDLE;
- }
-
- *outUsage = data->info.usage;
-
- return GRALLOC1_ERROR_NONE;
-}
-
-static int32_t device_get_stride(struct gralloc1_device* device,
- buffer_handle_t buffer, uint32_t* outStride)
-{
- const struct gralloc1_adapter_buffer_data* data =
- lookup_buffer_data(device, buffer);
- if (!data) {
- return GRALLOC1_ERROR_BAD_HANDLE;
- }
-
- *outStride = data->info.stride;
-
- return GRALLOC1_ERROR_NONE;
-}
-
-static int32_t device_allocate(struct gralloc1_device* device,
- uint32_t numDescriptors,
- const gralloc1_buffer_descriptor_t* descriptors,
- buffer_handle_t* outBuffers)
-{
- const struct gralloc1_adapter_module* mod =
- gralloc1_adapter_module(device);
- struct gralloc1_adapter_device* dev = gralloc1_adapter_device(device);
- gralloc1_error_t err = GRALLOC1_ERROR_NONE;
- uint32_t i;
-
- for (i = 0; i < numDescriptors; i++) {
- const struct gralloc1_adapter_buffer_descriptor* desc =
- lookup_buffer_descriptor(device, descriptors[i]);
- struct gralloc1_adapter_buffer_data* data;
- buffer_handle_t buffer;
- int dummy_stride;
- int ret;
-
- if (!desc) {
- err = GRALLOC1_ERROR_BAD_DESCRIPTOR;
- break;
- }
-
- data = calloc(1, sizeof(*data));
- if (!data) {
- err = GRALLOC1_ERROR_NO_RESOURCES;
- break;
- }
-
- ret = dev->alloc_dev->alloc(dev->alloc_dev, desc->width, desc->height,
- desc->format, desc->producer_usage | desc->consumer_usage,
- &buffer, &dummy_stride);
- if (ret) {
- free(data);
- err = GRALLOC1_ERROR_NO_RESOURCES;
- break;
- }
-
- mod->adapter.get_info(&mod->base, buffer, &data->info);
- data->refcount = 1;
- data->owned = true;
-
- mod->adapter.set_data(&mod->base, buffer, data);
-
- outBuffers[i] = buffer;
- }
-
- if (err != GRALLOC1_ERROR_NONE) {
- uint32_t j;
- for (j = 0; j < i; j++) {
- free(mod->adapter.get_data(&mod->base, outBuffers[i]));
- dev->alloc_dev->free(dev->alloc_dev, outBuffers[i]);
- }
-
- return err;
- }
-
- return (numDescriptors > 1) ?
- GRALLOC1_ERROR_NOT_SHARED : GRALLOC1_ERROR_NONE;
-}
-
-static int32_t device_retain(struct gralloc1_device* device,
- buffer_handle_t buffer)
-{
- static pthread_mutex_t register_mutex = PTHREAD_MUTEX_INITIALIZER;
- const struct gralloc1_adapter_module* mod =
- gralloc1_adapter_module(device);
- struct gralloc1_adapter_buffer_data* data;
-
- pthread_mutex_lock(®ister_mutex);
-
- if (mod->adapter.is_registered(&mod->base, buffer)) {
- data = mod->adapter.get_data(&mod->base, buffer);
- data->refcount++;
- } else {
- int ret;
-
- data = calloc(1, sizeof(*data));
- if (!data) {
- pthread_mutex_unlock(®ister_mutex);
- return GRALLOC1_ERROR_NO_RESOURCES;
- }
-
- ret = mod->base.registerBuffer(&mod->base, buffer);
- if (ret) {
- pthread_mutex_unlock(®ister_mutex);
- free(data);
-
- return GRALLOC1_ERROR_NO_RESOURCES;
- }
-
- mod->adapter.get_info(&mod->base, buffer, &data->info);
- data->refcount = 1;
- data->owned = false;
-
- mod->adapter.set_data(&mod->base, buffer, data);
- }
-
- pthread_mutex_unlock(®ister_mutex);
-
- return GRALLOC1_ERROR_NONE;
-}
-
-static int32_t device_release(struct gralloc1_device* device,
- buffer_handle_t buffer)
-{
- struct gralloc1_adapter_buffer_data* data =
- lookup_buffer_data(device, buffer);
- if (!data) {
- ALOGE("unable to release unregistered buffer %p", buffer);
- return GRALLOC1_ERROR_BAD_HANDLE;
- }
-
- data->refcount--;
- if (!data->refcount) {
- if (data->owned) {
- struct gralloc1_adapter_device* dev =
- gralloc1_adapter_device(device);
- dev->alloc_dev->free(dev->alloc_dev, buffer);
- } else {
- const struct gralloc1_adapter_module* mod =
- gralloc1_adapter_module(device);
- mod->base.unregisterBuffer(&mod->base, buffer);
-
- native_handle_close(buffer);
- native_handle_delete((native_handle_t*) buffer);
- }
-
- free(data);
- }
-
- return GRALLOC1_ERROR_NONE;
-}
-
-static int32_t device_get_num_flex_planes(struct gralloc1_device* device,
- buffer_handle_t buffer, uint32_t* outNumPlanes)
-{
- const struct gralloc1_adapter_buffer_data* data =
- lookup_buffer_data(device, buffer);
- if (!data) {
- return GRALLOC1_ERROR_BAD_HANDLE;
- }
-
- *outNumPlanes = data->info.num_flex_planes;
-
- return GRALLOC1_ERROR_NONE;
-}
-
-static int32_t device_lock(struct gralloc1_device* device,
- buffer_handle_t buffer,
- uint64_t producerUsage, uint64_t consumerUsage,
- const gralloc1_rect_t* accessRegion, void** outData,
- int32_t acquireFence)
-{
- const struct gralloc1_adapter_module* mod =
- gralloc1_adapter_module(device);
- const int usage = (int) (producerUsage | consumerUsage);
- const struct gralloc1_adapter_buffer_data* data =
- lookup_buffer_data(device, buffer);
- int ret;
-
- if (!data) {
- ALOGE("unable to lock unregistered buffer %p", buffer);
- return GRALLOC1_ERROR_BAD_HANDLE;
- }
-
- if (mod->adapter.real_module_api_version >=
- GRALLOC_MODULE_API_VERSION_0_3) {
- ret = mod->base.lockAsync(&mod->base,
- buffer, usage,
- accessRegion->left,
- accessRegion->top,
- accessRegion->width,
- accessRegion->height,
- outData, acquireFence);
- } else {
- if (acquireFence >= 0) {
- sync_wait(acquireFence, -1);
- }
-
- ret = mod->base.lock(&mod->base,
- buffer, usage,
- accessRegion->left,
- accessRegion->top,
- accessRegion->width,
- accessRegion->height,
- outData);
-
- if (acquireFence >= 0 && !ret) {
- close(acquireFence);
- }
- }
-
- return (ret) ? GRALLOC1_ERROR_NO_RESOURCES : GRALLOC1_ERROR_NONE;
-}
-
-static int32_t device_lock_flex(struct gralloc1_device* device,
- buffer_handle_t buffer,
- uint64_t producerUsage, uint64_t consumerUsage,
- const gralloc1_rect_t* accessRegion,
- struct android_flex_layout* outFlexLayout,
- int32_t acquireFence)
-{
- const struct gralloc1_adapter_module* mod =
- gralloc1_adapter_module(device);
- const int usage = (int) (producerUsage | consumerUsage);
- const struct gralloc1_adapter_buffer_data* data =
- lookup_buffer_data(device, buffer);
- struct android_ycbcr ycbcr;
- int ret;
-
- if (!data) {
- ALOGE("unable to lockFlex unregistered buffer %p", buffer);
- return GRALLOC1_ERROR_BAD_HANDLE;
- }
-
- if (outFlexLayout->num_planes < data->info.num_flex_planes) {
- return GRALLOC1_ERROR_BAD_VALUE;
- }
-
- if (mod->adapter.real_module_api_version >=
- GRALLOC_MODULE_API_VERSION_0_3 && mod->base.lockAsync_ycbcr) {
- ret = mod->base.lockAsync_ycbcr(&mod->base,
- buffer, usage,
- accessRegion->left,
- accessRegion->top,
- accessRegion->width,
- accessRegion->height,
- &ycbcr, acquireFence);
- } else if (mod->base.lock_ycbcr) {
- if (acquireFence >= 0) {
- sync_wait(acquireFence, -1);
- }
-
- ret = mod->base.lock_ycbcr(&mod->base,
- buffer, usage,
- accessRegion->left,
- accessRegion->top,
- accessRegion->width,
- accessRegion->height,
- &ycbcr);
-
- if (acquireFence >= 0 && !ret) {
- close(acquireFence);
- }
- } else {
- return GRALLOC1_ERROR_UNSUPPORTED;
- }
-
- if (ret) {
- return GRALLOC1_ERROR_NO_RESOURCES;
- }
-
- mod->adapter.get_flexible_layout(&mod->base, buffer,
- &ycbcr, outFlexLayout);
-
- return GRALLOC1_ERROR_NONE;
-}
-
-static int32_t device_unlock(struct gralloc1_device* device,
- buffer_handle_t buffer, int32_t* outReleaseFence)
-{
- const struct gralloc1_adapter_module* mod =
- gralloc1_adapter_module(device);
- int ret;
-
- if (mod->adapter.real_module_api_version >=
- GRALLOC_MODULE_API_VERSION_0_3) {
- ret = mod->base.unlockAsync(&mod->base, buffer, outReleaseFence);
- } else {
- ret = mod->base.unlock(&mod->base, buffer);
- if (!ret) {
- *outReleaseFence = -1;
- }
- }
-
- return (ret) ? GRALLOC1_ERROR_BAD_HANDLE : GRALLOC1_ERROR_NONE;
-}
-
-static gralloc1_function_pointer_t device_get_function(
- struct gralloc1_device* device, int32_t descriptor)
-{
- switch ((gralloc1_function_descriptor_t) descriptor) {
-#define CASE(id, ptr) \
- case GRALLOC1_FUNCTION_ ## id: \
- return (gralloc1_function_pointer_t) device_ ## ptr
- CASE(DUMP, dump);
- CASE(CREATE_DESCRIPTOR, create_descriptor);
- CASE(DESTROY_DESCRIPTOR, destroy_descriptor);
- CASE(SET_CONSUMER_USAGE, set_consumer_usage);
- CASE(SET_DIMENSIONS, set_dimensions);
- CASE(SET_FORMAT, set_format);
- CASE(SET_PRODUCER_USAGE, set_producer_usage);
- CASE(GET_BACKING_STORE, get_backing_store);
- CASE(GET_CONSUMER_USAGE, get_consumer_usage);
- CASE(GET_DIMENSIONS, get_dimensions);
- CASE(GET_FORMAT, get_format);
- CASE(GET_PRODUCER_USAGE, get_producer_usage);
- CASE(GET_STRIDE, get_stride);
- CASE(ALLOCATE, allocate);
- CASE(RETAIN, retain);
- CASE(RELEASE, release);
- CASE(GET_NUM_FLEX_PLANES, get_num_flex_planes);
- CASE(LOCK, lock);
- CASE(LOCK_FLEX, lock_flex);
- CASE(UNLOCK, unlock);
-#undef CASE
- default: return NULL;
- }
-}
-
-static void device_get_capabilities(struct gralloc1_device* device,
- uint32_t* outCount, int32_t* outCapabilities)
-{
- *outCount = 0;
-}
-
-static int device_close(struct hw_device_t* device)
-{
- struct gralloc1_adapter_device* dev =
- (struct gralloc1_adapter_device*) device;
- int ret;
-
- ret = dev->alloc_dev->common.close(&dev->alloc_dev->common);
- if (!ret) {
- free(dev);
- }
-
- return ret;
-}
-
-int gralloc1_adapter_device_open(const struct hw_module_t* module,
- const char* id, struct hw_device_t** device)
-{
- const struct gralloc1_adapter_module* mod =
- (const struct gralloc1_adapter_module*) module;
- struct alloc_device_t* alloc_dev;
- struct gralloc1_adapter_device* dev;
- int ret;
-
- if (strcmp(id, GRALLOC_HARDWARE_MODULE_ID) != 0) {
- ALOGE("unknown gralloc1 device id: %s", id);
- return -EINVAL;
- }
-
- ret = module->methods->open(module, GRALLOC_HARDWARE_GPU0,
- (struct hw_device_t**) &alloc_dev);
- if (ret) {
- return ret;
- }
-
- dev = malloc(sizeof(*dev));
- if (!dev) {
- alloc_dev->common.close(&alloc_dev->common);
- return -ENOMEM;
- }
-
- *dev = (struct gralloc1_adapter_device) {
- .base = {
- .common = {
- .tag = HARDWARE_DEVICE_TAG,
- .version = HARDWARE_DEVICE_API_VERSION(0, 0),
- .module = (struct hw_module_t*) mod,
- .close = device_close,
- },
- .getCapabilities = device_get_capabilities,
- .getFunction = device_get_function,
- },
- .alloc_dev = alloc_dev,
- };
-
- *device = (struct hw_device_t*) dev;
-
- return 0;
-}
diff --git a/graphics/allocator/2.0/default/gralloc1-adapter.cpp b/graphics/allocator/2.0/default/gralloc1-adapter.cpp
new file mode 100644
index 0000000..fcc59cd
--- /dev/null
+++ b/graphics/allocator/2.0/default/gralloc1-adapter.cpp
@@ -0,0 +1,32 @@
+/*
+ * Copyright 2016 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 "Gralloc1On0Adapter.h"
+#include "gralloc1-adapter.h"
+
+int gralloc1_adapter_device_open(const struct hw_module_t* module,
+ const char* id, struct hw_device_t** device)
+{
+ if (strcmp(id, GRALLOC_HARDWARE_MODULE_ID) != 0) {
+ ALOGE("unknown gralloc1 device id: %s", id);
+ return -EINVAL;
+ }
+
+ auto adapter_device = new android::hardware::Gralloc1On0Adapter(module);
+ *device = &adapter_device->common;
+
+ return 0;
+}
diff --git a/graphics/allocator/2.0/default/gralloc1-adapter.h b/graphics/allocator/2.0/default/gralloc1-adapter.h
index f48cd9e..b912ef6 100644
--- a/graphics/allocator/2.0/default/gralloc1-adapter.h
+++ b/graphics/allocator/2.0/default/gralloc1-adapter.h
@@ -16,52 +16,69 @@
#ifndef ANDROID_HARDWARE_GRALLOC1_ADAPTER_H
#define ANDROID_HARDWARE_GRALLOC1_ADAPTER_H
-#include <stdbool.h>
-#include <hardware/gralloc.h>
+#include <hardware/hardware.h>
__BEGIN_DECLS
-struct gralloc1_adapter_buffer_info {
- int width;
- int height;
- int format;
- int usage;
+#define GRALLOC1_ADAPTER_MODULE_API_VERSION_1_0 \
+ HARDWARE_MODULE_API_VERSION(1, 0)
- int stride;
- uint32_t num_flex_planes;
-};
+enum {
+ GRALLOC1_ADAPTER_PERFORM_FIRST = 10000,
-/* This struct must be embedded in the HAL's HAL_MODULE_INFO_SYM and must
- * follow gralloc_module_t immediately. */
-struct gralloc1_adapter {
- uint16_t real_module_api_version;
+ // void getRealModuleApiVersionMinor(..., int* outMinorVersion);
+ GRALLOC1_ADAPTER_PERFORM_GET_REAL_MODULE_API_VERSION_MINOR =
+ GRALLOC1_ADAPTER_PERFORM_FIRST,
- /* Return true if the buffer is registered. A locally allocated buffer is
- * always registered.
- *
- * This function is called frequently. It must be thread safe just like
- * other functions are.
- */
- bool (*is_registered)(const struct gralloc_module_t* mod,
- buffer_handle_t buffer);
+ // void setUsages(..., buffer_handle_t buffer,
+ // int producerUsage,
+ // int consumerUsage);
+ GRALLOC1_ADAPTER_PERFORM_SET_USAGES =
+ GRALLOC1_ADAPTER_PERFORM_FIRST + 1,
- /* Set the adapter data for a registered buffer. */
- void (*set_data)(const struct gralloc_module_t* mod,
- buffer_handle_t buffer, void* data);
+ // void getDimensions(..., buffer_handle_t buffer,
+ // int* outWidth,
+ // int* outHeight);
+ GRALLOC1_ADAPTER_PERFORM_GET_DIMENSIONS =
+ GRALLOC1_ADAPTER_PERFORM_FIRST + 2,
- /* Get the adapter data for a registered buffer. */
- void* (*get_data)(const struct gralloc_module_t* mod,
- buffer_handle_t buffer);
+ // void getFormat(..., buffer_handle_t buffer, int* outFormat);
+ GRALLOC1_ADAPTER_PERFORM_GET_FORMAT =
+ GRALLOC1_ADAPTER_PERFORM_FIRST + 3,
- /* Get the buffer info, such as width, height, etc. */
- void (*get_info)(const struct gralloc_module_t* mod,
- buffer_handle_t buffer,
- struct gralloc1_adapter_buffer_info* info);
+ // void getProducerUsage(..., buffer_handle_t buffer, int* outUsage);
+ GRALLOC1_ADAPTER_PERFORM_GET_PRODUCER_USAGE =
+ GRALLOC1_ADAPTER_PERFORM_FIRST + 4,
- /* Get the flexilble layout matching ycbcr. */
- void (*get_flexible_layout)(const struct gralloc_module_t* mod,
- buffer_handle_t buffer, const struct android_ycbcr* ycbcr,
- struct android_flex_layout* layout);
+ // void getConsumerUsage(..., buffer_handle_t buffer, int* outUsage);
+ GRALLOC1_ADAPTER_PERFORM_GET_CONSUMER_USAGE =
+ GRALLOC1_ADAPTER_PERFORM_FIRST + 5,
+
+ // void getBackingStore(..., buffer_handle_t buffer,
+ // uint64_t* outBackingStore);
+ GRALLOC1_ADAPTER_PERFORM_GET_BACKING_STORE =
+ GRALLOC1_ADAPTER_PERFORM_FIRST + 6,
+
+ // void getNumFlexPlanes(..., buffer_handle_t buffer,
+ // int* outNumFlexPlanes);
+ GRALLOC1_ADAPTER_PERFORM_GET_NUM_FLEX_PLANES =
+ GRALLOC1_ADAPTER_PERFORM_FIRST + 7,
+
+ // void getStride(..., buffer_handle_t buffer, int* outStride);
+ GRALLOC1_ADAPTER_PERFORM_GET_STRIDE =
+ GRALLOC1_ADAPTER_PERFORM_FIRST + 8,
+
+ // void lockFlex(..., buffer_handle_t buffer,
+ // int producerUsage,
+ // int consumerUsage,
+ // int left,
+ // int top,
+ // int width,
+ // int height,
+ // android_flex_layout* outLayout,
+ // int acquireFence);
+ GRALLOC1_ADAPTER_PERFORM_LOCK_FLEX =
+ GRALLOC1_ADAPTER_PERFORM_FIRST + 9,
};
int gralloc1_adapter_device_open(const struct hw_module_t* module,
diff --git a/graphics/composer/2.1/default/HwcClient.cpp b/graphics/composer/2.1/default/HwcClient.cpp
index 8c2dd6d..54dfd89 100644
--- a/graphics/composer/2.1/default/HwcClient.cpp
+++ b/graphics/composer/2.1/default/HwcClient.cpp
@@ -176,9 +176,9 @@
mRelease(mDevice, handle);
} else {
mModule->unregisterBuffer(mModule, handle);
- native_handle_close(handle);
- native_handle_delete(const_cast<native_handle_t*>(handle));
}
+ native_handle_close(handle);
+ native_handle_delete(const_cast<native_handle_t*>(handle));
}
// gralloc1
diff --git a/graphics/mapper/2.0/default/Android.bp b/graphics/mapper/2.0/default/Android.bp
index 02ed877..c3d2281 100644
--- a/graphics/mapper/2.0/default/Android.bp
+++ b/graphics/mapper/2.0/default/Android.bp
@@ -19,6 +19,7 @@
srcs: ["GrallocMapper.cpp"],
cppflags: ["-Wall", "-Wextra"],
shared_libs: [
+ "android.hardware.graphics.allocator@2.0",
"android.hardware.graphics.mapper@2.0",
"libbase",
"libcutils",
diff --git a/graphics/mapper/2.0/default/GrallocMapper.cpp b/graphics/mapper/2.0/default/GrallocMapper.cpp
index cd9db38..3b6460a 100644
--- a/graphics/mapper/2.0/default/GrallocMapper.cpp
+++ b/graphics/mapper/2.0/default/GrallocMapper.cpp
@@ -17,7 +17,9 @@
#include "GrallocMapper.h"
+#include <mutex>
#include <vector>
+#include <unordered_map>
#include <string.h>
@@ -100,6 +102,9 @@
GRALLOC1_PFN_LOCK_FLEX lockFlex;
GRALLOC1_PFN_UNLOCK unlock;
} mDispatch;
+
+ std::mutex mMutex;
+ std::unordered_map<buffer_handle_t, size_t> mBufferReferenceCounts;
};
GrallocMapperHal::GrallocMapperHal(const hw_module_t* module)
@@ -201,12 +206,34 @@
Return<Error> GrallocMapperHal::retain(const hidl_handle& bufferHandle)
{
int32_t err = mDispatch.retain(mDevice, bufferHandle);
+ if (err == GRALLOC1_ERROR_NONE) {
+ auto nativeHandle = bufferHandle.getNativeHandle();
+ std::lock_guard<std::mutex> lock(mMutex);
+
+ ++mBufferReferenceCounts[nativeHandle];
+ }
return static_cast<Error>(err);
}
Return<Error> GrallocMapperHal::release(const hidl_handle& bufferHandle)
{
int32_t err = mDispatch.release(mDevice, bufferHandle);
+ if (err == GRALLOC1_ERROR_NONE) {
+ auto nativeHandle = bufferHandle.getNativeHandle();
+ std::lock_guard<std::mutex> lock(mMutex);
+
+ auto iter = mBufferReferenceCounts.find(bufferHandle);
+ if (iter == mBufferReferenceCounts.end()) {
+ // this should never happen
+ err = GRALLOC1_ERROR_BAD_HANDLE;
+ } else if (--iter->second == 0) {
+ native_handle_close(nativeHandle);
+ native_handle_delete(const_cast<native_handle_t*>(nativeHandle));
+
+ mBufferReferenceCounts.erase(iter);
+ }
+ }
+
return static_cast<Error>(err);
}
diff --git a/graphics/mapper/2.0/vts/functional/Android.bp b/graphics/mapper/2.0/vts/functional/Android.bp
index 53e6d16..27ea350 100644
--- a/graphics/mapper/2.0/vts/functional/Android.bp
+++ b/graphics/mapper/2.0/vts/functional/Android.bp
@@ -30,6 +30,7 @@
"libutils",
"android.hardware.graphics.allocator@2.0",
"android.hardware.graphics.mapper@2.0",
+ "android.hardware.graphics.common@1.0",
],
static_libs: ["libgtest"],
cflags: [
diff --git a/sensors/1.0/vts/functional/sensors_hidl_hal_test.cpp b/sensors/1.0/vts/functional/sensors_hidl_hal_test.cpp
index 8e85b23..17c439e 100644
--- a/sensors/1.0/vts/functional/sensors_hidl_hal_test.cpp
+++ b/sensors/1.0/vts/functional/sensors_hidl_hal_test.cpp
@@ -84,6 +84,10 @@
collectionEnabled = false;
startPollingThread();
+
+ // In case framework just stopped for test and there is sensor events in the pipe,
+ // wait some time for those events to be cleared to avoid them messing up the test.
+ std::this_thread::sleep_for(std::chrono::seconds(3));
}
void SensorsHidlEnvironment::TearDown() {
diff --git a/soundtrigger/2.0/vts/functional/vts/testcases/hal/soundtrigger/hidl/target/AndroidTest.xml b/soundtrigger/2.0/vts/functional/vts/testcases/hal/soundtrigger/hidl/target/AndroidTest.xml
index b75d97e..ca8ecdb 100644
--- a/soundtrigger/2.0/vts/functional/vts/testcases/hal/soundtrigger/hidl/target/AndroidTest.xml
+++ b/soundtrigger/2.0/vts/functional/vts/testcases/hal/soundtrigger/hidl/target/AndroidTest.xml
@@ -24,6 +24,7 @@
_32bit::DATA/nativetest/soundtrigger_hidl_hal_test/soundtrigger_hidl_hal_test,
_64bit::DATA/nativetest64/soundtrigger_hidl_hal_test/soundtrigger_hidl_hal_test,
"/>
+ <option name="test-config-path" value="vts/testcases/hal/soundtrigger/hidl/target/HalSoundTriggerHidlTargetBasicTest.config" />
<option name="binary-test-type" value="gtest" />
<option name="test-timeout" value="1m" />
</test>
diff --git a/soundtrigger/2.0/vts/functional/vts/testcases/hal/soundtrigger/hidl/target/HalSoundTriggerHidlTargetBasicTest.config b/soundtrigger/2.0/vts/functional/vts/testcases/hal/soundtrigger/hidl/target/HalSoundTriggerHidlTargetBasicTest.config
new file mode 100644
index 0000000..7558911
--- /dev/null
+++ b/soundtrigger/2.0/vts/functional/vts/testcases/hal/soundtrigger/hidl/target/HalSoundTriggerHidlTargetBasicTest.config
@@ -0,0 +1,41 @@
+{
+ "use_gae_db": true,
+ "coverage": true,
+ "modules": [
+ {
+ "module_name": "system/lib/hw/sound_trigger.primary.bullhead",
+ "git_project": {
+ "name": "platform/vendor/lge/bullhead",
+ "path": "vendor/lge/bullhead"
+ },
+ },
+ {
+ "module_name": "system/lib/hw/sound_trigger.primary.angler",
+ "git_project": {
+ "name": "platform/vendor/huawei/angler",
+ "path": "vendor/huawei/angler"
+ },
+ },
+ {
+ "module_name": "system/lib/hw/sound_trigger.primary.marlin",
+ "git_project": {
+ "name": "platform/vendor/google_devices/marlin",
+ "path": "vendor/google_devices/marlin"
+ },
+ },
+ {
+ "module_name": "system/lib/hw/sound_trigger.primary.sailfish",
+ "git_project": {
+ "name": "platform/vendor/google_devices/marlin",
+ "path": "vendor/google_devices/marlin"
+ },
+ },
+ {
+ "module_name": "system/lib/hw/android.hardware.soundtrigger@2.0-impl",
+ "git_project": {
+ "name": "platform/hardware/interfaces",
+ "path": "hardware/interfaces"
+ },
+ },
+ ]
+}
diff --git a/tests/foo/1.0/IFoo.hal b/tests/foo/1.0/IFoo.hal
index fc76c1c..76aefcf 100644
--- a/tests/foo/1.0/IFoo.hal
+++ b/tests/foo/1.0/IFoo.hal
@@ -98,6 +98,29 @@
typedef bitfield<BitField> Mask;
+ struct Everything {
+ union U {
+ int8_t number;
+ int8_t[1][2] multidimArray;
+ pointer p;
+ Fumble anotherStruct;
+ bitfield<BitField> bf;
+ } u;
+
+ int8_t number;
+ handle h;
+ fmq_sync<uint8_t> descSync;
+ fmq_unsync<uint8_t> descUnsync;
+ memory mem;
+ pointer p;
+ string s;
+ vec<string> vs;
+ string[2][2] multidimArray;
+ string[3] sArray;
+ Quux anotherStruct;
+ bitfield<BitField> bf;
+ };
+
doThis(float param);
doThatAndReturnSomething(int64_t param) generates (int32_t result);
doQuiteABit(int32_t a, int64_t b, float c, double d) generates (double something);
diff --git a/tv/cec/1.0/vts/functional/vts/testcases/hal/tv_cec/hidl/host/TvCecHidlTest.py b/tv/cec/1.0/vts/functional/vts/testcases/hal/tv_cec/hidl/host/TvCecHidlTest.py
index dcf21c9..977cbcd 100644
--- a/tv/cec/1.0/vts/functional/vts/testcases/hal/tv_cec/hidl/host/TvCecHidlTest.py
+++ b/tv/cec/1.0/vts/functional/vts/testcases/hal/tv_cec/hidl/host/TvCecHidlTest.py
@@ -17,6 +17,7 @@
import logging
+from vts.proto import ComponentSpecificationMessage_pb2 as CompSpecMsg
from vts.runners.host import asserts
from vts.runners.host import base_test_with_webdb
from vts.runners.host import const
@@ -43,7 +44,7 @@
target_version=1.0,
target_package="android.hardware.tv.cec",
target_component_name="IHdmiCec",
- hw_binder_service_name="tv.cec",
+ hw_binder_service_name="cec-hal-1-0",
bits=64 if self.dut.is64Bit else 32)
def testGetCecVersion1(self):
@@ -52,6 +53,40 @@
version = self.dut.hal.tv_cec.getCecVersion()
logging.info('Cec version: %s', version)
+ def testSendRandomMessage(self):
+ """A test case which sends a random message."""
+ self.vtypes = self.dut.hal.tv_cec.GetHidlTypeInterface("types")
+ logging.info("tv_cec types: %s", self.vtypes)
+
+ message = CompSpecMsg.VariableSpecificationMessage()
+ message.name = "CecMessage"
+ message.type = CompSpecMsg.TYPE_STRUCT
+ initiator = message.struct_value.add()
+ initiator.name = "initiator"
+ initiator.type = CompSpecMsg.TYPE_ENUM
+ initiator.scalar_value.int32_t = self.vtypes.TV
+ destination = message.struct_value.add()
+ destination.name = "destination"
+ destination.type = CompSpecMsg.TYPE_ENUM
+ destination.scalar_value.int32_t = self.vtypes.PLAYBACK_1
+ body = message.struct_value.add()
+ body.name = "body"
+ body.type = CompSpecMsg.TYPE_VECTOR
+ vector1 = body.vector_value.add()
+ vector1.type = CompSpecMsg.TYPE_SCALAR
+ vector1.scalar_type = "uint8_t"
+ vector1.scalar_value.uint8_t = 1
+ vector2 = body.vector_value.add()
+ vector2.type = CompSpecMsg.TYPE_SCALAR
+ vector2.scalar_type = "uint8_t"
+ vector2.scalar_value.uint8_t = 2
+ vector3 = body.vector_value.add()
+ vector3.type = CompSpecMsg.TYPE_SCALAR
+ vector3.scalar_type = "uint8_t"
+ vector3.scalar_value.uint8_t = 3
+ logging.info("message: %s", message)
+ result = self.dut.hal.tv_cec.sendMessage(message)
+ logging.info('sendMessage result: %s', result)
if __name__ == "__main__":
test_runner.main()
diff --git a/tv/input/1.0/Android.bp b/tv/input/1.0/Android.bp
index 94dcdc9..9504961 100644
--- a/tv/input/1.0/Android.bp
+++ b/tv/input/1.0/Android.bp
@@ -128,3 +128,95 @@
"android.hidl.base@1.0",
],
}
+
+genrule {
+ name: "android.hardware.tv.input@1.0-ITvInput-vts.profiler_genc++",
+ tools: ["hidl-gen", "vtsc"],
+ cmd: "$(location hidl-gen) -o $(genDir) -Lvts -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tv.input@1.0 && $(location vtsc) -mPROFILER -tSOURCE -b$(genDir) android/hardware/tv/input/1.0/ $(genDir)/android/hardware/tv/input/1.0/",
+ srcs: [
+ "ITvInput.hal",
+ "types.hal",
+ ],
+ out: [
+ "android/hardware/tv/input/1.0/TvInput.vts.cpp",
+ "android/hardware/tv/input/1.0/types.vts.cpp",
+ ],
+}
+
+genrule {
+ name: "android.hardware.tv.input@1.0-ITvInput-vts.profiler_genc++_headers",
+ tools: ["hidl-gen", "vtsc"],
+ cmd: "$(location hidl-gen) -o $(genDir) -Lvts -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tv.input@1.0 && $(location vtsc) -mPROFILER -tHEADER -b$(genDir) android/hardware/tv/input/1.0/ $(genDir)/android/hardware/tv/input/1.0/",
+ srcs: [
+ "ITvInput.hal",
+ "types.hal",
+ ],
+ out: [
+ "android/hardware/tv/input/1.0/TvInput.vts.h",
+ "android/hardware/tv/input/1.0/types.vts.h",
+ ],
+}
+
+cc_library_shared {
+ name: "android.hardware.tv.input@1.0-ITvInput-vts.profiler",
+ generated_sources: ["android.hardware.tv.input@1.0-ITvInput-vts.profiler_genc++"],
+ generated_headers: ["android.hardware.tv.input@1.0-ITvInput-vts.profiler_genc++_headers"],
+ export_generated_headers: ["android.hardware.tv.input@1.0-ITvInput-vts.profiler_genc++_headers"],
+ shared_libs: [
+ "libbase",
+ "libhidlbase",
+ "libhidltransport",
+ "libvts_profiling",
+ "libvts_multidevice_proto",
+ "libprotobuf-cpp-full",
+ "android.hardware.audio.common@2.0",
+ "android.hidl.base@1.0",
+ "android.hardware.tv.input@1.0",
+ ],
+}
+
+genrule {
+ name: "android.hardware.tv.input@1.0-ITvInputCallback-vts.profiler_genc++",
+ tools: ["hidl-gen", "vtsc"],
+ cmd: "$(location hidl-gen) -o $(genDir) -Lvts -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tv.input@1.0 && $(location vtsc) -mPROFILER -tSOURCE -b$(genDir) android/hardware/tv/input/1.0/ $(genDir)/android/hardware/tv/input/1.0/",
+ srcs: [
+ "ITvInputCallback.hal",
+ "types.hal",
+ ],
+ out: [
+ "android/hardware/tv/input/1.0/TvInputCallback.vts.cpp",
+ "android/hardware/tv/input/1.0/types.vts.cpp",
+ ],
+}
+
+genrule {
+ name: "android.hardware.tv.input@1.0-ITvInputCallback-vts.profiler_genc++_headers",
+ tools: ["hidl-gen", "vtsc"],
+ cmd: "$(location hidl-gen) -o $(genDir) -Lvts -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.tv.input@1.0 && $(location vtsc) -mPROFILER -tHEADER -b$(genDir) android/hardware/tv/input/1.0/ $(genDir)/android/hardware/tv/input/1.0/",
+ srcs: [
+ "ITvInputCallback.hal",
+ "types.hal",
+ ],
+ out: [
+ "android/hardware/tv/input/1.0/TvInputCallback.vts.h",
+ "android/hardware/tv/input/1.0/types.vts.h",
+ ],
+}
+
+cc_library_shared {
+ name: "android.hardware.tv.input@1.0-ITvInputCallback-vts.profiler",
+ generated_sources: ["android.hardware.tv.input@1.0-ITvInputCallback-vts.profiler_genc++"],
+ generated_headers: ["android.hardware.tv.input@1.0-ITvInputCallback-vts.profiler_genc++_headers"],
+ export_generated_headers: ["android.hardware.tv.input@1.0-ITvInputCallback-vts.profiler_genc++_headers"],
+ shared_libs: [
+ "libbase",
+ "libhidlbase",
+ "libhidltransport",
+ "libvts_profiling",
+ "libvts_multidevice_proto",
+ "libprotobuf-cpp-full",
+ "android.hardware.audio.common@2.0",
+ "android.hidl.base@1.0",
+ "android.hardware.tv.input@1.0",
+ ],
+}
diff --git a/tv/input/1.0/vts/functional/vts/testcases/hal/tv_input/hidl/host/TvInputHidlTest.py b/tv/input/1.0/vts/functional/vts/testcases/hal/tv_input/hidl/host/TvInputHidlTest.py
index c99c82c..9b49078 100644
--- a/tv/input/1.0/vts/functional/vts/testcases/hal/tv_input/hidl/host/TvInputHidlTest.py
+++ b/tv/input/1.0/vts/functional/vts/testcases/hal/tv_input/hidl/host/TvInputHidlTest.py
@@ -39,13 +39,14 @@
target_version=1.0,
target_package="android.hardware.tv.input",
target_component_name="ITvInput",
- bits=64)
+ hw_binder_service_name="tv-input-1-0",
+ bits=64 if self.dut.is64Bit else 32)
self.dut.shell.InvokeTerminal("one")
def testGetStreamConfigurations(self):
configs = self.dut.hal.tv_input.getStreamConfigurations(0)
- logging.info('tv input configs: %s', configs)
+ logging.info('return value of getStreamConfigurations(0): %s', configs)
if __name__ == "__main__":
diff --git a/vehicle/2.0/IVehicle.hal b/vehicle/2.0/IVehicle.hal
index 5b0df67..cab6ce0 100644
--- a/vehicle/2.0/IVehicle.hal
+++ b/vehicle/2.0/IVehicle.hal
@@ -99,9 +99,6 @@
* primitives used (such as mutex locks or semaphores) must be acquired
* with a timeout.
*
- * TODO(pavelm): we cannot use handle here due to Java compatibility, it's
- * better to pass file descriptor and write debug data directly in vehicle HAL
- * rather than passing back a string.
*/
debugDump() generates (string s);
};
diff --git a/vehicle/2.0/types.hal b/vehicle/2.0/types.hal
index 62521cb..bb83c8a 100644
--- a/vehicle/2.0/types.hal
+++ b/vehicle/2.0/types.hal
@@ -332,7 +332,6 @@
*
* @change_mode VehiclePropertyChangeMode:ON_CHANGE
* @access VehiclePropertyAccess:READ_WRITE
- * @data_enum TODO
* @allow_out_of_range_value : OFF
*/
HVAC_FAN_SPEED = (
@@ -346,7 +345,7 @@
*
* @change_mode VehiclePropertyChangeMode:ON_CHANGE
* @access VehiclePropertyAccess:READ_WRITE
- * @data_enum TODO
+ * @data_enum VehicleHvacFanDirection
* @allow_out_of_range_value : OFF
*/
HVAC_FAN_DIRECTION = (
@@ -2746,7 +2745,7 @@
* tests are available and whether they are complete. The semantics of the individual
* bits in this value are given by, respectively, SparkIgnitionMonitors and
* CompressionIgnitionMonitors depending on the value of IGNITION_MONITORS_SUPPORTED.
- /*
+ */
IGNITION_SPECIFIC_MONITORS = 3,
INTAKE_AIR_TEMPERATURE = 4,
diff --git a/vehicle/2.0/vts/functional/vts/testcases/hal/vehicle/hidl/host/VehicleHidlTest.py b/vehicle/2.0/vts/functional/vts/testcases/hal/vehicle/hidl/host/VehicleHidlTest.py
index e17c72d..715cba8 100644
--- a/vehicle/2.0/vts/functional/vts/testcases/hal/vehicle/hidl/host/VehicleHidlTest.py
+++ b/vehicle/2.0/vts/functional/vts/testcases/hal/vehicle/hidl/host/VehicleHidlTest.py
@@ -47,9 +47,15 @@
hw_binder_service_name="Vehicle",
bits=64 if self.dut.is64Bit else 32)
+ self.vehicle = self.dut.hal.vehicle # shortcut
+ self.vtypes = self.dut.hal.vehicle.GetHidlTypeInterface("types")
+ logging.info("vehicle types: %s", self.vtypes)
+
def tearDownClass(self):
- """ If profiling is enabled for the test, collect the profiling data
- and disable profiling after the test is done.
+ """Disables the profiling.
+
+ If profiling is enabled for the test, collect the profiling data
+ and disable profiling after the test is done.
"""
if self.enable_profiling:
profiling_trace_path = getattr(
@@ -58,12 +64,26 @@
profiling_utils.DisableVTSProfiling(self.dut.shell.one)
def testListProperties(self):
- logging.info("vehicle_types")
- vehicle_types = self.dut.hal.vehicle.GetHidlTypeInterface("types")
- logging.info("vehicle_types: %s", vehicle_types)
+ """Checks whether some PropConfigs are returned.
- allConfigs = self.dut.hal.vehicle.getAllPropConfigs()
+ Verifies that call to getAllPropConfigs is not failing and
+ it returns at least 1 vehicle property config.
+ """
+ allConfigs = self.vehicle.getAllPropConfigs()
logging.info("all supported properties: %s", allConfigs)
+ asserts.assertLess(0, len(allConfigs))
+
+ def testMandatoryProperties(self):
+ """Verifies that all mandatory properties are supported."""
+ mandatoryProps = set([self.vtypes.DRIVING_STATUS]) # 1 property so far
+ logging.info(self.vtypes.DRIVING_STATUS)
+ allConfigs = self.dut.hal.vehicle.getAllPropConfigs()
+
+ for config in allConfigs:
+ mandatoryProps.discard(config['prop'])
+
+ asserts.assertEqual(0, len(mandatoryProps))
+
if __name__ == "__main__":
test_runner.main()
diff --git a/vehicle/2.0/vts/types.vts b/vehicle/2.0/vts/types.vts
index 99fa6e7..fa7d892 100644
--- a/vehicle/2.0/vts/types.vts
+++ b/vehicle/2.0/vts/types.vts
@@ -43,6 +43,10 @@
scalar_value: {
int32_t: 7340032
}
+ enumerator: "COMPLEX"
+ scalar_value: {
+ int32_t: 14680064
+ }
enumerator: "MASK"
scalar_value: {
int32_t: 16711680
@@ -186,6 +190,10 @@
scalar_value: {
int32_t: 289408008
}
+ enumerator: "IGNITION_STATE"
+ scalar_value: {
+ int32_t: 289408009
+ }
enumerator: "HVAC_FAN_SPEED"
scalar_value: {
int32_t: 306185472
@@ -486,6 +494,18 @@
scalar_value: {
int32_t: 287312836
}
+ enumerator: "VEHICLE_MAPS_DATA_SERVICE"
+ scalar_value: {
+ int32_t: 299895808
+ }
+ enumerator: "OBD2_LIVE_FRAME"
+ scalar_value: {
+ int32_t: 299896064
+ }
+ enumerator: "OBD2_FREEZE_FRAME"
+ scalar_value: {
+ int32_t: 299896065
+ }
}
}
@@ -1686,6 +1706,39 @@
}
attribute: {
+ name: "::android::hardware::vehicle::V2_0::VehicleIgnitionState"
+ type: TYPE_ENUM
+ enum_value: {
+ scalar_type: "int32_t"
+
+ enumerator: "UNDEFINED"
+ scalar_value: {
+ int32_t: 0
+ }
+ enumerator: "LOCK"
+ scalar_value: {
+ int32_t: 1
+ }
+ enumerator: "OFF"
+ scalar_value: {
+ int32_t: 2
+ }
+ enumerator: "ACC"
+ scalar_value: {
+ int32_t: 3
+ }
+ enumerator: "ON"
+ scalar_value: {
+ int32_t: 4
+ }
+ enumerator: "START"
+ scalar_value: {
+ int32_t: 5
+ }
+ }
+}
+
+attribute: {
name: "::android::hardware::vehicle::V2_0::VehiclePropertyOperation"
type: TYPE_ENUM
enum_value: {
@@ -1793,3 +1846,828 @@
}
}
+attribute: {
+ name: "::android::hardware::vehicle::V2_0::FuelSystemStatus"
+ type: TYPE_ENUM
+ enum_value: {
+ scalar_type: "int32_t"
+
+ enumerator: "OPEN_INSUFFICIENT_ENGINE_TEMPERATURE"
+ scalar_value: {
+ int32_t: 1
+ }
+ enumerator: "CLOSED_LOOP"
+ scalar_value: {
+ int32_t: 2
+ }
+ enumerator: "OPEN_ENGINE_LOAD_OR_DECELERATION"
+ scalar_value: {
+ int32_t: 4
+ }
+ enumerator: "OPEN_SYSTEM_FAILURE"
+ scalar_value: {
+ int32_t: 8
+ }
+ enumerator: "CLOSED_LOOP_BUT_FEEDBACK_FAULT"
+ scalar_value: {
+ int32_t: 16
+ }
+ }
+}
+
+attribute: {
+ name: "::android::hardware::vehicle::V2_0::IgnitionMonitorKind"
+ type: TYPE_ENUM
+ enum_value: {
+ scalar_type: "int32_t"
+
+ enumerator: "SPARK"
+ scalar_value: {
+ int32_t: 0
+ }
+ enumerator: "COMPRESSION"
+ scalar_value: {
+ int32_t: 1
+ }
+ }
+}
+
+attribute: {
+ name: "::android::hardware::vehicle::V2_0::CommonIgnitionMonitors"
+ type: TYPE_ENUM
+ enum_value: {
+ scalar_type: "int32_t"
+
+ enumerator: "COMPONENTS_AVAILABLE"
+ scalar_value: {
+ int32_t: 1
+ }
+ enumerator: "COMPONENTS_INCOMPLETE"
+ scalar_value: {
+ int32_t: 2
+ }
+ enumerator: "FUEL_SYSTEM_AVAILABLE"
+ scalar_value: {
+ int32_t: 4
+ }
+ enumerator: "FUEL_SYSTEM_INCOMPLETE"
+ scalar_value: {
+ int32_t: 8
+ }
+ enumerator: "MISFIRE_AVAILABLE"
+ scalar_value: {
+ int32_t: 16
+ }
+ enumerator: "MISFIRE_INCOMPLETE"
+ scalar_value: {
+ int32_t: 32
+ }
+ }
+}
+
+attribute: {
+ name: "::android::hardware::vehicle::V2_0::SparkIgnitionMonitors"
+ type: TYPE_ENUM
+ enum_value: {
+ scalar_type: "int32_t"
+
+ enumerator: "COMPONENTS_AVAILABLE"
+ scalar_value: {
+ int32_t: 1
+ }
+ enumerator: "COMPONENTS_INCOMPLETE"
+ scalar_value: {
+ int32_t: 2
+ }
+ enumerator: "FUEL_SYSTEM_AVAILABLE"
+ scalar_value: {
+ int32_t: 4
+ }
+ enumerator: "FUEL_SYSTEM_INCOMPLETE"
+ scalar_value: {
+ int32_t: 8
+ }
+ enumerator: "MISFIRE_AVAILABLE"
+ scalar_value: {
+ int32_t: 16
+ }
+ enumerator: "MISFIRE_INCOMPLETE"
+ scalar_value: {
+ int32_t: 32
+ }
+ enumerator: "EGR_AVAILABLE"
+ scalar_value: {
+ int32_t: 64
+ }
+ enumerator: "EGR_INCOMPLETE"
+ scalar_value: {
+ int32_t: 128
+ }
+ enumerator: "OXYGEN_SENSOR_HEATER_AVAILABLE"
+ scalar_value: {
+ int32_t: 256
+ }
+ enumerator: "OXYGEN_SENSOR_HEATER_INCOMPLETE"
+ scalar_value: {
+ int32_t: 512
+ }
+ enumerator: "OXYGEN_SENSOR_AVAILABLE"
+ scalar_value: {
+ int32_t: 1024
+ }
+ enumerator: "OXYGEN_SENSOR_INCOMPLETE"
+ scalar_value: {
+ int32_t: 2048
+ }
+ enumerator: "AC_REFRIGERANT_AVAILABLE"
+ scalar_value: {
+ int32_t: 4096
+ }
+ enumerator: "AC_REFRIGERANT_INCOMPLETE"
+ scalar_value: {
+ int32_t: 8192
+ }
+ enumerator: "SECONDARY_AIR_SYSTEM_AVAILABLE"
+ scalar_value: {
+ int32_t: 16384
+ }
+ enumerator: "SECONDARY_AIR_SYSTEM_INCOMPLETE"
+ scalar_value: {
+ int32_t: 32768
+ }
+ enumerator: "EVAPORATIVE_SYSTEM_AVAILABLE"
+ scalar_value: {
+ int32_t: 65536
+ }
+ enumerator: "EVAPORATIVE_SYSTEM_INCOMPLETE"
+ scalar_value: {
+ int32_t: 131072
+ }
+ enumerator: "HEATED_CATALYST_AVAILABLE"
+ scalar_value: {
+ int32_t: 262144
+ }
+ enumerator: "HEATED_CATALYST_INCOMPLETE"
+ scalar_value: {
+ int32_t: 524288
+ }
+ enumerator: "CATALYST_AVAILABLE"
+ scalar_value: {
+ int32_t: 1048576
+ }
+ enumerator: "CATALYST_INCOMPLETE"
+ scalar_value: {
+ int32_t: 2097152
+ }
+ }
+}
+
+attribute: {
+ name: "::android::hardware::vehicle::V2_0::CompressionIgnitionMonitors"
+ type: TYPE_ENUM
+ enum_value: {
+ scalar_type: "int32_t"
+
+ enumerator: "COMPONENTS_AVAILABLE"
+ scalar_value: {
+ int32_t: 1
+ }
+ enumerator: "COMPONENTS_INCOMPLETE"
+ scalar_value: {
+ int32_t: 2
+ }
+ enumerator: "FUEL_SYSTEM_AVAILABLE"
+ scalar_value: {
+ int32_t: 4
+ }
+ enumerator: "FUEL_SYSTEM_INCOMPLETE"
+ scalar_value: {
+ int32_t: 8
+ }
+ enumerator: "MISFIRE_AVAILABLE"
+ scalar_value: {
+ int32_t: 16
+ }
+ enumerator: "MISFIRE_INCOMPLETE"
+ scalar_value: {
+ int32_t: 32
+ }
+ enumerator: "EGR_OR_VVT_AVAILABLE"
+ scalar_value: {
+ int32_t: 64
+ }
+ enumerator: "EGR_OR_VVT_INCOMPLETE"
+ scalar_value: {
+ int32_t: 128
+ }
+ enumerator: "PM_FILTER_AVAILABLE"
+ scalar_value: {
+ int32_t: 256
+ }
+ enumerator: "PM_FILTER_INCOMPLETE"
+ scalar_value: {
+ int32_t: 512
+ }
+ enumerator: "EXHAUST_GAS_SENSOR_AVAILABLE"
+ scalar_value: {
+ int32_t: 1024
+ }
+ enumerator: "EXHAUST_GAS_SENSOR_INCOMPLETE"
+ scalar_value: {
+ int32_t: 2048
+ }
+ enumerator: "BOOST_PRESSURE_AVAILABLE"
+ scalar_value: {
+ int32_t: 4096
+ }
+ enumerator: "BOOST_PRESSURE_INCOMPLETE"
+ scalar_value: {
+ int32_t: 8192
+ }
+ enumerator: "NOx_SCR__AVAILABLE"
+ scalar_value: {
+ int32_t: 16384
+ }
+ enumerator: "NOx_SCR_INCOMPLETE"
+ scalar_value: {
+ int32_t: 32768
+ }
+ enumerator: "NMHC_CATALYST_AVAILABLE"
+ scalar_value: {
+ int32_t: 65536
+ }
+ enumerator: "NMHC_CATALYST_INCOMPLETE"
+ scalar_value: {
+ int32_t: 131072
+ }
+ }
+}
+
+attribute: {
+ name: "::android::hardware::vehicle::V2_0::SecondaryAirStatus"
+ type: TYPE_ENUM
+ enum_value: {
+ scalar_type: "int32_t"
+
+ enumerator: "UPSTREAM"
+ scalar_value: {
+ int32_t: 1
+ }
+ enumerator: "DOWNSTREAM_OF_CATALYCIC_CONVERTER"
+ scalar_value: {
+ int32_t: 2
+ }
+ enumerator: "FROM_OUTSIDE_OR_OFF"
+ scalar_value: {
+ int32_t: 4
+ }
+ enumerator: "PUMP_ON_FOR_DIAGNOSTICS"
+ scalar_value: {
+ int32_t: 8
+ }
+ }
+}
+
+attribute: {
+ name: "::android::hardware::vehicle::V2_0::FuelType"
+ type: TYPE_ENUM
+ enum_value: {
+ scalar_type: "int32_t"
+
+ enumerator: "NOT_AVAILABLE"
+ scalar_value: {
+ int32_t: 0
+ }
+ enumerator: "GASOLINE"
+ scalar_value: {
+ int32_t: 1
+ }
+ enumerator: "METHANOL"
+ scalar_value: {
+ int32_t: 2
+ }
+ enumerator: "ETHANOL"
+ scalar_value: {
+ int32_t: 3
+ }
+ enumerator: "DIESEL"
+ scalar_value: {
+ int32_t: 4
+ }
+ enumerator: "LPG"
+ scalar_value: {
+ int32_t: 5
+ }
+ enumerator: "CNG"
+ scalar_value: {
+ int32_t: 6
+ }
+ enumerator: "PROPANE"
+ scalar_value: {
+ int32_t: 7
+ }
+ enumerator: "ELECTRIC"
+ scalar_value: {
+ int32_t: 8
+ }
+ enumerator: "BIFUEL_RUNNING_GASOLINE"
+ scalar_value: {
+ int32_t: 9
+ }
+ enumerator: "BIFUEL_RUNNING_METHANOL"
+ scalar_value: {
+ int32_t: 10
+ }
+ enumerator: "BIFUEL_RUNNING_ETHANOL"
+ scalar_value: {
+ int32_t: 11
+ }
+ enumerator: "BIFUEL_RUNNING_LPG"
+ scalar_value: {
+ int32_t: 12
+ }
+ enumerator: "BIFUEL_RUNNING_CNG"
+ scalar_value: {
+ int32_t: 13
+ }
+ enumerator: "BIFUEL_RUNNING_PROPANE"
+ scalar_value: {
+ int32_t: 14
+ }
+ enumerator: "BIFUEL_RUNNING_ELECTRIC"
+ scalar_value: {
+ int32_t: 15
+ }
+ enumerator: "BIFUEL_RUNNING_ELECTRIC_AND_COMBUSTION"
+ scalar_value: {
+ int32_t: 16
+ }
+ enumerator: "HYBRID_GASOLINE"
+ scalar_value: {
+ int32_t: 17
+ }
+ enumerator: "HYBRID_ETHANOL"
+ scalar_value: {
+ int32_t: 18
+ }
+ enumerator: "HYBRID_DIESEL"
+ scalar_value: {
+ int32_t: 19
+ }
+ enumerator: "HYBRID_ELECTRIC"
+ scalar_value: {
+ int32_t: 20
+ }
+ enumerator: "HYBRID_RUNNING_ELECTRIC_AND_COMBUSTION"
+ scalar_value: {
+ int32_t: 21
+ }
+ enumerator: "HYBRID_REGENERATIVE"
+ scalar_value: {
+ int32_t: 22
+ }
+ enumerator: "BIFUEL_RUNNING_DIESEL"
+ scalar_value: {
+ int32_t: 23
+ }
+ }
+}
+
+attribute: {
+ name: "::android::hardware::vehicle::V2_0::Obd2IntegerSensorIndex"
+ type: TYPE_ENUM
+ enum_value: {
+ scalar_type: "int32_t"
+
+ enumerator: "FUEL_SYSTEM_STATUS"
+ scalar_value: {
+ int32_t: 0
+ }
+ enumerator: "MALFUNCTION_INDICATOR_LIGHT_ON"
+ scalar_value: {
+ int32_t: 1
+ }
+ enumerator: "IGNITION_MONITORS_SUPPORTED"
+ scalar_value: {
+ int32_t: 2
+ }
+ enumerator: "COMMANDED_SECONDARY_AIR_STATUS"
+ scalar_value: {
+ int32_t: 5
+ }
+ enumerator: "NUM_OXYGEN_SENSORS_PRESENT"
+ scalar_value: {
+ int32_t: 6
+ }
+ enumerator: "RUNTIME_SINCE_ENGINE_START"
+ scalar_value: {
+ int32_t: 7
+ }
+ enumerator: "DISTANCE_TRAVELED_WITH_MALFUNCTION_INDICATOR_LIGHT_ON"
+ scalar_value: {
+ int32_t: 8
+ }
+ enumerator: "WARMUPS_SINCE_CODES_CLEARED"
+ scalar_value: {
+ int32_t: 9
+ }
+ enumerator: "DISTANCE_TRAVELED_SINCE_CODES_CLEARED"
+ scalar_value: {
+ int32_t: 10
+ }
+ enumerator: "ABSOLUTE_BAROMETRIC_PRESSURE"
+ scalar_value: {
+ int32_t: 11
+ }
+ enumerator: "CONTROL_MODULE_VOLTAGE"
+ scalar_value: {
+ int32_t: 12
+ }
+ enumerator: "AMBIENT_AIR_TEMPERATURE"
+ scalar_value: {
+ int32_t: 13
+ }
+ enumerator: "TIME_WITH_MALFUNCTION_LIGHT_ON"
+ scalar_value: {
+ int32_t: 14
+ }
+ enumerator: "TIME_SINCE_TROUBLE_CODES_CLEARED"
+ scalar_value: {
+ int32_t: 15
+ }
+ enumerator: "MAX_FUEL_AIR_EQUIVALENCE_RATIO"
+ scalar_value: {
+ int32_t: 16
+ }
+ enumerator: "MAX_OXYGEN_SENSOR_VOLTAGE"
+ scalar_value: {
+ int32_t: 17
+ }
+ enumerator: "MAX_OXYGEN_SENSOR_CURRENT"
+ scalar_value: {
+ int32_t: 18
+ }
+ enumerator: "MAX_INTAKE_MANIFOLD_ABSOLUTE_PRESSURE"
+ scalar_value: {
+ int32_t: 19
+ }
+ enumerator: "MAX_AIR_FLOW_RATE_FROM_MASS_AIR_FLOW_SENSOR"
+ scalar_value: {
+ int32_t: 20
+ }
+ enumerator: "FUEL_TYPE"
+ scalar_value: {
+ int32_t: 21
+ }
+ enumerator: "FUEL_RAIL_ABSOLUTE_PRESSURE"
+ scalar_value: {
+ int32_t: 22
+ }
+ enumerator: "ENGINE_OIL_TEMPERATURE"
+ scalar_value: {
+ int32_t: 23
+ }
+ enumerator: "DRIVER_DEMAND_PERCENT_TORQUE"
+ scalar_value: {
+ int32_t: 24
+ }
+ enumerator: "ENGINE_ACTUAL_PERCENT_TORQUE"
+ scalar_value: {
+ int32_t: 25
+ }
+ enumerator: "ENGINE_REFERENCE_PERCENT_TORQUE"
+ scalar_value: {
+ int32_t: 26
+ }
+ enumerator: "ENGINE_PERCENT_TORQUE_DATA_IDLE"
+ scalar_value: {
+ int32_t: 27
+ }
+ enumerator: "ENGINE_PERCENT_TORQUE_DATA_POINT1"
+ scalar_value: {
+ int32_t: 28
+ }
+ enumerator: "ENGINE_PERCENT_TORQUE_DATA_POINT2"
+ scalar_value: {
+ int32_t: 29
+ }
+ enumerator: "ENGINE_PERCENT_TORQUE_DATA_POINT3"
+ scalar_value: {
+ int32_t: 30
+ }
+ enumerator: "ENGINE_PERCENT_TORQUE_DATA_POINT4"
+ scalar_value: {
+ int32_t: 31
+ }
+ enumerator: "LAST_SYSTEM_INDEX"
+ scalar_value: {
+ int32_t: 31
+ }
+ enumerator: "VENDOR_START_INDEX"
+ scalar_value: {
+ int32_t: 32
+ }
+ }
+}
+
+attribute: {
+ name: "::android::hardware::vehicle::V2_0::Obd2FloatSensorIndex"
+ type: TYPE_ENUM
+ enum_value: {
+ scalar_type: "int32_t"
+
+ enumerator: "CALCULATED_ENGINE_LOAD"
+ scalar_value: {
+ int32_t: 0
+ }
+ enumerator: "ENGINE_COOLANT_TEMPERATURE"
+ scalar_value: {
+ int32_t: 1
+ }
+ enumerator: "SHORT_TERM_FUEL_TRIM_BANK1"
+ scalar_value: {
+ int32_t: 2
+ }
+ enumerator: "LONG_TERM_FUEL_TRIM_BANK1"
+ scalar_value: {
+ int32_t: 3
+ }
+ enumerator: "SHORT_TERM_FUEL_TRIM_BANK2"
+ scalar_value: {
+ int32_t: 4
+ }
+ enumerator: "LONG_TERM_FUEL_TRIM_BANK2"
+ scalar_value: {
+ int32_t: 5
+ }
+ enumerator: "FUEL_PRESSURE"
+ scalar_value: {
+ int32_t: 6
+ }
+ enumerator: "INTAKE_MANIFOLD_ABSOLUTE_PRESSURE"
+ scalar_value: {
+ int32_t: 7
+ }
+ enumerator: "ENGINE_RPM"
+ scalar_value: {
+ int32_t: 8
+ }
+ enumerator: "VEHICLE_SPEED"
+ scalar_value: {
+ int32_t: 9
+ }
+ enumerator: "TIMING_ADVANCE"
+ scalar_value: {
+ int32_t: 10
+ }
+ enumerator: "MAF_AIR_FLOW_RATE"
+ scalar_value: {
+ int32_t: 11
+ }
+ enumerator: "THROTTLE_POSITION"
+ scalar_value: {
+ int32_t: 12
+ }
+ enumerator: "OXYGEN_SENSOR1_VOLTAGE"
+ scalar_value: {
+ int32_t: 13
+ }
+ enumerator: "OXYGEN_SENSOR1_SHORT_TERM_FUEL_TRIM"
+ scalar_value: {
+ int32_t: 14
+ }
+ enumerator: "OXYGEN_SENSOR1_FUEL_AIR_EQUIVALENCE_RATIO"
+ scalar_value: {
+ int32_t: 15
+ }
+ enumerator: "OXYGEN_SENSOR2_VOLTAGE"
+ scalar_value: {
+ int32_t: 16
+ }
+ enumerator: "OXYGEN_SENSOR2_SHORT_TERM_FUEL_TRIM"
+ scalar_value: {
+ int32_t: 17
+ }
+ enumerator: "OXYGEN_SENSOR2_FUEL_AIR_EQUIVALENCE_RATIO"
+ scalar_value: {
+ int32_t: 18
+ }
+ enumerator: "OXYGEN_SENSOR3_VOLTAGE"
+ scalar_value: {
+ int32_t: 19
+ }
+ enumerator: "OXYGEN_SENSOR3_SHORT_TERM_FUEL_TRIM"
+ scalar_value: {
+ int32_t: 20
+ }
+ enumerator: "OXYGEN_SENSOR3_FUEL_AIR_EQUIVALENCE_RATIO"
+ scalar_value: {
+ int32_t: 21
+ }
+ enumerator: "OXYGEN_SENSOR4_VOLTAGE"
+ scalar_value: {
+ int32_t: 22
+ }
+ enumerator: "OXYGEN_SENSOR4_SHORT_TERM_FUEL_TRIM"
+ scalar_value: {
+ int32_t: 23
+ }
+ enumerator: "OXYGEN_SENSOR4_FUEL_AIR_EQUIVALENCE_RATIO"
+ scalar_value: {
+ int32_t: 24
+ }
+ enumerator: "OXYGEN_SENSOR5_VOLTAGE"
+ scalar_value: {
+ int32_t: 25
+ }
+ enumerator: "OXYGEN_SENSOR5_SHORT_TERM_FUEL_TRIM"
+ scalar_value: {
+ int32_t: 26
+ }
+ enumerator: "OXYGEN_SENSOR5_FUEL_AIR_EQUIVALENCE_RATIO"
+ scalar_value: {
+ int32_t: 27
+ }
+ enumerator: "OXYGEN_SENSOR6_VOLTAGE"
+ scalar_value: {
+ int32_t: 28
+ }
+ enumerator: "OXYGEN_SENSOR6_SHORT_TERM_FUEL_TRIM"
+ scalar_value: {
+ int32_t: 29
+ }
+ enumerator: "OXYGEN_SENSOR6_FUEL_AIR_EQUIVALENCE_RATIO"
+ scalar_value: {
+ int32_t: 30
+ }
+ enumerator: "OXYGEN_SENSOR7_VOLTAGE"
+ scalar_value: {
+ int32_t: 31
+ }
+ enumerator: "OXYGEN_SENSOR7_SHORT_TERM_FUEL_TRIM"
+ scalar_value: {
+ int32_t: 32
+ }
+ enumerator: "OXYGEN_SENSOR7_FUEL_AIR_EQUIVALENCE_RATIO"
+ scalar_value: {
+ int32_t: 33
+ }
+ enumerator: "OXYGEN_SENSOR8_VOLTAGE"
+ scalar_value: {
+ int32_t: 34
+ }
+ enumerator: "OXYGEN_SENSOR8_SHORT_TERM_FUEL_TRIM"
+ scalar_value: {
+ int32_t: 35
+ }
+ enumerator: "OXYGEN_SENSOR8_FUEL_AIR_EQUIVALENCE_RATIO"
+ scalar_value: {
+ int32_t: 36
+ }
+ enumerator: "FUEL_RAIL_PRESSURE"
+ scalar_value: {
+ int32_t: 37
+ }
+ enumerator: "FUEL_RAIL_GAUGE_PRESSURE"
+ scalar_value: {
+ int32_t: 38
+ }
+ enumerator: "COMMANDED_EXHAUST_GAS_RECIRCULATION"
+ scalar_value: {
+ int32_t: 39
+ }
+ enumerator: "EXHAUST_GAS_RECIRCULATION_ERROR"
+ scalar_value: {
+ int32_t: 40
+ }
+ enumerator: "COMMANDED_EVAPORATIVE_PURGE"
+ scalar_value: {
+ int32_t: 41
+ }
+ enumerator: "FUEL_TANK_LEVEL_INPUT"
+ scalar_value: {
+ int32_t: 42
+ }
+ enumerator: "EVAPORATION_SYSTEM_VAPOR_PRESSURE"
+ scalar_value: {
+ int32_t: 43
+ }
+ enumerator: "CATALYST_TEMPERATURE_BANK1_SENSOR1"
+ scalar_value: {
+ int32_t: 44
+ }
+ enumerator: "CATALYST_TEMPERATURE_BANK2_SENSOR1"
+ scalar_value: {
+ int32_t: 45
+ }
+ enumerator: "CATALYST_TEMPERATURE_BANK1_SENSOR2"
+ scalar_value: {
+ int32_t: 46
+ }
+ enumerator: "CATALYST_TEMPERATURE_BANK2_SENSOR2"
+ scalar_value: {
+ int32_t: 47
+ }
+ enumerator: "ABSOLUTE_LOAD_VALUE"
+ scalar_value: {
+ int32_t: 48
+ }
+ enumerator: "FUEL_AIR_COMMANDED_EQUIVALENCE_RATIO"
+ scalar_value: {
+ int32_t: 49
+ }
+ enumerator: "RELATIVE_THROTTLE_POSITION"
+ scalar_value: {
+ int32_t: 50
+ }
+ enumerator: "ABSOLUTE_THROTTLE_POSITION_B"
+ scalar_value: {
+ int32_t: 51
+ }
+ enumerator: "ABSOLUTE_THROTTLE_POSITION_C"
+ scalar_value: {
+ int32_t: 52
+ }
+ enumerator: "ACCELERATOR_PEDAL_POSITION_D"
+ scalar_value: {
+ int32_t: 53
+ }
+ enumerator: "ACCELERATOR_PEDAL_POSITION_E"
+ scalar_value: {
+ int32_t: 54
+ }
+ enumerator: "ACCELERATOR_PEDAL_POSITION_F"
+ scalar_value: {
+ int32_t: 55
+ }
+ enumerator: "COMMANDED_THROTTLE_ACTUATOR"
+ scalar_value: {
+ int32_t: 56
+ }
+ enumerator: "ETHANOL_FUEL_PERCENTAGE"
+ scalar_value: {
+ int32_t: 57
+ }
+ enumerator: "ABSOLUTE_EVAPORATION_SYSTEM_VAPOR_PRESSURE"
+ scalar_value: {
+ int32_t: 58
+ }
+ enumerator: "SHORT_TERM_SECONDARY_OXYGEN_SENSOR_TRIM_BANK1"
+ scalar_value: {
+ int32_t: 59
+ }
+ enumerator: "SHORT_TERM_SECONDARY_OXYGEN_SENSOR_TRIM_BANK2"
+ scalar_value: {
+ int32_t: 60
+ }
+ enumerator: "SHORT_TERM_SECONDARY_OXYGEN_SENSOR_TRIM_BANK3"
+ scalar_value: {
+ int32_t: 61
+ }
+ enumerator: "SHORT_TERM_SECONDARY_OXYGEN_SENSOR_TRIM_BANK4"
+ scalar_value: {
+ int32_t: 62
+ }
+ enumerator: "LONG_TERM_SECONDARY_OXYGEN_SENSOR_TRIM_BANK1"
+ scalar_value: {
+ int32_t: 63
+ }
+ enumerator: "LONG_TERM_SECONDARY_OXYGEN_SENSOR_TRIM_BANK2"
+ scalar_value: {
+ int32_t: 64
+ }
+ enumerator: "LONG_TERM_SECONDARY_OXYGEN_SENSOR_TRIM_BANK3"
+ scalar_value: {
+ int32_t: 65
+ }
+ enumerator: "LONG_TERM_SECONDARY_OXYGEN_SENSOR_TRIM_BANK4"
+ scalar_value: {
+ int32_t: 66
+ }
+ enumerator: "RELATIVE_ACCELERATOR_PEDAL_POSITION"
+ scalar_value: {
+ int32_t: 67
+ }
+ enumerator: "HYBRID_BATTERY_PACK_REMAINING_LIFE"
+ scalar_value: {
+ int32_t: 68
+ }
+ enumerator: "FUEL_INJECTION_TIMING"
+ scalar_value: {
+ int32_t: 69
+ }
+ enumerator: "ENGINE_FUEL_RATE"
+ scalar_value: {
+ int32_t: 70
+ }
+ enumerator: "LAST_SYSTEM_INDEX"
+ scalar_value: {
+ int32_t: 70
+ }
+ enumerator: "VENDOR_START_INDEX"
+ scalar_value: {
+ int32_t: 71
+ }
+ }
+}
+