graphics/mapper/4.0/utils/vts/MapperVts.cpp - android_hardware_interfaces - Gitiles

 /*
  * Copyright 2019 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 <aidlcommonsupport/NativeHandle.h>
 #include <android-base/properties.h>
 #include <android/binder_manager.h>
 #include <gralloctypes/Gralloc4.h>
 #include <mapper-vts/4.0/MapperVts.h>

 namespace android {
 namespace hardware {
 namespace graphics {
 namespace mapper {
 namespace V4_0 {
 namespace vts {

 Gralloc::Gralloc(const std::string& aidlAllocatorServiceName,
                  const std::string& hidlAllocatorServiceName, const std::string& mapperServiceName,
                  bool errOnFailure) {
     if (errOnFailure) {
         init(aidlAllocatorServiceName, hidlAllocatorServiceName, mapperServiceName);
     } else {
         initNoErr(aidlAllocatorServiceName, hidlAllocatorServiceName, mapperServiceName);
     }
 }

 void Gralloc::init(const std::string& aidlAllocatorServiceName,
                    const std::string& hidlAllocatorServiceName,
                    const std::string& mapperServiceName) {
     mAidlAllocator = aidl::android::hardware::graphics::allocator::IAllocator::fromBinder(
             ndk::SpAIBinder(AServiceManager_checkService(aidlAllocatorServiceName.c_str())));

     if (mAidlAllocator == nullptr) {
         mHidlAllocator = IAllocator::getService(hidlAllocatorServiceName);
     }
     ASSERT_TRUE(nullptr != mAidlAllocator || mHidlAllocator != nullptr)
             << "failed to get allocator service";

     mMapper = IMapper::getService(mapperServiceName);
     ASSERT_NE(nullptr, mMapper.get()) << "failed to get mapper service";
     ASSERT_FALSE(mMapper->isRemote()) << "mapper is not in passthrough mode";
 }

 void Gralloc::initNoErr(const std::string& aidlAllocatorServiceName,
                         const std::string& hidlAllocatorServiceName,
                         const std::string& mapperServiceName) {
     mAidlAllocator = aidl::android::hardware::graphics::allocator::IAllocator::fromBinder(
             ndk::SpAIBinder(AServiceManager_checkService(aidlAllocatorServiceName.c_str())));

     if (mAidlAllocator == nullptr) {
         mHidlAllocator = IAllocator::getService(hidlAllocatorServiceName);
     }

     mMapper = IMapper::getService(mapperServiceName);
     if (mMapper.get()) {
         ASSERT_FALSE(mMapper->isRemote()) << "mapper is not in passthrough mode";
     }
 }

 Gralloc::~Gralloc() {
     for (auto bufferHandle : mClonedBuffers) {
         auto buffer = const_cast<native_handle_t*>(bufferHandle);
         native_handle_close(buffer);
         native_handle_delete(buffer);
     }
     mClonedBuffers.clear();

     for (auto bufferHandle : mImportedBuffers) {
         auto buffer = const_cast<native_handle_t*>(bufferHandle);
         EXPECT_EQ(Error::NONE, mMapper->freeBuffer(buffer)) << "failed to free buffer " << buffer;
     }
     mImportedBuffers.clear();
 }

 const native_handle_t* Gralloc::cloneBuffer(const hidl_handle& rawHandle,
                                             enum Tolerance /*tolerance*/) {
     const native_handle_t* bufferHandle = native_handle_clone(rawHandle.getNativeHandle());
     EXPECT_NE(nullptr, bufferHandle);

     if (bufferHandle) {
         mClonedBuffers.insert(bufferHandle);
     }

     return bufferHandle;
 }

 std::vector<const native_handle_t*> Gralloc::allocate(const BufferDescriptor& descriptor,
                                                       uint32_t count, bool import,
                                                       enum Tolerance tolerance,
                                                       uint32_t* outStride) {
     std::vector<const native_handle_t*> bufferHandles;
     bufferHandles.reserve(count);

     auto callback = [&](Error error, uint32_t stride,
                         const hidl_vec<hidl_handle>& buffers) -> void {
         if (canTolerate(tolerance, error)) {
             return;
         }

         if (error != Error::NONE) {
             GTEST_FAIL() << "failed to allocate buffers";
         }
         ASSERT_EQ(count, buffers.size()) << "invalid buffer array";

         for (uint32_t i = 0; i < count; i++) {
             const native_handle_t* bufferHandle = nullptr;
             if (import) {
                 ASSERT_NO_FATAL_FAILURE(bufferHandle = importBuffer(buffers[i], tolerance));
             } else {
                 ASSERT_NO_FATAL_FAILURE(bufferHandle = cloneBuffer(buffers[i], tolerance));
             }
             if (bufferHandle) {
                 bufferHandles.push_back(bufferHandle);
             }
         }

         if (outStride) {
             *outStride = stride;
         }
     };

     rawAllocate(descriptor, count, callback);

     if (::testing::Test::HasFatalFailure()) {
         bufferHandles.clear();
     }

     return bufferHandles;
 }

 const native_handle_t* Gralloc::allocate(const IMapper::BufferDescriptorInfo& descriptorInfo,
                                          bool import, enum Tolerance tolerance,
                                          uint32_t* outStride) {
     BufferDescriptor descriptor = createDescriptor(descriptorInfo);
     if (::testing::Test::HasFatalFailure()) {
         return nullptr;
     }

     auto buffers = allocate(descriptor, 1, import, tolerance, outStride);
     if (::testing::Test::HasFatalFailure() || ::testing::Test::IsSkipped() || buffers.size() != 1) {
         return nullptr;
     }
     return buffers[0];
 }

 void Gralloc::rawAllocate(
         const BufferDescriptor& descriptor, uint32_t count,
         std::function<void(Error, uint32_t, const hidl_vec<hidl_handle>&)> callback) {
     if (mAidlAllocator) {
         aidl::android::hardware::graphics::allocator::AllocationResult result;
         auto status = mAidlAllocator->allocate(descriptor, count, &result);
         const Error error = toHidlError(status);
         std::vector<hidl_handle> handles;
         for (const auto& aidlHandle : result.buffers) {
             handles.push_back(hidl_handle(makeFromAidl(aidlHandle)));
         }
         callback(error, result.stride, handles);
     } else {
         mHidlAllocator->allocate(descriptor, count, callback);
     }
 }

 sp<IMapper> Gralloc::getMapper() const {
     return mMapper;
 }

 BufferDescriptor Gralloc::createDescriptor(const IMapper::BufferDescriptorInfo& descriptorInfo) {
     BufferDescriptor descriptor;
     mMapper->createDescriptor(descriptorInfo, [&](const auto& tmpError, const auto& tmpDescriptor) {
         ASSERT_EQ(Error::NONE, tmpError) << "failed to create descriptor";
         descriptor = tmpDescriptor;
     });

     return descriptor;
 }

 const native_handle_t* Gralloc::importBuffer(const hidl_handle& rawHandle,
                                              enum Tolerance tolerance) {
     const native_handle_t* bufferHandle = nullptr;
     mMapper->importBuffer(rawHandle, [&](const auto& tmpError, const auto& tmpBuffer) {
         if (!canTolerate(tolerance, tmpError)) {
             ASSERT_EQ(Error::NONE, tmpError)
                     << "failed to import buffer %p" << rawHandle.getNativeHandle();
         }
         bufferHandle = static_cast<const native_handle_t*>(tmpBuffer);
     });

     if (bufferHandle) {
         mImportedBuffers.insert(bufferHandle);
     }

     return bufferHandle;
 }

 void Gralloc::freeBuffer(const native_handle_t* bufferHandle) {
     if (bufferHandle == nullptr) {
         return;
     }

     auto buffer = const_cast<native_handle_t*>(bufferHandle);

     if (mImportedBuffers.erase(bufferHandle)) {
         Error error = mMapper->freeBuffer(buffer);
         ASSERT_EQ(Error::NONE, error) << "failed to free buffer " << buffer;
     } else {
         mClonedBuffers.erase(bufferHandle);
         native_handle_close(buffer);
         native_handle_delete(buffer);
     }
 }

 void* Gralloc::lock(const native_handle_t* bufferHandle, uint64_t cpuUsage,
                     const IMapper::Rect& accessRegion, int acquireFence) {
     auto buffer = const_cast<native_handle_t*>(bufferHandle);

     NATIVE_HANDLE_DECLARE_STORAGE(acquireFenceStorage, 1, 0);
     hidl_handle acquireFenceHandle;
     if (acquireFence >= 0) {
         auto h = native_handle_init(acquireFenceStorage, 1, 0);
         h->data[0] = acquireFence;
         acquireFenceHandle = h;
     }

     void* data = nullptr;
     mMapper->lock(buffer, cpuUsage, accessRegion, acquireFenceHandle,
                   [&](const auto& tmpError, const auto& tmpData) {
                       ASSERT_EQ(Error::NONE, tmpError) << "failed to lock buffer " << buffer;
                       data = tmpData;
                   });

     if (acquireFence >= 0) {
         close(acquireFence);
     }

     return data;
 }

 int Gralloc::unlock(const native_handle_t* bufferHandle) {
     auto buffer = const_cast<native_handle_t*>(bufferHandle);

     int releaseFence = -1;
     mMapper->unlock(buffer, [&](const auto& tmpError, const auto& tmpReleaseFence) {
         ASSERT_EQ(Error::NONE, tmpError) << "failed to unlock buffer " << buffer;

         auto fenceHandle = tmpReleaseFence.getNativeHandle();
         if (fenceHandle) {
             ASSERT_EQ(0, fenceHandle->numInts) << "invalid fence handle " << fenceHandle;
             if (fenceHandle->numFds == 1) {
                 releaseFence = dup(fenceHandle->data[0]);
                 ASSERT_LT(0, releaseFence) << "failed to dup fence fd";
             } else {
                 ASSERT_EQ(0, fenceHandle->numFds) << " invalid fence handle " << fenceHandle;
             }
         }
     });

     return releaseFence;
 }

 int Gralloc::flushLockedBuffer(const native_handle_t* bufferHandle) {
     auto buffer = const_cast<native_handle_t*>(bufferHandle);

     int releaseFence = -1;
     mMapper->flushLockedBuffer(buffer, [&](const auto& tmpError, const auto& tmpReleaseFence) {
         ASSERT_EQ(Error::NONE, tmpError) << "failed to flush locked buffer " << buffer;

         auto fenceHandle = tmpReleaseFence.getNativeHandle();
         if (fenceHandle) {
             ASSERT_EQ(0, fenceHandle->numInts) << "invalid fence handle " << fenceHandle;
             if (fenceHandle->numFds == 1) {
                 releaseFence = dup(fenceHandle->data[0]);
                 ASSERT_LT(0, releaseFence) << "failed to dup fence fd";
             } else {
                 ASSERT_EQ(0, fenceHandle->numFds) << " invalid fence handle " << fenceHandle;
             }
         }
     });

     return releaseFence;
 }

 void Gralloc::rereadLockedBuffer(const native_handle_t* bufferHandle) {
     auto buffer = const_cast<native_handle_t*>(bufferHandle);

     ASSERT_EQ(Error::NONE, mMapper->rereadLockedBuffer(buffer));
 }

 bool Gralloc::validateBufferSize(const native_handle_t* bufferHandle,
                                  const IMapper::BufferDescriptorInfo& descriptorInfo,
                                  uint32_t stride) {
     auto buffer = const_cast<native_handle_t*>(bufferHandle);

     Error error = mMapper->validateBufferSize(buffer, descriptorInfo, stride);
     return error == Error::NONE;
 }

 void Gralloc::getTransportSize(const native_handle_t* bufferHandle, uint32_t* outNumFds,
                                uint32_t* outNumInts) {
     auto buffer = const_cast<native_handle_t*>(bufferHandle);

     *outNumFds = 0;
     *outNumInts = 0;
     mMapper->getTransportSize(buffer, [&](const auto& tmpError, const auto& tmpNumFds,
                                           const auto& tmpNumInts) {
         ASSERT_EQ(Error::NONE, tmpError) << "failed to get transport size";
         ASSERT_GE(bufferHandle->numFds, int(tmpNumFds)) << "invalid numFds " << tmpNumFds;
         ASSERT_GE(bufferHandle->numInts, int(tmpNumInts)) << "invalid numInts " << tmpNumInts;

         *outNumFds = tmpNumFds;
         *outNumInts = tmpNumInts;
     });
 }

 bool Gralloc::isSupported(const IMapper::BufferDescriptorInfo& descriptorInfo) {
     bool supported = false;
     mMapper->isSupported(descriptorInfo, [&](const auto& tmpError, const auto& tmpSupported) {
         ASSERT_EQ(Error::NONE, tmpError) << "failed to check is supported";
         supported = tmpSupported;
     });
     return supported;
 }

 bool Gralloc::isSupportedNoFailure(const IMapper::BufferDescriptorInfo& descriptorInfo) {
     bool supported = false;
     mMapper->isSupported(descriptorInfo, [&](const auto& tmpError, const auto& tmpSupported) {
         supported = tmpSupported && tmpError == Error::NONE;
     });
     return supported;
 }

 Error Gralloc::get(const native_handle_t* bufferHandle, const IMapper::MetadataType& metadataType,
                    hidl_vec<uint8_t>* outVec) {
     Error err;
     mMapper->get(const_cast<native_handle_t*>(bufferHandle), metadataType,
                  [&](const auto& tmpError, const hidl_vec<uint8_t>& tmpVec) {
                      err = tmpError;
                      *outVec = tmpVec;
                  });
     return err;
 }

 Error Gralloc::set(const native_handle_t* bufferHandle, const IMapper::MetadataType& metadataType,
                    const hidl_vec<uint8_t>& vec) {
     return mMapper->set(const_cast<native_handle_t*>(bufferHandle), metadataType, vec);
 }

 Error Gralloc::getFromBufferDescriptorInfo(const IMapper::BufferDescriptorInfo& descriptorInfo,
                                            const IMapper::MetadataType& metadataType,
                                            hidl_vec<uint8_t>* outVec) {
     Error err;
     mMapper->getFromBufferDescriptorInfo(
             descriptorInfo, metadataType,
             [&](const auto& tmpError, const hidl_vec<uint8_t>& tmpVec) {
                 err = tmpError;
                 *outVec = tmpVec;
             });
     return err;
 }

 Error Gralloc::getReservedRegion(const native_handle_t* bufferHandle, void** outReservedRegion,
                                  uint64_t* outReservedSize) {
     Error err;
     mMapper->getReservedRegion(
             const_cast<native_handle_t*>(bufferHandle),
             [&](const auto& tmpError, const auto& tmpReservedRegion, const auto& tmpReservedSize) {
                 err = tmpError;
                 *outReservedRegion = tmpReservedRegion;
                 *outReservedSize = tmpReservedSize;
             });
     return err;
 }

 }  // namespace vts
 }  // namespace V4_0
 }  // namespace mapper
 }  // namespace graphics
 }  // namespace hardware
 }  // namespace android
	/*
	* Copyright 2019 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 <aidlcommonsupport/NativeHandle.h>
	#include <android-base/properties.h>
	#include <android/binder_manager.h>
	#include <gralloctypes/Gralloc4.h>
	#include <mapper-vts/4.0/MapperVts.h>

	namespace android {
	namespace hardware {
	namespace graphics {
	namespace mapper {
	namespace V4_0 {
	namespace vts {

	Gralloc::Gralloc(const std::string& aidlAllocatorServiceName,
	const std::string& hidlAllocatorServiceName, const std::string& mapperServiceName,
	bool errOnFailure) {
	if (errOnFailure) {
	init(aidlAllocatorServiceName, hidlAllocatorServiceName, mapperServiceName);
	} else {
	initNoErr(aidlAllocatorServiceName, hidlAllocatorServiceName, mapperServiceName);
	}
	}

	void Gralloc::init(const std::string& aidlAllocatorServiceName,
	const std::string& hidlAllocatorServiceName,
	const std::string& mapperServiceName) {
	mAidlAllocator = aidl::android::hardware::graphics::allocator::IAllocator::fromBinder(
	ndk::SpAIBinder(AServiceManager_checkService(aidlAllocatorServiceName.c_str())));

	if (mAidlAllocator == nullptr) {
	mHidlAllocator = IAllocator::getService(hidlAllocatorServiceName);
	}
	ASSERT_TRUE(nullptr != mAidlAllocator \|\| mHidlAllocator != nullptr)
	<< "failed to get allocator service";

	mMapper = IMapper::getService(mapperServiceName);
	ASSERT_NE(nullptr, mMapper.get()) << "failed to get mapper service";
	ASSERT_FALSE(mMapper->isRemote()) << "mapper is not in passthrough mode";
	}

	void Gralloc::initNoErr(const std::string& aidlAllocatorServiceName,
	const std::string& hidlAllocatorServiceName,
	const std::string& mapperServiceName) {
	mAidlAllocator = aidl::android::hardware::graphics::allocator::IAllocator::fromBinder(
	ndk::SpAIBinder(AServiceManager_checkService(aidlAllocatorServiceName.c_str())));

	if (mAidlAllocator == nullptr) {
	mHidlAllocator = IAllocator::getService(hidlAllocatorServiceName);
	}

	mMapper = IMapper::getService(mapperServiceName);
	if (mMapper.get()) {
	ASSERT_FALSE(mMapper->isRemote()) << "mapper is not in passthrough mode";
	}
	}

	Gralloc::~Gralloc() {
	for (auto bufferHandle : mClonedBuffers) {
	auto buffer = const_cast<native_handle_t*>(bufferHandle);
	native_handle_close(buffer);
	native_handle_delete(buffer);
	}
	mClonedBuffers.clear();

	for (auto bufferHandle : mImportedBuffers) {
	auto buffer = const_cast<native_handle_t*>(bufferHandle);
	EXPECT_EQ(Error::NONE, mMapper->freeBuffer(buffer)) << "failed to free buffer " << buffer;
	}
	mImportedBuffers.clear();
	}

	const native_handle_t* Gralloc::cloneBuffer(const hidl_handle& rawHandle,
	enum Tolerance /tolerance/) {
	const native_handle_t* bufferHandle = native_handle_clone(rawHandle.getNativeHandle());
	EXPECT_NE(nullptr, bufferHandle);

	if (bufferHandle) {
	mClonedBuffers.insert(bufferHandle);
	}

	return bufferHandle;
	}

	std::vector<const native_handle_t*> Gralloc::allocate(const BufferDescriptor& descriptor,
	uint32_t count, bool import,
	enum Tolerance tolerance,
	uint32_t* outStride) {
	std::vector<const native_handle_t*> bufferHandles;
	bufferHandles.reserve(count);

	auto callback = [&](Error error, uint32_t stride,
	const hidl_vec<hidl_handle>& buffers) -> void {
	if (canTolerate(tolerance, error)) {
	return;
	}

	if (error != Error::NONE) {
	GTEST_FAIL() << "failed to allocate buffers";
	}
	ASSERT_EQ(count, buffers.size()) << "invalid buffer array";

	for (uint32_t i = 0; i < count; i++) {
	const native_handle_t* bufferHandle = nullptr;
	if (import) {
	ASSERT_NO_FATAL_FAILURE(bufferHandle = importBuffer(buffers[i], tolerance));
	} else {
	ASSERT_NO_FATAL_FAILURE(bufferHandle = cloneBuffer(buffers[i], tolerance));
	}
	if (bufferHandle) {
	bufferHandles.push_back(bufferHandle);
	}
	}

	if (outStride) {
	*outStride = stride;
	}
	};

	rawAllocate(descriptor, count, callback);

	if (::testing::Test::HasFatalFailure()) {
	bufferHandles.clear();
	}

	return bufferHandles;
	}

	const native_handle_t* Gralloc::allocate(const IMapper::BufferDescriptorInfo& descriptorInfo,
	bool import, enum Tolerance tolerance,
	uint32_t* outStride) {
	BufferDescriptor descriptor = createDescriptor(descriptorInfo);
	if (::testing::Test::HasFatalFailure()) {
	return nullptr;
	}

	auto buffers = allocate(descriptor, 1, import, tolerance, outStride);
	if (::testing::Test::HasFatalFailure() \|\| ::testing::Test::IsSkipped() \|\| buffers.size() != 1) {
	return nullptr;
	}
	return buffers[0];
	}

	void Gralloc::rawAllocate(
	const BufferDescriptor& descriptor, uint32_t count,
	std::function<void(Error, uint32_t, const hidl_vec<hidl_handle>&)> callback) {
	if (mAidlAllocator) {
	aidl::android::hardware::graphics::allocator::AllocationResult result;
	auto status = mAidlAllocator->allocate(descriptor, count, &result);
	const Error error = toHidlError(status);
	std::vector<hidl_handle> handles;
	for (const auto& aidlHandle : result.buffers) {
	handles.push_back(hidl_handle(makeFromAidl(aidlHandle)));
	}
	callback(error, result.stride, handles);
	} else {
	mHidlAllocator->allocate(descriptor, count, callback);
	}
	}

	sp<IMapper> Gralloc::getMapper() const {
	return mMapper;
	}

	BufferDescriptor Gralloc::createDescriptor(const IMapper::BufferDescriptorInfo& descriptorInfo) {
	BufferDescriptor descriptor;
	mMapper->createDescriptor(descriptorInfo, [&](const auto& tmpError, const auto& tmpDescriptor) {
	ASSERT_EQ(Error::NONE, tmpError) << "failed to create descriptor";
	descriptor = tmpDescriptor;
	});

	return descriptor;
	}

	const native_handle_t* Gralloc::importBuffer(const hidl_handle& rawHandle,
	enum Tolerance tolerance) {
	const native_handle_t* bufferHandle = nullptr;
	mMapper->importBuffer(rawHandle, [&](const auto& tmpError, const auto& tmpBuffer) {
	if (!canTolerate(tolerance, tmpError)) {
	ASSERT_EQ(Error::NONE, tmpError)
	<< "failed to import buffer %p" << rawHandle.getNativeHandle();
	}
	bufferHandle = static_cast<const native_handle_t*>(tmpBuffer);
	});

	if (bufferHandle) {
	mImportedBuffers.insert(bufferHandle);
	}

	return bufferHandle;
	}

	void Gralloc::freeBuffer(const native_handle_t* bufferHandle) {
	if (bufferHandle == nullptr) {
	return;
	}

	auto buffer = const_cast<native_handle_t*>(bufferHandle);

	if (mImportedBuffers.erase(bufferHandle)) {
	Error error = mMapper->freeBuffer(buffer);
	ASSERT_EQ(Error::NONE, error) << "failed to free buffer " << buffer;
	} else {
	mClonedBuffers.erase(bufferHandle);
	native_handle_close(buffer);
	native_handle_delete(buffer);
	}
	}

	void* Gralloc::lock(const native_handle_t* bufferHandle, uint64_t cpuUsage,
	const IMapper::Rect& accessRegion, int acquireFence) {
	auto buffer = const_cast<native_handle_t*>(bufferHandle);

	NATIVE_HANDLE_DECLARE_STORAGE(acquireFenceStorage, 1, 0);
	hidl_handle acquireFenceHandle;
	if (acquireFence >= 0) {
	auto h = native_handle_init(acquireFenceStorage, 1, 0);
	h->data[0] = acquireFence;
	acquireFenceHandle = h;
	}

	void* data = nullptr;
	mMapper->lock(buffer, cpuUsage, accessRegion, acquireFenceHandle,
	[&](const auto& tmpError, const auto& tmpData) {
	ASSERT_EQ(Error::NONE, tmpError) << "failed to lock buffer " << buffer;
	data = tmpData;
	});

	if (acquireFence >= 0) {
	close(acquireFence);
	}

	return data;
	}

	int Gralloc::unlock(const native_handle_t* bufferHandle) {
	auto buffer = const_cast<native_handle_t*>(bufferHandle);

	int releaseFence = -1;
	mMapper->unlock(buffer, [&](const auto& tmpError, const auto& tmpReleaseFence) {
	ASSERT_EQ(Error::NONE, tmpError) << "failed to unlock buffer " << buffer;

	auto fenceHandle = tmpReleaseFence.getNativeHandle();
	if (fenceHandle) {
	ASSERT_EQ(0, fenceHandle->numInts) << "invalid fence handle " << fenceHandle;
	if (fenceHandle->numFds == 1) {
	releaseFence = dup(fenceHandle->data[0]);
	ASSERT_LT(0, releaseFence) << "failed to dup fence fd";
	} else {
	ASSERT_EQ(0, fenceHandle->numFds) << " invalid fence handle " << fenceHandle;
	}
	}
	});

	return releaseFence;
	}

	int Gralloc::flushLockedBuffer(const native_handle_t* bufferHandle) {
	auto buffer = const_cast<native_handle_t*>(bufferHandle);

	int releaseFence = -1;
	mMapper->flushLockedBuffer(buffer, [&](const auto& tmpError, const auto& tmpReleaseFence) {
	ASSERT_EQ(Error::NONE, tmpError) << "failed to flush locked buffer " << buffer;

	auto fenceHandle = tmpReleaseFence.getNativeHandle();
	if (fenceHandle) {
	ASSERT_EQ(0, fenceHandle->numInts) << "invalid fence handle " << fenceHandle;
	if (fenceHandle->numFds == 1) {
	releaseFence = dup(fenceHandle->data[0]);
	ASSERT_LT(0, releaseFence) << "failed to dup fence fd";
	} else {
	ASSERT_EQ(0, fenceHandle->numFds) << " invalid fence handle " << fenceHandle;
	}
	}
	});

	return releaseFence;
	}

	void Gralloc::rereadLockedBuffer(const native_handle_t* bufferHandle) {
	auto buffer = const_cast<native_handle_t*>(bufferHandle);

	ASSERT_EQ(Error::NONE, mMapper->rereadLockedBuffer(buffer));
	}

	bool Gralloc::validateBufferSize(const native_handle_t* bufferHandle,
	const IMapper::BufferDescriptorInfo& descriptorInfo,
	uint32_t stride) {
	auto buffer = const_cast<native_handle_t*>(bufferHandle);

	Error error = mMapper->validateBufferSize(buffer, descriptorInfo, stride);
	return error == Error::NONE;
	}

	void Gralloc::getTransportSize(const native_handle_t* bufferHandle, uint32_t* outNumFds,
	uint32_t* outNumInts) {
	auto buffer = const_cast<native_handle_t*>(bufferHandle);

	*outNumFds = 0;
	*outNumInts = 0;
	mMapper->getTransportSize(buffer, [&](const auto& tmpError, const auto& tmpNumFds,
	const auto& tmpNumInts) {
	ASSERT_EQ(Error::NONE, tmpError) << "failed to get transport size";
	ASSERT_GE(bufferHandle->numFds, int(tmpNumFds)) << "invalid numFds " << tmpNumFds;
	ASSERT_GE(bufferHandle->numInts, int(tmpNumInts)) << "invalid numInts " << tmpNumInts;

	*outNumFds = tmpNumFds;
	*outNumInts = tmpNumInts;
	});
	}

	bool Gralloc::isSupported(const IMapper::BufferDescriptorInfo& descriptorInfo) {
	bool supported = false;
	mMapper->isSupported(descriptorInfo, [&](const auto& tmpError, const auto& tmpSupported) {
	ASSERT_EQ(Error::NONE, tmpError) << "failed to check is supported";
	supported = tmpSupported;
	});
	return supported;
	}

	bool Gralloc::isSupportedNoFailure(const IMapper::BufferDescriptorInfo& descriptorInfo) {
	bool supported = false;
	mMapper->isSupported(descriptorInfo, [&](const auto& tmpError, const auto& tmpSupported) {
	supported = tmpSupported && tmpError == Error::NONE;
	});
	return supported;
	}

	Error Gralloc::get(const native_handle_t* bufferHandle, const IMapper::MetadataType& metadataType,
	hidl_vec<uint8_t>* outVec) {
	Error err;
	mMapper->get(const_cast<native_handle_t*>(bufferHandle), metadataType,
	[&](const auto& tmpError, const hidl_vec<uint8_t>& tmpVec) {
	err = tmpError;
	*outVec = tmpVec;
	});
	return err;
	}

	Error Gralloc::set(const native_handle_t* bufferHandle, const IMapper::MetadataType& metadataType,
	const hidl_vec<uint8_t>& vec) {
	return mMapper->set(const_cast<native_handle_t*>(bufferHandle), metadataType, vec);
	}

	Error Gralloc::getFromBufferDescriptorInfo(const IMapper::BufferDescriptorInfo& descriptorInfo,
	const IMapper::MetadataType& metadataType,
	hidl_vec<uint8_t>* outVec) {
	Error err;
	mMapper->getFromBufferDescriptorInfo(
	descriptorInfo, metadataType,
	[&](const auto& tmpError, const hidl_vec<uint8_t>& tmpVec) {
	err = tmpError;
	*outVec = tmpVec;
	});
	return err;
	}

	Error Gralloc::getReservedRegion(const native_handle_t* bufferHandle, void** outReservedRegion,
	uint64_t* outReservedSize) {
	Error err;
	mMapper->getReservedRegion(
	const_cast<native_handle_t*>(bufferHandle),
	[&](const auto& tmpError, const auto& tmpReservedRegion, const auto& tmpReservedSize) {
	err = tmpError;
	*outReservedRegion = tmpReservedRegion;
	*outReservedSize = tmpReservedSize;
	});
	return err;
	}

	} // namespace vts
	} // namespace V4_0
	} // namespace mapper
	} // namespace graphics
	} // namespace hardware
	} // namespace android