/*
* 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,
* 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 <unordered_map>
#include "aidl_to_cpp_common.h"
#include "logging.h"
#include "os.h"
namespace android {
namespace aidl {
namespace cpp {
string ClassName(const AidlDefinedType& defined_type, ClassNames type) {
string base_name = defined_type.GetName();
if (base_name.length() >= 2 && base_name[0] == 'I' && isupper(base_name[1])) {
base_name = base_name.substr(1);
}
switch (type) {
case ClassNames::CLIENT:
return "Bp" + base_name;
case ClassNames::SERVER:
return "Bn" + base_name;
case ClassNames::INTERFACE:
return "I" + base_name;
case ClassNames::DEFAULT_IMPL:
return "I" + base_name + "Default";
case ClassNames::BASE:
return base_name;
case ClassNames::RAW:
[[fallthrough]];
default:
return defined_type.GetName();
}
}
std::string HeaderFile(const AidlDefinedType& defined_type, ClassNames class_type,
bool use_os_sep) {
std::string file_path = defined_type.GetPackage();
for (char& c : file_path) {
if (c == '.') {
c = (use_os_sep) ? OS_PATH_SEPARATOR : '/';
}
}
if (!file_path.empty()) {
file_path += (use_os_sep) ? OS_PATH_SEPARATOR : '/';
}
file_path += ClassName(defined_type, class_type);
file_path += ".h";
return file_path;
}
void EnterNamespace(CodeWriter& out, const AidlDefinedType& defined_type) {
const std::vector<std::string> packages = defined_type.GetSplitPackage();
for (const std::string& package : packages) {
out << "namespace " << package << " {\n";
}
}
void LeaveNamespace(CodeWriter& out, const AidlDefinedType& defined_type) {
const std::vector<std::string> packages = defined_type.GetSplitPackage();
for (auto it = packages.rbegin(); it != packages.rend(); ++it) {
out << "} // namespace " << *it << "\n";
}
}
string BuildVarName(const AidlArgument& a) {
string prefix = "out_";
if (a.GetDirection() & AidlArgument::IN_DIR) {
prefix = "in_";
}
return prefix + a.GetName();
}
struct TypeInfo {
// name of the type in C++ output
std::string cpp_name;
// function that writes an expression to convert a variable to a Json::Value
// object
std::function<void(CodeWriter& w, const string& var_name, bool isNdk)> toJsonValueExpr;
};
const static std::unordered_map<std::string, TypeInfo> kTypeInfoMap = {
{"void", {"void", nullptr}},
{"boolean",
{
"bool",
[](CodeWriter& c, const string& var_name, bool) {
c << "Json::Value(" << var_name << "? \"true\" : \"false\")";
},
}},
{"byte",
{
"int8_t",
[](CodeWriter& c, const string& var_name, bool) {
c << "Json::Value(" << var_name << ")";
},
}},
{"char",
{
"char16_t",
[](CodeWriter& c, const string& var_name, bool isNdk) {
if (isNdk) {
c << "Json::Value(" << var_name << ")";
} else {
c << "Json::Value(std::string(android::String8(&" << var_name << ", 1)))";
}
},
}},
{"int",
{
"int32_t",
[](CodeWriter& c, const string& var_name, bool) {
c << "Json::Value(" << var_name << ")";
},
}},
{"long",
{
"int64_t",
[](CodeWriter& c, const string& var_name, bool) {
c << "Json::Value(static_cast<Json::Int64>(" << var_name << "))";
},
}},
{"float",
{
"float",
[](CodeWriter& c, const string& var_name, bool) {
c << "Json::Value(" << var_name << ")";
},
}},
{"double",
{
"double",
[](CodeWriter& c, const string& var_name, bool) {
c << "Json::Value(" << var_name << ")";
},
}},
{"String",
{
"std::string",
[](CodeWriter& c, const string& var_name, bool) {
c << "Json::Value(" << var_name << ")";
},
}}
// missing List, Map, ParcelFileDescriptor, IBinder
};
TypeInfo GetTypeInfo(const AidlTypeSpecifier& aidl) {
CHECK(aidl.IsResolved()) << aidl.ToString();
const string& aidl_name = aidl.GetName();
TypeInfo info;
if (AidlTypenames::IsBuiltinTypename(aidl_name)) {
auto it = kTypeInfoMap.find(aidl_name);
if (it != kTypeInfoMap.end()) {
info = it->second;
}
}
// Missing interface and parcelable type
return info;
}
inline bool CanWriteLog(const TypeInfo& t) {
return t.cpp_name != "";
}
bool CanWriteLog(const AidlTypeSpecifier& aidl) {
return CanWriteLog(GetTypeInfo(aidl));
}
void WriteLogFor(CodeWriter& writer, const AidlTypeSpecifier& type, const std::string& name,
bool isPointer, const std::string& log, bool isNdk) {
const TypeInfo info = GetTypeInfo(type);
if (!CanWriteLog(info)) {
return;
}
const string var_object_expr = ((isPointer ? "*" : "")) + name;
if (type.IsArray()) {
writer << log << " = Json::Value(Json::arrayValue);\n";
writer << "for (const auto& v: " << var_object_expr << ") " << log << ".append(";
info.toJsonValueExpr(writer, "v", isNdk);
writer << ");";
} else {
writer << log << " = ";
info.toJsonValueExpr(writer, var_object_expr, isNdk);
writer << ";";
}
writer << "\n";
}
void WriteLogForArguments(CodeWriterPtr& writer, const AidlArgument& a, bool isServer,
string logVarName, bool isNdk) {
if (!CanWriteLog(a.GetType())) {
return;
}
string logElementVarName = "_log_arg_element";
(*writer) << "{\n";
(*writer).Indent();
(*writer) << "Json::Value " << logElementVarName << "(Json::objectValue);\n";
string varName = isServer || isNdk ? BuildVarName(a) : a.GetName();
(*writer) << logElementVarName << "[\"name\"] = \"" << varName << "\";\n";
bool isPointer = a.IsOut() && !isServer;
WriteLogFor(*(writer.get()), a.GetType(), varName, isPointer, logElementVarName + "[\"value\"]",
isNdk);
(*writer) << logVarName << ".append(" << logElementVarName << ");\n";
(*writer) << "}\n";
(*writer).Dedent();
}
const string GenLogBeforeExecute(const string className, const AidlMethod& method, bool isServer,
bool isNdk) {
string code;
CodeWriterPtr writer = CodeWriter::ForString(&code);
(*writer) << "Json::Value _log_input_args(Json::arrayValue);\n";
(*writer) << "if (" << className << "::logFunc != nullptr) {\n";
(*writer).Indent();
for (const auto& a : method.GetArguments()) {
if (a->IsIn()) {
WriteLogForArguments(writer, *a, isServer, "_log_input_args", isNdk);
}
}
(*writer).Dedent();
(*writer) << "}\n";
(*writer) << "auto _log_start = std::chrono::steady_clock::now();\n";
writer->Close();
return code;
}
const string GenLogAfterExecute(const string className, const AidlInterface& interface,
const AidlMethod& method, const string& statusVarName,
const string& returnVarName, bool isServer, bool isNdk) {
string code;
CodeWriterPtr writer = CodeWriter::ForString(&code);
(*writer) << "if (" << className << "::logFunc != nullptr) {\n";
(*writer).Indent();
// Write the log as a Json object. For example,
//
// Json log object for following interface description
//
// package foo.bar;
// interface IFoo {
// String TestMethod(int arg1, inout String[] arg2, out double arg3);
// }
//
// would be:
//
// {
// duration_ms: 100.42,
// interface_name: "foo.bar.IFoo",
// method_name: "TestMethod",
// (proxy|stub)_address: "0x12345678",
// input_args: [
// {name: "arg1", value: 30,},
// {name: "arg2", value: ["apple", "grape"],},
// ],
// output_args: [
// {name: "arg2", value: ["mango", "banana"],},
// {name: "arg3", value: "10.5",},
// ],
// _aidl_return: "ok",
// binder_status: {
// exception_code: -8,
// exception_message: "Something wrong",
// transaction_error: 0,
// service_specific_error_code: -42,
// },
// }
(*writer) << "auto _log_end = std::chrono::steady_clock::now();\n";
(*writer) << "Json::Value _log_transaction(Json::objectValue);\n";
(*writer) << "_log_transaction[\"duration_ms\"] = "
<< "std::chrono::duration<double, std::milli>(_log_end - "
"_log_start).count();\n";
(*writer) << "_log_transaction[\"interface_name\"] = "
<< "Json::Value(\"" << interface.GetCanonicalName() << "\");\n";
(*writer) << "_log_transaction[\"method_name\"] = "
<< "Json::Value(\"" << method.GetName() << "\");\n";
(*writer) << "_log_transaction[\"" << (isServer ? "stub_address" : "proxy_address") << "\"] = ";
(*writer) << "Json::Value("
<< "(std::ostringstream() << "
<< (isNdk && isServer ? "_aidl_impl" : "static_cast<const void*>(this)") << ").str()"
<< ");\n";
(*writer) << "_log_transaction[\"input_args\"] = _log_input_args;\n";
(*writer) << "Json::Value _log_output_args(Json::arrayValue);\n";
(*writer) << "Json::Value _log_status(Json::objectValue);\n";
if (isNdk) {
(*writer) << "_log_status[\"exception_code\"] = Json::Value(AStatus_getExceptionCode("
<< statusVarName << ".get()));\n";
(*writer) << "_log_status[\"exception_message\"] = Json::Value(AStatus_getMessage("
<< statusVarName << ".get()));\n";
(*writer) << "_log_status[\"transaction_error\"] = Json::Value(AStatus_getStatus("
<< statusVarName << ".get()));\n";
(*writer) << "_log_status[\"service_specific_error_code\"] = "
"Json::Value(AStatus_getServiceSpecificError("
<< statusVarName << ".get()));\n";
} else {
(*writer) << "_log_status[\"exception_code\"] = Json::Value(" << statusVarName
<< ".exceptionCode());\n";
(*writer) << "_log_status[\"exception_message\"] = Json::Value(" << statusVarName
<< ".exceptionMessage());\n";
(*writer) << "_log_status[\"transaction_error\"] = Json::Value(" << statusVarName
<< ".transactionError());\n";
(*writer) << "_log_status[\"service_specific_error_code\"] = Json::Value(" << statusVarName
<< ".serviceSpecificErrorCode());\n";
}
(*writer) << "_log_transaction[\"binder_status\"] = _log_status;\n";
for (const auto& a : method.GetOutArguments()) {
WriteLogForArguments(writer, *a, isServer, "_log_output_args", isNdk);
}
(*writer) << "_log_transaction[\"output_args\"] = _log_output_args;\n";
if (method.GetType().GetName() != "void") {
WriteLogFor(*(writer.get()), method.GetType(), returnVarName, !isServer,
"_log_transaction[\"" + returnVarName + "\"]", isNdk);
}
// call the user-provided function with the Json object for the entire
// transaction
(*writer) << className << "::logFunc(_log_transaction);\n";
(*writer).Dedent();
(*writer) << "}\n";
writer->Close();
return code;
}
} // namespace cpp
} // namespace aidl
} // namespace android