aidl_to_ndk.cpp - platform/system/tools/aidl - Gitiles

 /*
  * Copyright (C) 2018, The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * limitations under the License.
  */

 #include "aidl_to_ndk.h"
 #include "aidl_language.h"
 #include "aidl_to_cpp_common.h"
 #include "logging.h"
 #include "os.h"

 #include <android-base/strings.h>

 #include <functional>

 using ::android::base::Join;

 namespace android {
 namespace aidl {
 namespace ndk {

 std::string NdkHeaderFile(const AidlDefinedType& defined_type, cpp::ClassNames name,
                           bool use_os_sep) {
   char seperator = (use_os_sep) ? OS_PATH_SEPARATOR : '/';
   return std::string("aidl") + seperator + cpp::HeaderFile(defined_type, name, use_os_sep);
 }

 // This represents a type in AIDL (e.g. 'String' which can be referenced in multiple ways)
 struct TypeInfo {
   struct Aspect {
     // name of the type in C++ output
     std::string cpp_name;
     // whether to prefer 'value type' over 'const&'
     bool value_is_cheap;

     std::function<void(const CodeGeneratorContext& c)> read_func;
     std::function<void(const CodeGeneratorContext& c)> write_func;
   };

   // e.g. 'String'
   Aspect raw;

   // e.g. 'String[]'
   std::shared_ptr<Aspect> array;

   // note: Nullable types do not exist in Java. For most Java types, the type is split into a
   // nullable and non-nullable variant. This is because C++ types are more usually non-nullable, but
   // everything in Java is non-nullable. This does mean that some Java interfaces may have to have
   // '@nullable' added to them in order to function as expected w/ the NDK. It also means that some
   // transactions will be allowed in Java which are not allowed in C++. However, in Java, if a null
   // is ignored, it will just result in a NullPointerException and be delivered to the other side.
   // C++ does not have this same capacity (in Android), and so instead, we distinguish nullability
   // in the type system.

   // e.g. '@nullable String'
   std::shared_ptr<Aspect> nullable;

   // e.g. '@nullable String[]'
   std::shared_ptr<Aspect> nullable_array;
 };

 static std::function<void(const CodeGeneratorContext& c)> StandardRead(const std::string& name) {
   return [name](const CodeGeneratorContext& c) {
     c.writer << name << "(" << c.parcel << ", " << c.var << ")";
   };
 }
 static std::function<void(const CodeGeneratorContext& c)> StandardWrite(const std::string& name) {
   return [name](const CodeGeneratorContext& c) {
     c.writer << name << "(" << c.parcel << ", " << c.var << ")";
   };
 }

 TypeInfo PrimitiveType(const std::string& cpp_name, const std::string& pretty_name) {
   return TypeInfo{
       .raw =
           TypeInfo::Aspect{
               .cpp_name = cpp_name,
               .value_is_cheap = true,
               .read_func = StandardRead("AParcel_read" + pretty_name),
               .write_func = StandardWrite("AParcel_write" + pretty_name),
           },
       .array = std::shared_ptr<TypeInfo::Aspect>(new TypeInfo::Aspect{
           .cpp_name = "std::vector<" + cpp_name + ">",
           .value_is_cheap = false,
           .read_func = StandardRead("::ndk::AParcel_readVector"),
           .write_func = StandardWrite("::ndk::AParcel_writeVector"),
       }),
       .nullable = nullptr,
       .nullable_array = std::shared_ptr<TypeInfo::Aspect>(new TypeInfo::Aspect{
           .cpp_name = "std::optional<std::vector<" + cpp_name + ">>",
           .value_is_cheap = false,
           .read_func = StandardRead("::ndk::AParcel_readVector"),
           .write_func = StandardWrite("::ndk::AParcel_writeVector"),
       }),
   };
 }

 TypeInfo InterfaceTypeInfo(const AidlInterface& type) {
   const std::string clazz = NdkFullClassName(type, cpp::ClassNames::INTERFACE);

   return TypeInfo{
       .raw =
           TypeInfo::Aspect{
               .cpp_name = "std::shared_ptr<" + clazz + ">",
               .value_is_cheap = false,
               // TODO(b/111445392): these should be non-null
               .read_func = StandardRead(clazz + "::readFromParcel"),
               .write_func = StandardWrite(clazz + "::writeToParcel"),
           },
       .array = nullptr,
       .nullable = std::shared_ptr<TypeInfo::Aspect>(new TypeInfo::Aspect{
           .cpp_name = "std::shared_ptr<" + clazz + ">",
           .value_is_cheap = false,
           .read_func = StandardRead(clazz + "::readFromParcel"),
           .write_func = StandardWrite(clazz + "::writeToParcel"),
       }),
       .nullable_array = nullptr,
   };
 }

 TypeInfo ParcelableTypeInfo(const AidlParcelable& type) {
   const std::string clazz = NdkFullClassName(type, cpp::ClassNames::BASE);

   return TypeInfo{
       .raw =
           TypeInfo::Aspect{
               .cpp_name = clazz,
               .value_is_cheap = false,
               .read_func =
                   [](const CodeGeneratorContext& c) {
                     c.writer << "(" << c.var << ")->readFromParcel(" << c.parcel << ")";
                   },
               .write_func =
                   [](const CodeGeneratorContext& c) {
                     c.writer << "(" << c.var << ").writeToParcel(" << c.parcel << ")";
                   },
           },
       .array = std::shared_ptr<TypeInfo::Aspect>(new TypeInfo::Aspect{
           .cpp_name = "std::vector<" + clazz + ">",
           .value_is_cheap = false,
           .read_func = StandardRead("::ndk::AParcel_readVector"),
           .write_func = StandardWrite("::ndk::AParcel_writeVector"),
       }),
       .nullable = nullptr,
       .nullable_array = nullptr,
   };
 }

 // map from AIDL built-in type name to the corresponding Ndk type name
 static map<std::string, TypeInfo> kNdkTypeInfoMap = {
     {"void", TypeInfo{{"void", true, nullptr, nullptr}, nullptr, nullptr, nullptr}},
     {"boolean", PrimitiveType("bool", "Bool")},
     {"byte", PrimitiveType("int8_t", "Byte")},
     {"char", PrimitiveType("char16_t", "Char")},
     {"int", PrimitiveType("int32_t", "Int32")},
     {"long", PrimitiveType("int64_t", "Int64")},
     {"float", PrimitiveType("float", "Float")},
     {"double", PrimitiveType("double", "Double")},
     {"String",
      TypeInfo{
          .raw =
              TypeInfo::Aspect{
                  .cpp_name = "std::string",
                  .value_is_cheap = false,
                  .read_func = StandardRead("::ndk::AParcel_readString"),
                  .write_func = StandardWrite("::ndk::AParcel_writeString"),
              },
          .array = std::shared_ptr<TypeInfo::Aspect>(new TypeInfo::Aspect{
              .cpp_name = "std::vector<std::string>",
              .value_is_cheap = false,
              .read_func = StandardRead("::ndk::AParcel_readVector"),
              .write_func = StandardWrite("::ndk::AParcel_writeVector"),
          }),
          .nullable = std::shared_ptr<TypeInfo::Aspect>(new TypeInfo::Aspect{
              .cpp_name = "std::optional<std::string>",
              .value_is_cheap = false,
              .read_func = StandardRead("::ndk::AParcel_readString"),
              .write_func = StandardWrite("::ndk::AParcel_writeString"),
          }),
          .nullable_array = std::shared_ptr<TypeInfo::Aspect>(new TypeInfo::Aspect{
              .cpp_name = "std::optional<std::vector<std::optional<std::string>>>",
              .value_is_cheap = false,
              .read_func = StandardRead("::ndk::AParcel_readVector"),
              .write_func = StandardWrite("::ndk::AParcel_writeVector"),
          }),
      }},
     // TODO(b/111445392) {"List", ""},
     // TODO(b/111445392) {"Map", ""},
     {"IBinder",
      TypeInfo{
          .raw =
              TypeInfo::Aspect{
                  .cpp_name = "::ndk::SpAIBinder",
                  .value_is_cheap = false,
                  .read_func = StandardRead("::ndk::AParcel_readRequiredStrongBinder"),
                  .write_func = StandardRead("::ndk::AParcel_writeRequiredStrongBinder"),
              },
          .array = nullptr,
          .nullable = std::shared_ptr<TypeInfo::Aspect>(new TypeInfo::Aspect{
              .cpp_name = "::ndk::SpAIBinder",
              .value_is_cheap = false,
              .read_func = StandardRead("::ndk::AParcel_readNullableStrongBinder"),
              .write_func = StandardRead("::ndk::AParcel_writeNullableStrongBinder"),
          }),
          .nullable_array = nullptr,
      }},
     // TODO(b/111445392) {"FileDescriptor", ""},
     {"ParcelFileDescriptor",
      TypeInfo{
          .raw =
              TypeInfo::Aspect{
                  .cpp_name = "::ndk::ScopedFileDescriptor",
                  .value_is_cheap = false,
                  .read_func = StandardRead("::ndk::AParcel_readRequiredParcelFileDescriptor"),
                  .write_func = StandardRead("::ndk::AParcel_writeRequiredParcelFileDescriptor"),
              },
          .array = nullptr,
          .nullable = std::shared_ptr<TypeInfo::Aspect>(new TypeInfo::Aspect{
              .cpp_name = "::ndk::ScopedFileDescriptor",
              .value_is_cheap = false,
              .read_func = StandardRead("::ndk::AParcel_readNullableParcelFileDescriptor"),
              .write_func = StandardRead("::ndk::AParcel_writeNullableParcelFileDescriptor"),
          }),
          .nullable_array = nullptr,
      }},
     // TODO(b/111445392) {"CharSequence", ""},
 };

 static TypeInfo::Aspect GetTypeAspect(const AidlTypenames& types, const AidlTypeSpecifier& aidl) {
   CHECK(aidl.IsResolved()) << aidl.ToString();

   const string aidl_name = aidl.GetName();

   // TODO(b/112664205): this is okay for some types
   AIDL_FATAL_IF(aidl.IsGeneric(), aidl) << aidl.ToString();

   TypeInfo info;
   if (AidlTypenames::IsBuiltinTypename(aidl_name)) {
     auto it = kNdkTypeInfoMap.find(aidl_name);
     CHECK(it != kNdkTypeInfoMap.end());
     info = it->second;
   } else {
     const AidlDefinedType* type = types.TryGetDefinedType(aidl_name);
     AIDL_FATAL_IF(type == nullptr, aidl_name) << "Unrecognized type.";

     if (type->AsInterface() != nullptr) {
       info = InterfaceTypeInfo(*type->AsInterface());
     } else if (type->AsParcelable() != nullptr) {
       info = ParcelableTypeInfo(*type->AsParcelable());
     } else {
       AIDL_FATAL(aidl_name) << "Unrecognized type";
     }
   }

   if (aidl.IsArray()) {
     if (aidl.IsNullable()) {
       AIDL_FATAL_IF(info.nullable_array == nullptr, aidl) << "Unsupported type in NDK Backend.";
       return *info.nullable_array;
     }
     AIDL_FATAL_IF(info.array == nullptr, aidl) << "Unsupported type in NDK Backend.";
     return *info.array;
   }

   if (aidl.IsNullable()) {
     AIDL_FATAL_IF(info.nullable == nullptr, aidl) << "Unsupported type in NDK Backend.";
     return *info.nullable;
   }

   return info.raw;
 }

 std::string NdkFullClassName(const AidlDefinedType& type, cpp::ClassNames name) {
   std::vector<std::string> pieces = {"::aidl"};
   std::vector<std::string> package = type.GetSplitPackage();
   pieces.insert(pieces.end(), package.begin(), package.end());
   pieces.push_back(cpp::ClassName(type, name));

   return Join(pieces, "::");
 }

 std::string NdkNameOf(const AidlTypenames& types, const AidlTypeSpecifier& aidl, StorageMode mode) {
   TypeInfo::Aspect aspect = GetTypeAspect(types, aidl);

   switch (mode) {
     case StorageMode::STACK:
       return aspect.cpp_name;
     case StorageMode::ARGUMENT:
       if (aspect.value_is_cheap) {
         return aspect.cpp_name;
       } else {
         return "const " + aspect.cpp_name + "&";
       }
     case StorageMode::OUT_ARGUMENT:
       return aspect.cpp_name + "*";
     default:
       AIDL_FATAL(aidl.GetName()) << "Unrecognized mode type: " << static_cast<int>(mode);
   }
 }

 void WriteToParcelFor(const CodeGeneratorContext& c) {
   TypeInfo::Aspect aspect = GetTypeAspect(c.types, c.type);
   aspect.write_func(c);
 }

 void ReadFromParcelFor(const CodeGeneratorContext& c) {
   TypeInfo::Aspect aspect = GetTypeAspect(c.types, c.type);
   aspect.read_func(c);
 }

 std::string NdkArgList(
     const AidlTypenames& types, const AidlMethod& method,
     std::function<std::string(const std::string& type, const std::string& name, bool isOut)>
         formatter) {
   std::vector<std::string> method_arguments;
   for (const auto& a : method.GetArguments()) {
     StorageMode mode = a->IsOut() ? StorageMode::OUT_ARGUMENT : StorageMode::ARGUMENT;
     std::string type = NdkNameOf(types, a->GetType(), mode);
     std::string name = cpp::BuildVarName(*a);
     method_arguments.emplace_back(formatter(type, name, a->IsOut()));
   }

   if (method.GetType().GetName() != "void") {
     std::string type = NdkNameOf(types, method.GetType(), StorageMode::OUT_ARGUMENT);
     std::string name = "_aidl_return";
     method_arguments.emplace_back(formatter(type, name, true));
   }

   return Join(method_arguments, ", ");
 }

 std::string NdkMethodDecl(const AidlTypenames& types, const AidlMethod& method,
                           const std::string& clazz) {
   std::string class_prefix = clazz.empty() ? "" : (clazz + "::");
   return "::ndk::ScopedAStatus " + class_prefix + method.GetName() + "(" +
          NdkArgList(types, method, FormatArgForDecl) + ")";
 }

 }  // namespace ndk
 }  // namespace aidl
 }  // namespace android
	/*
	* Copyright (C) 2018, The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* limitations under the License.
	*/

	#include "aidl_to_ndk.h"
	#include "aidl_language.h"
	#include "aidl_to_cpp_common.h"
	#include "logging.h"
	#include "os.h"

	#include <android-base/strings.h>

	#include <functional>

	using ::android::base::Join;

	namespace android {
	namespace aidl {
	namespace ndk {

	std::string NdkHeaderFile(const AidlDefinedType& defined_type, cpp::ClassNames name,
	bool use_os_sep) {
	char seperator = (use_os_sep) ? OS_PATH_SEPARATOR : '/';
	return std::string("aidl") + seperator + cpp::HeaderFile(defined_type, name, use_os_sep);
	}

	// This represents a type in AIDL (e.g. 'String' which can be referenced in multiple ways)
	struct TypeInfo {
	struct Aspect {
	// name of the type in C++ output
	std::string cpp_name;
	// whether to prefer 'value type' over 'const&'
	bool value_is_cheap;

	std::function<void(const CodeGeneratorContext& c)> read_func;
	std::function<void(const CodeGeneratorContext& c)> write_func;
	};

	// e.g. 'String'
	Aspect raw;

	// e.g. 'String[]'
	std::shared_ptr<Aspect> array;

	// note: Nullable types do not exist in Java. For most Java types, the type is split into a
	// nullable and non-nullable variant. This is because C++ types are more usually non-nullable, but
	// everything in Java is non-nullable. This does mean that some Java interfaces may have to have
	// '@nullable' added to them in order to function as expected w/ the NDK. It also means that some
	// transactions will be allowed in Java which are not allowed in C++. However, in Java, if a null
	// is ignored, it will just result in a NullPointerException and be delivered to the other side.
	// C++ does not have this same capacity (in Android), and so instead, we distinguish nullability
	// in the type system.

	// e.g. '@nullable String'
	std::shared_ptr<Aspect> nullable;

	// e.g. '@nullable String[]'
	std::shared_ptr<Aspect> nullable_array;
	};

	static std::function<void(const CodeGeneratorContext& c)> StandardRead(const std::string& name) {
	return [name](const CodeGeneratorContext& c) {
	c.writer << name << "(" << c.parcel << ", " << c.var << ")";
	};
	}
	static std::function<void(const CodeGeneratorContext& c)> StandardWrite(const std::string& name) {
	return [name](const CodeGeneratorContext& c) {
	c.writer << name << "(" << c.parcel << ", " << c.var << ")";
	};
	}

	TypeInfo PrimitiveType(const std::string& cpp_name, const std::string& pretty_name) {
	return TypeInfo{
	.raw =
	TypeInfo::Aspect{
	.cpp_name = cpp_name,
	.value_is_cheap = true,
	.read_func = StandardRead("AParcel_read" + pretty_name),
	.write_func = StandardWrite("AParcel_write" + pretty_name),
	},
	.array = std::shared_ptr<TypeInfo::Aspect>(new TypeInfo::Aspect{
	.cpp_name = "std::vector<" + cpp_name + ">",
	.value_is_cheap = false,
	.read_func = StandardRead("::ndk::AParcel_readVector"),
	.write_func = StandardWrite("::ndk::AParcel_writeVector"),
	}),
	.nullable = nullptr,
	.nullable_array = std::shared_ptr<TypeInfo::Aspect>(new TypeInfo::Aspect{
	.cpp_name = "std::optional<std::vector<" + cpp_name + ">>",
	.value_is_cheap = false,
	.read_func = StandardRead("::ndk::AParcel_readVector"),
	.write_func = StandardWrite("::ndk::AParcel_writeVector"),
	}),
	};
	}

	TypeInfo InterfaceTypeInfo(const AidlInterface& type) {
	const std::string clazz = NdkFullClassName(type, cpp::ClassNames::INTERFACE);

	return TypeInfo{
	.raw =
	TypeInfo::Aspect{
	.cpp_name = "std::shared_ptr<" + clazz + ">",
	.value_is_cheap = false,
	// TODO(b/111445392): these should be non-null
	.read_func = StandardRead(clazz + "::readFromParcel"),
	.write_func = StandardWrite(clazz + "::writeToParcel"),
	},
	.array = nullptr,
	.nullable = std::shared_ptr<TypeInfo::Aspect>(new TypeInfo::Aspect{
	.cpp_name = "std::shared_ptr<" + clazz + ">",
	.value_is_cheap = false,
	.read_func = StandardRead(clazz + "::readFromParcel"),
	.write_func = StandardWrite(clazz + "::writeToParcel"),
	}),
	.nullable_array = nullptr,
	};
	}

	TypeInfo ParcelableTypeInfo(const AidlParcelable& type) {
	const std::string clazz = NdkFullClassName(type, cpp::ClassNames::BASE);

	return TypeInfo{
	.raw =
	TypeInfo::Aspect{
	.cpp_name = clazz,
	.value_is_cheap = false,
	.read_func =
	[](const CodeGeneratorContext& c) {
	c.writer << "(" << c.var << ")->readFromParcel(" << c.parcel << ")";
	},
	.write_func =
	[](const CodeGeneratorContext& c) {
	c.writer << "(" << c.var << ").writeToParcel(" << c.parcel << ")";
	},
	},
	.array = std::shared_ptr<TypeInfo::Aspect>(new TypeInfo::Aspect{
	.cpp_name = "std::vector<" + clazz + ">",
	.value_is_cheap = false,
	.read_func = StandardRead("::ndk::AParcel_readVector"),
	.write_func = StandardWrite("::ndk::AParcel_writeVector"),
	}),
	.nullable = nullptr,
	.nullable_array = nullptr,
	};
	}

	// map from AIDL built-in type name to the corresponding Ndk type name
	static map<std::string, TypeInfo> kNdkTypeInfoMap = {
	{"void", TypeInfo{{"void", true, nullptr, nullptr}, nullptr, nullptr, nullptr}},
	{"boolean", PrimitiveType("bool", "Bool")},
	{"byte", PrimitiveType("int8_t", "Byte")},
	{"char", PrimitiveType("char16_t", "Char")},
	{"int", PrimitiveType("int32_t", "Int32")},
	{"long", PrimitiveType("int64_t", "Int64")},
	{"float", PrimitiveType("float", "Float")},
	{"double", PrimitiveType("double", "Double")},
	{"String",
	TypeInfo{
	.raw =
	TypeInfo::Aspect{
	.cpp_name = "std::string",
	.value_is_cheap = false,
	.read_func = StandardRead("::ndk::AParcel_readString"),
	.write_func = StandardWrite("::ndk::AParcel_writeString"),
	},
	.array = std::shared_ptr<TypeInfo::Aspect>(new TypeInfo::Aspect{
	.cpp_name = "std::vector<std::string>",
	.value_is_cheap = false,
	.read_func = StandardRead("::ndk::AParcel_readVector"),
	.write_func = StandardWrite("::ndk::AParcel_writeVector"),
	}),
	.nullable = std::shared_ptr<TypeInfo::Aspect>(new TypeInfo::Aspect{
	.cpp_name = "std::optional<std::string>",
	.value_is_cheap = false,
	.read_func = StandardRead("::ndk::AParcel_readString"),
	.write_func = StandardWrite("::ndk::AParcel_writeString"),
	}),
	.nullable_array = std::shared_ptr<TypeInfo::Aspect>(new TypeInfo::Aspect{
	.cpp_name = "std::optional<std::vector<std::optional<std::string>>>",
	.value_is_cheap = false,
	.read_func = StandardRead("::ndk::AParcel_readVector"),
	.write_func = StandardWrite("::ndk::AParcel_writeVector"),
	}),
	}},
	// TODO(b/111445392) {"List", ""},
	// TODO(b/111445392) {"Map", ""},
	{"IBinder",
	TypeInfo{
	.raw =
	TypeInfo::Aspect{
	.cpp_name = "::ndk::SpAIBinder",
	.value_is_cheap = false,
	.read_func = StandardRead("::ndk::AParcel_readRequiredStrongBinder"),
	.write_func = StandardRead("::ndk::AParcel_writeRequiredStrongBinder"),
	},
	.array = nullptr,
	.nullable = std::shared_ptr<TypeInfo::Aspect>(new TypeInfo::Aspect{
	.cpp_name = "::ndk::SpAIBinder",
	.value_is_cheap = false,
	.read_func = StandardRead("::ndk::AParcel_readNullableStrongBinder"),
	.write_func = StandardRead("::ndk::AParcel_writeNullableStrongBinder"),
	}),
	.nullable_array = nullptr,
	}},
	// TODO(b/111445392) {"FileDescriptor", ""},
	{"ParcelFileDescriptor",
	TypeInfo{
	.raw =
	TypeInfo::Aspect{
	.cpp_name = "::ndk::ScopedFileDescriptor",
	.value_is_cheap = false,
	.read_func = StandardRead("::ndk::AParcel_readRequiredParcelFileDescriptor"),
	.write_func = StandardRead("::ndk::AParcel_writeRequiredParcelFileDescriptor"),
	},
	.array = nullptr,
	.nullable = std::shared_ptr<TypeInfo::Aspect>(new TypeInfo::Aspect{
	.cpp_name = "::ndk::ScopedFileDescriptor",
	.value_is_cheap = false,
	.read_func = StandardRead("::ndk::AParcel_readNullableParcelFileDescriptor"),
	.write_func = StandardRead("::ndk::AParcel_writeNullableParcelFileDescriptor"),
	}),
	.nullable_array = nullptr,
	}},
	// TODO(b/111445392) {"CharSequence", ""},
	};

	static TypeInfo::Aspect GetTypeAspect(const AidlTypenames& types, const AidlTypeSpecifier& aidl) {
	CHECK(aidl.IsResolved()) << aidl.ToString();

	const string aidl_name = aidl.GetName();

	// TODO(b/112664205): this is okay for some types
	AIDL_FATAL_IF(aidl.IsGeneric(), aidl) << aidl.ToString();

	TypeInfo info;
	if (AidlTypenames::IsBuiltinTypename(aidl_name)) {
	auto it = kNdkTypeInfoMap.find(aidl_name);
	CHECK(it != kNdkTypeInfoMap.end());
	info = it->second;
	} else {
	const AidlDefinedType* type = types.TryGetDefinedType(aidl_name);
	AIDL_FATAL_IF(type == nullptr, aidl_name) << "Unrecognized type.";

	if (type->AsInterface() != nullptr) {
	info = InterfaceTypeInfo(*type->AsInterface());
	} else if (type->AsParcelable() != nullptr) {
	info = ParcelableTypeInfo(*type->AsParcelable());
	} else {
	AIDL_FATAL(aidl_name) << "Unrecognized type";
	}
	}

	if (aidl.IsArray()) {
	if (aidl.IsNullable()) {
	AIDL_FATAL_IF(info.nullable_array == nullptr, aidl) << "Unsupported type in NDK Backend.";
	return *info.nullable_array;
	}
	AIDL_FATAL_IF(info.array == nullptr, aidl) << "Unsupported type in NDK Backend.";
	return *info.array;
	}

	if (aidl.IsNullable()) {
	AIDL_FATAL_IF(info.nullable == nullptr, aidl) << "Unsupported type in NDK Backend.";
	return *info.nullable;
	}

	return info.raw;
	}

	std::string NdkFullClassName(const AidlDefinedType& type, cpp::ClassNames name) {
	std::vector<std::string> pieces = {"::aidl"};
	std::vector<std::string> package = type.GetSplitPackage();
	pieces.insert(pieces.end(), package.begin(), package.end());
	pieces.push_back(cpp::ClassName(type, name));

	return Join(pieces, "::");
	}

	std::string NdkNameOf(const AidlTypenames& types, const AidlTypeSpecifier& aidl, StorageMode mode) {
	TypeInfo::Aspect aspect = GetTypeAspect(types, aidl);

	switch (mode) {
	case StorageMode::STACK:
	return aspect.cpp_name;
	case StorageMode::ARGUMENT:
	if (aspect.value_is_cheap) {
	return aspect.cpp_name;
	} else {
	return "const " + aspect.cpp_name + "&";
	}
	case StorageMode::OUT_ARGUMENT:
	return aspect.cpp_name + "*";
	default:
	AIDL_FATAL(aidl.GetName()) << "Unrecognized mode type: " << static_cast<int>(mode);
	}
	}

	void WriteToParcelFor(const CodeGeneratorContext& c) {
	TypeInfo::Aspect aspect = GetTypeAspect(c.types, c.type);
	aspect.write_func(c);
	}

	void ReadFromParcelFor(const CodeGeneratorContext& c) {
	TypeInfo::Aspect aspect = GetTypeAspect(c.types, c.type);
	aspect.read_func(c);
	}

	std::string NdkArgList(
	const AidlTypenames& types, const AidlMethod& method,
	std::function<std::string(const std::string& type, const std::string& name, bool isOut)>
	formatter) {
	std::vector<std::string> method_arguments;
	for (const auto& a : method.GetArguments()) {
	StorageMode mode = a->IsOut() ? StorageMode::OUT_ARGUMENT : StorageMode::ARGUMENT;
	std::string type = NdkNameOf(types, a->GetType(), mode);
	std::string name = cpp::BuildVarName(*a);
	method_arguments.emplace_back(formatter(type, name, a->IsOut()));
	}

	if (method.GetType().GetName() != "void") {
	std::string type = NdkNameOf(types, method.GetType(), StorageMode::OUT_ARGUMENT);
	std::string name = "_aidl_return";
	method_arguments.emplace_back(formatter(type, name, true));
	}

	return Join(method_arguments, ", ");
	}

	std::string NdkMethodDecl(const AidlTypenames& types, const AidlMethod& method,
	const std::string& clazz) {
	std::string class_prefix = clazz.empty() ? "" : (clazz + "::");
	return "::ndk::ScopedAStatus " + class_prefix + method.GetName() + "(" +
	NdkArgList(types, method, FormatArgForDecl) + ")";
	}

	} // namespace ndk
	} // namespace aidl
	} // namespace android