aidl_to_ndk.cpp

/*
 * 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/stringprintf.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;
};

std::string ConstantValueDecorator(const AidlTypeSpecifier& type, const std::string& raw_value) {
  if (type.IsArray()) {
    return raw_value;
  }

  if (type.GetName() == "long" && !type.IsArray()) {
    return raw_value + "L";
  }

  if (auto defined_type = type.GetDefinedType(); defined_type) {
    auto enum_type = defined_type->AsEnumDeclaration();
    AIDL_FATAL_IF(!enum_type, type) << "Invalid type for \"" << raw_value << "\"";
    return NdkFullClassName(*enum_type, cpp::ClassNames::RAW) +
           "::" + raw_value.substr(raw_value.find_last_of('.') + 1);
  }

  return raw_value;
};

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,
                       const std::optional<std::string>& cpp_name_for_array_opt = std::nullopt) {
  std::string cpp_name_for_array = cpp_name_for_array_opt.value_or(cpp_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_for_array + ">",
          .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_for_array + ">>",
          .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,
              .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 AidlTypeSpecifier& typeSpec,
                            const AidlTypenames& types) {
  std::string clazz = NdkFullClassName(type, cpp::ClassNames::RAW);
  std::string template_params = "";
  if (typeSpec.IsGeneric()) {
    std::vector<std::string> type_params;
    for (const auto& parameter : typeSpec.GetTypeParameters()) {
      type_params.push_back(NdkNameOf(types, *parameter, StorageMode::STACK));
    }
    clazz += base::StringPrintf("<%s>", base::Join(type_params, ", ").c_str());
  }
  const std::string nullable = typeSpec.IsHeapNullable() ? "std::unique_ptr" : "std::optional";
  return TypeInfo{
      .raw =
          TypeInfo::Aspect{
              .cpp_name = clazz,
              .value_is_cheap = false,
              .read_func = StandardRead("::ndk::AParcel_readParcelable"),
              .write_func = StandardWrite("::ndk::AParcel_writeParcelable"),
          },
      .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 = std::shared_ptr<TypeInfo::Aspect>(new TypeInfo::Aspect{
          .cpp_name = nullable + "<" + clazz + ">",
          .value_is_cheap = false,
          .read_func = StandardRead("::ndk::AParcel_readNullableParcelable"),
          .write_func = StandardWrite("::ndk::AParcel_writeNullableParcelable"),
      }),
      .nullable_array = nullptr,
  };
}

TypeInfo EnumDeclarationTypeInfo(const AidlEnumDeclaration& enum_decl) {
  const std::string clazz = NdkFullClassName(enum_decl, cpp::ClassNames::RAW);

  static map<std::string, std::string> kAParcelTypeNameMap = {
      {"byte", "Byte"},
      {"int", "Int32"},
      {"long", "Int64"},
  };
  auto aparcel_name_it = kAParcelTypeNameMap.find(enum_decl.GetBackingType().GetName());
  AIDL_FATAL_IF(aparcel_name_it == kAParcelTypeNameMap.end(), enum_decl);
  const std::string aparcel_name = aparcel_name_it->second;

  const std::string backing_type_name =
      NdkNameOf(AidlTypenames(), enum_decl.GetBackingType(), StorageMode::STACK);

  return TypeInfo{
      .raw = TypeInfo::Aspect{
          .cpp_name = clazz,
          .value_is_cheap = true,
          .read_func =
              [aparcel_name, backing_type_name](const CodeGeneratorContext& c) {
                c.writer << "AParcel_read" << aparcel_name << "(" << c.parcel
                         << ", reinterpret_cast<" << backing_type_name << "*>(" << c.var << "))";
              },
          .write_func =
              [aparcel_name, backing_type_name](const CodeGeneratorContext& c) {
                c.writer << "AParcel_write" << aparcel_name << "(" << c.parcel << ", static_cast<"
                         << backing_type_name << ">(" << c.var << "))";
              },
      },
      .array = std::shared_ptr<TypeInfo::Aspect>(new TypeInfo::Aspect{
          .cpp_name = "std::vector<" + clazz + ">",
          .value_is_cheap = false,
          .read_func =
              [aparcel_name, backing_type_name](const CodeGeneratorContext& c) {
                c.writer << "AParcel_read" << aparcel_name << "Array(" << c.parcel
                         << ", static_cast<void*>(" << c.var
                         << "), ndk::AParcel_stdVectorAllocator<" << backing_type_name << ">)";
              },
          .write_func =
              [aparcel_name, backing_type_name](const CodeGeneratorContext& c) {
                c.writer << "AParcel_write" << aparcel_name << "Array(" << c.parcel
                         << ", reinterpret_cast<const " << backing_type_name << "*>(" << c.var
                         << ".data()), " << c.var << ".size())";
              },
      }),
      .nullable = nullptr,
      .nullable_array = std::shared_ptr<TypeInfo::Aspect>(new TypeInfo::Aspect{
          .cpp_name = "std::optional<std::vector<" + clazz + ">>",
          .value_is_cheap = false,
          .read_func =
              [aparcel_name, backing_type_name](const CodeGeneratorContext& c) {
                c.writer << "AParcel_read" << aparcel_name << "Array(" << c.parcel
                         << ", static_cast<void*>(" << c.var
                         << "), ndk::AParcel_nullableStdVectorAllocator<" << backing_type_name
                         << ">)";
              },
          .write_func =
              [aparcel_name, backing_type_name](const CodeGeneratorContext& c) {
                // If the var exists, use writeArray with data() and size().
                // Otherwise, use nullptr and -1.
                c.writer << "AParcel_write" << aparcel_name << "Array(" << c.parcel << ", ("
                         << c.var << " ? reinterpret_cast<const " << backing_type_name << "*>("
                         << c.var << "->data()) : nullptr)"
                         << ", (" << c.var << " ? " << c.var << "->size() : -1))";
              },
      }),
  };
}

// map from AIDL built-in type name to the corresponding Ndk type info
static map<std::string, TypeInfo> kNdkTypeInfoMap = {
    {"void", TypeInfo{{"void", true, nullptr, nullptr}, nullptr, nullptr, nullptr}},
    {"boolean", PrimitiveType("bool", "Bool")},
    {"byte", PrimitiveType("int8_t", "Byte", "uint8_t")},
    {"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/136048684) {"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,
     }},
    {"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 = std::shared_ptr<TypeInfo::Aspect>(new TypeInfo::Aspect{
             .cpp_name = "std::vector<::ndk::ScopedFileDescriptor>",
             .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 = "::ndk::ScopedFileDescriptor",
             .value_is_cheap = false,
             .read_func = StandardRead("::ndk::AParcel_readNullableParcelFileDescriptor"),
             .write_func = StandardRead("::ndk::AParcel_writeNullableParcelFileDescriptor"),
         }),
         .nullable_array = nullptr,
     }},
    {"ParcelableHolder",
     TypeInfo{
         .raw =
             TypeInfo::Aspect{
                 .cpp_name = "::ndk::AParcelableHolder",
                 .value_is_cheap = false,
                 .read_func = StandardRead("::ndk::AParcel_readParcelable"),
                 .write_func = StandardWrite("::ndk::AParcel_writeParcelable"),
             },
         .array = nullptr,
         .nullable = nullptr,
         .nullable_array = nullptr,
     }},
};

static TypeInfo::Aspect GetTypeAspect(const AidlTypenames& types, const AidlTypeSpecifier& aidl) {
  AIDL_FATAL_IF(!aidl.IsResolved(), aidl) << aidl.ToString();
  auto& aidl_name = aidl.GetName();

  TypeInfo info;

  // TODO(b/136048684): For now, List<T> is converted to T[].(Both are using vector<T>)
  if (aidl_name == "List") {
    AIDL_FATAL_IF(!aidl.IsGeneric(), aidl) << "List must be generic type.";
    AIDL_FATAL_IF(aidl.GetTypeParameters().size() != 1, aidl)
        << "List can accept only one type parameter.";
    const auto& type_param = aidl.GetTypeParameters()[0];
    // TODO(b/136048684) AIDL doesn't support nested type parameter yet.
    AIDL_FATAL_IF(type_param->IsGeneric(), aidl) << "AIDL doesn't support nested type parameter";

    AidlTypeSpecifier array_type =
        AidlTypeSpecifier(AIDL_LOCATION_HERE, type_param->GetName(), true /* isArray */,
                          nullptr /* type_params */, aidl.GetComments());
    if (!(array_type.Resolve(types, nullptr) && array_type.CheckValid(types))) {
      AIDL_FATAL(aidl) << "The type parameter is wrong.";
    }
    return GetTypeAspect(types, array_type);
  }

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

    if (const AidlInterface* intf = type->AsInterface(); intf != nullptr) {
      info = InterfaceTypeInfo(*intf);
    } else if (const AidlParcelable* parcelable = type->AsParcelable(); parcelable != nullptr) {
      info = ParcelableTypeInfo(*parcelable, aidl, types);
    } else if (const AidlEnumDeclaration* enum_decl = type->AsEnumDeclaration();
               enum_decl != nullptr) {
      info = EnumDeclarationTypeInfo(*enum_decl);
    } 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: " << aidl.ToString();
      return *info.nullable_array;
    }
    AIDL_FATAL_IF(info.array == nullptr, aidl)
        << "Unsupported type in NDK Backend: " << aidl.ToString();
    return *info.array;
  }

  if (aidl.IsNullable()) {
    AIDL_FATAL_IF(info.nullable == nullptr, aidl)
        << "Unsupported type in NDK Backend: " << aidl.ToString();
    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);
  }
}

size_t NdkAlignmentOf(const AidlTypenames& types, const AidlTypeSpecifier& aidl) {
  // map from NDK type name to the corresponding alignment size
  static map<string, int> alignment = {
      {"bool", 1},  {"int8_t", 1},  {"char16_t", 2}, {"double", 8},
      {"float", 4}, {"int32_t", 4}, {"int64_t", 8},
  };

  const string& name = NdkNameOf(types, aidl, StorageMode::STACK);
  if (alignment.find(name) != alignment.end()) {
    return alignment[name];
  } else {
    const auto& definedType = types.TryGetDefinedType(aidl.GetName());
    AIDL_FATAL_IF(definedType == nullptr, aidl) << "Failed to resolve type.";
    if (const auto& enumType = definedType->AsEnumDeclaration(); enumType != nullptr) {
      return NdkAlignmentOf(types, enumType->GetBackingType());
    }
  }
  return 0;
}

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