neuralnetworks/utils/adapter/aidl/src/Device.cpp - platform/hardware/interfaces - Git at Google

 /*
  * Copyright (C) 2021 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 "Device.h"

 #include "Adapter.h"
 #include "Buffer.h"
 #include "PreparedModel.h"

 #include <aidl/android/hardware/neuralnetworks/BnDevice.h>
 #include <aidl/android/hardware/neuralnetworks/BufferDesc.h>
 #include <aidl/android/hardware/neuralnetworks/BufferRole.h>
 #include <aidl/android/hardware/neuralnetworks/DeviceBuffer.h>
 #include <aidl/android/hardware/neuralnetworks/DeviceType.h>
 #include <aidl/android/hardware/neuralnetworks/ErrorStatus.h>
 #include <aidl/android/hardware/neuralnetworks/ExecutionPreference.h>
 #include <aidl/android/hardware/neuralnetworks/Extension.h>
 #include <aidl/android/hardware/neuralnetworks/IPreparedModelCallback.h>
 #include <aidl/android/hardware/neuralnetworks/IPreparedModelParcel.h>
 #include <aidl/android/hardware/neuralnetworks/Model.h>
 #include <aidl/android/hardware/neuralnetworks/NumberOfCacheFiles.h>
 #include <aidl/android/hardware/neuralnetworks/Priority.h>
 #include <android-base/logging.h>
 #include <android/binder_auto_utils.h>
 #include <android/binder_interface_utils.h>
 #include <nnapi/IDevice.h>
 #include <nnapi/Result.h>
 #include <nnapi/TypeUtils.h>
 #include <nnapi/Types.h>
 #include <nnapi/hal/aidl/Conversions.h>

 #include <chrono>
 #include <memory>
 #include <string>
 #include <vector>

 namespace aidl::android::hardware::neuralnetworks::adapter {
 namespace {

 template <typename Type>
 auto convertInput(const Type& object) -> decltype(nn::convert(std::declval<Type>())) {
     auto result = nn::convert(object);
     if (!result.has_value()) {
         result.error().code = nn::ErrorStatus::INVALID_ARGUMENT;
     }
     return result;
 }

 nn::Duration makeDuration(int64_t durationNs) {
     return nn::Duration(std::chrono::nanoseconds(durationNs));
 }

 nn::GeneralResult<nn::OptionalTimePoint> makeOptionalTimePoint(int64_t durationNs) {
     if (durationNs < -1) {
         return NN_ERROR(nn::ErrorStatus::INVALID_ARGUMENT) << "Invalid time point " << durationNs;
     }
     return durationNs < 0 ? nn::OptionalTimePoint{} : nn::TimePoint(makeDuration(durationNs));
 }

 nn::GeneralResult<nn::CacheToken> convertCacheToken(const std::vector<uint8_t>& token) {
     nn::CacheToken nnToken;
     if (token.size() != nnToken.size()) {
         return NN_ERROR(nn::ErrorStatus::INVALID_ARGUMENT) << "Invalid token";
     }
     std::copy(token.begin(), token.end(), nnToken.begin());
     return nnToken;
 }

 nn::GeneralResult<nn::SharedPreparedModel> downcast(const IPreparedModelParcel& preparedModel) {
     if (preparedModel.preparedModel == nullptr) {
         return NN_ERROR(nn::ErrorStatus::INVALID_ARGUMENT) << "preparedModel is nullptr";
     }
     if (preparedModel.preparedModel->isRemote()) {
         return NN_ERROR(nn::ErrorStatus::INVALID_ARGUMENT) << "Cannot convert remote models";
     }

     // This static_cast is safe because adapter::PreparedModel is the only class that implements
     // the IPreparedModel interface in the adapter service code.
     const auto* casted = static_cast<const PreparedModel*>(preparedModel.preparedModel.get());
     return casted->getUnderlyingPreparedModel();
 }

 nn::GeneralResult<std::vector<nn::SharedPreparedModel>> downcastAll(
         const std::vector<IPreparedModelParcel>& preparedModels) {
     std::vector<nn::SharedPreparedModel> canonical;
     canonical.reserve(preparedModels.size());
     for (const auto& preparedModel : preparedModels) {
         canonical.push_back(NN_TRY(downcast(preparedModel)));
     }
     return canonical;
 }

 nn::GeneralResult<DeviceBuffer> allocate(const nn::IDevice& device, const BufferDesc& desc,
                                          const std::vector<IPreparedModelParcel>& preparedModels,
                                          const std::vector<BufferRole>& inputRoles,
                                          const std::vector<BufferRole>& outputRoles) {
     auto nnDesc = NN_TRY(convertInput(desc));
     auto nnPreparedModels = NN_TRY(downcastAll(preparedModels));
     auto nnInputRoles = NN_TRY(convertInput(inputRoles));
     auto nnOutputRoles = NN_TRY(convertInput(outputRoles));

     auto buffer = NN_TRY(device.allocate(nnDesc, nnPreparedModels, nnInputRoles, nnOutputRoles));
     CHECK(buffer != nullptr);

     const nn::Request::MemoryDomainToken token = buffer->getToken();
     auto aidlBuffer = ndk::SharedRefBase::make<Buffer>(std::move(buffer));
     return DeviceBuffer{.buffer = std::move(aidlBuffer), .token = static_cast<int32_t>(token)};
 }

 nn::GeneralResult<std::vector<bool>> getSupportedOperations(const nn::IDevice& device,
                                                             const Model& model) {
     const auto nnModel = NN_TRY(convertInput(model));
     return device.getSupportedOperations(nnModel);
 }

 using PrepareModelResult = nn::GeneralResult<nn::SharedPreparedModel>;

 std::shared_ptr<PreparedModel> adaptPreparedModel(nn::SharedPreparedModel preparedModel) {
     if (preparedModel == nullptr) {
         return nullptr;
     }
     return ndk::SharedRefBase::make<PreparedModel>(std::move(preparedModel));
 }

 void notify(IPreparedModelCallback* callback, ErrorStatus status,
             const std::shared_ptr<IPreparedModel>& preparedModel) {
     if (callback != nullptr) {
         const auto ret = callback->notify(status, preparedModel);
         if (!ret.isOk()) {
             LOG(ERROR) << "IPreparedModelCallback::notify failed with " << ret.getDescription();
         }
     }
 }

 void notify(IPreparedModelCallback* callback, PrepareModelResult result) {
     if (!result.has_value()) {
         const auto& [message, status] = result.error();
         LOG(ERROR) << message;
         const auto aidlCode = utils::convert(status).value_or(ErrorStatus::GENERAL_FAILURE);
         notify(callback, aidlCode, nullptr);
     } else {
         auto preparedModel = std::move(result).value();
         auto aidlPreparedModel = adaptPreparedModel(std::move(preparedModel));
         notify(callback, ErrorStatus::NONE, std::move(aidlPreparedModel));
     }
 }

 nn::GeneralResult<void> prepareModel(
         const nn::SharedDevice& device, const Executor& executor, const Model& model,
         ExecutionPreference preference, Priority priority, int64_t deadlineNs,
         const std::vector<ndk::ScopedFileDescriptor>& modelCache,
         const std::vector<ndk::ScopedFileDescriptor>& dataCache, const std::vector<uint8_t>& token,
         const std::vector<TokenValuePair>& hints,
         const std::vector<ExtensionNameAndPrefix>& extensionNameToPrefix,
         const std::shared_ptr<IPreparedModelCallback>& callback) {
     if (callback.get() == nullptr) {
         return NN_ERROR(nn::ErrorStatus::INVALID_ARGUMENT) << "Invalid callback";
     }

     auto nnModel = NN_TRY(convertInput(model));
     const auto nnPreference = NN_TRY(convertInput(preference));
     const auto nnPriority = NN_TRY(convertInput(priority));
     const auto nnDeadline = NN_TRY(makeOptionalTimePoint(deadlineNs));
     auto nnModelCache = NN_TRY(convertInput(modelCache));
     auto nnDataCache = NN_TRY(convertInput(dataCache));
     const auto nnToken = NN_TRY(convertCacheToken(token));
     auto nnHints = NN_TRY(convertInput(hints));
     auto nnExtensionNameToPrefix = NN_TRY(convertInput(extensionNameToPrefix));

     Task task = [device, nnModel = std::move(nnModel), nnPreference, nnPriority, nnDeadline,
                  nnModelCache = std::move(nnModelCache), nnDataCache = std::move(nnDataCache),
                  nnToken, nnHints = std::move(nnHints),
                  nnExtensionNameToPrefix = std::move(nnExtensionNameToPrefix), callback] {
         auto result =
                 device->prepareModel(nnModel, nnPreference, nnPriority, nnDeadline, nnModelCache,
                                      nnDataCache, nnToken, nnHints, nnExtensionNameToPrefix);
         notify(callback.get(), std::move(result));
     };
     executor(std::move(task), nnDeadline);

     return {};
 }

 nn::GeneralResult<void> prepareModelFromCache(
         const nn::SharedDevice& device, const Executor& executor, int64_t deadlineNs,
         const std::vector<ndk::ScopedFileDescriptor>& modelCache,
         const std::vector<ndk::ScopedFileDescriptor>& dataCache, const std::vector<uint8_t>& token,
         const std::shared_ptr<IPreparedModelCallback>& callback) {
     if (callback.get() == nullptr) {
         return NN_ERROR(nn::ErrorStatus::INVALID_ARGUMENT) << "Invalid callback";
     }

     const auto nnDeadline = NN_TRY(makeOptionalTimePoint(deadlineNs));
     auto nnModelCache = NN_TRY(convertInput(modelCache));
     auto nnDataCache = NN_TRY(convertInput(dataCache));
     const auto nnToken = NN_TRY(convertCacheToken(token));

     auto task = [device, nnDeadline, nnModelCache = std::move(nnModelCache),
                  nnDataCache = std::move(nnDataCache), nnToken, callback] {
         auto result = device->prepareModelFromCache(nnDeadline, nnModelCache, nnDataCache, nnToken);
         notify(callback.get(), std::move(result));
     };
     executor(std::move(task), nnDeadline);

     return {};
 }

 }  // namespace

 Device::Device(::android::nn::SharedDevice device, Executor executor)
     : kDevice(std::move(device)), kExecutor(std::move(executor)) {
     CHECK(kDevice != nullptr);
     CHECK(kExecutor != nullptr);
 }

 ndk::ScopedAStatus Device::allocate(const BufferDesc& desc,
                                     const std::vector<IPreparedModelParcel>& preparedModels,
                                     const std::vector<BufferRole>& inputRoles,
                                     const std::vector<BufferRole>& outputRoles,
                                     DeviceBuffer* buffer) {
     auto result = adapter::allocate(*kDevice, desc, preparedModels, inputRoles, outputRoles);
     if (!result.has_value()) {
         const auto& [message, code] = result.error();
         const auto aidlCode = utils::convert(code).value_or(ErrorStatus::GENERAL_FAILURE);
         return ndk::ScopedAStatus::fromServiceSpecificErrorWithMessage(
                 static_cast<int32_t>(aidlCode), message.c_str());
     }
     *buffer = std::move(result).value();
     return ndk::ScopedAStatus::ok();
 }

 ndk::ScopedAStatus Device::getCapabilities(Capabilities* capabilities) {
     *capabilities = utils::convert(kDevice->getCapabilities()).value();
     return ndk::ScopedAStatus::ok();
 }

 ndk::ScopedAStatus Device::getNumberOfCacheFilesNeeded(NumberOfCacheFiles* numberOfCacheFiles) {
     const auto [numModelCache, numDataCache] = kDevice->getNumberOfCacheFilesNeeded();
     *numberOfCacheFiles = NumberOfCacheFiles{.numModelCache = static_cast<int32_t>(numModelCache),
                                              .numDataCache = static_cast<int32_t>(numDataCache)};
     return ndk::ScopedAStatus::ok();
 }

 ndk::ScopedAStatus Device::getSupportedExtensions(std::vector<Extension>* extensions) {
     *extensions = utils::convert(kDevice->getSupportedExtensions()).value();
     return ndk::ScopedAStatus::ok();
 }

 ndk::ScopedAStatus Device::getSupportedOperations(const Model& model,
                                                   std::vector<bool>* supported) {
     auto result = adapter::getSupportedOperations(*kDevice, model);
     if (!result.has_value()) {
         const auto& [message, code] = result.error();
         const auto aidlCode = utils::convert(code).value_or(ErrorStatus::GENERAL_FAILURE);
         return ndk::ScopedAStatus::fromServiceSpecificErrorWithMessage(
                 static_cast<int32_t>(aidlCode), message.c_str());
     }
     *supported = std::move(result).value();
     return ndk::ScopedAStatus::ok();
 }

 ndk::ScopedAStatus Device::getType(DeviceType* deviceType) {
     *deviceType = utils::convert(kDevice->getType()).value();
     return ndk::ScopedAStatus::ok();
 }

 ndk::ScopedAStatus Device::getVersionString(std::string* version) {
     *version = kDevice->getVersionString();
     return ndk::ScopedAStatus::ok();
 }

 ndk::ScopedAStatus Device::prepareModel(const Model& model, ExecutionPreference preference,
                                         Priority priority, int64_t deadlineNs,
                                         const std::vector<ndk::ScopedFileDescriptor>& modelCache,
                                         const std::vector<ndk::ScopedFileDescriptor>& dataCache,
                                         const std::vector<uint8_t>& token,
                                         const std::shared_ptr<IPreparedModelCallback>& callback) {
     const auto result =
             adapter::prepareModel(kDevice, kExecutor, model, preference, priority, deadlineNs,
                                   modelCache, dataCache, token, {}, {}, callback);
     if (!result.has_value()) {
         const auto& [message, code] = result.error();
         const auto aidlCode = utils::convert(code).value_or(ErrorStatus::GENERAL_FAILURE);
         notify(callback.get(), aidlCode, nullptr);
         return ndk::ScopedAStatus::fromServiceSpecificErrorWithMessage(
                 static_cast<int32_t>(aidlCode), message.c_str());
     }
     return ndk::ScopedAStatus::ok();
 }

 ndk::ScopedAStatus Device::prepareModelFromCache(
         int64_t deadlineNs, const std::vector<ndk::ScopedFileDescriptor>& modelCache,
         const std::vector<ndk::ScopedFileDescriptor>& dataCache, const std::vector<uint8_t>& token,
         const std::shared_ptr<IPreparedModelCallback>& callback) {
     const auto result = adapter::prepareModelFromCache(kDevice, kExecutor, deadlineNs, modelCache,
                                                        dataCache, token, callback);
     if (!result.has_value()) {
         const auto& [message, code] = result.error();
         const auto aidlCode = utils::convert(code).value_or(ErrorStatus::GENERAL_FAILURE);
         notify(callback.get(), aidlCode, nullptr);
         return ndk::ScopedAStatus::fromServiceSpecificErrorWithMessage(
                 static_cast<int32_t>(aidlCode), message.c_str());
     }
     return ndk::ScopedAStatus::ok();
 }

 ndk::ScopedAStatus Device::prepareModelWithConfig(
         const Model& model, const PrepareModelConfig& config,
         const std::shared_ptr<IPreparedModelCallback>& callback) {
     const auto result = adapter::prepareModel(
             kDevice, kExecutor, model, config.preference, config.priority, config.deadlineNs,
             config.modelCache, config.dataCache, utils::toVec(config.cacheToken),
             config.compilationHints, config.extensionNameToPrefix, callback);
     if (!result.has_value()) {
         const auto& [message, code] = result.error();
         const auto aidlCode = utils::convert(code).value_or(ErrorStatus::GENERAL_FAILURE);
         notify(callback.get(), aidlCode, nullptr);
         return ndk::ScopedAStatus::fromServiceSpecificErrorWithMessage(
                 static_cast<int32_t>(aidlCode), message.c_str());
     }
     return ndk::ScopedAStatus::ok();
 }

 }  // namespace aidl::android::hardware::neuralnetworks::adapter
	/*
	* Copyright (C) 2021 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 "Device.h"

	#include "Adapter.h"
	#include "Buffer.h"
	#include "PreparedModel.h"

	#include <aidl/android/hardware/neuralnetworks/BnDevice.h>
	#include <aidl/android/hardware/neuralnetworks/BufferDesc.h>
	#include <aidl/android/hardware/neuralnetworks/BufferRole.h>
	#include <aidl/android/hardware/neuralnetworks/DeviceBuffer.h>
	#include <aidl/android/hardware/neuralnetworks/DeviceType.h>
	#include <aidl/android/hardware/neuralnetworks/ErrorStatus.h>
	#include <aidl/android/hardware/neuralnetworks/ExecutionPreference.h>
	#include <aidl/android/hardware/neuralnetworks/Extension.h>
	#include <aidl/android/hardware/neuralnetworks/IPreparedModelCallback.h>
	#include <aidl/android/hardware/neuralnetworks/IPreparedModelParcel.h>
	#include <aidl/android/hardware/neuralnetworks/Model.h>
	#include <aidl/android/hardware/neuralnetworks/NumberOfCacheFiles.h>
	#include <aidl/android/hardware/neuralnetworks/Priority.h>
	#include <android-base/logging.h>
	#include <android/binder_auto_utils.h>
	#include <android/binder_interface_utils.h>
	#include <nnapi/IDevice.h>
	#include <nnapi/Result.h>
	#include <nnapi/TypeUtils.h>
	#include <nnapi/Types.h>
	#include <nnapi/hal/aidl/Conversions.h>

	#include <chrono>
	#include <memory>
	#include <string>
	#include <vector>

	namespace aidl::android::hardware::neuralnetworks::adapter {
	namespace {

	template <typename Type>
	auto convertInput(const Type& object) -> decltype(nn::convert(std::declval<Type>())) {
	auto result = nn::convert(object);
	if (!result.has_value()) {
	result.error().code = nn::ErrorStatus::INVALID_ARGUMENT;
	}
	return result;
	}

	nn::Duration makeDuration(int64_t durationNs) {
	return nn::Duration(std::chrono::nanoseconds(durationNs));
	}

	nn::GeneralResult<nn::OptionalTimePoint> makeOptionalTimePoint(int64_t durationNs) {
	if (durationNs < -1) {
	return NN_ERROR(nn::ErrorStatus::INVALID_ARGUMENT) << "Invalid time point " << durationNs;
	}
	return durationNs < 0 ? nn::OptionalTimePoint{} : nn::TimePoint(makeDuration(durationNs));
	}

	nn::GeneralResult<nn::CacheToken> convertCacheToken(const std::vector<uint8_t>& token) {
	nn::CacheToken nnToken;
	if (token.size() != nnToken.size()) {
	return NN_ERROR(nn::ErrorStatus::INVALID_ARGUMENT) << "Invalid token";
	}
	std::copy(token.begin(), token.end(), nnToken.begin());
	return nnToken;
	}

	nn::GeneralResult<nn::SharedPreparedModel> downcast(const IPreparedModelParcel& preparedModel) {
	if (preparedModel.preparedModel == nullptr) {
	return NN_ERROR(nn::ErrorStatus::INVALID_ARGUMENT) << "preparedModel is nullptr";
	}
	if (preparedModel.preparedModel->isRemote()) {
	return NN_ERROR(nn::ErrorStatus::INVALID_ARGUMENT) << "Cannot convert remote models";
	}

	// This static_cast is safe because adapter::PreparedModel is the only class that implements
	// the IPreparedModel interface in the adapter service code.
	const auto* casted = static_cast<const PreparedModel*>(preparedModel.preparedModel.get());
	return casted->getUnderlyingPreparedModel();
	}

	nn::GeneralResult<std::vector<nn::SharedPreparedModel>> downcastAll(
	const std::vector<IPreparedModelParcel>& preparedModels) {
	std::vector<nn::SharedPreparedModel> canonical;
	canonical.reserve(preparedModels.size());
	for (const auto& preparedModel : preparedModels) {
	canonical.push_back(NN_TRY(downcast(preparedModel)));
	}
	return canonical;
	}

	nn::GeneralResult<DeviceBuffer> allocate(const nn::IDevice& device, const BufferDesc& desc,
	const std::vector<IPreparedModelParcel>& preparedModels,
	const std::vector<BufferRole>& inputRoles,
	const std::vector<BufferRole>& outputRoles) {
	auto nnDesc = NN_TRY(convertInput(desc));
	auto nnPreparedModels = NN_TRY(downcastAll(preparedModels));
	auto nnInputRoles = NN_TRY(convertInput(inputRoles));
	auto nnOutputRoles = NN_TRY(convertInput(outputRoles));

	auto buffer = NN_TRY(device.allocate(nnDesc, nnPreparedModels, nnInputRoles, nnOutputRoles));
	CHECK(buffer != nullptr);

	const nn::Request::MemoryDomainToken token = buffer->getToken();
	auto aidlBuffer = ndk::SharedRefBase::make<Buffer>(std::move(buffer));
	return DeviceBuffer{.buffer = std::move(aidlBuffer), .token = static_cast<int32_t>(token)};
	}

	nn::GeneralResult<std::vector<bool>> getSupportedOperations(const nn::IDevice& device,
	const Model& model) {
	const auto nnModel = NN_TRY(convertInput(model));
	return device.getSupportedOperations(nnModel);
	}

	using PrepareModelResult = nn::GeneralResult<nn::SharedPreparedModel>;

	std::shared_ptr<PreparedModel> adaptPreparedModel(nn::SharedPreparedModel preparedModel) {
	if (preparedModel == nullptr) {
	return nullptr;
	}
	return ndk::SharedRefBase::make<PreparedModel>(std::move(preparedModel));
	}

	void notify(IPreparedModelCallback* callback, ErrorStatus status,
	const std::shared_ptr<IPreparedModel>& preparedModel) {
	if (callback != nullptr) {
	const auto ret = callback->notify(status, preparedModel);
	if (!ret.isOk()) {
	LOG(ERROR) << "IPreparedModelCallback::notify failed with " << ret.getDescription();
	}
	}
	}

	void notify(IPreparedModelCallback* callback, PrepareModelResult result) {
	if (!result.has_value()) {
	const auto& [message, status] = result.error();
	LOG(ERROR) << message;
	const auto aidlCode = utils::convert(status).value_or(ErrorStatus::GENERAL_FAILURE);
	notify(callback, aidlCode, nullptr);
	} else {
	auto preparedModel = std::move(result).value();
	auto aidlPreparedModel = adaptPreparedModel(std::move(preparedModel));
	notify(callback, ErrorStatus::NONE, std::move(aidlPreparedModel));
	}
	}

	nn::GeneralResult<void> prepareModel(
	const nn::SharedDevice& device, const Executor& executor, const Model& model,
	ExecutionPreference preference, Priority priority, int64_t deadlineNs,
	const std::vector<ndk::ScopedFileDescriptor>& modelCache,
	const std::vector<ndk::ScopedFileDescriptor>& dataCache, const std::vector<uint8_t>& token,
	const std::vector<TokenValuePair>& hints,
	const std::vector<ExtensionNameAndPrefix>& extensionNameToPrefix,
	const std::shared_ptr<IPreparedModelCallback>& callback) {
	if (callback.get() == nullptr) {
	return NN_ERROR(nn::ErrorStatus::INVALID_ARGUMENT) << "Invalid callback";
	}

	auto nnModel = NN_TRY(convertInput(model));
	const auto nnPreference = NN_TRY(convertInput(preference));
	const auto nnPriority = NN_TRY(convertInput(priority));
	const auto nnDeadline = NN_TRY(makeOptionalTimePoint(deadlineNs));
	auto nnModelCache = NN_TRY(convertInput(modelCache));
	auto nnDataCache = NN_TRY(convertInput(dataCache));
	const auto nnToken = NN_TRY(convertCacheToken(token));
	auto nnHints = NN_TRY(convertInput(hints));
	auto nnExtensionNameToPrefix = NN_TRY(convertInput(extensionNameToPrefix));

	Task task = [device, nnModel = std::move(nnModel), nnPreference, nnPriority, nnDeadline,
	nnModelCache = std::move(nnModelCache), nnDataCache = std::move(nnDataCache),
	nnToken, nnHints = std::move(nnHints),
	nnExtensionNameToPrefix = std::move(nnExtensionNameToPrefix), callback] {
	auto result =
	device->prepareModel(nnModel, nnPreference, nnPriority, nnDeadline, nnModelCache,
	nnDataCache, nnToken, nnHints, nnExtensionNameToPrefix);
	notify(callback.get(), std::move(result));
	};
	executor(std::move(task), nnDeadline);

	return {};
	}

	nn::GeneralResult<void> prepareModelFromCache(
	const nn::SharedDevice& device, const Executor& executor, int64_t deadlineNs,
	const std::vector<ndk::ScopedFileDescriptor>& modelCache,
	const std::vector<ndk::ScopedFileDescriptor>& dataCache, const std::vector<uint8_t>& token,
	const std::shared_ptr<IPreparedModelCallback>& callback) {
	if (callback.get() == nullptr) {
	return NN_ERROR(nn::ErrorStatus::INVALID_ARGUMENT) << "Invalid callback";
	}

	const auto nnDeadline = NN_TRY(makeOptionalTimePoint(deadlineNs));
	auto nnModelCache = NN_TRY(convertInput(modelCache));
	auto nnDataCache = NN_TRY(convertInput(dataCache));
	const auto nnToken = NN_TRY(convertCacheToken(token));

	auto task = [device, nnDeadline, nnModelCache = std::move(nnModelCache),
	nnDataCache = std::move(nnDataCache), nnToken, callback] {
	auto result = device->prepareModelFromCache(nnDeadline, nnModelCache, nnDataCache, nnToken);
	notify(callback.get(), std::move(result));
	};
	executor(std::move(task), nnDeadline);

	return {};
	}

	} // namespace

	Device::Device(::android::nn::SharedDevice device, Executor executor)
	: kDevice(std::move(device)), kExecutor(std::move(executor)) {
	CHECK(kDevice != nullptr);
	CHECK(kExecutor != nullptr);
	}

	ndk::ScopedAStatus Device::allocate(const BufferDesc& desc,
	const std::vector<IPreparedModelParcel>& preparedModels,
	const std::vector<BufferRole>& inputRoles,
	const std::vector<BufferRole>& outputRoles,
	DeviceBuffer* buffer) {
	auto result = adapter::allocate(*kDevice, desc, preparedModels, inputRoles, outputRoles);
	if (!result.has_value()) {
	const auto& [message, code] = result.error();
	const auto aidlCode = utils::convert(code).value_or(ErrorStatus::GENERAL_FAILURE);
	return ndk::ScopedAStatus::fromServiceSpecificErrorWithMessage(
	static_cast<int32_t>(aidlCode), message.c_str());
	}
	*buffer = std::move(result).value();
	return ndk::ScopedAStatus::ok();
	}

	ndk::ScopedAStatus Device::getCapabilities(Capabilities* capabilities) {
	*capabilities = utils::convert(kDevice->getCapabilities()).value();
	return ndk::ScopedAStatus::ok();
	}

	ndk::ScopedAStatus Device::getNumberOfCacheFilesNeeded(NumberOfCacheFiles* numberOfCacheFiles) {
	const auto [numModelCache, numDataCache] = kDevice->getNumberOfCacheFilesNeeded();
	*numberOfCacheFiles = NumberOfCacheFiles{.numModelCache = static_cast<int32_t>(numModelCache),
	.numDataCache = static_cast<int32_t>(numDataCache)};
	return ndk::ScopedAStatus::ok();
	}

	ndk::ScopedAStatus Device::getSupportedExtensions(std::vector<Extension>* extensions) {
	*extensions = utils::convert(kDevice->getSupportedExtensions()).value();
	return ndk::ScopedAStatus::ok();
	}

	ndk::ScopedAStatus Device::getSupportedOperations(const Model& model,
	std::vector<bool>* supported) {
	auto result = adapter::getSupportedOperations(*kDevice, model);
	if (!result.has_value()) {
	const auto& [message, code] = result.error();
	const auto aidlCode = utils::convert(code).value_or(ErrorStatus::GENERAL_FAILURE);
	return ndk::ScopedAStatus::fromServiceSpecificErrorWithMessage(
	static_cast<int32_t>(aidlCode), message.c_str());
	}
	*supported = std::move(result).value();
	return ndk::ScopedAStatus::ok();
	}

	ndk::ScopedAStatus Device::getType(DeviceType* deviceType) {
	*deviceType = utils::convert(kDevice->getType()).value();
	return ndk::ScopedAStatus::ok();
	}

	ndk::ScopedAStatus Device::getVersionString(std::string* version) {
	*version = kDevice->getVersionString();
	return ndk::ScopedAStatus::ok();
	}

	ndk::ScopedAStatus Device::prepareModel(const Model& model, ExecutionPreference preference,
	Priority priority, int64_t deadlineNs,
	const std::vector<ndk::ScopedFileDescriptor>& modelCache,
	const std::vector<ndk::ScopedFileDescriptor>& dataCache,
	const std::vector<uint8_t>& token,
	const std::shared_ptr<IPreparedModelCallback>& callback) {
	const auto result =
	adapter::prepareModel(kDevice, kExecutor, model, preference, priority, deadlineNs,
	modelCache, dataCache, token, {}, {}, callback);
	if (!result.has_value()) {
	const auto& [message, code] = result.error();
	const auto aidlCode = utils::convert(code).value_or(ErrorStatus::GENERAL_FAILURE);
	notify(callback.get(), aidlCode, nullptr);
	return ndk::ScopedAStatus::fromServiceSpecificErrorWithMessage(
	static_cast<int32_t>(aidlCode), message.c_str());
	}
	return ndk::ScopedAStatus::ok();
	}

	ndk::ScopedAStatus Device::prepareModelFromCache(
	int64_t deadlineNs, const std::vector<ndk::ScopedFileDescriptor>& modelCache,
	const std::vector<ndk::ScopedFileDescriptor>& dataCache, const std::vector<uint8_t>& token,
	const std::shared_ptr<IPreparedModelCallback>& callback) {
	const auto result = adapter::prepareModelFromCache(kDevice, kExecutor, deadlineNs, modelCache,
	dataCache, token, callback);
	if (!result.has_value()) {
	const auto& [message, code] = result.error();
	const auto aidlCode = utils::convert(code).value_or(ErrorStatus::GENERAL_FAILURE);
	notify(callback.get(), aidlCode, nullptr);
	return ndk::ScopedAStatus::fromServiceSpecificErrorWithMessage(
	static_cast<int32_t>(aidlCode), message.c_str());
	}
	return ndk::ScopedAStatus::ok();
	}

	ndk::ScopedAStatus Device::prepareModelWithConfig(
	const Model& model, const PrepareModelConfig& config,
	const std::shared_ptr<IPreparedModelCallback>& callback) {
	const auto result = adapter::prepareModel(
	kDevice, kExecutor, model, config.preference, config.priority, config.deadlineNs,
	config.modelCache, config.dataCache, utils::toVec(config.cacheToken),
	config.compilationHints, config.extensionNameToPrefix, callback);
	if (!result.has_value()) {
	const auto& [message, code] = result.error();
	const auto aidlCode = utils::convert(code).value_or(ErrorStatus::GENERAL_FAILURE);
	notify(callback.get(), aidlCode, nullptr);
	return ndk::ScopedAStatus::fromServiceSpecificErrorWithMessage(
	static_cast<int32_t>(aidlCode), message.c_str());
	}
	return ndk::ScopedAStatus::ok();
	}

	} // namespace aidl::android::hardware::neuralnetworks::adapter