You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2332 lines
73 KiB
2332 lines
73 KiB
/* |
|
* Copyright (C) 2016 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 "AST.h" |
|
|
|
#include "Coordinator.h" |
|
#include "EnumType.h" |
|
#include "Interface.h" |
|
#include "HidlTypeAssertion.h" |
|
#include "Method.h" |
|
#include "ScalarType.h" |
|
#include "Scope.h" |
|
|
|
#include <algorithm> |
|
#include <hidl-util/Formatter.h> |
|
#include <hidl-util/StringHelper.h> |
|
#include <android-base/logging.h> |
|
#include <string> |
|
#include <vector> |
|
|
|
namespace android { |
|
|
|
status_t AST::generateCpp(const std::string &outputPath) const { |
|
status_t err = generateCppHeaders(outputPath); |
|
|
|
if (err == OK) { |
|
err = generateCppSources(outputPath); |
|
} |
|
|
|
return err; |
|
} |
|
|
|
status_t AST::generateCppHeaders(const std::string &outputPath) const { |
|
status_t err = generateInterfaceHeader(outputPath); |
|
|
|
if (err == OK) { |
|
err = generateStubHeader(outputPath); |
|
} |
|
|
|
if (err == OK) { |
|
err = generateHwBinderHeader(outputPath); |
|
} |
|
|
|
if (err == OK) { |
|
err = generateProxyHeader(outputPath); |
|
} |
|
|
|
if (err == OK) { |
|
err = generatePassthroughHeader(outputPath); |
|
} |
|
|
|
return err; |
|
} |
|
|
|
void AST::getPackageComponents( |
|
std::vector<std::string> *components) const { |
|
mPackage.getPackageComponents(components); |
|
} |
|
|
|
void AST::getPackageAndVersionComponents( |
|
std::vector<std::string> *components, bool cpp_compatible) const { |
|
mPackage.getPackageAndVersionComponents(components, cpp_compatible); |
|
} |
|
|
|
std::string AST::makeHeaderGuard(const std::string &baseName, |
|
bool indicateGenerated) const { |
|
std::string guard; |
|
|
|
if (indicateGenerated) { |
|
guard += "HIDL_GENERATED_"; |
|
} |
|
|
|
guard += StringHelper::Uppercase(mPackage.tokenName()); |
|
guard += "_"; |
|
guard += StringHelper::Uppercase(baseName); |
|
guard += "_H"; |
|
|
|
return guard; |
|
} |
|
|
|
void AST::generateCppPackageInclude( |
|
Formatter &out, |
|
const FQName &package, |
|
const std::string &klass) { |
|
|
|
out << "#include <"; |
|
|
|
std::vector<std::string> components; |
|
package.getPackageAndVersionComponents(&components, false /* cpp_compatible */); |
|
|
|
for (const auto &component : components) { |
|
out << component << "/"; |
|
} |
|
|
|
out << klass |
|
<< ".h>\n"; |
|
} |
|
|
|
void AST::enterLeaveNamespace(Formatter &out, bool enter) const { |
|
std::vector<std::string> packageComponents; |
|
getPackageAndVersionComponents( |
|
&packageComponents, true /* cpp_compatible */); |
|
|
|
if (enter) { |
|
for (const auto &component : packageComponents) { |
|
out << "namespace " << component << " {\n"; |
|
} |
|
|
|
out.setNamespace(mPackage.cppNamespace() + "::"); |
|
} else { |
|
out.setNamespace(std::string()); |
|
|
|
for (auto it = packageComponents.rbegin(); |
|
it != packageComponents.rend(); |
|
++it) { |
|
out << "} // namespace " << *it << "\n"; |
|
} |
|
} |
|
} |
|
|
|
static void declareGetService(Formatter &out, const std::string &interfaceName, bool isTry) { |
|
const std::string functionName = isTry ? "tryGetService" : "getService"; |
|
|
|
out << "static ::android::sp<" << interfaceName << "> " << functionName << "(" |
|
<< "const std::string &serviceName=\"default\", bool getStub=false);\n"; |
|
out << "static ::android::sp<" << interfaceName << "> " << functionName << "(" |
|
<< "const char serviceName[], bool getStub=false)" |
|
<< " { std::string str(serviceName ? serviceName : \"\");" |
|
<< " return " << functionName << "(str, getStub); }\n"; |
|
out << "static ::android::sp<" << interfaceName << "> " << functionName << "(" |
|
<< "const ::android::hardware::hidl_string& serviceName, bool getStub=false)" |
|
// without c_str the std::string constructor is ambiguous |
|
<< " { std::string str(serviceName.c_str());" |
|
<< " return " << functionName << "(str, getStub); }\n"; |
|
out << "static ::android::sp<" << interfaceName << "> " << functionName << "(" |
|
<< "bool getStub) { return " << functionName << "(\"default\", getStub); }\n"; |
|
} |
|
|
|
static void declareServiceManagerInteractions(Formatter &out, const std::string &interfaceName) { |
|
declareGetService(out, interfaceName, true /* isTry */); |
|
declareGetService(out, interfaceName, false /* isTry */); |
|
|
|
out << "__attribute__ ((warn_unused_result))" |
|
<< "::android::status_t registerAsService(const std::string &serviceName=\"default\");\n"; |
|
out << "static bool registerForNotifications(\n"; |
|
out.indent(2, [&] { |
|
out << "const std::string &serviceName,\n" |
|
<< "const ::android::sp<::android::hidl::manager::V1_0::IServiceNotification> " |
|
<< "¬ification);\n"; |
|
}); |
|
|
|
} |
|
|
|
static void implementGetService(Formatter &out, |
|
const FQName &fqName, |
|
bool isTry) { |
|
|
|
const std::string interfaceName = fqName.getInterfaceName(); |
|
const std::string functionName = isTry ? "tryGetService" : "getService"; |
|
|
|
out << "// static\n" |
|
<< "::android::sp<" << interfaceName << "> " << interfaceName << "::" << functionName << "(" |
|
<< "const std::string &serviceName, const bool getStub) "; |
|
out.block([&] { |
|
out << "using ::android::hardware::defaultServiceManager;\n"; |
|
out << "using ::android::hardware::details::waitForHwService;\n"; |
|
out << "using ::android::hardware::getPassthroughServiceManager;\n"; |
|
out << "using ::android::hardware::Return;\n"; |
|
out << "using ::android::sp;\n"; |
|
out << "using Transport = ::android::hidl::manager::V1_0::IServiceManager::Transport;\n\n"; |
|
|
|
out << "sp<" << interfaceName << "> iface = nullptr;\n"; |
|
|
|
out.endl(); |
|
|
|
out << "const sp<::android::hidl::manager::V1_0::IServiceManager> sm" |
|
<< " = defaultServiceManager();\n"; |
|
|
|
out.sIf("sm == nullptr", [&] { |
|
// hwbinder is not available on this device, so future tries |
|
// would also be null. I can only return nullptr. |
|
out << "ALOGE(\"getService: defaultServiceManager() is null\");\n" |
|
<< "return nullptr;\n"; |
|
}).endl().endl(); |
|
|
|
out << "Return<Transport> transportRet = sm->getTransport(" |
|
<< interfaceName << "::descriptor, serviceName);\n\n"; |
|
|
|
out.sIf("!transportRet.isOk()", [&] { |
|
out << "ALOGE(\"getService: defaultServiceManager()->getTransport returns %s\", " |
|
<< "transportRet.description().c_str());\n"; |
|
out << "return nullptr;\n"; |
|
}).endl(); |
|
|
|
out << "Transport transport = transportRet;\n"; |
|
out << "const bool vintfHwbinder = (transport == Transport::HWBINDER);\n" |
|
<< "const bool vintfPassthru = (transport == Transport::PASSTHROUGH);\n\n"; |
|
|
|
// This means that you must set TREBLE_TESTING_OVERRIDE when running a test such |
|
// as hidl_test. Ideally these binaries set this value themselves. This allows |
|
// test modules to dynamically add and unset services even though they are not |
|
// declared in the device manifest. This prevents a problem where framework |
|
// changes are accidentally made in a way that is not backwards compatible. For |
|
// instance, consider the following situation for two devices developed in the |
|
// same tree: |
|
// A: serves @1.1::IFoo, declares @1.0::IFoo (incorrect) |
|
// B: serves @1.0::IFoo, declares @1.0::IFoo (correct configuration) |
|
// If development is done on device A, then framework code like: "V1_1::IFoo:: |
|
// getService()->doV1_0Api()" will work. However, this will unintentionally break |
|
// the feature for devices like device B for which "V1_1::IFoo::getService() |
|
// will return nullptr. In order to prevent problems like this, we only allow |
|
// fetching an interface if it is declared in a VINTF manifest. |
|
out << "#ifdef __ANDROID_TREBLE__\n\n" |
|
<< "#ifdef __ANDROID_DEBUGGABLE__\n" |
|
<< "const char* env = std::getenv(\"TREBLE_TESTING_OVERRIDE\");\n" |
|
<< "const bool trebleTestingOverride = env && !strcmp(env, \"true\");\n" |
|
<< "const bool vintfLegacy = (transport == Transport::EMPTY) && trebleTestingOverride;\n" |
|
<< "#else // __ANDROID_TREBLE__ but not __ANDROID_DEBUGGABLE__\n" |
|
<< "const bool trebleTestingOverride = false;\n" |
|
<< "const bool vintfLegacy = false;\n" |
|
<< "#endif // __ANDROID_DEBUGGABLE__\n\n" |
|
<< "#else // not __ANDROID_TREBLE__\n" |
|
<< "const char* env = std::getenv(\"TREBLE_TESTING_OVERRIDE\");\n" |
|
<< "const bool trebleTestingOverride = env && !strcmp(env, \"true\");\n" |
|
<< "const bool vintfLegacy = (transport == Transport::EMPTY);\n\n" |
|
<< "#endif // __ANDROID_TREBLE__\n\n"; |
|
|
|
// if (getStub) { |
|
// getPassthroughServiceManager()->get only once. |
|
// } else { |
|
// if (vintfHwbinder) { |
|
// while (no alive service) { |
|
// if (have already tried to get service) |
|
// waitForHwService |
|
// defaultServiceManager()->get |
|
// } |
|
// } else if (vintfLegacy) { |
|
// defaultServiceManager()->get only once. |
|
// getPassthroughServiceManager()->get only once. |
|
// } else if (vintfPassthru) { |
|
// getPassthroughServiceManager()->get only once. |
|
// } |
|
// } |
|
|
|
out.sFor("int tries = 0; !getStub && (vintfHwbinder || (vintfLegacy && tries == 0)); tries++", [&] { |
|
if (!isTry) { |
|
out.sIf("tries > 1", [&] { |
|
// sleep only after the first time we've called waitForHwService. |
|
out << "ALOGI(\"" << functionName << ": Will do try %d for %s/%s in 1s...\", tries, " |
|
<< interfaceName << "::descriptor, serviceName.c_str());\n" |
|
<< "sleep(1);\n"; |
|
}).endl(); |
|
|
|
out.sIf("vintfHwbinder && tries > 0", [&] { |
|
out << "waitForHwService(" |
|
<< interfaceName << "::descriptor, serviceName);\n"; |
|
}).endl(); |
|
} |
|
|
|
out << "Return<sp<" << gIBaseFqName.cppName() << ">> ret = \n"; |
|
out.indent(2, [&] { |
|
out << "sm->get(" << interfaceName << "::descriptor, serviceName);\n"; |
|
}); |
|
|
|
out.sIf("!ret.isOk()", [&] { |
|
// hwservicemanager fails, may be security issue |
|
out << "ALOGE(\"" << interfaceName << ": defaultServiceManager()->get returns %s\", " |
|
<< "ret.description().c_str());\n" |
|
<< "break;\n"; |
|
}).endl(); |
|
|
|
out << "sp<" << gIBaseFqName.cppName() << "> base = ret;\n"; |
|
out.sIf("base == nullptr", [&] { |
|
// if tries > 0: race condition. hwservicemanager drops the service |
|
// from waitForHwService to here |
|
out.sIf("tries > 0", [&] { |
|
out << "ALOGW(\"" << interfaceName << ": found null hwbinder interface\");\n"; |
|
}); |
|
out << (isTry ? "break" : "continue") |
|
<< ";\n"; |
|
}).endl(); |
|
out << "Return<sp<" << interfaceName |
|
<< ">> castRet = " << interfaceName << "::castFrom(base, true /* emitError */);\n"; |
|
out.sIf("!castRet.isOk()", [&] { |
|
out.sIf("castRet.isDeadObject()", [&] { |
|
// service is dead (castFrom cannot call interfaceChain) |
|
out << "ALOGW(\"" << interfaceName << ": found dead hwbinder service\");\n" |
|
<< (isTry ? "break" : "continue") |
|
<< ";\n"; |
|
}).sElse([&] { |
|
out << "ALOGW(\"" << interfaceName << ": cannot call into hwbinder service: %s" |
|
<< "; No permission? Check for selinux denials.\", " |
|
<< "castRet.description().c_str());\n" |
|
<< "break;\n"; |
|
}).endl(); |
|
}).endl(); |
|
out << "iface = castRet;\n"; |
|
out.sIf("iface == nullptr", [&] { |
|
// returned service isn't of correct type; this is a bug |
|
// to hwservicemanager or to the service itself (interfaceChain |
|
// is not consistent). |
|
out << "ALOGW(\"" << interfaceName << ": received incompatible service; bug in hwservicemanager?\");\n" |
|
<< "break;\n"; |
|
}).endl(); |
|
|
|
out << "return iface;\n"; |
|
}).endl(); |
|
|
|
out.sIf("getStub || vintfPassthru || vintfLegacy", [&] { |
|
out << "const sp<::android::hidl::manager::V1_0::IServiceManager> pm" |
|
<< " = getPassthroughServiceManager();\n"; |
|
|
|
out.sIf("pm != nullptr", [&] () { |
|
out << "Return<sp<" << gIBaseFqName.cppName() << ">> ret = \n"; |
|
out.indent(2, [&] { |
|
out << "pm->get(" << interfaceName << "::descriptor" << ", serviceName);\n"; |
|
}); |
|
out.sIf("ret.isOk()", [&] { |
|
out << "sp<" << gIBaseFqName.cppName() |
|
<< "> baseInterface = ret;\n"; |
|
out.sIf("baseInterface != nullptr", [&]() { |
|
out << "iface = " << interfaceName << "::castFrom(baseInterface);\n"; |
|
out.sIf("!getStub || trebleTestingOverride", [&] () { |
|
out << "iface = new " << fqName.getInterfacePassthroughName() << "(iface);\n"; |
|
}).endl(); |
|
}).endl(); |
|
}).endl(); |
|
}).endl(); |
|
}).endl(); |
|
|
|
out << "return iface;\n"; |
|
}).endl().endl(); |
|
} |
|
|
|
static void implementServiceManagerInteractions(Formatter &out, |
|
const FQName &fqName, const std::string &package) { |
|
|
|
const std::string interfaceName = fqName.getInterfaceName(); |
|
|
|
implementGetService(out, fqName, true /* isTry */); |
|
implementGetService(out, fqName, false /* isTry */); |
|
|
|
out << "::android::status_t " << interfaceName << "::registerAsService(" |
|
<< "const std::string &serviceName) "; |
|
out.block([&] { |
|
out << "::android::hardware::details::onRegistration(\"" |
|
<< fqName.getPackageAndVersion().string() << "\", \"" |
|
<< interfaceName |
|
<< "\", serviceName);\n\n"; |
|
out << "const ::android::sp<::android::hidl::manager::V1_0::IServiceManager> sm\n"; |
|
out.indent(2, [&] { |
|
out << "= ::android::hardware::defaultServiceManager();\n"; |
|
}); |
|
out.sIf("sm == nullptr", [&] { |
|
out << "return ::android::INVALID_OPERATION;\n"; |
|
}).endl(); |
|
out << "::android::hardware::Return<bool> ret = " |
|
<< "sm->add(serviceName.c_str(), this);\n" |
|
<< "return ret.isOk() && ret ? ::android::OK : ::android::UNKNOWN_ERROR;\n"; |
|
}).endl().endl(); |
|
|
|
out << "bool " << interfaceName << "::registerForNotifications(\n"; |
|
out.indent(2, [&] { |
|
out << "const std::string &serviceName,\n" |
|
<< "const ::android::sp<::android::hidl::manager::V1_0::IServiceNotification> " |
|
<< "¬ification) "; |
|
}); |
|
out.block([&] { |
|
out << "const ::android::sp<::android::hidl::manager::V1_0::IServiceManager> sm\n"; |
|
out.indent(2, [&] { |
|
out << "= ::android::hardware::defaultServiceManager();\n"; |
|
}); |
|
out.sIf("sm == nullptr", [&] { |
|
out << "return false;\n"; |
|
}).endl(); |
|
out << "::android::hardware::Return<bool> success =\n"; |
|
out.indent(2, [&] { |
|
out << "sm->registerForNotifications(\"" << package << "::" << interfaceName << "\",\n"; |
|
out.indent(2, [&] { |
|
out << "serviceName, notification);\n"; |
|
}); |
|
}); |
|
out << "return success.isOk() && success;\n"; |
|
}).endl().endl(); |
|
} |
|
|
|
status_t AST::generateInterfaceHeader(const std::string &outputPath) const { |
|
const Interface *iface = getInterface(); |
|
std::string ifaceName = iface ? iface->localName() : "types"; |
|
|
|
std::string path = outputPath; |
|
path.append(mCoordinator->convertPackageRootToPath(mPackage)); |
|
path.append(mCoordinator->getPackagePath(mPackage, true /* relative */)); |
|
path.append(ifaceName); |
|
path.append(".h"); |
|
|
|
CHECK(Coordinator::MakeParentHierarchy(path)); |
|
FILE *file = fopen(path.c_str(), "w"); |
|
|
|
if (file == NULL) { |
|
return -errno; |
|
} |
|
|
|
Formatter out(file); |
|
|
|
const std::string guard = makeHeaderGuard(ifaceName); |
|
|
|
out << "#ifndef " << guard << "\n"; |
|
out << "#define " << guard << "\n\n"; |
|
|
|
for (const auto &item : mImportedNames) { |
|
generateCppPackageInclude(out, item, item.name()); |
|
} |
|
|
|
if (!mImportedNames.empty()) { |
|
out << "\n"; |
|
} |
|
|
|
if (iface) { |
|
if (isIBase()) { |
|
out << "// skipped #include IServiceNotification.h\n\n"; |
|
} else { |
|
out << "#include <android/hidl/manager/1.0/IServiceNotification.h>\n\n"; |
|
} |
|
} |
|
|
|
out << "#include <hidl/HidlSupport.h>\n"; |
|
out << "#include <hidl/MQDescriptor.h>\n"; |
|
|
|
if (iface) { |
|
out << "#include <hidl/Status.h>\n"; |
|
} |
|
|
|
out << "#include <utils/NativeHandle.h>\n"; |
|
out << "#include <utils/misc.h>\n\n"; /* for report_sysprop_change() */ |
|
|
|
enterLeaveNamespace(out, true /* enter */); |
|
out << "\n"; |
|
|
|
if (iface) { |
|
out << "struct " |
|
<< ifaceName; |
|
|
|
const Interface *superType = iface->superType(); |
|
|
|
if (superType == NULL) { |
|
out << " : virtual public ::android::RefBase"; |
|
} else { |
|
out << " : public " |
|
<< superType->fullName(); |
|
} |
|
|
|
out << " {\n"; |
|
|
|
out.indent(); |
|
|
|
} |
|
|
|
status_t err = emitTypeDeclarations(out); |
|
|
|
if (err != OK) { |
|
return err; |
|
} |
|
|
|
if (iface) { |
|
out << "virtual bool isRemote() const "; |
|
if (!isIBase()) { |
|
out << "override "; |
|
} |
|
out << "{ return false; }\n\n"; |
|
|
|
for (const auto& tuple : iface->allMethodsFromRoot()) { |
|
const Method* method = tuple.method(); |
|
|
|
out << "\n"; |
|
|
|
const bool returnsValue = !method->results().empty(); |
|
const TypedVar *elidedReturn = method->canElideCallback(); |
|
|
|
if (elidedReturn == nullptr && returnsValue) { |
|
out << "using " |
|
<< method->name() |
|
<< "_cb = std::function<void("; |
|
method->emitCppResultSignature(out, true /* specify namespaces */); |
|
out << ")>;\n"; |
|
} |
|
|
|
method->dumpAnnotations(out); |
|
|
|
if (elidedReturn) { |
|
out << "virtual ::android::hardware::Return<"; |
|
out << elidedReturn->type().getCppResultType() << "> "; |
|
} else { |
|
out << "virtual ::android::hardware::Return<void> "; |
|
} |
|
|
|
out << method->name() |
|
<< "("; |
|
method->emitCppArgSignature(out, true /* specify namespaces */); |
|
out << ")"; |
|
if (method->isHidlReserved()) { |
|
if (!isIBase()) { |
|
out << " override"; |
|
} |
|
} else { |
|
out << " = 0"; |
|
} |
|
out << ";\n"; |
|
} |
|
|
|
out << "// cast static functions\n"; |
|
std::string childTypeResult = iface->getCppResultType(); |
|
|
|
for (const Interface *superType : iface->typeChain()) { |
|
out << "static ::android::hardware::Return<" |
|
<< childTypeResult |
|
<< "> castFrom(" |
|
<< superType->getCppArgumentType() |
|
<< " parent" |
|
<< ", bool emitError = false);\n"; |
|
} |
|
|
|
out << "\nstatic const char* descriptor;\n\n"; |
|
|
|
if (isIBase()) { |
|
out << "// skipped getService, registerAsService, registerForNotifications\n\n"; |
|
} else { |
|
declareServiceManagerInteractions(out, iface->localName()); |
|
} |
|
} |
|
|
|
if (iface) { |
|
out.unindent(); |
|
|
|
out << "};\n\n"; |
|
} |
|
|
|
err = mRootScope.emitGlobalTypeDeclarations(out); |
|
|
|
if (err != OK) { |
|
return err; |
|
} |
|
|
|
out << "\n"; |
|
enterLeaveNamespace(out, false /* enter */); |
|
|
|
out << "\n#endif // " << guard << "\n"; |
|
|
|
return OK; |
|
} |
|
|
|
status_t AST::generateHwBinderHeader(const std::string &outputPath) const { |
|
const Interface *iface = getInterface(); |
|
std::string klassName = iface ? iface->getHwName() : "hwtypes"; |
|
|
|
std::string path = outputPath; |
|
path.append(mCoordinator->convertPackageRootToPath(mPackage)); |
|
path.append(mCoordinator->getPackagePath(mPackage, true /* relative */)); |
|
path.append(klassName + ".h"); |
|
|
|
FILE *file = fopen(path.c_str(), "w"); |
|
|
|
if (file == NULL) { |
|
return -errno; |
|
} |
|
|
|
Formatter out(file); |
|
|
|
const std::string guard = makeHeaderGuard(klassName); |
|
|
|
out << "#ifndef " << guard << "\n"; |
|
out << "#define " << guard << "\n\n"; |
|
|
|
generateCppPackageInclude(out, mPackage, iface ? iface->localName() : "types"); |
|
|
|
out << "\n"; |
|
|
|
for (const auto &item : mImportedNames) { |
|
if (item.name() == "types") { |
|
generateCppPackageInclude(out, item, "hwtypes"); |
|
} else { |
|
generateCppPackageInclude(out, item, item.getInterfaceStubName()); |
|
generateCppPackageInclude(out, item, item.getInterfaceProxyName()); |
|
} |
|
} |
|
|
|
out << "\n"; |
|
|
|
out << "#include <hidl/Status.h>\n"; |
|
out << "#include <hwbinder/IBinder.h>\n"; |
|
out << "#include <hwbinder/Parcel.h>\n"; |
|
|
|
out << "\n"; |
|
|
|
enterLeaveNamespace(out, true /* enter */); |
|
|
|
status_t err = mRootScope.emitGlobalHwDeclarations(out); |
|
if (err != OK) { |
|
return err; |
|
} |
|
|
|
enterLeaveNamespace(out, false /* enter */); |
|
|
|
out << "\n#endif // " << guard << "\n"; |
|
|
|
return OK; |
|
} |
|
|
|
status_t AST::emitTypeDeclarations(Formatter &out) const { |
|
return mRootScope.emitTypeDeclarations(out); |
|
} |
|
|
|
static void wrapPassthroughArg(Formatter &out, |
|
const TypedVar *arg, bool addPrefixToName, |
|
std::function<void(void)> handleError) { |
|
if (!arg->type().isInterface()) { |
|
return; |
|
} |
|
std::string name = (addPrefixToName ? "_hidl_out_" : "") + arg->name(); |
|
std::string wrappedName = (addPrefixToName ? "_hidl_out_wrapped_" : "_hidl_wrapped_") |
|
+ arg->name(); |
|
const Interface &iface = static_cast<const Interface &>(arg->type()); |
|
out << iface.getCppStackType() << " " << wrappedName << ";\n"; |
|
// TODO(elsk): b/33754152 Should not wrap this if object is Bs* |
|
out.sIf(name + " != nullptr && !" + name + "->isRemote()", [&] { |
|
out << wrappedName |
|
<< " = " |
|
<< iface.fqName().cppName() |
|
<< "::castFrom(::android::hardware::details::wrapPassthrough<" |
|
<< iface.fqName().cppName() |
|
<< ">(" |
|
<< name << "));\n"; |
|
out.sIf(wrappedName + " == nullptr", [&] { |
|
// Fatal error. Happens when the BsFoo class is not found in the binary |
|
// or any dynamic libraries. |
|
handleError(); |
|
}).endl(); |
|
}).sElse([&] { |
|
out << wrappedName << " = " << name << ";\n"; |
|
}).endl().endl(); |
|
} |
|
|
|
status_t AST::generatePassthroughMethod(Formatter &out, |
|
const Method *method) const { |
|
method->generateCppSignature(out); |
|
|
|
out << " {\n"; |
|
out.indent(); |
|
|
|
if (method->isHidlReserved() |
|
&& method->overridesCppImpl(IMPL_PASSTHROUGH)) { |
|
method->cppImpl(IMPL_PASSTHROUGH, out); |
|
out.unindent(); |
|
out << "}\n\n"; |
|
return OK; |
|
} |
|
|
|
const bool returnsValue = !method->results().empty(); |
|
const TypedVar *elidedReturn = method->canElideCallback(); |
|
|
|
if (returnsValue && elidedReturn == nullptr) { |
|
generateCheckNonNull(out, "_hidl_cb"); |
|
} |
|
|
|
generateCppInstrumentationCall( |
|
out, |
|
InstrumentationEvent::PASSTHROUGH_ENTRY, |
|
method); |
|
|
|
|
|
for (const auto &arg : method->args()) { |
|
wrapPassthroughArg(out, arg, false /* addPrefixToName */, [&] { |
|
out << "return ::android::hardware::Status::fromExceptionCode(\n"; |
|
out.indent(2, [&] { |
|
out << "::android::hardware::Status::EX_TRANSACTION_FAILED,\n" |
|
<< "\"Cannot wrap passthrough interface.\");\n"; |
|
}); |
|
}); |
|
} |
|
|
|
out << "auto _hidl_error = ::android::hardware::Void();\n"; |
|
out << "auto _hidl_return = "; |
|
|
|
if (method->isOneway()) { |
|
out << "addOnewayTask([mImpl = this->mImpl\n" |
|
<< "#ifdef __ANDROID_DEBUGGABLE__\n" |
|
", mEnableInstrumentation = this->mEnableInstrumentation, " |
|
"mInstrumentationCallbacks = this->mInstrumentationCallbacks\n" |
|
<< "#endif // __ANDROID_DEBUGGABLE__\n"; |
|
for (const auto &arg : method->args()) { |
|
out << ", " |
|
<< (arg->type().isInterface() ? "_hidl_wrapped_" : "") |
|
<< arg->name(); |
|
} |
|
out << "] {\n"; |
|
out.indent(); |
|
} |
|
|
|
out << "mImpl->" |
|
<< method->name() |
|
<< "("; |
|
|
|
out.join(method->args().begin(), method->args().end(), ", ", [&](const auto &arg) { |
|
out << (arg->type().isInterface() ? "_hidl_wrapped_" : "") << arg->name(); |
|
}); |
|
if (returnsValue && elidedReturn == nullptr) { |
|
// never true if oneway since oneway methods don't return values |
|
|
|
if (!method->args().empty()) { |
|
out << ", "; |
|
} |
|
out << "[&]("; |
|
out.join(method->results().begin(), method->results().end(), ", ", [&](const auto &arg) { |
|
out << "const auto &_hidl_out_" |
|
<< arg->name(); |
|
}); |
|
|
|
out << ") {\n"; |
|
out.indent(); |
|
generateCppInstrumentationCall( |
|
out, |
|
InstrumentationEvent::PASSTHROUGH_EXIT, |
|
method); |
|
|
|
for (const auto &arg : method->results()) { |
|
wrapPassthroughArg(out, arg, true /* addPrefixToName */, [&] { |
|
out << "_hidl_error = ::android::hardware::Status::fromExceptionCode(\n"; |
|
out.indent(2, [&] { |
|
out << "::android::hardware::Status::EX_TRANSACTION_FAILED,\n" |
|
<< "\"Cannot wrap passthrough interface.\");\n"; |
|
}); |
|
out << "return;\n"; |
|
}); |
|
} |
|
|
|
out << "_hidl_cb("; |
|
out.join(method->results().begin(), method->results().end(), ", ", [&](const auto &arg) { |
|
out << (arg->type().isInterface() ? "_hidl_out_wrapped_" : "_hidl_out_") |
|
<< arg->name(); |
|
}); |
|
out << ");\n"; |
|
out.unindent(); |
|
out << "});\n\n"; |
|
} else { |
|
out << ");\n\n"; |
|
|
|
// used by generateCppInstrumentationCall |
|
if (elidedReturn != nullptr) { |
|
out << "#ifdef __ANDROID_DEBUGGABLE__\n" |
|
<< elidedReturn->type().getCppResultType() << " _hidl_out_" << elidedReturn->name() |
|
<< " = _hidl_return;\n" |
|
<< "#endif // __ANDROID_DEBUGGABLE__\n"; |
|
} |
|
generateCppInstrumentationCall( |
|
out, |
|
InstrumentationEvent::PASSTHROUGH_EXIT, |
|
method); |
|
} |
|
|
|
if (method->isOneway()) { |
|
out.unindent(); |
|
out << "});\n"; |
|
} |
|
|
|
out << "return _hidl_return;\n"; |
|
|
|
out.unindent(); |
|
out << "}\n"; |
|
|
|
return OK; |
|
} |
|
|
|
status_t AST::generateMethods(Formatter &out, MethodGenerator gen, bool includeParent) const { |
|
const Interface* iface = mRootScope.getInterface(); |
|
|
|
const Interface *prevIterface = nullptr; |
|
for (const auto &tuple : iface->allMethodsFromRoot()) { |
|
const Method *method = tuple.method(); |
|
const Interface *superInterface = tuple.interface(); |
|
|
|
if (!includeParent && superInterface != iface) { |
|
continue; |
|
} |
|
|
|
if(prevIterface != superInterface) { |
|
if (prevIterface != nullptr) { |
|
out << "\n"; |
|
} |
|
out << "// Methods from " |
|
<< superInterface->fullName() |
|
<< " follow.\n"; |
|
prevIterface = superInterface; |
|
} |
|
status_t err = gen(method, superInterface); |
|
|
|
if (err != OK) { |
|
return err; |
|
} |
|
} |
|
|
|
out << "\n"; |
|
|
|
return OK; |
|
} |
|
|
|
void AST::generateTemplatizationLink(Formatter& out) const { |
|
out << "typedef " << mRootScope.getInterface()->localName() << " Pure;\n\n"; |
|
} |
|
|
|
status_t AST::generateStubHeader(const std::string &outputPath) const { |
|
if (!AST::isInterface()) { |
|
// types.hal does not get a stub header. |
|
return OK; |
|
} |
|
|
|
const Interface* iface = mRootScope.getInterface(); |
|
const std::string klassName = iface->getStubName(); |
|
|
|
std::string path = outputPath; |
|
path.append(mCoordinator->convertPackageRootToPath(mPackage)); |
|
path.append(mCoordinator->getPackagePath(mPackage, true /* relative */)); |
|
path.append(klassName); |
|
path.append(".h"); |
|
|
|
CHECK(Coordinator::MakeParentHierarchy(path)); |
|
FILE *file = fopen(path.c_str(), "w"); |
|
|
|
if (file == NULL) { |
|
return -errno; |
|
} |
|
|
|
Formatter out(file); |
|
|
|
const std::string guard = makeHeaderGuard(klassName); |
|
|
|
out << "#ifndef " << guard << "\n"; |
|
out << "#define " << guard << "\n\n"; |
|
|
|
generateCppPackageInclude(out, mPackage, iface->getHwName()); |
|
out << "\n"; |
|
|
|
enterLeaveNamespace(out, true /* enter */); |
|
out << "\n"; |
|
|
|
out << "struct " |
|
<< klassName; |
|
if (iface->isIBase()) { |
|
out << " : public ::android::hardware::BHwBinder"; |
|
out << ", public ::android::hardware::details::HidlInstrumentor {\n"; |
|
} else { |
|
out << " : public " |
|
<< gIBaseFqName.getInterfaceStubFqName().cppName() |
|
<< " {\n"; |
|
} |
|
|
|
out.indent(); |
|
out << "explicit " |
|
<< klassName |
|
<< "(const ::android::sp<" << iface->localName() << "> &_hidl_impl);" |
|
<< "\n"; |
|
out << "explicit " |
|
<< klassName |
|
<< "(const ::android::sp<" << iface->localName() << "> &_hidl_impl," |
|
<< " const std::string& HidlInstrumentor_package," |
|
<< " const std::string& HidlInstrumentor_interface);" |
|
<< "\n\n"; |
|
out << "virtual ~" << klassName << "();\n\n"; |
|
out << "::android::status_t onTransact(\n"; |
|
out.indent(); |
|
out.indent(); |
|
out << "uint32_t _hidl_code,\n"; |
|
out << "const ::android::hardware::Parcel &_hidl_data,\n"; |
|
out << "::android::hardware::Parcel *_hidl_reply,\n"; |
|
out << "uint32_t _hidl_flags = 0,\n"; |
|
out << "TransactCallback _hidl_cb = nullptr) override;\n\n"; |
|
out.unindent(); |
|
out.unindent(); |
|
|
|
out.endl(); |
|
generateTemplatizationLink(out); |
|
|
|
out << "::android::sp<" << iface->localName() << "> getImpl() { return _hidl_mImpl; };\n"; |
|
|
|
status_t err = generateMethods(out, [&](const Method *method, const Interface *) { |
|
if (method->isHidlReserved() && method->overridesCppImpl(IMPL_PROXY)) { |
|
return OK; |
|
} |
|
|
|
out << "static ::android::status_t _hidl_" << method->name() << "(\n"; |
|
|
|
out.indent(2, [&] { |
|
out << "::android::hidl::base::V1_0::BnHwBase* _hidl_this,\n" |
|
<< "const ::android::hardware::Parcel &_hidl_data,\n" |
|
<< "::android::hardware::Parcel *_hidl_reply,\n" |
|
<< "TransactCallback _hidl_cb);\n"; |
|
}).endl().endl(); |
|
|
|
return OK; |
|
}, false /* include parents */); |
|
|
|
if (err != OK) { |
|
return err; |
|
} |
|
|
|
out.unindent(); |
|
out << "private:\n"; |
|
out.indent(); |
|
|
|
|
|
err = generateMethods(out, [&](const Method *method, const Interface *iface) { |
|
if (!method->isHidlReserved() || !method->overridesCppImpl(IMPL_STUB_IMPL)) { |
|
return OK; |
|
} |
|
const bool returnsValue = !method->results().empty(); |
|
const TypedVar *elidedReturn = method->canElideCallback(); |
|
|
|
if (elidedReturn == nullptr && returnsValue) { |
|
out << "using " << method->name() << "_cb = " |
|
<< iface->fqName().cppName() |
|
<< "::" << method->name() << "_cb;\n"; |
|
} |
|
method->generateCppSignature(out); |
|
out << ";\n"; |
|
return OK; |
|
}); |
|
if (err != OK) { |
|
return err; |
|
} |
|
|
|
out << "::android::sp<" << iface->localName() << "> _hidl_mImpl;\n"; |
|
out.unindent(); |
|
out << "};\n\n"; |
|
|
|
enterLeaveNamespace(out, false /* enter */); |
|
|
|
out << "\n#endif // " << guard << "\n"; |
|
|
|
return OK; |
|
} |
|
|
|
status_t AST::generateProxyHeader(const std::string &outputPath) const { |
|
if (!AST::isInterface()) { |
|
// types.hal does not get a proxy header. |
|
return OK; |
|
} |
|
|
|
const Interface* iface = mRootScope.getInterface(); |
|
const std::string proxyName = iface->getProxyName(); |
|
|
|
std::string path = outputPath; |
|
path.append(mCoordinator->convertPackageRootToPath(mPackage)); |
|
path.append(mCoordinator->getPackagePath(mPackage, true /* relative */)); |
|
path.append(proxyName); |
|
path.append(".h"); |
|
|
|
CHECK(Coordinator::MakeParentHierarchy(path)); |
|
FILE *file = fopen(path.c_str(), "w"); |
|
|
|
if (file == NULL) { |
|
return -errno; |
|
} |
|
|
|
Formatter out(file); |
|
|
|
const std::string guard = makeHeaderGuard(proxyName); |
|
|
|
out << "#ifndef " << guard << "\n"; |
|
out << "#define " << guard << "\n\n"; |
|
|
|
out << "#include <hidl/HidlTransportSupport.h>\n\n"; |
|
|
|
std::vector<std::string> packageComponents; |
|
getPackageAndVersionComponents( |
|
&packageComponents, false /* cpp_compatible */); |
|
|
|
generateCppPackageInclude(out, mPackage, iface->getHwName()); |
|
out << "\n"; |
|
|
|
enterLeaveNamespace(out, true /* enter */); |
|
out << "\n"; |
|
|
|
out << "struct " |
|
<< proxyName |
|
<< " : public ::android::hardware::BpInterface<" |
|
<< iface->localName() |
|
<< ">, public ::android::hardware::details::HidlInstrumentor {\n"; |
|
|
|
out.indent(); |
|
|
|
out << "explicit " |
|
<< proxyName |
|
<< "(const ::android::sp<::android::hardware::IBinder> &_hidl_impl);" |
|
<< "\n\n"; |
|
|
|
generateTemplatizationLink(out); |
|
|
|
out << "virtual bool isRemote() const override { return true; }\n\n"; |
|
|
|
status_t err = generateMethods(out, [&](const Method *method, const Interface *) { |
|
if (method->isHidlReserved() && method->overridesCppImpl(IMPL_PROXY)) { |
|
return OK; |
|
} |
|
|
|
out << "static "; |
|
method->generateCppReturnType(out); |
|
out << " _hidl_" |
|
<< method->name() |
|
<< "(" |
|
<< "::android::hardware::IInterface* _hidl_this, " |
|
<< "::android::hardware::details::HidlInstrumentor *_hidl_this_instrumentor"; |
|
|
|
if (!method->hasEmptyCppArgSignature()) { |
|
out << ", "; |
|
} |
|
method->emitCppArgSignature(out); |
|
out << ");\n"; |
|
return OK; |
|
}, false /* include parents */); |
|
|
|
if (err != OK) { |
|
return err; |
|
} |
|
|
|
err = generateMethods(out, [&](const Method *method, const Interface *) { |
|
method->generateCppSignature(out); |
|
out << " override;\n"; |
|
return OK; |
|
}); |
|
|
|
if (err != OK) { |
|
return err; |
|
} |
|
|
|
out.unindent(); |
|
out << "private:\n"; |
|
out.indent(); |
|
out << "std::mutex _hidl_mMutex;\n" |
|
<< "std::vector<::android::sp<::android::hardware::hidl_binder_death_recipient>>" |
|
<< " _hidl_mDeathRecipients;\n"; |
|
out.unindent(); |
|
out << "};\n\n"; |
|
|
|
enterLeaveNamespace(out, false /* enter */); |
|
|
|
out << "\n#endif // " << guard << "\n"; |
|
|
|
return OK; |
|
} |
|
|
|
status_t AST::generateCppSources(const std::string &outputPath) const { |
|
std::string baseName = getBaseName(); |
|
const Interface *iface = getInterface(); |
|
|
|
std::string path = outputPath; |
|
path.append(mCoordinator->convertPackageRootToPath(mPackage)); |
|
path.append(mCoordinator->getPackagePath(mPackage, true /* relative */)); |
|
path.append(baseName); |
|
|
|
if (baseName != "types") { |
|
path.append("All"); |
|
} |
|
|
|
path.append(".cpp"); |
|
|
|
CHECK(Coordinator::MakeParentHierarchy(path)); |
|
FILE *file = fopen(path.c_str(), "w"); |
|
|
|
if (file == NULL) { |
|
return -errno; |
|
} |
|
|
|
Formatter out(file); |
|
|
|
out << "#define LOG_TAG \"" |
|
<< mPackage.string() << "::" << baseName |
|
<< "\"\n\n"; |
|
|
|
out << "#include <android/log.h>\n"; |
|
out << "#include <cutils/trace.h>\n"; |
|
out << "#include <hidl/HidlTransportSupport.h>\n\n"; |
|
if (iface) { |
|
// This is a no-op for IServiceManager itself. |
|
out << "#include <android/hidl/manager/1.0/IServiceManager.h>\n"; |
|
|
|
generateCppPackageInclude(out, mPackage, iface->getProxyName()); |
|
generateCppPackageInclude(out, mPackage, iface->getStubName()); |
|
generateCppPackageInclude(out, mPackage, iface->getPassthroughName()); |
|
|
|
for (const Interface *superType : iface->superTypeChain()) { |
|
generateCppPackageInclude(out, |
|
superType->fqName(), |
|
superType->fqName().getInterfaceProxyName()); |
|
} |
|
|
|
out << "#include <hidl/ServiceManagement.h>\n"; |
|
} else { |
|
generateCppPackageInclude(out, mPackage, "types"); |
|
generateCppPackageInclude(out, mPackage, "hwtypes"); |
|
} |
|
|
|
out << "\n"; |
|
|
|
enterLeaveNamespace(out, true /* enter */); |
|
out << "\n"; |
|
|
|
status_t err = generateTypeSource(out, iface ? iface->localName() : ""); |
|
|
|
if (err == OK && iface) { |
|
const Interface* iface = mRootScope.getInterface(); |
|
|
|
// need to be put here, generateStubSource is using this. |
|
out << "const char* " |
|
<< iface->localName() |
|
<< "::descriptor(\"" |
|
<< iface->fqName().string() |
|
<< "\");\n\n"; |
|
out << "__attribute__((constructor))"; |
|
out << "static void static_constructor() {\n"; |
|
out.indent([&] { |
|
out << "::android::hardware::details::gBnConstructorMap.set(" |
|
<< iface->localName() |
|
<< "::descriptor,\n"; |
|
out.indent(2, [&] { |
|
out << "[](void *iIntf) -> ::android::sp<::android::hardware::IBinder> {\n"; |
|
out.indent([&] { |
|
out << "return new " |
|
<< iface->getStubName() |
|
<< "(static_cast<" |
|
<< iface->localName() |
|
<< " *>(iIntf));\n"; |
|
}); |
|
out << "});\n"; |
|
}); |
|
out << "::android::hardware::details::gBsConstructorMap.set(" |
|
<< iface->localName() |
|
<< "::descriptor,\n"; |
|
out.indent(2, [&] { |
|
out << "[](void *iIntf) -> ::android::sp<" |
|
<< gIBaseFqName.cppName() |
|
<< "> {\n"; |
|
out.indent([&] { |
|
out << "return new " |
|
<< iface->getPassthroughName() |
|
<< "(static_cast<" |
|
<< iface->localName() |
|
<< " *>(iIntf));\n"; |
|
}); |
|
out << "});\n"; |
|
}); |
|
}); |
|
out << "};\n\n"; |
|
out << "__attribute__((destructor))"; |
|
out << "static void static_destructor() {\n"; |
|
out.indent([&] { |
|
out << "::android::hardware::details::gBnConstructorMap.erase(" |
|
<< iface->localName() |
|
<< "::descriptor);\n"; |
|
out << "::android::hardware::details::gBsConstructorMap.erase(" |
|
<< iface->localName() |
|
<< "::descriptor);\n"; |
|
}); |
|
out << "};\n\n"; |
|
|
|
err = generateInterfaceSource(out); |
|
} |
|
|
|
if (err == OK && iface) { |
|
err = generateProxySource(out, iface->fqName()); |
|
} |
|
|
|
if (err == OK && iface) { |
|
err = generateStubSource(out, iface); |
|
} |
|
|
|
if (err == OK && iface) { |
|
err = generatePassthroughSource(out); |
|
} |
|
|
|
if (err == OK && iface) { |
|
const Interface* iface = mRootScope.getInterface(); |
|
|
|
if (isIBase()) { |
|
out << "// skipped getService, registerAsService, registerForNotifications\n"; |
|
} else { |
|
std::string package = iface->fqName().package() |
|
+ iface->fqName().atVersion(); |
|
|
|
implementServiceManagerInteractions(out, iface->fqName(), package); |
|
} |
|
} |
|
|
|
HidlTypeAssertion::EmitAll(out); |
|
out << "\n"; |
|
|
|
enterLeaveNamespace(out, false /* enter */); |
|
|
|
return err; |
|
} |
|
|
|
void AST::generateCheckNonNull(Formatter &out, const std::string &nonNull) { |
|
out.sIf(nonNull + " == nullptr", [&] { |
|
out << "return ::android::hardware::Status::fromExceptionCode(\n"; |
|
out.indent(2, [&] { |
|
out << "::android::hardware::Status::EX_ILLEGAL_ARGUMENT,\n" |
|
<< "\"Null synchronous callback passed.\");\n"; |
|
}); |
|
}).endl().endl(); |
|
} |
|
|
|
status_t AST::generateTypeSource( |
|
Formatter &out, const std::string &ifaceName) const { |
|
return mRootScope.emitTypeDefinitions(out, ifaceName); |
|
} |
|
|
|
void AST::declareCppReaderLocals( |
|
Formatter &out, |
|
const std::vector<TypedVar *> &args, |
|
bool forResults) const { |
|
if (args.empty()) { |
|
return; |
|
} |
|
|
|
for (const auto &arg : args) { |
|
const Type &type = arg->type(); |
|
|
|
out << type.getCppResultType() |
|
<< " " |
|
<< (forResults ? "_hidl_out_" : "") + arg->name() |
|
<< ";\n"; |
|
} |
|
|
|
out << "\n"; |
|
} |
|
|
|
void AST::emitCppReaderWriter( |
|
Formatter &out, |
|
const std::string &parcelObj, |
|
bool parcelObjIsPointer, |
|
const TypedVar *arg, |
|
bool isReader, |
|
Type::ErrorMode mode, |
|
bool addPrefixToName) const { |
|
const Type &type = arg->type(); |
|
|
|
type.emitReaderWriter( |
|
out, |
|
addPrefixToName ? ("_hidl_out_" + arg->name()) : arg->name(), |
|
parcelObj, |
|
parcelObjIsPointer, |
|
isReader, |
|
mode); |
|
} |
|
|
|
void AST::emitCppResolveReferences( |
|
Formatter &out, |
|
const std::string &parcelObj, |
|
bool parcelObjIsPointer, |
|
const TypedVar *arg, |
|
bool isReader, |
|
Type::ErrorMode mode, |
|
bool addPrefixToName) const { |
|
const Type &type = arg->type(); |
|
if(type.needsResolveReferences()) { |
|
type.emitResolveReferences( |
|
out, |
|
addPrefixToName ? ("_hidl_out_" + arg->name()) : arg->name(), |
|
isReader, // nameIsPointer |
|
parcelObj, |
|
parcelObjIsPointer, |
|
isReader, |
|
mode); |
|
} |
|
} |
|
|
|
status_t AST::generateProxyMethodSource(Formatter &out, |
|
const std::string &klassName, |
|
const Method *method, |
|
const Interface *superInterface) const { |
|
method->generateCppSignature(out, |
|
klassName, |
|
true /* specify namespaces */); |
|
|
|
if (method->isHidlReserved() && method->overridesCppImpl(IMPL_PROXY)) { |
|
out.block([&] { |
|
method->cppImpl(IMPL_PROXY, out); |
|
}).endl().endl(); |
|
return OK; |
|
} |
|
|
|
status_t err = OK; |
|
|
|
out.block([&] { |
|
const bool returnsValue = !method->results().empty(); |
|
const TypedVar *elidedReturn = method->canElideCallback(); |
|
|
|
method->generateCppReturnType(out); |
|
|
|
out << " _hidl_out = " |
|
<< superInterface->fqName().cppNamespace() |
|
<< "::" |
|
<< superInterface->getProxyName() |
|
<< "::_hidl_" |
|
<< method->name() |
|
<< "(this, this"; |
|
|
|
if (!method->hasEmptyCppArgSignature()) { |
|
out << ", "; |
|
} |
|
|
|
out.join(method->args().begin(), method->args().end(), ", ", [&](const auto &arg) { |
|
out << arg->name(); |
|
}); |
|
|
|
if (returnsValue && elidedReturn == nullptr) { |
|
if (!method->args().empty()) { |
|
out << ", "; |
|
} |
|
out << "_hidl_cb"; |
|
} |
|
|
|
out << ");\n\n"; |
|
|
|
out << "return _hidl_out;\n"; |
|
}).endl().endl(); |
|
|
|
return err; |
|
} |
|
|
|
status_t AST::generateStaticProxyMethodSource(Formatter &out, |
|
const std::string &klassName, |
|
const Method *method) const { |
|
if (method->isHidlReserved() && method->overridesCppImpl(IMPL_PROXY)) { |
|
return OK; |
|
} |
|
|
|
method->generateCppReturnType(out); |
|
|
|
out << klassName |
|
<< "::_hidl_" |
|
<< method->name() |
|
<< "(" |
|
<< "::android::hardware::IInterface *_hidl_this, " |
|
<< "::android::hardware::details::HidlInstrumentor *_hidl_this_instrumentor"; |
|
|
|
if (!method->hasEmptyCppArgSignature()) { |
|
out << ", "; |
|
} |
|
|
|
method->emitCppArgSignature(out); |
|
out << ") {\n"; |
|
|
|
out.indent(); |
|
|
|
out << "#ifdef __ANDROID_DEBUGGABLE__\n"; |
|
out << "bool mEnableInstrumentation = _hidl_this_instrumentor->isInstrumentationEnabled();\n"; |
|
out << "const auto &mInstrumentationCallbacks = _hidl_this_instrumentor->getInstrumentationCallbacks();\n"; |
|
out << "#else\n"; |
|
out << "(void) _hidl_this_instrumentor;\n"; |
|
out << "#endif // __ANDROID_DEBUGGABLE__\n"; |
|
|
|
const bool returnsValue = !method->results().empty(); |
|
const TypedVar *elidedReturn = method->canElideCallback(); |
|
if (returnsValue && elidedReturn == nullptr) { |
|
generateCheckNonNull(out, "_hidl_cb"); |
|
} |
|
|
|
generateCppInstrumentationCall( |
|
out, |
|
InstrumentationEvent::CLIENT_API_ENTRY, |
|
method); |
|
|
|
out << "::android::hardware::Parcel _hidl_data;\n"; |
|
out << "::android::hardware::Parcel _hidl_reply;\n"; |
|
out << "::android::status_t _hidl_err;\n"; |
|
out << "::android::hardware::Status _hidl_status;\n\n"; |
|
|
|
declareCppReaderLocals( |
|
out, method->results(), true /* forResults */); |
|
|
|
out << "_hidl_err = _hidl_data.writeInterfaceToken("; |
|
out << klassName; |
|
out << "::descriptor);\n"; |
|
out << "if (_hidl_err != ::android::OK) { goto _hidl_error; }\n\n"; |
|
|
|
bool hasInterfaceArgument = false; |
|
// First DFS: write all buffers and resolve pointers for parent |
|
for (const auto &arg : method->args()) { |
|
if (arg->type().isInterface()) { |
|
hasInterfaceArgument = true; |
|
} |
|
emitCppReaderWriter( |
|
out, |
|
"_hidl_data", |
|
false /* parcelObjIsPointer */, |
|
arg, |
|
false /* reader */, |
|
Type::ErrorMode_Goto, |
|
false /* addPrefixToName */); |
|
} |
|
|
|
// Second DFS: resolve references. |
|
for (const auto &arg : method->args()) { |
|
emitCppResolveReferences( |
|
out, |
|
"_hidl_data", |
|
false /* parcelObjIsPointer */, |
|
arg, |
|
false /* reader */, |
|
Type::ErrorMode_Goto, |
|
false /* addPrefixToName */); |
|
} |
|
|
|
if (hasInterfaceArgument) { |
|
// Start binder threadpool to handle incoming transactions |
|
out << "::android::hardware::ProcessState::self()->startThreadPool();\n"; |
|
} |
|
out << "_hidl_err = ::android::hardware::IInterface::asBinder(_hidl_this)->transact(" |
|
<< method->getSerialId() |
|
<< " /* " |
|
<< method->name() |
|
<< " */, _hidl_data, &_hidl_reply"; |
|
|
|
if (method->isOneway()) { |
|
out << ", ::android::hardware::IBinder::FLAG_ONEWAY"; |
|
} |
|
out << ");\n"; |
|
|
|
out << "if (_hidl_err != ::android::OK) { goto _hidl_error; }\n\n"; |
|
|
|
if (!method->isOneway()) { |
|
out << "_hidl_err = ::android::hardware::readFromParcel(&_hidl_status, _hidl_reply);\n"; |
|
out << "if (_hidl_err != ::android::OK) { goto _hidl_error; }\n\n"; |
|
out << "if (!_hidl_status.isOk()) { return _hidl_status; }\n\n"; |
|
|
|
|
|
// First DFS: write all buffers and resolve pointers for parent |
|
for (const auto &arg : method->results()) { |
|
emitCppReaderWriter( |
|
out, |
|
"_hidl_reply", |
|
false /* parcelObjIsPointer */, |
|
arg, |
|
true /* reader */, |
|
Type::ErrorMode_Goto, |
|
true /* addPrefixToName */); |
|
} |
|
|
|
// Second DFS: resolve references. |
|
for (const auto &arg : method->results()) { |
|
emitCppResolveReferences( |
|
out, |
|
"_hidl_reply", |
|
false /* parcelObjIsPointer */, |
|
arg, |
|
true /* reader */, |
|
Type::ErrorMode_Goto, |
|
true /* addPrefixToName */); |
|
} |
|
|
|
if (returnsValue && elidedReturn == nullptr) { |
|
out << "_hidl_cb("; |
|
|
|
out.join(method->results().begin(), method->results().end(), ", ", [&] (const auto &arg) { |
|
if (arg->type().resultNeedsDeref()) { |
|
out << "*"; |
|
} |
|
out << "_hidl_out_" << arg->name(); |
|
}); |
|
|
|
out << ");\n\n"; |
|
} |
|
} |
|
|
|
generateCppInstrumentationCall( |
|
out, |
|
InstrumentationEvent::CLIENT_API_EXIT, |
|
method); |
|
|
|
if (elidedReturn != nullptr) { |
|
out << "_hidl_status.setFromStatusT(_hidl_err);\n"; |
|
out << "return ::android::hardware::Return<"; |
|
out << elidedReturn->type().getCppResultType() |
|
<< ">(_hidl_out_" << elidedReturn->name() << ");\n\n"; |
|
} else { |
|
out << "_hidl_status.setFromStatusT(_hidl_err);\n"; |
|
out << "return ::android::hardware::Return<void>();\n\n"; |
|
} |
|
|
|
out.unindent(); |
|
out << "_hidl_error:\n"; |
|
out.indent(); |
|
out << "_hidl_status.setFromStatusT(_hidl_err);\n"; |
|
out << "return ::android::hardware::Return<"; |
|
if (elidedReturn != nullptr) { |
|
out << method->results().at(0)->type().getCppResultType(); |
|
} else { |
|
out << "void"; |
|
} |
|
out << ">(_hidl_status);\n"; |
|
|
|
out.unindent(); |
|
out << "}\n\n"; |
|
return OK; |
|
} |
|
|
|
status_t AST::generateProxySource( |
|
Formatter &out, const FQName &fqName) const { |
|
const std::string klassName = fqName.getInterfaceProxyName(); |
|
|
|
out << klassName |
|
<< "::" |
|
<< klassName |
|
<< "(const ::android::sp<::android::hardware::IBinder> &_hidl_impl)\n"; |
|
|
|
out.indent(); |
|
out.indent(); |
|
|
|
out << ": BpInterface" |
|
<< "<" |
|
<< fqName.getInterfaceName() |
|
<< ">(_hidl_impl),\n" |
|
<< " ::android::hardware::details::HidlInstrumentor(\"" |
|
<< mPackage.string() |
|
<< "\", \"" |
|
<< fqName.getInterfaceName() |
|
<< "\") {\n"; |
|
|
|
out.unindent(); |
|
out.unindent(); |
|
out << "}\n\n"; |
|
|
|
status_t err = generateMethods(out, [&](const Method *method, const Interface *) { |
|
return generateStaticProxyMethodSource(out, klassName, method); |
|
}, false /* include parents */); |
|
|
|
if (err != OK) { |
|
return err; |
|
} |
|
|
|
err = generateMethods(out, [&](const Method *method, const Interface *superInterface) { |
|
return generateProxyMethodSource(out, klassName, method, superInterface); |
|
}); |
|
|
|
return err; |
|
} |
|
|
|
status_t AST::generateStubSource( |
|
Formatter &out, |
|
const Interface *iface) const { |
|
const std::string interfaceName = iface->localName(); |
|
const std::string klassName = iface->getStubName(); |
|
|
|
out << klassName |
|
<< "::" |
|
<< klassName |
|
<< "(const ::android::sp<" << interfaceName <<"> &_hidl_impl)\n"; |
|
|
|
out.indent(); |
|
out.indent(); |
|
|
|
if (iface->isIBase()) { |
|
out << ": ::android::hardware::details::HidlInstrumentor(\""; |
|
} else { |
|
out << ": " |
|
<< gIBaseFqName.getInterfaceStubFqName().cppName() |
|
<< "(_hidl_impl, \""; |
|
} |
|
|
|
out << mPackage.string() |
|
<< "\", \"" |
|
<< interfaceName |
|
<< "\") { \n"; |
|
out.indent(); |
|
out << "_hidl_mImpl = _hidl_impl;\n"; |
|
out << "auto prio = ::android::hardware::details::gServicePrioMap.get(" |
|
<< "_hidl_impl, {SCHED_NORMAL, 0});\n"; |
|
out << "mSchedPolicy = prio.sched_policy;\n"; |
|
out << "mSchedPriority = prio.prio;\n"; |
|
out.unindent(); |
|
|
|
out.unindent(); |
|
out.unindent(); |
|
out << "}\n\n"; |
|
|
|
if (iface->isIBase()) { |
|
// BnHwBase has a constructor to initialize the HidlInstrumentor |
|
// class properly. |
|
out << klassName |
|
<< "::" |
|
<< klassName |
|
<< "(const ::android::sp<" << interfaceName << "> &_hidl_impl," |
|
<< " const std::string &HidlInstrumentor_package," |
|
<< " const std::string &HidlInstrumentor_interface)\n"; |
|
|
|
out.indent(); |
|
out.indent(); |
|
|
|
out << ": ::android::hardware::details::HidlInstrumentor(" |
|
<< "HidlInstrumentor_package, HidlInstrumentor_interface) {\n"; |
|
out.indent(); |
|
out << "_hidl_mImpl = _hidl_impl;\n"; |
|
out.unindent(); |
|
|
|
out.unindent(); |
|
out.unindent(); |
|
out << "}\n\n"; |
|
} |
|
|
|
out << klassName << "::~" << klassName << "() "; |
|
out.block([&]() { |
|
out << "::android::hardware::details::gBnMap.eraseIfEqual(_hidl_mImpl.get(), this);\n"; |
|
}).endl().endl(); |
|
|
|
status_t err = generateMethods(out, [&](const Method *method, const Interface *) { |
|
return generateStaticStubMethodSource(out, klassName, method); |
|
}, false /* include parents */); |
|
|
|
err = generateMethods(out, [&](const Method *method, const Interface *) { |
|
if (!method->isHidlReserved() || !method->overridesCppImpl(IMPL_STUB_IMPL)) { |
|
return OK; |
|
} |
|
method->generateCppSignature(out, iface->getStubName()); |
|
out << " "; |
|
out.block([&] { |
|
method->cppImpl(IMPL_STUB_IMPL, out); |
|
}).endl(); |
|
return OK; |
|
}); |
|
if (err != OK) { |
|
return err; |
|
} |
|
|
|
out << "::android::status_t " << klassName << "::onTransact(\n"; |
|
|
|
out.indent(); |
|
out.indent(); |
|
|
|
out << "uint32_t _hidl_code,\n" |
|
<< "const ::android::hardware::Parcel &_hidl_data,\n" |
|
<< "::android::hardware::Parcel *_hidl_reply,\n" |
|
<< "uint32_t _hidl_flags,\n" |
|
<< "TransactCallback _hidl_cb) {\n"; |
|
|
|
out.unindent(); |
|
|
|
out << "::android::status_t _hidl_err = ::android::OK;\n\n"; |
|
out << "switch (_hidl_code) {\n"; |
|
out.indent(); |
|
|
|
for (const auto &tuple : iface->allMethodsFromRoot()) { |
|
const Method *method = tuple.method(); |
|
const Interface *superInterface = tuple.interface(); |
|
|
|
out << "case " |
|
<< method->getSerialId() |
|
<< " /* " |
|
<< method->name() |
|
<< " */:\n{\n"; |
|
|
|
out.indent(); |
|
|
|
out << "bool _hidl_is_oneway = _hidl_flags & ::android::hardware::IBinder::FLAG_ONEWAY;\n"; |
|
out << "if (_hidl_is_oneway != " << (method->isOneway() ? "true" : "false") << ") "; |
|
out.block([&] { out << "return ::android::UNKNOWN_ERROR;\n"; }).endl().endl(); |
|
|
|
status_t err = generateStubSourceForMethod(out, method, superInterface); |
|
|
|
if (err != OK) { |
|
return err; |
|
} |
|
|
|
out.unindent(); |
|
out << "}\n\n"; |
|
} |
|
|
|
out << "default:\n{\n"; |
|
out.indent(); |
|
|
|
if (iface->isIBase()) { |
|
out << "(void)_hidl_flags;\n"; |
|
out << "return ::android::UNKNOWN_TRANSACTION;\n"; |
|
} else { |
|
out << "return "; |
|
out << gIBaseFqName.getInterfaceStubFqName().cppName(); |
|
out << "::onTransact(\n"; |
|
|
|
out.indent(); |
|
out.indent(); |
|
|
|
out << "_hidl_code, _hidl_data, _hidl_reply, " |
|
<< "_hidl_flags, _hidl_cb);\n"; |
|
|
|
out.unindent(); |
|
out.unindent(); |
|
} |
|
|
|
out.unindent(); |
|
out << "}\n"; |
|
|
|
out.unindent(); |
|
out << "}\n\n"; |
|
|
|
out.sIf("_hidl_err == ::android::UNEXPECTED_NULL", [&] { |
|
out << "_hidl_err = ::android::hardware::writeToParcel(\n"; |
|
out.indent(2, [&] { |
|
out << "::android::hardware::Status::fromExceptionCode(::android::hardware::Status::EX_NULL_POINTER),\n"; |
|
out << "_hidl_reply);\n"; |
|
}); |
|
}); |
|
|
|
out << "return _hidl_err;\n"; |
|
|
|
out.unindent(); |
|
out << "}\n\n"; |
|
|
|
return OK; |
|
} |
|
|
|
status_t AST::generateStubSourceForMethod( |
|
Formatter &out, |
|
const Method *method, |
|
const Interface* superInterface) const { |
|
|
|
if (method->isHidlReserved() && method->overridesCppImpl(IMPL_STUB)) { |
|
method->cppImpl(IMPL_STUB, out); |
|
out << "break;\n"; |
|
return OK; |
|
} |
|
|
|
out << "_hidl_err = " |
|
<< superInterface->fqName().cppNamespace() |
|
<< "::" |
|
<< superInterface->getStubName() |
|
<< "::_hidl_" |
|
<< method->name() |
|
<< "(this, _hidl_data, _hidl_reply, _hidl_cb);\n"; |
|
out << "break;\n"; |
|
|
|
return OK; |
|
} |
|
|
|
status_t AST::generateStaticStubMethodSource(Formatter &out, |
|
const std::string &klassName, |
|
const Method *method) const { |
|
if (method->isHidlReserved() && method->overridesCppImpl(IMPL_STUB)) { |
|
return OK; |
|
} |
|
|
|
out << "::android::status_t " << klassName << "::_hidl_" << method->name() << "(\n"; |
|
|
|
out.indent(); |
|
out.indent(); |
|
|
|
out << "::android::hidl::base::V1_0::BnHwBase* _hidl_this,\n" |
|
<< "const ::android::hardware::Parcel &_hidl_data,\n" |
|
<< "::android::hardware::Parcel *_hidl_reply,\n" |
|
<< "TransactCallback _hidl_cb) {\n"; |
|
|
|
out.unindent(); |
|
|
|
out << "#ifdef __ANDROID_DEBUGGABLE__\n"; |
|
out << "bool mEnableInstrumentation = _hidl_this->isInstrumentationEnabled();\n"; |
|
out << "const auto &mInstrumentationCallbacks = _hidl_this->getInstrumentationCallbacks();\n"; |
|
out << "#endif // __ANDROID_DEBUGGABLE__\n\n"; |
|
|
|
out << "::android::status_t _hidl_err = ::android::OK;\n"; |
|
|
|
out << "if (!_hidl_data.enforceInterface(" |
|
<< klassName |
|
<< "::Pure::descriptor)) {\n"; |
|
|
|
out.indent(); |
|
out << "_hidl_err = ::android::BAD_TYPE;\n"; |
|
out << "return _hidl_err;\n"; |
|
out.unindent(); |
|
out << "}\n\n"; |
|
|
|
declareCppReaderLocals(out, method->args(), false /* forResults */); |
|
|
|
// First DFS: write buffers |
|
for (const auto &arg : method->args()) { |
|
emitCppReaderWriter( |
|
out, |
|
"_hidl_data", |
|
false /* parcelObjIsPointer */, |
|
arg, |
|
true /* reader */, |
|
Type::ErrorMode_Return, |
|
false /* addPrefixToName */); |
|
} |
|
|
|
// Second DFS: resolve references |
|
for (const auto &arg : method->args()) { |
|
emitCppResolveReferences( |
|
out, |
|
"_hidl_data", |
|
false /* parcelObjIsPointer */, |
|
arg, |
|
true /* reader */, |
|
Type::ErrorMode_Return, |
|
false /* addPrefixToName */); |
|
} |
|
|
|
generateCppInstrumentationCall( |
|
out, |
|
InstrumentationEvent::SERVER_API_ENTRY, |
|
method); |
|
|
|
const bool returnsValue = !method->results().empty(); |
|
const TypedVar *elidedReturn = method->canElideCallback(); |
|
|
|
std::string callee; |
|
|
|
if (method->isHidlReserved() && method->overridesCppImpl(IMPL_STUB_IMPL)) { |
|
callee = "_hidl_this"; |
|
} else { |
|
callee = "static_cast<" + klassName + "*>(_hidl_this)->_hidl_mImpl"; |
|
} |
|
|
|
if (elidedReturn != nullptr) { |
|
out << elidedReturn->type().getCppResultType() |
|
<< " _hidl_out_" |
|
<< elidedReturn->name() |
|
<< " = " |
|
<< callee << "->" << method->name() |
|
<< "("; |
|
|
|
out.join(method->args().begin(), method->args().end(), ", ", [&] (const auto &arg) { |
|
if (arg->type().resultNeedsDeref()) { |
|
out << "*"; |
|
} |
|
out << arg->name(); |
|
}); |
|
|
|
out << ");\n\n"; |
|
out << "::android::hardware::writeToParcel(::android::hardware::Status::ok(), " |
|
<< "_hidl_reply);\n\n"; |
|
|
|
elidedReturn->type().emitReaderWriter( |
|
out, |
|
"_hidl_out_" + elidedReturn->name(), |
|
"_hidl_reply", |
|
true, /* parcelObjIsPointer */ |
|
false, /* isReader */ |
|
Type::ErrorMode_Ignore); |
|
|
|
emitCppResolveReferences( |
|
out, |
|
"_hidl_reply", |
|
true /* parcelObjIsPointer */, |
|
elidedReturn, |
|
false /* reader */, |
|
Type::ErrorMode_Ignore, |
|
true /* addPrefixToName */); |
|
|
|
generateCppInstrumentationCall( |
|
out, |
|
InstrumentationEvent::SERVER_API_EXIT, |
|
method); |
|
|
|
out << "_hidl_cb(*_hidl_reply);\n"; |
|
} else { |
|
if (returnsValue) { |
|
out << "bool _hidl_callbackCalled = false;\n\n"; |
|
} |
|
|
|
out << callee << "->" << method->name() << "("; |
|
|
|
out.join(method->args().begin(), method->args().end(), ", ", [&] (const auto &arg) { |
|
if (arg->type().resultNeedsDeref()) { |
|
out << "*"; |
|
} |
|
|
|
out << arg->name(); |
|
}); |
|
|
|
if (returnsValue) { |
|
if (!method->args().empty()) { |
|
out << ", "; |
|
} |
|
|
|
out << "[&]("; |
|
|
|
out.join(method->results().begin(), method->results().end(), ", ", [&](const auto &arg) { |
|
out << "const auto &_hidl_out_" << arg->name(); |
|
}); |
|
|
|
out << ") {\n"; |
|
out.indent(); |
|
out << "if (_hidl_callbackCalled) {\n"; |
|
out.indent(); |
|
out << "LOG_ALWAYS_FATAL(\"" |
|
<< method->name() |
|
<< ": _hidl_cb called a second time, but must be called once.\");\n"; |
|
out.unindent(); |
|
out << "}\n"; |
|
out << "_hidl_callbackCalled = true;\n\n"; |
|
|
|
out << "::android::hardware::writeToParcel(::android::hardware::Status::ok(), " |
|
<< "_hidl_reply);\n\n"; |
|
|
|
// First DFS: buffers |
|
for (const auto &arg : method->results()) { |
|
emitCppReaderWriter( |
|
out, |
|
"_hidl_reply", |
|
true /* parcelObjIsPointer */, |
|
arg, |
|
false /* reader */, |
|
Type::ErrorMode_Ignore, |
|
true /* addPrefixToName */); |
|
} |
|
|
|
// Second DFS: resolve references |
|
for (const auto &arg : method->results()) { |
|
emitCppResolveReferences( |
|
out, |
|
"_hidl_reply", |
|
true /* parcelObjIsPointer */, |
|
arg, |
|
false /* reader */, |
|
Type::ErrorMode_Ignore, |
|
true /* addPrefixToName */); |
|
} |
|
|
|
generateCppInstrumentationCall( |
|
out, |
|
InstrumentationEvent::SERVER_API_EXIT, |
|
method); |
|
|
|
out << "_hidl_cb(*_hidl_reply);\n"; |
|
|
|
out.unindent(); |
|
out << "});\n\n"; |
|
} else { |
|
out << ");\n\n"; |
|
out << "(void) _hidl_cb;\n\n"; |
|
generateCppInstrumentationCall( |
|
out, |
|
InstrumentationEvent::SERVER_API_EXIT, |
|
method); |
|
} |
|
|
|
if (returnsValue) { |
|
out << "if (!_hidl_callbackCalled) {\n"; |
|
out.indent(); |
|
out << "LOG_ALWAYS_FATAL(\"" |
|
<< method->name() |
|
<< ": _hidl_cb not called, but must be called once.\");\n"; |
|
out.unindent(); |
|
out << "}\n\n"; |
|
} else { |
|
out << "::android::hardware::writeToParcel(" |
|
<< "::android::hardware::Status::ok(), " |
|
<< "_hidl_reply);\n\n"; |
|
} |
|
} |
|
|
|
out << "return _hidl_err;\n"; |
|
out.unindent(); |
|
out << "}\n\n"; |
|
|
|
return OK; |
|
} |
|
|
|
status_t AST::generatePassthroughHeader(const std::string &outputPath) const { |
|
if (!AST::isInterface()) { |
|
// types.hal does not get a stub header. |
|
return OK; |
|
} |
|
|
|
const Interface* iface = mRootScope.getInterface(); |
|
CHECK(iface != nullptr); |
|
|
|
const std::string klassName = iface->getPassthroughName(); |
|
|
|
bool supportOneway = iface->hasOnewayMethods(); |
|
|
|
std::string path = outputPath; |
|
path.append(mCoordinator->convertPackageRootToPath(mPackage)); |
|
path.append(mCoordinator->getPackagePath(mPackage, true /* relative */)); |
|
path.append(klassName); |
|
path.append(".h"); |
|
|
|
CHECK(Coordinator::MakeParentHierarchy(path)); |
|
FILE *file = fopen(path.c_str(), "w"); |
|
|
|
if (file == NULL) { |
|
return -errno; |
|
} |
|
|
|
Formatter out(file); |
|
|
|
const std::string guard = makeHeaderGuard(klassName); |
|
|
|
out << "#ifndef " << guard << "\n"; |
|
out << "#define " << guard << "\n\n"; |
|
|
|
std::vector<std::string> packageComponents; |
|
getPackageAndVersionComponents( |
|
&packageComponents, false /* cpp_compatible */); |
|
|
|
out << "#include <android-base/macros.h>\n"; |
|
out << "#include <cutils/trace.h>\n"; |
|
out << "#include <future>\n"; |
|
|
|
generateCppPackageInclude(out, mPackage, iface->localName()); |
|
out << "\n"; |
|
|
|
out << "#include <hidl/HidlPassthroughSupport.h>\n"; |
|
if (supportOneway) { |
|
out << "#include <hidl/TaskRunner.h>\n"; |
|
} |
|
|
|
enterLeaveNamespace(out, true /* enter */); |
|
out << "\n"; |
|
|
|
out << "struct " |
|
<< klassName |
|
<< " : " << iface->localName() |
|
<< ", ::android::hardware::details::HidlInstrumentor {\n"; |
|
|
|
out.indent(); |
|
out << "explicit " |
|
<< klassName |
|
<< "(const ::android::sp<" |
|
<< iface->localName() |
|
<< "> impl);\n"; |
|
|
|
out.endl(); |
|
generateTemplatizationLink(out); |
|
|
|
status_t err = generateMethods(out, [&](const Method *method, const Interface *) { |
|
return generatePassthroughMethod(out, method); |
|
}); |
|
|
|
if (err != OK) { |
|
return err; |
|
} |
|
|
|
out.unindent(); |
|
out << "private:\n"; |
|
out.indent(); |
|
out << "const ::android::sp<" << iface->localName() << "> mImpl;\n"; |
|
|
|
if (supportOneway) { |
|
out << "::android::hardware::details::TaskRunner mOnewayQueue;\n"; |
|
|
|
out << "\n"; |
|
|
|
out << "::android::hardware::Return<void> addOnewayTask(" |
|
"std::function<void(void)>);\n\n"; |
|
} |
|
|
|
out.unindent(); |
|
|
|
out << "};\n\n"; |
|
|
|
enterLeaveNamespace(out, false /* enter */); |
|
|
|
out << "\n#endif // " << guard << "\n"; |
|
|
|
return OK; |
|
} |
|
|
|
status_t AST::generateInterfaceSource(Formatter &out) const { |
|
const Interface* iface = mRootScope.getInterface(); |
|
|
|
// generate castFrom functions |
|
std::string childTypeResult = iface->getCppResultType(); |
|
|
|
status_t err = generateMethods(out, [&](const Method *method, const Interface *) { |
|
bool reserved = method->isHidlReserved(); |
|
|
|
if (!reserved) { |
|
out << "// no default implementation for: "; |
|
} |
|
method->generateCppSignature(out, iface->localName()); |
|
if (reserved) { |
|
out.block([&]() { |
|
method->cppImpl(IMPL_INTERFACE, out); |
|
}).endl(); |
|
} |
|
|
|
out << "\n"; |
|
|
|
return OK; |
|
}); |
|
if (err != OK) { |
|
return err; |
|
} |
|
|
|
for (const Interface *superType : iface->typeChain()) { |
|
out << "// static \n::android::hardware::Return<" |
|
<< childTypeResult |
|
<< "> " |
|
<< iface->localName() |
|
<< "::castFrom(" |
|
<< superType->getCppArgumentType() |
|
<< " parent, bool " |
|
<< (iface == superType ? "/* emitError */" : "emitError") |
|
<< ") {\n"; |
|
out.indent(); |
|
if (iface == superType) { |
|
out << "return parent;\n"; |
|
} else { |
|
out << "return ::android::hardware::details::castInterface<"; |
|
out << iface->localName() << ", " |
|
<< superType->fqName().cppName() << ", " |
|
<< iface->getProxyName() |
|
<< ">(\n"; |
|
out.indent(); |
|
out.indent(); |
|
out << "parent, \"" |
|
<< iface->fqName().string() |
|
<< "\", emitError);\n"; |
|
out.unindent(); |
|
out.unindent(); |
|
} |
|
out.unindent(); |
|
out << "}\n\n"; |
|
} |
|
|
|
return OK; |
|
} |
|
|
|
status_t AST::generatePassthroughSource(Formatter &out) const { |
|
const Interface* iface = mRootScope.getInterface(); |
|
|
|
const std::string klassName = iface->getPassthroughName(); |
|
|
|
out << klassName |
|
<< "::" |
|
<< klassName |
|
<< "(const ::android::sp<" |
|
<< iface->fullName() |
|
<< "> impl) : ::android::hardware::details::HidlInstrumentor(\"" |
|
<< mPackage.string() |
|
<< "\", \"" |
|
<< iface->localName() |
|
<< "\"), mImpl(impl) {"; |
|
if (iface->hasOnewayMethods()) { |
|
out << "\n"; |
|
out.indent([&] { |
|
out << "mOnewayQueue.start(3000 /* similar limit to binderized */);\n"; |
|
}); |
|
} |
|
out << "}\n\n"; |
|
|
|
if (iface->hasOnewayMethods()) { |
|
out << "::android::hardware::Return<void> " |
|
<< klassName |
|
<< "::addOnewayTask(std::function<void(void)> fun) {\n"; |
|
out.indent(); |
|
out << "if (!mOnewayQueue.push(fun)) {\n"; |
|
out.indent(); |
|
out << "return ::android::hardware::Status::fromExceptionCode(\n"; |
|
out.indent(); |
|
out.indent(); |
|
out << "::android::hardware::Status::EX_TRANSACTION_FAILED,\n" |
|
<< "\"Passthrough oneway function queue exceeds maximum size.\");\n"; |
|
out.unindent(); |
|
out.unindent(); |
|
out.unindent(); |
|
out << "}\n"; |
|
|
|
out << "return ::android::hardware::Status();\n"; |
|
|
|
out.unindent(); |
|
out << "}\n\n"; |
|
|
|
|
|
} |
|
|
|
return OK; |
|
} |
|
|
|
void AST::generateCppAtraceCall(Formatter &out, |
|
InstrumentationEvent event, |
|
const Method *method) const { |
|
const Interface* iface = mRootScope.getInterface(); |
|
std::string baseString = "HIDL::" + iface->localName() + "::" + method->name(); |
|
switch (event) { |
|
case SERVER_API_ENTRY: |
|
{ |
|
out << "atrace_begin(ATRACE_TAG_HAL, \"" |
|
<< baseString + "::server\");\n"; |
|
break; |
|
} |
|
case CLIENT_API_ENTRY: |
|
{ |
|
out << "atrace_begin(ATRACE_TAG_HAL, \"" |
|
<< baseString + "::client\");\n"; |
|
break; |
|
} |
|
case PASSTHROUGH_ENTRY: |
|
{ |
|
out << "atrace_begin(ATRACE_TAG_HAL, \"" |
|
<< baseString + "::passthrough\");\n"; |
|
break; |
|
} |
|
case SERVER_API_EXIT: |
|
case CLIENT_API_EXIT: |
|
case PASSTHROUGH_EXIT: |
|
{ |
|
out << "atrace_end(ATRACE_TAG_HAL);\n"; |
|
break; |
|
} |
|
default: |
|
{ |
|
LOG(FATAL) << "Unsupported instrumentation event: " << event; |
|
} |
|
} |
|
} |
|
|
|
void AST::generateCppInstrumentationCall( |
|
Formatter &out, |
|
InstrumentationEvent event, |
|
const Method *method) const { |
|
generateCppAtraceCall(out, event, method); |
|
|
|
out << "#ifdef __ANDROID_DEBUGGABLE__\n"; |
|
out << "if (UNLIKELY(mEnableInstrumentation)) {\n"; |
|
out.indent(); |
|
out << "std::vector<void *> _hidl_args;\n"; |
|
std::string event_str = ""; |
|
switch (event) { |
|
case SERVER_API_ENTRY: |
|
{ |
|
event_str = "InstrumentationEvent::SERVER_API_ENTRY"; |
|
for (const auto &arg : method->args()) { |
|
out << "_hidl_args.push_back((void *)" |
|
<< (arg->type().resultNeedsDeref() ? "" : "&") |
|
<< arg->name() |
|
<< ");\n"; |
|
} |
|
break; |
|
} |
|
case SERVER_API_EXIT: |
|
{ |
|
event_str = "InstrumentationEvent::SERVER_API_EXIT"; |
|
for (const auto &arg : method->results()) { |
|
out << "_hidl_args.push_back((void *)&_hidl_out_" |
|
<< arg->name() |
|
<< ");\n"; |
|
} |
|
break; |
|
} |
|
case CLIENT_API_ENTRY: |
|
{ |
|
event_str = "InstrumentationEvent::CLIENT_API_ENTRY"; |
|
for (const auto &arg : method->args()) { |
|
out << "_hidl_args.push_back((void *)&" |
|
<< arg->name() |
|
<< ");\n"; |
|
} |
|
break; |
|
} |
|
case CLIENT_API_EXIT: |
|
{ |
|
event_str = "InstrumentationEvent::CLIENT_API_EXIT"; |
|
for (const auto &arg : method->results()) { |
|
out << "_hidl_args.push_back((void *)" |
|
<< (arg->type().resultNeedsDeref() ? "" : "&") |
|
<< "_hidl_out_" |
|
<< arg->name() |
|
<< ");\n"; |
|
} |
|
break; |
|
} |
|
case PASSTHROUGH_ENTRY: |
|
{ |
|
event_str = "InstrumentationEvent::PASSTHROUGH_ENTRY"; |
|
for (const auto &arg : method->args()) { |
|
out << "_hidl_args.push_back((void *)&" |
|
<< arg->name() |
|
<< ");\n"; |
|
} |
|
break; |
|
} |
|
case PASSTHROUGH_EXIT: |
|
{ |
|
event_str = "InstrumentationEvent::PASSTHROUGH_EXIT"; |
|
for (const auto &arg : method->results()) { |
|
out << "_hidl_args.push_back((void *)&_hidl_out_" |
|
<< arg->name() |
|
<< ");\n"; |
|
} |
|
break; |
|
} |
|
default: |
|
{ |
|
LOG(FATAL) << "Unsupported instrumentation event: " << event; |
|
} |
|
} |
|
|
|
const Interface* iface = mRootScope.getInterface(); |
|
|
|
out << "for (const auto &callback: mInstrumentationCallbacks) {\n"; |
|
out.indent(); |
|
out << "callback(" |
|
<< event_str |
|
<< ", \"" |
|
<< mPackage.package() |
|
<< "\", \"" |
|
<< mPackage.version() |
|
<< "\", \"" |
|
<< iface->localName() |
|
<< "\", \"" |
|
<< method->name() |
|
<< "\", &_hidl_args);\n"; |
|
out.unindent(); |
|
out << "}\n"; |
|
out.unindent(); |
|
out << "}\n"; |
|
out << "#endif // __ANDROID_DEBUGGABLE__\n\n"; |
|
} |
|
|
|
} // namespace android
|
|
|