media/audioaidlconversion/include/media/AidlConversionUtil-impl.h - third_party/android/platform/frameworks/av - Git at Google

 /*
  * Copyright (C) 2023 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.
  */

 // WARNING: This file is intended for multiple inclusion, one time
 // with BACKEND_NDK_IMPL defined, one time without it.
 // Do not include directly, use 'AidlConversionUtil.h'.
 #if (defined(BACKEND_NDK_IMPL) && !defined(AUDIO_AIDL_CONVERSION_AIDL_CONVERSION_UTIL_NDK)) || \
     (!defined(BACKEND_NDK_IMPL) && !defined(AUDIO_AIDL_CONVERSION_AIDL_CONVERSION_UTIL_CPP))
 #if defined(BACKEND_NDK_IMPL)
 #define AUDIO_AIDL_CONVERSION_AIDL_CONVERSION_UTIL_NDK
 #else
 #define AUDIO_AIDL_CONVERSION_AIDL_CONVERSION_UTIL_CPP
 #endif  // BACKEND_NDK_IMPL

 #include <limits>
 #include <type_traits>
 #include <utility>

 #include <android-base/expected.h>
 #include <binder/Status.h>

 #if defined(BACKEND_NDK_IMPL)
 #include <android/binder_auto_utils.h>
 #include <android/binder_enums.h>
 #include <android/binder_status.h>

 namespace aidl {
 #else
 #include <binder/Enums.h>
 #endif  // BACKEND_NDK_IMPL
 namespace android {

 #if defined(BACKEND_NDK_IMPL)
 // This adds `::aidl::android::ConversionResult` for convenience.
 // Otherwise, it would be required to write `::android::ConversionResult` everywhere.
 template <typename T>
 using ConversionResult = ::android::ConversionResult<T>;
 #endif  // BACKEND_NDK_IMPL

 /**
  * A generic template to safely cast between integral types, respecting limits of the destination
  * type.
  */
 template<typename To, typename From>
 ConversionResult<To> convertIntegral(From from) {
     // Special handling is required for signed / vs. unsigned comparisons, since otherwise we may
     // have the signed converted to unsigned and produce wrong results.
     if constexpr (std::is_signed_v<From> && !std::is_signed_v<To>) {
         if (from < 0 || from > std::numeric_limits<To>::max()) {
             return ::android::base::unexpected(::android::BAD_VALUE);
         }
     } else if constexpr (std::is_signed_v<To> && !std::is_signed_v<From>) {
         if (from > std::numeric_limits<To>::max()) {
             return ::android::base::unexpected(::android::BAD_VALUE);
         }
     } else /* constexpr */ {
         if (from < std::numeric_limits<To>::min() || from > std::numeric_limits<To>::max()) {
             return ::android::base::unexpected(::android::BAD_VALUE);
         }
     }
     return static_cast<To>(from);
 }

 /**
  * A generic template to safely cast between types, that are intended to be the same size, but
  * interpreted differently.
  */
 template<typename To, typename From>
 ConversionResult<To> convertReinterpret(From from) {
     static_assert(sizeof(From) == sizeof(To));
     return static_cast<To>(from);
 }

 /**
  * A generic template that helps convert containers of convertible types, using iterators.
  */
 template<typename InputIterator, typename OutputIterator, typename Func>
 ::android::status_t convertRange(InputIterator start,
                       InputIterator end,
                       OutputIterator out,
                       const Func& itemConversion) {
     for (InputIterator iter = start; iter != end; ++iter, ++out) {
         *out = VALUE_OR_RETURN_STATUS(itemConversion(*iter));
     }
     return ::android::OK;
 }

 /**
  * A generic template that helps convert containers of convertible types, using iterators.
  * Uses a limit as maximum conversion items.
  */
 template<typename InputIterator, typename OutputIterator, typename Func>
 ::android::status_t convertRangeWithLimit(InputIterator start,
                       InputIterator end,
                       OutputIterator out,
                       const Func& itemConversion,
                       const size_t limit) {
     InputIterator last = end;
     if (end - start > limit) {
         last = start + limit;
     }
     for (InputIterator iter = start; (iter != last); ++iter, ++out) {
         *out = VALUE_OR_RETURN_STATUS(itemConversion(*iter));
     }
     return ::android::OK;
 }

 /**
  * A generic template that helps convert containers of convertible types without
  * using an intermediate container.
  */
 template<typename InputContainer, typename OutputContainer, typename Func>
 ::android::status_t convertContainer(const InputContainer& input, OutputContainer* output,
         const Func& itemConversion) {
     auto ins = std::inserter(*output, output->begin());
     for (const auto& item : input) {
         *ins = VALUE_OR_RETURN_STATUS(itemConversion(item));
     }
     return ::android::OK;
 }

 /**
  * A generic template that helps convert containers of convertible types.
  */
 template<typename OutputContainer, typename InputContainer, typename Func>
 ConversionResult<OutputContainer>
 convertContainer(const InputContainer& input, const Func& itemConversion) {
     OutputContainer output;
     auto ins = std::inserter(output, output.begin());
     for (const auto& item : input) {
         *ins = VALUE_OR_RETURN(itemConversion(item));
     }
     return output;
 }

 /**
  * A generic template that helps convert containers of convertible types
  * using an item conversion function with an additional parameter.
  */
 template<typename OutputContainer, typename InputContainer, typename Func, typename Parameter>
 ConversionResult<OutputContainer>
 convertContainer(const InputContainer& input, const Func& itemConversion, const Parameter& param) {
     OutputContainer output;
     auto ins = std::inserter(output, output.begin());
     for (const auto& item : input) {
         *ins = VALUE_OR_RETURN(itemConversion(item, param));
     }
     return output;
 }

 /**
  * A generic template that helps to "zip" two input containers of the same size
  * into a single vector of converted types. The conversion function must
  * thus accept two arguments.
  */
 template<typename OutputContainer, typename InputContainer1,
         typename InputContainer2, typename Func>
 ConversionResult<OutputContainer>
 convertContainers(const InputContainer1& input1, const InputContainer2& input2,
         const Func& itemConversion) {
     auto iter2 = input2.begin();
     OutputContainer output;
     auto ins = std::inserter(output, output.begin());
     for (const auto& item1 : input1) {
         RETURN_IF_ERROR(iter2 != input2.end() ? ::android::OK : ::android::BAD_VALUE);
         *ins = VALUE_OR_RETURN(itemConversion(item1, *iter2++));
     }
     return output;
 }

 /**
  * A generic template that helps to "unzip" a per-element conversion into
  * a pair of elements into a pair of containers. The conversion function
  * must emit a pair of elements.
  */
 template<typename OutputContainer1, typename OutputContainer2,
         typename InputContainer, typename Func>
 ConversionResult<std::pair<OutputContainer1, OutputContainer2>>
 convertContainerSplit(const InputContainer& input, const Func& itemConversion) {
     OutputContainer1 output1;
     OutputContainer2 output2;
     auto ins1 = std::inserter(output1, output1.begin());
     auto ins2 = std::inserter(output2, output2.begin());
     for (const auto& item : input) {
         auto out_pair = VALUE_OR_RETURN(itemConversion(item));
         *ins1 = out_pair.first;
         *ins2 = out_pair.second;
     }
     return std::make_pair(output1, output2);
 }

 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // The code below establishes:
 // IntegralTypeOf<T>, which works for either integral types (in which case it evaluates to T), or
 // enum types (in which case it evaluates to std::underlying_type_T<T>).

 template<typename T, typename = std::enable_if_t<std::is_integral_v<T> || std::is_enum_v<T>>>
 struct IntegralTypeOfStruct {
     using Type = T;
 };

 template<typename T>
 struct IntegralTypeOfStruct<T, std::enable_if_t<std::is_enum_v<T>>> {
     using Type = std::underlying_type_t<T>;
 };

 template<typename T>
 using IntegralTypeOf = typename IntegralTypeOfStruct<T>::Type;

 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // Utilities for handling bitmasks.
 // Some AIDL enums are specified using bit indices, for example:
 //   `AidlEnum { FOO = 0, BAR = 1, BAZ = 2' }`
 // while corresponding legacy types universally uses actual bitmasks, for example:
 //   `enum legacy_enum_t { LEGACY_FOO = 1 << 0, LEGACY_BAR = 1 << 1, LEGACY_BAZ = 1 << 2 }`
 // There is also the third type used to store the resulting mask, which is combined
 // from individual bits. In AIDL this is typically an int (`int32_t`), in legacy types this
 // is often the enum type itself (although, strictly this is not correct since masks are not
 // declared as part of the enum type). The bit index value always has an integer type.
 //
 // `indexToEnum_index` constructs an instance of the enum from an index,
 // for example `AidlEnum::BAR` from `1`.
 // `indexToEnum_bitmask` produces a corresponding legacy bitmask enum instance,
 // for example, `LEGACY_BAR` (`2`) from `1`.
 // `enumToMask_bitmask` simply casts an enum type to a bitmask type.
 // `enumToMask_index` creates a mask from an enum type which specifies an index.
 //
 // All these functions can be plugged into `convertBitmask`. For example, to implement
 // conversion from `AidlEnum` to `legacy_enum_t`, with a mask stored in `int32_t`,
 // the following call needs to be made:
 //   convertBitmask<legacy_enum_t /*DestMask*/, int32_t /*SrcMask*/,
 //                  legacy_enum_t /*DestEnum*/, AidlEnum /*SrcEnum*/>(
 //     maskField /*int32_t*/, aidl2legacy_AidlEnum_legacy_enum_t /*enumConversion*/,
 //     indexToEnum_index<AidlEnum> /*srcIndexToEnum*/,
 //     enumToMask_bitmask<legacy_enum_t, legacy_enum_t> /*destEnumToMask*/)
 //
 // The only extra function needed is for mapping between corresponding enum values
 // of the AidlEnum and the legacy_enum_t. Note that the mapping is between values
 // of enums, for example, `AidlEnum::BAZ` maps to `LEGACY_BAZ` and vice versa.

 template<typename Enum>
 Enum indexToEnum_index(int index) {
     static_assert(std::is_enum_v<Enum> || std::is_integral_v<Enum>);
     return static_cast<Enum>(index);
 }

 template<typename Enum>
 Enum indexToEnum_bitmask(int index) {
     static_assert(std::is_enum_v<Enum> || std::is_integral_v<Enum>);
     return static_cast<Enum>(1 << index);
 }

 template<typename Mask, typename Enum>
 Mask enumToMask_bitmask(Enum e) {
     static_assert(std::is_enum_v<Enum> || std::is_integral_v<Enum>);
     static_assert(std::is_enum_v<Mask> || std::is_integral_v<Mask>);
     return static_cast<Mask>(e);
 }

 template<typename Mask, typename Enum>
 Mask enumToMask_index(Enum e) {
     static_assert(std::is_enum_v<Enum> || std::is_integral_v<Enum>);
     static_assert(std::is_enum_v<Mask> || std::is_integral_v<Mask>);
     return static_cast<Mask>(static_cast<std::make_unsigned_t<IntegralTypeOf<Mask>>>(1)
             << static_cast<int>(e));
 }

 template<typename DestMask, typename SrcMask, typename DestEnum, typename SrcEnum>
 ConversionResult<DestMask> convertBitmask(
         SrcMask src, const std::function<ConversionResult<DestEnum>(SrcEnum)>& enumConversion,
         const std::function<SrcEnum(int)>& srcIndexToEnum,
         const std::function<DestMask(DestEnum)>& destEnumToMask) {
     using UnsignedDestMask = std::make_unsigned_t<IntegralTypeOf<DestMask>>;
     using UnsignedSrcMask = std::make_unsigned_t<IntegralTypeOf<SrcMask>>;

     UnsignedDestMask dest = static_cast<UnsignedDestMask>(0);
     UnsignedSrcMask usrc = static_cast<UnsignedSrcMask>(src);

     int srcBitIndex = 0;
     while (usrc != 0) {
         if (usrc & 1) {
             SrcEnum srcEnum = srcIndexToEnum(srcBitIndex);
             DestEnum destEnum = VALUE_OR_RETURN(enumConversion(srcEnum));
             DestMask destMask = destEnumToMask(destEnum);
             dest |= destMask;
         }
         ++srcBitIndex;
         usrc >>= 1;
     }
     return static_cast<DestMask>(dest);
 }

 template<typename Mask, typename Enum>
 bool bitmaskIsSet(Mask mask, Enum index) {
     return (mask & enumToMask_index<Mask, Enum>(index)) != 0;
 }

 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // Utilities for working with AIDL unions.
 // UNION_GET(obj, fieldname) returns a ConversionResult<T> containing either the strongly-typed
 //   value of the respective field, or ::android::BAD_VALUE if the union is not set to the requested
 //   field.
 // UNION_SET(obj, fieldname, value) sets the requested field to the given value.

 template<typename T, typename T::Tag tag>
 using UnionFieldType = std::decay_t<decltype(std::declval<T>().template get<tag>())>;

 template<typename T, typename T::Tag tag>
 ConversionResult<UnionFieldType<T, tag>> unionGetField(const T& u) {
     if (u.getTag() != tag) {
         return ::android::base::unexpected(::android::BAD_VALUE);
     }
     return u.template get<tag>();
 }

 #define UNION_GET(u, field) \
     unionGetField<std::decay_t<decltype(u)>, std::decay_t<decltype(u)>::Tag::field>(u)

 #define UNION_SET(u, field, value) \
     (u).set<std::decay_t<decltype(u)>::Tag::field>(value)

 #define UNION_MAKE(u, field, value) u::make<u::Tag::field>(value)

 namespace aidl_utils {

 /**
  * Return true if the value is valid for the AIDL enumeration.
  */
 template <typename T>
 bool isValidEnum(T value) {
 #if defined(BACKEND_NDK_IMPL)
     constexpr ndk::enum_range<T> er{};
 #else
     constexpr ::android::enum_range<T> er{};
 #endif
     return std::find(er.begin(), er.end(), value) != er.end();
 }

 // T is a "container" of enum binder types with a toString().
 template <typename T>
 std::string enumsToString(const T& t) {
     std::string s;
     for (const auto item : t) {
         if (s.empty()) {
             s = toString(item);
         } else {
             s.append("|").append(toString(item));
         }
     }
     return s;
 }

 /**
  * Return the equivalent Android ::android::status_t from a binder exception code.
  *
  * Generally one should use statusTFromBinderStatus() instead.
  *
  * Exception codes can be generated from a remote Java service exception, translate
  * them for use on the Native side.
  *
  * Note: for EX_TRANSACTION_FAILED and EX_SERVICE_SPECIFIC a more detailed error code
  * can be found from transactionError() or serviceSpecificErrorCode().
  */
 static inline ::android::status_t statusTFromExceptionCode(int32_t exceptionCode) {
     using namespace ::android::binder;
     switch (exceptionCode) {
         case Status::EX_NONE:
             return ::android::OK;
         case Status::EX_SECURITY:  // Java SecurityException, rethrows locally in Java
             return ::android::PERMISSION_DENIED;
         case Status::EX_BAD_PARCELABLE:  // Java BadParcelableException, rethrows in Java
         case Status::EX_ILLEGAL_ARGUMENT:  // Java IllegalArgumentException, rethrows in Java
         case Status::EX_NULL_POINTER:  // Java NullPointerException, rethrows in Java
             return ::android::BAD_VALUE;
         case Status::EX_ILLEGAL_STATE:  // Java IllegalStateException, rethrows in Java
         case Status::EX_UNSUPPORTED_OPERATION:  // Java UnsupportedOperationException, rethrows
             return ::android::INVALID_OPERATION;
         case Status::EX_HAS_REPLY_HEADER: // Native strictmode violation
         case Status::EX_PARCELABLE:  // Java bootclass loader (not standard exception), rethrows
         case Status::EX_NETWORK_MAIN_THREAD:  // Java NetworkOnMainThreadException, rethrows
         case Status::EX_TRANSACTION_FAILED: // Native - see error code
         case Status::EX_SERVICE_SPECIFIC:   // Java ServiceSpecificException,
                                             // rethrows in Java with integer error code
             return ::android::UNKNOWN_ERROR;
     }
     return ::android::UNKNOWN_ERROR;
 }

 /**
  * Return the equivalent Android ::android::status_t from a binder status.
  *
  * Used to handle errors from a AIDL method declaration
  *
  * [oneway] void method(type0 param0, ...)
  *
  * or the following (where return_type is not a status_t)
  *
  * return_type method(type0 param0, ...)
  */
 static inline ::android::status_t statusTFromBinderStatus(const ::android::binder::Status &status) {
     return status.isOk() ? ::android::OK // check ::android::OK,
         : status.serviceSpecificErrorCode() // service-side error, not standard Java exception
                                             // (fromServiceSpecificError)
         ?: status.transactionError() // a native binder transaction error (fromStatusT)
         ?: statusTFromExceptionCode(status.exceptionCode()); // a service-side error with a
                                                     // standard Java exception (fromExceptionCode)
 }

 #if defined(BACKEND_NDK_IMPL)
 static inline ::android::status_t statusTFromBinderStatus(const ::ndk::ScopedAStatus &status) {
     // What we want to do is to 'return statusTFromBinderStatus(status.get()->get())'
     // However, since the definition of AStatus is not exposed, we have to do the same
     // via methods of ScopedAStatus:
     return status.isOk() ? ::android::OK // check ::android::OK,
         : status.getServiceSpecificError() // service-side error, not standard Java exception
                                            // (fromServiceSpecificError)
         ?: status.getStatus() // a native binder transaction error (fromStatusT)
         ?: statusTFromExceptionCode(status.getExceptionCode()); // a service-side error with a
                                                      // standard Java exception (fromExceptionCode)
 }

 static inline ::android::status_t statusTFromBinderStatusT(binder_status_t status) {
     return statusTFromBinderStatus(::ndk::ScopedAStatus::fromStatus(status));
 }
 #endif

 /**
  * Return a binder::Status from native service status.
  *
  * This is used for methods not returning an explicit status_t,
  * where Java callers expect an exception, not an integer return value.
  */
 static inline ::android::binder::Status binderStatusFromStatusT(
         ::android::status_t status, const char *optionalMessage = nullptr) {
     const char * const emptyIfNull = optionalMessage == nullptr ? "" : optionalMessage;
     // From binder::Status instructions:
     //  Prefer a generic exception code when possible, then a service specific
     //  code, and finally a ::android::status_t for low level failures or legacy support.
     //  Exception codes and service specific errors map to nicer exceptions for
     //  Java clients.

     using namespace ::android::binder;
     switch (status) {
         case ::android::OK:
             return Status::ok();
         case ::android::PERMISSION_DENIED: // throw SecurityException on Java side
             return Status::fromExceptionCode(Status::EX_SECURITY, emptyIfNull);
         case ::android::BAD_VALUE: // throw IllegalArgumentException on Java side
             return Status::fromExceptionCode(Status::EX_ILLEGAL_ARGUMENT, emptyIfNull);
         case ::android::INVALID_OPERATION: // throw IllegalStateException on Java side
             return Status::fromExceptionCode(Status::EX_ILLEGAL_STATE, emptyIfNull);
     }

     // A service specific error will not show on status.transactionError() so
     // be sure to use statusTFromBinderStatus() for reliable error handling.

     // throw a ServiceSpecificException.
     return Status::fromServiceSpecificError(status, emptyIfNull);
 }

 } // namespace aidl_utils

 }  // namespace android

 #if defined(BACKEND_NDK_IMPL)
 }  // namespace aidl
 #endif

 // (defined(BACKEND_NDK_IMPL) && !defined(AUDIO_AIDL_CONVERSION_AIDL_CONVERSION_UTIL_NDK)) || \
 // (!defined(BACKEND_NDK_IMPL) && !defined(AUDIO_AIDL_CONVERSION_AIDL_CONVERSION_UTIL_CPP))
 #endif
	/*
	* Copyright (C) 2023 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.
	*/

	// WARNING: This file is intended for multiple inclusion, one time
	// with BACKEND_NDK_IMPL defined, one time without it.
	// Do not include directly, use 'AidlConversionUtil.h'.
	#if (defined(BACKEND_NDK_IMPL) && !defined(AUDIO_AIDL_CONVERSION_AIDL_CONVERSION_UTIL_NDK)) \|\| \
	(!defined(BACKEND_NDK_IMPL) && !defined(AUDIO_AIDL_CONVERSION_AIDL_CONVERSION_UTIL_CPP))
	#if defined(BACKEND_NDK_IMPL)
	#define AUDIO_AIDL_CONVERSION_AIDL_CONVERSION_UTIL_NDK
	#else
	#define AUDIO_AIDL_CONVERSION_AIDL_CONVERSION_UTIL_CPP
	#endif // BACKEND_NDK_IMPL

	#include <limits>
	#include <type_traits>
	#include <utility>

	#include <android-base/expected.h>
	#include <binder/Status.h>

	#if defined(BACKEND_NDK_IMPL)
	#include <android/binder_auto_utils.h>
	#include <android/binder_enums.h>
	#include <android/binder_status.h>

	namespace aidl {
	#else
	#include <binder/Enums.h>
	#endif // BACKEND_NDK_IMPL
	namespace android {

	#if defined(BACKEND_NDK_IMPL)
	// This adds `::aidl::android::ConversionResult` for convenience.
	// Otherwise, it would be required to write `::android::ConversionResult` everywhere.
	template <typename T>
	using ConversionResult = ::android::ConversionResult<T>;
	#endif // BACKEND_NDK_IMPL

	/**
	* A generic template to safely cast between integral types, respecting limits of the destination
	* type.
	*/
	template<typename To, typename From>
	ConversionResult<To> convertIntegral(From from) {
	// Special handling is required for signed / vs. unsigned comparisons, since otherwise we may
	// have the signed converted to unsigned and produce wrong results.
	if constexpr (std::is_signed_v<From> && !std::is_signed_v<To>) {
	if (from < 0 \|\| from > std::numeric_limits<To>::max()) {
	return ::android::base::unexpected(::android::BAD_VALUE);
	}
	} else if constexpr (std::is_signed_v<To> && !std::is_signed_v<From>) {
	if (from > std::numeric_limits<To>::max()) {
	return ::android::base::unexpected(::android::BAD_VALUE);
	}
	} else /* constexpr */ {
	if (from < std::numeric_limits<To>::min() \|\| from > std::numeric_limits<To>::max()) {
	return ::android::base::unexpected(::android::BAD_VALUE);
	}
	}
	return static_cast<To>(from);
	}

	/**
	* A generic template to safely cast between types, that are intended to be the same size, but
	* interpreted differently.
	*/
	template<typename To, typename From>
	ConversionResult<To> convertReinterpret(From from) {
	static_assert(sizeof(From) == sizeof(To));
	return static_cast<To>(from);
	}

	/**
	* A generic template that helps convert containers of convertible types, using iterators.
	*/
	template<typename InputIterator, typename OutputIterator, typename Func>
	::android::status_t convertRange(InputIterator start,
	InputIterator end,
	OutputIterator out,
	const Func& itemConversion) {
	for (InputIterator iter = start; iter != end; ++iter, ++out) {
	out = VALUE_OR_RETURN_STATUS(itemConversion(iter));
	}
	return ::android::OK;
	}

	/**
	* A generic template that helps convert containers of convertible types, using iterators.
	* Uses a limit as maximum conversion items.
	*/
	template<typename InputIterator, typename OutputIterator, typename Func>
	::android::status_t convertRangeWithLimit(InputIterator start,
	InputIterator end,
	OutputIterator out,
	const Func& itemConversion,
	const size_t limit) {
	InputIterator last = end;
	if (end - start > limit) {
	last = start + limit;
	}
	for (InputIterator iter = start; (iter != last); ++iter, ++out) {
	out = VALUE_OR_RETURN_STATUS(itemConversion(iter));
	}
	return ::android::OK;
	}

	/**
	* A generic template that helps convert containers of convertible types without
	* using an intermediate container.
	*/
	template<typename InputContainer, typename OutputContainer, typename Func>
	::android::status_t convertContainer(const InputContainer& input, OutputContainer* output,
	const Func& itemConversion) {
	auto ins = std::inserter(*output, output->begin());
	for (const auto& item : input) {
	*ins = VALUE_OR_RETURN_STATUS(itemConversion(item));
	}
	return ::android::OK;
	}

	/**
	* A generic template that helps convert containers of convertible types.
	*/
	template<typename OutputContainer, typename InputContainer, typename Func>
	ConversionResult<OutputContainer>
	convertContainer(const InputContainer& input, const Func& itemConversion) {
	OutputContainer output;
	auto ins = std::inserter(output, output.begin());
	for (const auto& item : input) {
	*ins = VALUE_OR_RETURN(itemConversion(item));
	}
	return output;
	}

	/**
	* A generic template that helps convert containers of convertible types
	* using an item conversion function with an additional parameter.
	*/
	template<typename OutputContainer, typename InputContainer, typename Func, typename Parameter>
	ConversionResult<OutputContainer>
	convertContainer(const InputContainer& input, const Func& itemConversion, const Parameter& param) {
	OutputContainer output;
	auto ins = std::inserter(output, output.begin());
	for (const auto& item : input) {
	*ins = VALUE_OR_RETURN(itemConversion(item, param));
	}
	return output;
	}

	/**
	* A generic template that helps to "zip" two input containers of the same size
	* into a single vector of converted types. The conversion function must
	* thus accept two arguments.
	*/
	template<typename OutputContainer, typename InputContainer1,
	typename InputContainer2, typename Func>
	ConversionResult<OutputContainer>
	convertContainers(const InputContainer1& input1, const InputContainer2& input2,
	const Func& itemConversion) {
	auto iter2 = input2.begin();
	OutputContainer output;
	auto ins = std::inserter(output, output.begin());
	for (const auto& item1 : input1) {
	RETURN_IF_ERROR(iter2 != input2.end() ? ::android::OK : ::android::BAD_VALUE);
	ins = VALUE_OR_RETURN(itemConversion(item1, iter2++));
	}
	return output;
	}

	/**
	* A generic template that helps to "unzip" a per-element conversion into
	* a pair of elements into a pair of containers. The conversion function
	* must emit a pair of elements.
	*/
	template<typename OutputContainer1, typename OutputContainer2,
	typename InputContainer, typename Func>
	ConversionResult<std::pair<OutputContainer1, OutputContainer2>>
	convertContainerSplit(const InputContainer& input, const Func& itemConversion) {
	OutputContainer1 output1;
	OutputContainer2 output2;
	auto ins1 = std::inserter(output1, output1.begin());
	auto ins2 = std::inserter(output2, output2.begin());
	for (const auto& item : input) {
	auto out_pair = VALUE_OR_RETURN(itemConversion(item));
	*ins1 = out_pair.first;
	*ins2 = out_pair.second;
	}
	return std::make_pair(output1, output2);
	}

	////////////////////////////////////////////////////////////////////////////////////////////////////
	// The code below establishes:
	// IntegralTypeOf<T>, which works for either integral types (in which case it evaluates to T), or
	// enum types (in which case it evaluates to std::underlying_type_T<T>).

	template<typename T, typename = std::enable_if_t<std::is_integral_v<T> \|\| std::is_enum_v<T>>>
	struct IntegralTypeOfStruct {
	using Type = T;
	};

	template<typename T>
	struct IntegralTypeOfStruct<T, std::enable_if_t<std::is_enum_v<T>>> {
	using Type = std::underlying_type_t<T>;
	};

	template<typename T>
	using IntegralTypeOf = typename IntegralTypeOfStruct<T>::Type;

	////////////////////////////////////////////////////////////////////////////////////////////////////
	// Utilities for handling bitmasks.
	// Some AIDL enums are specified using bit indices, for example:
	// `AidlEnum { FOO = 0, BAR = 1, BAZ = 2' }`
	// while corresponding legacy types universally uses actual bitmasks, for example:
	// `enum legacy_enum_t { LEGACY_FOO = 1 << 0, LEGACY_BAR = 1 << 1, LEGACY_BAZ = 1 << 2 }`
	// There is also the third type used to store the resulting mask, which is combined
	// from individual bits. In AIDL this is typically an int (`int32_t`), in legacy types this
	// is often the enum type itself (although, strictly this is not correct since masks are not
	// declared as part of the enum type). The bit index value always has an integer type.
	//
	// `indexToEnum_index` constructs an instance of the enum from an index,
	// for example `AidlEnum::BAR` from `1`.
	// `indexToEnum_bitmask` produces a corresponding legacy bitmask enum instance,
	// for example, `LEGACY_BAR` (`2`) from `1`.
	// `enumToMask_bitmask` simply casts an enum type to a bitmask type.
	// `enumToMask_index` creates a mask from an enum type which specifies an index.
	//
	// All these functions can be plugged into `convertBitmask`. For example, to implement
	// conversion from `AidlEnum` to `legacy_enum_t`, with a mask stored in `int32_t`,
	// the following call needs to be made:
	// convertBitmask<legacy_enum_t /DestMask/, int32_t /SrcMask/,
	// legacy_enum_t /DestEnum/, AidlEnum /SrcEnum/>(
	// maskField /int32_t/, aidl2legacy_AidlEnum_legacy_enum_t /enumConversion/,
	// indexToEnum_index<AidlEnum> /srcIndexToEnum/,
	// enumToMask_bitmask<legacy_enum_t, legacy_enum_t> /destEnumToMask/)
	//
	// The only extra function needed is for mapping between corresponding enum values
	// of the AidlEnum and the legacy_enum_t. Note that the mapping is between values
	// of enums, for example, `AidlEnum::BAZ` maps to `LEGACY_BAZ` and vice versa.

	template<typename Enum>
	Enum indexToEnum_index(int index) {
	static_assert(std::is_enum_v<Enum> \|\| std::is_integral_v<Enum>);
	return static_cast<Enum>(index);
	}

	template<typename Enum>
	Enum indexToEnum_bitmask(int index) {
	static_assert(std::is_enum_v<Enum> \|\| std::is_integral_v<Enum>);
	return static_cast<Enum>(1 << index);
	}

	template<typename Mask, typename Enum>
	Mask enumToMask_bitmask(Enum e) {
	static_assert(std::is_enum_v<Enum> \|\| std::is_integral_v<Enum>);
	static_assert(std::is_enum_v<Mask> \|\| std::is_integral_v<Mask>);
	return static_cast<Mask>(e);
	}

	template<typename Mask, typename Enum>
	Mask enumToMask_index(Enum e) {
	static_assert(std::is_enum_v<Enum> \|\| std::is_integral_v<Enum>);
	static_assert(std::is_enum_v<Mask> \|\| std::is_integral_v<Mask>);
	return static_cast<Mask>(static_cast<std::make_unsigned_t<IntegralTypeOf<Mask>>>(1)
	<< static_cast<int>(e));
	}

	template<typename DestMask, typename SrcMask, typename DestEnum, typename SrcEnum>
	ConversionResult<DestMask> convertBitmask(
	SrcMask src, const std::function<ConversionResult<DestEnum>(SrcEnum)>& enumConversion,
	const std::function<SrcEnum(int)>& srcIndexToEnum,
	const std::function<DestMask(DestEnum)>& destEnumToMask) {
	using UnsignedDestMask = std::make_unsigned_t<IntegralTypeOf<DestMask>>;
	using UnsignedSrcMask = std::make_unsigned_t<IntegralTypeOf<SrcMask>>;

	UnsignedDestMask dest = static_cast<UnsignedDestMask>(0);
	UnsignedSrcMask usrc = static_cast<UnsignedSrcMask>(src);

	int srcBitIndex = 0;
	while (usrc != 0) {
	if (usrc & 1) {
	SrcEnum srcEnum = srcIndexToEnum(srcBitIndex);
	DestEnum destEnum = VALUE_OR_RETURN(enumConversion(srcEnum));
	DestMask destMask = destEnumToMask(destEnum);
	dest \|= destMask;
	}
	++srcBitIndex;
	usrc >>= 1;
	}
	return static_cast<DestMask>(dest);
	}

	template<typename Mask, typename Enum>
	bool bitmaskIsSet(Mask mask, Enum index) {
	return (mask & enumToMask_index<Mask, Enum>(index)) != 0;
	}

	////////////////////////////////////////////////////////////////////////////////////////////////////
	// Utilities for working with AIDL unions.
	// UNION_GET(obj, fieldname) returns a ConversionResult<T> containing either the strongly-typed
	// value of the respective field, or ::android::BAD_VALUE if the union is not set to the requested
	// field.
	// UNION_SET(obj, fieldname, value) sets the requested field to the given value.

	template<typename T, typename T::Tag tag>
	using UnionFieldType = std::decay_t<decltype(std::declval<T>().template get<tag>())>;

	template<typename T, typename T::Tag tag>
	ConversionResult<UnionFieldType<T, tag>> unionGetField(const T& u) {
	if (u.getTag() != tag) {
	return ::android::base::unexpected(::android::BAD_VALUE);
	}
	return u.template get<tag>();
	}

	#define UNION_GET(u, field) \
	unionGetField<std::decay_t<decltype(u)>, std::decay_t<decltype(u)>::Tag::field>(u)

	#define UNION_SET(u, field, value) \
	(u).set<std::decay_t<decltype(u)>::Tag::field>(value)

	#define UNION_MAKE(u, field, value) u::make<u::Tag::field>(value)

	namespace aidl_utils {

	/**
	* Return true if the value is valid for the AIDL enumeration.
	*/
	template <typename T>
	bool isValidEnum(T value) {
	#if defined(BACKEND_NDK_IMPL)
	constexpr ndk::enum_range<T> er{};
	#else
	constexpr ::android::enum_range<T> er{};
	#endif
	return std::find(er.begin(), er.end(), value) != er.end();
	}

	// T is a "container" of enum binder types with a toString().
	template <typename T>
	std::string enumsToString(const T& t) {
	std::string s;
	for (const auto item : t) {
	if (s.empty()) {
	s = toString(item);
	} else {
	s.append("\|").append(toString(item));
	}
	}
	return s;
	}

	/**
	* Return the equivalent Android ::android::status_t from a binder exception code.
	*
	* Generally one should use statusTFromBinderStatus() instead.
	*
	* Exception codes can be generated from a remote Java service exception, translate
	* them for use on the Native side.
	*
	* Note: for EX_TRANSACTION_FAILED and EX_SERVICE_SPECIFIC a more detailed error code
	* can be found from transactionError() or serviceSpecificErrorCode().
	*/
	static inline ::android::status_t statusTFromExceptionCode(int32_t exceptionCode) {
	using namespace ::android::binder;
	switch (exceptionCode) {
	case Status::EX_NONE:
	return ::android::OK;
	case Status::EX_SECURITY: // Java SecurityException, rethrows locally in Java
	return ::android::PERMISSION_DENIED;
	case Status::EX_BAD_PARCELABLE: // Java BadParcelableException, rethrows in Java
	case Status::EX_ILLEGAL_ARGUMENT: // Java IllegalArgumentException, rethrows in Java
	case Status::EX_NULL_POINTER: // Java NullPointerException, rethrows in Java
	return ::android::BAD_VALUE;
	case Status::EX_ILLEGAL_STATE: // Java IllegalStateException, rethrows in Java
	case Status::EX_UNSUPPORTED_OPERATION: // Java UnsupportedOperationException, rethrows
	return ::android::INVALID_OPERATION;
	case Status::EX_HAS_REPLY_HEADER: // Native strictmode violation
	case Status::EX_PARCELABLE: // Java bootclass loader (not standard exception), rethrows
	case Status::EX_NETWORK_MAIN_THREAD: // Java NetworkOnMainThreadException, rethrows
	case Status::EX_TRANSACTION_FAILED: // Native - see error code
	case Status::EX_SERVICE_SPECIFIC: // Java ServiceSpecificException,
	// rethrows in Java with integer error code
	return ::android::UNKNOWN_ERROR;
	}
	return ::android::UNKNOWN_ERROR;
	}

	/**
	* Return the equivalent Android ::android::status_t from a binder status.
	*
	* Used to handle errors from a AIDL method declaration
	*
	* [oneway] void method(type0 param0, ...)
	*
	* or the following (where return_type is not a status_t)
	*
	* return_type method(type0 param0, ...)
	*/
	static inline ::android::status_t statusTFromBinderStatus(const ::android::binder::Status &status) {
	return status.isOk() ? ::android::OK // check ::android::OK,
	: status.serviceSpecificErrorCode() // service-side error, not standard Java exception
	// (fromServiceSpecificError)
	?: status.transactionError() // a native binder transaction error (fromStatusT)
	?: statusTFromExceptionCode(status.exceptionCode()); // a service-side error with a
	// standard Java exception (fromExceptionCode)
	}

	#if defined(BACKEND_NDK_IMPL)
	static inline ::android::status_t statusTFromBinderStatus(const ::ndk::ScopedAStatus &status) {
	// What we want to do is to 'return statusTFromBinderStatus(status.get()->get())'
	// However, since the definition of AStatus is not exposed, we have to do the same
	// via methods of ScopedAStatus:
	return status.isOk() ? ::android::OK // check ::android::OK,
	: status.getServiceSpecificError() // service-side error, not standard Java exception
	// (fromServiceSpecificError)
	?: status.getStatus() // a native binder transaction error (fromStatusT)
	?: statusTFromExceptionCode(status.getExceptionCode()); // a service-side error with a
	// standard Java exception (fromExceptionCode)
	}

	static inline ::android::status_t statusTFromBinderStatusT(binder_status_t status) {
	return statusTFromBinderStatus(::ndk::ScopedAStatus::fromStatus(status));
	}
	#endif

	/**
	* Return a binder::Status from native service status.
	*
	* This is used for methods not returning an explicit status_t,
	* where Java callers expect an exception, not an integer return value.
	*/
	static inline ::android::binder::Status binderStatusFromStatusT(
	::android::status_t status, const char *optionalMessage = nullptr) {
	const char * const emptyIfNull = optionalMessage == nullptr ? "" : optionalMessage;
	// From binder::Status instructions:
	// Prefer a generic exception code when possible, then a service specific
	// code, and finally a ::android::status_t for low level failures or legacy support.
	// Exception codes and service specific errors map to nicer exceptions for
	// Java clients.

	using namespace ::android::binder;
	switch (status) {
	case ::android::OK:
	return Status::ok();
	case ::android::PERMISSION_DENIED: // throw SecurityException on Java side
	return Status::fromExceptionCode(Status::EX_SECURITY, emptyIfNull);
	case ::android::BAD_VALUE: // throw IllegalArgumentException on Java side
	return Status::fromExceptionCode(Status::EX_ILLEGAL_ARGUMENT, emptyIfNull);
	case ::android::INVALID_OPERATION: // throw IllegalStateException on Java side
	return Status::fromExceptionCode(Status::EX_ILLEGAL_STATE, emptyIfNull);
	}

	// A service specific error will not show on status.transactionError() so
	// be sure to use statusTFromBinderStatus() for reliable error handling.

	// throw a ServiceSpecificException.
	return Status::fromServiceSpecificError(status, emptyIfNull);
	}

	} // namespace aidl_utils

	} // namespace android

	#if defined(BACKEND_NDK_IMPL)
	} // namespace aidl
	#endif

	// (defined(BACKEND_NDK_IMPL) && !defined(AUDIO_AIDL_CONVERSION_AIDL_CONVERSION_UTIL_NDK)) \|\| \
	// (!defined(BACKEND_NDK_IMPL) && !defined(AUDIO_AIDL_CONVERSION_AIDL_CONVERSION_UTIL_CPP))
	#endif